GpgFrontend/gpgme
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

js: fix indentaion

Browse Source 
--

* doing the indentation changes that became neccesary in the last
  commit.
This commit is contained in:
Maximilian Krambach 2018-07-27 20:56:11 +02:00
parent 94ee0988d4
commit 522121ea7e
6 changed files with 1187 additions and 1175 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

374
lang/js/src/Connection.js
View File

@ -52,128 +52,128 @@ export class Connection{
}; };
/** /**
* @typedef {Object} backEndDetails * @typedef {Object} backEndDetails
* @property {String} gpgme Version number of gpgme * @property {String} gpgme Version number of gpgme
* @property {Array<Object>} info Further information about the backend * @property {Array<Object>} info Further information about the backend
* and the used applications (Example: * and the used applications (Example:
* { * {
* "protocol": "OpenPGP", * "protocol": "OpenPGP",
* "fname": "/usr/bin/gpg", * "fname": "/usr/bin/gpg",
* "version": "2.2.6", * "version": "2.2.6",
* "req_version": "1.4.0", * "req_version": "1.4.0",
* "homedir": "default" * "homedir": "default"
* } * }
*/ */
/** /**
* Retrieves the information about the backend. * Retrieves the information about the backend.
* @param {Boolean} details (optional) If set to false, the promise will * @param {Boolean} details (optional) If set to false, the promise will
* just return if a connection was successful. * just return if a connection was successful.
* @returns {Promise<backEndDetails>|Promise<Boolean>} Details from the * @returns {Promise<backEndDetails>|Promise<Boolean>} Details from the
* backend * backend
* @async * @async
*/ */
this.checkConnection = function(details = true){ this.checkConnection = function(details = true){
const msg = createMessage('version'); const msg = createMessage('version');
if (details === true) { if (details === true) {
return this.post(msg); return this.post(msg);
} else { } else {
let me = this; let me = this;
return new Promise(function(resolve) { return new Promise(function(resolve) {
Promise.race([ Promise.race([
me.post(msg), me.post(msg),
new Promise(function(resolve, reject){ new Promise(function(resolve, reject){
setTimeout(function(){ setTimeout(function(){
reject(gpgme_error('CONN_TIMEOUT')); reject(gpgme_error('CONN_TIMEOUT'));
}, 500); }, 500);
}) })
]).then(function(){ // success ]).then(function(){ // success
resolve(true); resolve(true);
}, function(){ // failure }, function(){ // failure
resolve(false); resolve(false);
});
}); });
}); }
} };
};
/** /**
* Sends a {@link GPGME_Message} via tghe nativeMessaging port. It resolves * Sends a {@link GPGME_Message} via tghe nativeMessaging port. It
* with the completed answer after all parts have been received and * resolves with the completed answer after all parts have been
* reassembled, or rejects with an {@link GPGME_Error}. * received and reassembled, or rejects with an {@link GPGME_Error}.
* *
* @param {GPGME_Message} message * @param {GPGME_Message} message
* @returns {Promise<Object>} The collected answer * @returns {Promise<Object>} The collected answer
* @async * @async
*/ */
this.post = function (message){ this.post = function (message){
if (!message || !(message instanceof GPGME_Message)){ if (!message || !(message instanceof GPGME_Message)){
this.disconnect(); this.disconnect();
return Promise.reject(gpgme_error( return Promise.reject(gpgme_error(
'PARAM_WRONG', 'Connection.post')); 'PARAM_WRONG', 'Connection.post'));
} }
if (message.isComplete() !== true){ if (message.isComplete() !== true){
this.disconnect(); this.disconnect();
return Promise.reject(gpgme_error('MSG_INCOMPLETE')); return Promise.reject(gpgme_error('MSG_INCOMPLETE'));
} }
let chunksize = message.chunksize; let chunksize = message.chunksize;
return new Promise(function(resolve, reject){ return new Promise(function(resolve, reject){
let answer = new Answer(message); let answer = new Answer(message);
let listener = function(msg) { let listener = function(msg) {
if (!msg){ if (!msg){
_connection.onMessage.removeListener(listener);
_connection.disconnect();
reject(gpgme_error('CONN_EMPTY_GPG_ANSWER'));
} else {
let answer_result = answer.collect(msg);
if (answer_result !== true){
_connection.onMessage.removeListener(listener); _connection.onMessage.removeListener(listener);
_connection.disconnect(); _connection.disconnect();
reject(answer_result); reject(gpgme_error('CONN_EMPTY_GPG_ANSWER'));
} else { } else {
if (msg.more === true){ let answer_result = answer.collect(msg);
_connection.postMessage({ if (answer_result !== true){
'op': 'getmore',
'chunksize': chunksize
});
} else {
_connection.onMessage.removeListener(listener); _connection.onMessage.removeListener(listener);
_connection.disconnect(); _connection.disconnect();
const message = answer.getMessage(); reject(answer_result);
if (message instanceof Error){ } else {
reject(message); if (msg.more === true){
_connection.postMessage({
'op': 'getmore',
'chunksize': chunksize
});
} else { } else {
resolve(message); _connection.onMessage.removeListener(listener);
_connection.disconnect();
const message = answer.getMessage();
if (message instanceof Error){
reject(message);
} else {
resolve(message);
}
} }
} }
} }
} };
}; _connection.onMessage.addListener(listener);
_connection.onMessage.addListener(listener); if (permittedOperations[message.operation].pinentry){
if (permittedOperations[message.operation].pinentry){ return _connection.postMessage(message.message);
return _connection.postMessage(message.message); } else {
} else { return Promise.race([
return Promise.race([ _connection.postMessage(message.message),
_connection.postMessage(message.message), function(resolve, reject){
function(resolve, reject){ setTimeout(function(){
setTimeout(function(){ _connection.disconnect();
reject(gpgme_error('CONN_TIMEOUT'));
}, 5000);
}]).then(function(result){
return result;
}, function(reject){
if(!(reject instanceof Error)) {
_connection.disconnect(); _connection.disconnect();
reject(gpgme_error('CONN_TIMEOUT')); return gpgme_error('GNUPG_ERROR', reject);
}, 5000); } else {
}]).then(function(result){ return reject;
return result; }
}, function(reject){ });
if(!(reject instanceof Error)) { }
_connection.disconnect(); });
return gpgme_error('GNUPG_ERROR', reject); };
} else { }
return reject;
}
});
}
});
};
}
} }
/** /**
@ -197,82 +197,84 @@ class Answer{
this.getExpect = function(){ this.getExpect = function(){
return expect; return expect;
}; };
/**
* Adds incoming base64 encoded data to the existing response /**
* @param {*} msg base64 encoded data. * Adds incoming base64 encoded data to the existing response
* @returns {Boolean} * @param {*} msg base64 encoded data.
* * @returns {Boolean}
* @private *
*/ * @private
this.collect = function (msg){ */
if (typeof(msg) !== 'object' || !msg.hasOwnProperty('response')) { this.collect = function (msg){
return gpgme_error('CONN_UNEXPECTED_ANSWER'); if (typeof(msg) !== 'object' || !msg.hasOwnProperty('response')) {
} return gpgme_error('CONN_UNEXPECTED_ANSWER');
if (response_b64 === null){
response_b64 = msg.response;
return true;
} else {
response_b64 += msg.response;
return true;
}
};
/**
* Returns the base64 encoded answer data with the content verified against
* {@link permittedOperations}.
*/
this.getMessage = function (){
if (response_b64 === undefined){
return gpgme_error('CONN_UNEXPECTED_ANSWER');
}
let _decodedResponse = JSON.parse(atob(response_b64));
let _response = {};
let messageKeys = Object.keys(_decodedResponse);
let poa = permittedOperations[this.getOperation()].answer;
if (messageKeys.length === 0){
return gpgme_error('CONN_UNEXPECTED_ANSWER');
}
for (let i= 0; i < messageKeys.length; i++){
let key = messageKeys[i];
switch (key) {
case 'type':
if (_decodedResponse.type === 'error'){
return (gpgme_error('GNUPG_ERROR',
decodeURIComponent(escape(_decodedResponse.msg))));
} else if (poa.type.indexOf(_decodedResponse.type) < 0){
return gpgme_error('CONN_UNEXPECTED_ANSWER');
}
break;
case 'base64':
break;
case 'msg':
if (_decodedResponse.type === 'error'){
return (gpgme_error('GNUPG_ERROR', _decodedResponse.msg));
}
break;
default:
if (!poa.data.hasOwnProperty(key)){
return gpgme_error('CONN_UNEXPECTED_ANSWER');
}
if( typeof(_decodedResponse[key]) !== poa.data[key] ){
return gpgme_error('CONN_UNEXPECTED_ANSWER');
}
if (_decodedResponse.base64 === true
&& poa.data[key] === 'string'
&& this.getExpect() === undefined
){
_response[key] = decodeURIComponent(
atob(_decodedResponse[key]).split('').map(
function(c) {
return '%' +
('00' + c.charCodeAt(0).toString(16)).slice(-2);
}).join(''));
} else {
_response[key] = _decodedResponse[key];
}
break;
} }
} if (response_b64 === null){
return _response; response_b64 = msg.response;
}; return true;
} } else {
response_b64 += msg.response;
return true;
}
};
/**
* Returns the base64 encoded answer data with the content verified
* against {@link permittedOperations}.
*/
this.getMessage = function (){
if (response_b64 === undefined){
return gpgme_error('CONN_UNEXPECTED_ANSWER');
}
let _decodedResponse = JSON.parse(atob(response_b64));
let _response = {};
let messageKeys = Object.keys(_decodedResponse);
let poa = permittedOperations[this.getOperation()].answer;
if (messageKeys.length === 0){
return gpgme_error('CONN_UNEXPECTED_ANSWER');
}
for (let i= 0; i < messageKeys.length; i++){
let key = messageKeys[i];
switch (key) {
case 'type':
if (_decodedResponse.type === 'error'){
return (gpgme_error('GNUPG_ERROR',
decodeURIComponent(escape(_decodedResponse.msg))));
} else if (poa.type.indexOf(_decodedResponse.type) < 0){
return gpgme_error('CONN_UNEXPECTED_ANSWER');
}
break;
case 'base64':
break;
case 'msg':
if (_decodedResponse.type === 'error'){
return (gpgme_error('GNUPG_ERROR',
_decodedResponse.msg));
}
break;
default:
if (!poa.data.hasOwnProperty(key)){
return gpgme_error('CONN_UNEXPECTED_ANSWER');
}
if( typeof(_decodedResponse[key]) !== poa.data[key] ){
return gpgme_error('CONN_UNEXPECTED_ANSWER');
}
if (_decodedResponse.base64 === true
&& poa.data[key] === 'string'
&& this.getExpect() === undefined
){
_response[key] = decodeURIComponent(
atob(_decodedResponse[key]).split('').map(
function(c) {
return '%' +
('00' + c.charCodeAt(0).toString(16)).slice(-2);
}).join(''));
} else {
_response[key] = _decodedResponse[key];
}
break;
}
}
return _response;
};
}
} }

503
lang/js/src/Key.js
View File

@ -66,224 +66,226 @@ export class GPGME_Key {
return _data.fingerprint; return _data.fingerprint;
}; };
/** /**
* Property indicating if the Key possesses a private/secret part. If this * Property indicating if the Key possesses a private/secret part. If
* information is not yet cached, it returns an {@link GPGME_Error} with * this information is not yet cached, it returns an
* code 'KEY_NO_INIT'. Running {@link refreshKey} may help in this case. * {@link GPGME_Error} with code 'KEY_NO_INIT'. Running
* @returns {Boolean} If the Key has a secret subkey. * {@link refreshKey} may help in this case.
*/ * @returns {Boolean} If the Key has a secret subkey.
this.hasSecret= function (){ */
return this.get('hasSecret', true); this.hasSecret= function (){
}; return this.get('hasSecret', true);
};
/** /**
* @param {Object} data Bulk set the data for this key, with an Object sent * @param {Object} data Bulk set the data for this key, with an Object
* by gpgme-json. * sent by gpgme-json.
* @returns {GPGME_Key|GPGME_Error} Itself after values have been set, an * @returns {GPGME_Key|GPGME_Error} Itself after values have been set,
* error if something went wrong * an error if something went wrong.
* @private * @private
*/ */
this.setKeyData = function (data){ this.setKeyData = function (data){
if (typeof(data) !== 'object') { if (typeof(data) !== 'object') {
return gpgme_error('KEY_INVALID'); return gpgme_error('KEY_INVALID');
}
if (!data.fingerprint || data.fingerprint !== _data.fingerprint){
return gpgme_error('KEY_INVALID');
}
let keys = Object.keys(data);
for (let i=0; i< keys.length; i++){
if (!validKeyProperties.hasOwnProperty(keys[i])){
return gpgme_error('KEY_INVALID');
}
//running the defined validation function
if (validKeyProperties[keys[i]](data[keys[i]]) !== true ){
return gpgme_error('KEY_INVALID');
}
switch (keys[i]){
case 'subkeys':
_data.subkeys = [];
for (let i=0; i< data.subkeys.length; i++) {
_data.subkeys.push(
new GPGME_Subkey(data.subkeys[i]));
}
break;
case 'userids':
_data.userids = [];
for (let i=0; i< data.userids.length; i++) {
_data.userids.push(
new GPGME_UserId(data.userids[i]));
}
break;
case 'last_update':
_data[keys[i]] = new Date( data[keys[i]] * 1000 );
break;
default:
_data[keys[i]] = data[keys[i]];
} }
} if (!data.fingerprint || data.fingerprint !== _data.fingerprint){
return this; return gpgme_error('KEY_INVALID');
}; }
let keys = Object.keys(data);
for (let i=0; i< keys.length; i++){
if (!validKeyProperties.hasOwnProperty(keys[i])){
return gpgme_error('KEY_INVALID');
}
//running the defined validation function
if (validKeyProperties[keys[i]](data[keys[i]]) !== true ){
return gpgme_error('KEY_INVALID');
}
switch (keys[i]){
case 'subkeys':
_data.subkeys = [];
for (let i=0; i< data.subkeys.length; i++) {
_data.subkeys.push(
new GPGME_Subkey(data.subkeys[i]));
}
break;
case 'userids':
_data.userids = [];
for (let i=0; i< data.userids.length; i++) {
_data.userids.push(
new GPGME_UserId(data.userids[i]));
}
break;
case 'last_update':
_data[keys[i]] = new Date( data[keys[i]] * 1000 );
break;
default:
_data[keys[i]] = data[keys[i]];
}
}
return this;
};
/** /**
* Query any property of the Key listed in {@link validKeyProperties} * Query any property of the Key listed in {@link validKeyProperties}
* @param {String} property property to be retreived * @param {String} property property to be retreived
* @returns {*|Promise<*>} the value (Boolean, String, Array, Object). * @returns {*|Promise<*>} the value (Boolean, String, Array, Object).
* If 'cached' is false, the value will be resolved as a Promise. * If 'cached' is false, the value will be resolved as a Promise.
*/ */
this.get = function(property) { this.get = function(property) {
if (this.isAsync === true) { if (this.isAsync === true) {
let me = this;
return new Promise(function(resolve, reject) {
if (property === 'armored'){
resolve(me.getArmor());
} else if (property === 'hasSecret'){
resolve(me.getHasSecret());
} else if (validKeyProperties.hasOwnProperty(property)){
let msg = createMessage('keylist');
msg.setParameter('keys', _data.fingerprint);
msg.post().then(function(result){
if (result.keys && result.keys.length === 1 &&
result.keys[0].hasOwnProperty(property)){
resolve(result.keys[0][property]);
} else {
reject(gpgme_error('CONN_UNEXPECTED_ANSWER'));
}
}, function(error){
reject(gpgme_error(error));
});
} else {
reject(gpgme_error('PARAM_WRONG'));
}
});
} else {
if (!validKeyProperties.hasOwnProperty(property)){
return gpgme_error('PARAM_WRONG');
}
if (!_data.hasOwnProperty(property)){
return gpgme_error('KEY_NO_INIT');
} else {
return (_data[property]);
}
}
};
/**
* Reloads the Key information from gnupg. This is only useful if you
* use the GPGME_Keys cached. Note that this is a performance hungry
* operation. If you desire more than a few refreshs, it may be
* advisable to run {@link Keyring.getKeys} instead.
* @returns {Promise<GPGME_Key|GPGME_Error>}
* @async
*/
this.refreshKey = function() {
let me = this; let me = this;
return new Promise(function(resolve, reject) { return new Promise(function(resolve, reject) {
if (property === 'armored'){ if (!_data.fingerprint){
resolve(me.getArmor()); reject(gpgme_error('KEY_INVALID'));
} else if (property === 'hasSecret'){
resolve(me.getHasSecret());
} else if (validKeyProperties.hasOwnProperty(property)){
let msg = createMessage('keylist');
msg.setParameter('keys', _data.fingerprint);
msg.post().then(function(result){
if (result.keys && result.keys.length === 1 &&
result.keys[0].hasOwnProperty(property)){
resolve(result.keys[0][property]);
} else {
reject(gpgme_error('CONN_UNEXPECTED_ANSWER'));
}
}, function(error){
reject(gpgme_error(error));
});
} else {
reject(gpgme_error('PARAM_WRONG'));
} }
}); let msg = createMessage('keylist');
} else { msg.setParameter('sigs', true);
if (!validKeyProperties.hasOwnProperty(property)){ msg.setParameter('keys', _data.fingerprint);
return gpgme_error('PARAM_WRONG'); msg.post().then(function(result){
} if (result.keys.length === 1){
if (!_data.hasOwnProperty(property)){ me.setKeyData(result.keys[0]);
return gpgme_error('KEY_NO_INIT'); me.getHasSecret().then(function(){
} else { me.getArmor().then(function(){
return (_data[property]); resolve(me);
} }, function(error){
} reject(error);
}; });
/**
* Reloads the Key information from gnupg. This is only useful if you use
* the GPGME_Keys cached. Note that this is a performance hungry operation.
* If you desire more than a few refreshs, it may be advisable to run
* {@link Keyring.getKeys} instead.
* @returns {Promise<GPGME_Key|GPGME_Error>}
* @async
*/
this.refreshKey = function() {
let me = this;
return new Promise(function(resolve, reject) {
if (!_data.fingerprint){
reject(gpgme_error('KEY_INVALID'));
}
let msg = createMessage('keylist');
msg.setParameter('sigs', true);
msg.setParameter('keys', _data.fingerprint);
msg.post().then(function(result){
if (result.keys.length === 1){
me.setKeyData(result.keys[0]);
me.getHasSecret().then(function(){
me.getArmor().then(function(){
resolve(me);
}, function(error){ }, function(error){
reject(error); reject(error);
}); });
}, function(error){ } else {
reject(error); reject(gpgme_error('KEY_NOKEY'));
}); }
} else { }, function (error) {
reject(gpgme_error('KEY_NOKEY')); reject(gpgme_error('GNUPG_ERROR'), error);
});
});
};
/**
* Query the armored block of the Key directly from gnupg. Please note
* that this will not get you any export of the secret/private parts of
* a Key
* @returns {Promise<String|GPGME_Error>}
* @async
*/
this.getArmor = function(){
return new Promise(function(resolve, reject) {
if (!_data.fingerprint){
reject(gpgme_error('KEY_INVALID'));
} }
}, function (error) { let msg = createMessage('export');
reject(gpgme_error('GNUPG_ERROR'), error); msg.setParameter('armor', true);
msg.setParameter('keys', _data.fingerprint);
msg.post().then(function(result){
_data.armored = result.data;
resolve(result.data);
}, function(error){
reject(error);
});
}); });
}); };
};
/** /**
* Query the armored block of the Key directly from gnupg. Please note that * Find out if the Key includes a secret part. Note that this is a
* this will not get you any export of the secret/private parts of a Key * rather nonperformant operation, as it needs to query gnupg twice.
* @returns {Promise<String|GPGME_Error>} * If you want this inforrmation about more than a few Keys, it may be
* @async * advisable to run {@link Keyring.getKeys} instead.
*/ * @returns {Promise<Boolean|GPGME_Error>} True if a secret/private Key
this.getArmor = function(){ * is available in the gnupg Keyring
return new Promise(function(resolve, reject) { * @async
if (!_data.fingerprint){ */
reject(gpgme_error('KEY_INVALID')); this.getHasSecret = function (){
} return new Promise(function(resolve, reject) {
let msg = createMessage('export'); if (!_data.fingerprint){
msg.setParameter('armor', true); reject(gpgme_error('KEY_INVALID'));
msg.setParameter('keys', _data.fingerprint);
msg.post().then(function(result){
_data.armored = result.data;
resolve(result.data);
}, function(error){
reject(error);
});
});
};
/**
* Find out if the Key includes a secret part. Note that this is a rather
* nonperformant operation, as it needs to query gnupg twice. If you want
* this inforrmation about more than a few Keys, it may be advisable to run
* {@link Keyring.getKeys} instead.
* @returns {Promise<Boolean|GPGME_Error>} True if a secret/private Key is
* available in the gnupg Keyring
* @async
*/
this.getHasSecret = function (){
return new Promise(function(resolve, reject) {
if (!_data.fingerprint){
reject(gpgme_error('KEY_INVALID'));
}
let msg = createMessage('keylist');
msg.setParameter('keys', _data.fingerprint);
msg.setParameter('secret', true);
msg.post().then(function(result){
_data.hasSecret = null;
if (
result.keys &&
result.keys.length === 1 &&
result.keys[0].secret === true
) {
_data.hasSecret = true;
resolve(true);
} else {
_data.hasSecret = false;
resolve(false);
} }
}, function(error){ let msg = createMessage('keylist');
reject(error); msg.setParameter('keys', _data.fingerprint);
msg.setParameter('secret', true);
msg.post().then(function(result){
_data.hasSecret = null;
if (
result.keys &&
result.keys.length === 1 &&
result.keys[0].secret === true
) {
_data.hasSecret = true;
resolve(true);
} else {
_data.hasSecret = false;
resolve(false);
}
}, function(error){
reject(error);
});
}); });
}); };
};
/** /**
* Deletes the (public) Key from the GPG Keyring. Note that a deletion of a * Deletes the (public) Key from the GPG Keyring. Note that a deletion
* secret key is not supported by the native backend. * of a secret key is not supported by the native backend.
* @returns {Promise<Boolean|GPGME_Error>} Success if key was deleted, * @returns {Promise<Boolean|GPGME_Error>} Success if key was deleted,
* rejects with a GPG error otherwise. * rejects with a GPG error otherwise.
*/ */
this.delete= function (){ this.delete= function (){
return new Promise(function(resolve, reject){ return new Promise(function(resolve, reject){
if (!_data.fingerprint){ if (!_data.fingerprint){
reject(gpgme_error('KEY_INVALID')); reject(gpgme_error('KEY_INVALID'));
} }
let msg = createMessage('delete'); let msg = createMessage('delete');
msg.setParameter('key', _data.fingerprint); msg.setParameter('key', _data.fingerprint);
msg.post().then(function(result){ msg.post().then(function(result){
resolve(result.success); resolve(result.success);
}, function(error){ }, function(error){
reject(error); reject(error);
});
}); });
}); };
};
} }
/** /**
@ -320,42 +322,39 @@ class GPGME_Subkey {
let _data = {}; let _data = {};
let keys = Object.keys(data); let keys = Object.keys(data);
/** /**
* Validates a subkey property against {@link validSubKeyProperties} and * Validates a subkey property against {@link validSubKeyProperties} and
* sets it if validation is successful * sets it if validation is successful
* @param {String} property * @param {String} property
* @param {*} value * @param {*} value
* @param private * @param private
*/ */
const setProperty = function (property, value){ const setProperty = function (property, value){
if (validSubKeyProperties.hasOwnProperty(property)){ if (validSubKeyProperties.hasOwnProperty(property)){
if (validSubKeyProperties[property](value) === true) { if (validSubKeyProperties[property](value) === true) {
if (property === 'timestamp' || property === 'expires'){ if (property === 'timestamp' || property === 'expires'){
_data[property] = new Date(value * 1000); _data[property] = new Date(value * 1000);
} else { } else {
_data[property] = value; _data[property] = value;
}
} }
} }
};
for (let i=0; i< keys.length; i++) {
setProperty(keys[i], data[keys[i]]);
} }
};
for (let i=0; i< keys.length; i++) { /**
setProperty(keys[i], data[keys[i]]); * Fetches any information about this subkey
* @param {String} property Information to request
* @returns {String | Number | Date}
*/
this.get = function(property) {
if (_data.hasOwnProperty(property)){
return (_data[property]);
}
};
} }
/**
* Fetches any information about this subkey
* @param {String} property Information to request
* @returns {String | Number | Date}
*/
this.get = function(property) {
if (_data.hasOwnProperty(property)){
return (_data[property]);
}
};
}
} }
/** /**
@ -388,28 +387,28 @@ class GPGME_UserId {
setProperty(keys[i], data[keys[i]]); setProperty(keys[i], data[keys[i]]);
} }
/** /**
* Validates a subkey property against {@link validUserIdProperties} and * Validates a subkey property against {@link validUserIdProperties} and
* sets it if validation is successful * sets it if validation is successful
* @param {String} property * @param {String} property
* @param {*} value * @param {*} value
* @param private * @param private
*/ */
/** /**
* Fetches information about the user * Fetches information about the user
* @param {String} property Information to request * @param {String} property Information to request
* @returns {String | Number} * @returns {String | Number}
*/ */
this.get = function (property) { this.get = function (property) {
if (_data.hasOwnProperty(property)){ if (_data.hasOwnProperty(property)){
return (_data[property]); return (_data[property]);
} }
}; };
}
} }
}
/** /**
* Validation definition for userIds. Each valid userId property is represented * Validation definition for userIds. Each valid userId property is represented
* as a key- Value pair, with their value being a validation function to check * as a key- Value pair, with their value being a validation function to check

677
lang/js/src/Keyring.js
View File

@ -33,359 +33,368 @@ import { gpgme_error } from './Errors';
export class GPGME_Keyring { export class GPGME_Keyring {
constructor(){ constructor(){
/** /**
* Queries Keys (all Keys or a subset) from gnupg. * Queries Keys (all Keys or a subset) from gnupg.
* *
* @param {String | Array<String>} pattern (optional) A pattern to search * @param {String | Array<String>} pattern (optional) A pattern to
* for in userIds or KeyIds. * search for in userIds or KeyIds.
* @param {Boolean} prepare_sync (optional) if set to true, the 'hasSecret' * @param {Boolean} prepare_sync (optional) if set to true, the
* and 'armored' properties will be fetched for the Keys as well. These * 'hasSecret' and 'armored' properties will be fetched for the Keys as
* require additional calls to gnupg, resulting in a performance hungry * well. These require additional calls to gnupg, resulting in a
* operation. Calling them here enables direct, synchronous use of these * performance hungry operation. Calling them here enables direct,
* properties for all keys, without having to resort to a refresh() first. * synchronous use of these properties for all keys, without having to
* @param {Boolean} search (optional) retrieve Keys from external servers * resort to a refresh() first.
* with the method(s) defined in gnupg (e.g. WKD/HKP lookup) * @param {Boolean} search (optional) retrieve Keys from external
* @returns {Promise.<Array<GPGME_Key>|GPGME_Error>} * servers with the method(s) defined in gnupg (e.g. WKD/HKP lookup)
* @static * @returns {Promise.<Array<GPGME_Key>|GPGME_Error>}
* @async * @static
*/ * @async
this.getKeys = function(pattern, prepare_sync=false, search=false){ */
return new Promise(function(resolve, reject) { this.getKeys = function(pattern, prepare_sync=false, search=false){
let msg = createMessage('keylist'); return new Promise(function(resolve, reject) {
if (pattern !== undefined && pattern !== null){ let msg = createMessage('keylist');
msg.setParameter('keys', pattern); if (pattern !== undefined && pattern !== null){
} msg.setParameter('keys', pattern);
msg.setParameter('sigs', true); }
if (search === true){ msg.setParameter('sigs', true);
msg.setParameter('locate', true); if (search === true){
} msg.setParameter('locate', true);
msg.post().then(function(result){ }
let resultset = []; msg.post().then(function(result){
if (result.keys.length === 0){ let resultset = [];
resolve([]); if (result.keys.length === 0){
} else { resolve([]);
let secondrequest;
if (prepare_sync === true) {
secondrequest = function() {
let msg2 = createMessage('keylist');
msg2.setParameter('keys', pattern);
msg2.setParameter('secret', true);
return msg2.post();
};
} else { } else {
secondrequest = function() { let secondrequest;
return Promise.resolve(true); if (prepare_sync === true) {
}; secondrequest = function() {
} let msg2 = createMessage('keylist');
secondrequest().then(function(answer) { msg2.setParameter('keys', pattern);
for (let i=0; i < result.keys.length; i++){ msg2.setParameter('secret', true);
if (prepare_sync === true){ return msg2.post();
result.keys[i].hasSecret = false; };
if (answer && answer.keys) { } else {
for (let j=0; j < answer.keys.length; j++ ){ secondrequest = function() {
if (result.keys[i].fingerprint === return Promise.resolve(true);
answer.keys[j].fingerprint };
) { }
if (answer.keys[j].secret === true){ secondrequest().then(function(answer) {
result.keys[i].hasSecret = true; for (let i=0; i < result.keys.length; i++){
if (prepare_sync === true){
result.keys[i].hasSecret = false;
if (answer && answer.keys) {
for (let j=0;
j < answer.keys.length; j++ ){
const a = answer.keys[j];
const b = result.keys[i];
if (
a.fingerprint === b.fingerprint
) {
if (a.secret === true){
a.hasSecret = true;
}
break;
} }
break;
} }
// TODO getArmor() to be used in sync
} }
// TODO getArmor() to be used in sync }
let k = createKey(result.keys[i].fingerprint);
k.setKeyData(result.keys[i]);
resultset.push(k);
}
resolve(resultset);
}, function(error){
reject(error);
});
}
});
});
};
/**
* @typedef {Object} exportResult The result of a getKeysArmored
* operation.
* @property {String} armored The public Key(s) as armored block. Note
* that the result is one armored block, and not a block per key.
* @property {Array<String>} secret_fprs (optional) list of
* fingerprints for those Keys that also have a secret Key available in
* gnupg. The secret key will not be exported, but the fingerprint can
* be used in operations needing a secret key.
*/
/**
* Fetches the armored public Key blocks for all Keys matching the
* pattern (if no pattern is given, fetches all keys known to gnupg).
* @param {String|Array<String>} pattern (optional) The Pattern to
* search for
* @param {Boolean} with_secret_fpr (optional) also return a list of
* fingerprints for the keys that have a secret key available
* @returns {Promise<exportResult|GPGME_Error>} Object containing the
* armored Key(s) and additional information.
* @static
* @async
*/
this.getKeysArmored = function(pattern, with_secret_fpr) {
return new Promise(function(resolve, reject) {
let msg = createMessage('export');
msg.setParameter('armor', true);
if (with_secret_fpr === true) {
msg.setParameter('with-sec-fprs', true);
}
if (pattern !== undefined && pattern !== null){
msg.setParameter('keys', pattern);
}
msg.post().then(function(answer){
const result = {armored: answer.data};
if (with_secret_fpr === true
&& answer.hasOwnProperty('sec-fprs')
) {
result.secret_fprs = answer['sec-fprs'];
}
resolve(result);
}, function(error){
reject(error);
});
});
};
/**
* Returns the Key used by default in gnupg.
* (a.k.a. 'primary Key or 'main key').
* It looks up the gpg configuration if set, or the first key that
* contains a secret key.
*
* @returns {Promise<GPGME_Key|GPGME_Error>}
* @async
* @static
*/
this.getDefaultKey = function() {
let me = this;
return new Promise(function(resolve, reject){
let msg = createMessage('config_opt');
msg.setParameter('component', 'gpg');
msg.setParameter('option', 'default-key');
msg.post().then(function(response){
if (response.value !== undefined
&& response.value.hasOwnProperty('string')
&& typeof(response.value.string) === 'string'
){
me.getKeys(response.value.string,true).then(
function(keys){
if(keys.length === 1){
resolve(keys[0]);
} else {
reject(gpgme_error('KEY_NO_DEFAULT'));
}
}, function(error){
reject(error);
});
} else {
// TODO: this is overly 'expensive' in communication
// and probably performance, too
me.getKeys(null,true).then(function(keys){
for (let i=0; i < keys.length; i++){
if (keys[i].get('hasSecret') === true){
resolve(keys[i]);
break;
}
if (i === keys.length -1){
reject(gpgme_error('KEY_NO_DEFAULT'));
} }
} }
let k = createKey(result.keys[i].fingerprint); }, function(error){
k.setKeyData(result.keys[i]); reject(error);
resultset.push(k); });
}
resolve(resultset);
}, function(error){
reject(error);
});
}
});
});
};
/**
* @typedef {Object} exportResult The result of a getKeysArmored operation.
* @property {String} armored The public Key(s) as armored block. Note that
* the result is one armored block, and not a block per key.
* @property {Array<String>} secret_fprs (optional) list of fingerprints
* for those Keys that also have a secret Key available in gnupg. The
* secret key will not be exported, but the fingerprint can be used in
* operations needing a secret key.
*/
/**
* Fetches the armored public Key blocks for all Keys matching the pattern
* (if no pattern is given, fetches all keys known to gnupg).
* @param {String|Array<String>} pattern (optional) The Pattern to search
* for
* @param {Boolean} with_secret_fpr (optional) also return a list of
* fingerprints for the keys that have a secret key available
* @returns {Promise<exportResult|GPGME_Error>} Object containing the
* armored Key(s) and additional information.
* @static
* @async
*/
this.getKeysArmored = function(pattern, with_secret_fpr) {
return new Promise(function(resolve, reject) {
let msg = createMessage('export');
msg.setParameter('armor', true);
if (with_secret_fpr === true) {
msg.setParameter('with-sec-fprs', true);
}
if (pattern !== undefined && pattern !== null){
msg.setParameter('keys', pattern);
}
msg.post().then(function(answer){
const result = {armored: answer.data};
if (with_secret_fpr === true
&& answer.hasOwnProperty('sec-fprs')
) {
result.secret_fprs = answer['sec-fprs'];
}
resolve(result);
}, function(error){
reject(error);
});
});
};
/**
* Returns the Key used by default in gnupg.
* (a.k.a. 'primary Key or 'main key').
* It looks up the gpg configuration if set, or the first key that contains
* a secret key.
*
* @returns {Promise<GPGME_Key|GPGME_Error>}
* @async
* @static
*/
this.getDefaultKey = function() {
let me = this;
return new Promise(function(resolve, reject){
let msg = createMessage('config_opt');
msg.setParameter('component', 'gpg');
msg.setParameter('option', 'default-key');
msg.post().then(function(response){
if (response.value !== undefined
&& response.value.hasOwnProperty('string')
&& typeof(response.value.string) === 'string'
){
me.getKeys(response.value.string,true).then(function(keys){
if(keys.length === 1){
resolve(keys[0]);
} else {
reject(gpgme_error('KEY_NO_DEFAULT'));
}
}, function(error){
reject(error);
});
} else {
// TODO: this is overly 'expensive' in communication
// and probably performance, too
me.getKeys(null,true).then(function(keys){
for (let i=0; i < keys.length; i++){
if (keys[i].get('hasSecret') === true){
resolve(keys[i]);
break;
}
if (i === keys.length -1){
reject(gpgme_error('KEY_NO_DEFAULT'));
}
}
}, function(error){
reject(error);
});
}
}, function(error){
reject(error);
});
});
};
/**
* @typedef {Object} importResult The result of a Key update
* @property {Object} summary Numerical summary of the result. See the
* feedbackValues variable for available Keys values and the gnupg
* documentation.
* https://www.gnupg.org/documentation/manuals/gpgme/Importing-Keys.html
* for details on their meaning.
* @property {Array<importedKeyResult>} Keys Array of Object containing
* GPGME_Keys with additional import information
*
*/
/**
* @typedef {Object} importedKeyResult
* @property {GPGME_Key} key The resulting key
* @property {String} status:
* 'nochange' if the Key was not changed,
* 'newkey' if the Key was imported in gpg, and did not exist previously,
* 'change' if the key existed, but details were updated. For details,
* Key.changes is available.
* @property {Boolean} changes.userId Changes in userIds
* @property {Boolean} changes.signature Changes in signatures
* @property {Boolean} changes.subkey Changes in subkeys
*/
/**
* Import an armored Key block into gnupg. Note that this currently will
* not succeed on private Key blocks.
* @param {String} armored Armored Key block of the Key(s) to be imported
* into gnupg
* @param {Boolean} prepare_sync prepare the keys for synched use
* (see {@link getKeys}).
* @returns {Promise<importResult>} A summary and Keys considered.
* @async
* @static
*/
this.importKey = function (armored, prepare_sync) {
let feedbackValues = ['considered', 'no_user_id', 'imported',
'imported_rsa', 'unchanged', 'new_user_ids', 'new_sub_keys',
'new_signatures', 'new_revocations', 'secret_read',
'secret_imported', 'secret_unchanged', 'skipped_new_keys',
'not_imported', 'skipped_v3_keys'];
if (!armored || typeof(armored) !== 'string'){
return Promise.reject(gpgme_error('PARAM_WRONG'));
}
let me = this;
return new Promise(function(resolve, reject){
let msg = createMessage('import');
msg.setParameter('data', armored);
msg.post().then(function(response){
let infos = {};
let fprs = [];
for (let res=0; res<response.result.imports.length; res++){
let result = response.result.imports[res];
let status = '';
if (result.status === 0){
status = 'nochange';
} else if ((result.status & 1) === 1){
status = 'newkey';
} else {
status = 'change';
} }
let changes = {}; }, function(error){
changes.userId = (result.status & 2) === 2; reject(error);
changes.signature = (result.status & 4) === 4; });
changes.subkey = (result.status & 8) === 8; });
//16 new secret key: not implemented };
fprs.push(result.fingerprint); /**
infos[result.fingerprint] = { * @typedef {Object} importResult The result of a Key update
changes: changes, * @property {Object} summary Numerical summary of the result. See the
status: status * feedbackValues variable for available Keys values and the gnupg
}; * documentation.
} * https://www.gnupg.org/documentation/manuals/gpgme/Importing-Keys.html
let resultset = []; * for details on their meaning.
if (prepare_sync === true){ * @property {Array<importedKeyResult>} Keys Array of Object containing
me.getKeys(fprs, true).then(function(result){ * GPGME_Keys with additional import information
for (let i=0; i < result.length; i++) { *
*/
/**
* @typedef {Object} importedKeyResult
* @property {GPGME_Key} key The resulting key
* @property {String} status:
* 'nochange' if the Key was not changed,
* 'newkey' if the Key was imported in gpg, and did not exist
* previously,
* 'change' if the key existed, but details were updated. For details,
* Key.changes is available.
* @property {Boolean} changes.userId Changes in userIds
* @property {Boolean} changes.signature Changes in signatures
* @property {Boolean} changes.subkey Changes in subkeys
*/
/**
* Import an armored Key block into gnupg. Note that this currently
* will not succeed on private Key blocks.
* @param {String} armored Armored Key block of the Key(s) to be
* imported into gnupg
* @param {Boolean} prepare_sync prepare the keys for synched use
* (see {@link getKeys}).
* @returns {Promise<importResult>} A summary and Keys considered.
* @async
* @static
*/
this.importKey = function (armored, prepare_sync) {
let feedbackValues = ['considered', 'no_user_id', 'imported',
'imported_rsa', 'unchanged', 'new_user_ids', 'new_sub_keys',
'new_signatures', 'new_revocations', 'secret_read',
'secret_imported', 'secret_unchanged', 'skipped_new_keys',
'not_imported', 'skipped_v3_keys'];
if (!armored || typeof(armored) !== 'string'){
return Promise.reject(gpgme_error('PARAM_WRONG'));
}
let me = this;
return new Promise(function(resolve, reject){
let msg = createMessage('import');
msg.setParameter('data', armored);
msg.post().then(function(response){
let infos = {};
let fprs = [];
for (let res=0; res<response.result.imports.length; res++){
let result = response.result.imports[res];
let status = '';
if (result.status === 0){
status = 'nochange';
} else if ((result.status & 1) === 1){
status = 'newkey';
} else {
status = 'change';
}
let changes = {};
changes.userId = (result.status & 2) === 2;
changes.signature = (result.status & 4) === 4;
changes.subkey = (result.status & 8) === 8;
//16 new secret key: not implemented
fprs.push(result.fingerprint);
infos[result.fingerprint] = {
changes: changes,
status: status
};
}
let resultset = [];
if (prepare_sync === true){
me.getKeys(fprs, true).then(function(result){
for (let i=0; i < result.length; i++) {
resultset.push({
key: result[i],
changes:
infos[result[i].fingerprint].changes,
status: infos[result[i].fingerprint].status
});
}
let summary = {};
for (let i=0; i < feedbackValues.length; i++ ){
summary[feedbackValues[i]] =
response[feedbackValues[i]];
}
resolve({
Keys:resultset,
summary: summary
});
}, function(error){
reject(error);
});
} else {
for (let i=0; i < fprs.length; i++) {
resultset.push({ resultset.push({
key: result[i], key: createKey(fprs[i]),
changes: infos[result[i].fingerprint].changes, changes: infos[fprs[i]].changes,
status: infos[result[i].fingerprint].status status: infos[fprs[i]].status
}); });
} }
let summary = {}; resolve(resultset);
for (let i=0; i < feedbackValues.length; i++ ){
summary[feedbackValues[i]] =
response[feedbackValues[i]];
}
resolve({
Keys:resultset,
summary: summary
});
}, function(error){
reject(error);
});
} else {
for (let i=0; i < fprs.length; i++) {
resultset.push({
key: createKey(fprs[i]),
changes: infos[fprs[i]].changes,
status: infos[fprs[i]].status
});
} }
resolve(resultset);
}
}, function(error){ }, function(error){
reject(error); reject(error);
});
}); });
}); };
/**
}; * Convenience function for deleting a Key. See {@link Key.delete} for
* further information about the return values.
/** * @param {String} fingerprint
* Convenience function for deleting a Key. See {@link Key.delete} for * @returns {Promise<Boolean|GPGME_Error>}
* further information about the return values. * @async
* @param {String} fingerprint * @static
* @returns {Promise<Boolean|GPGME_Error>} */
* @async this.deleteKey = function(fingerprint){
* @static if (isFingerprint(fingerprint) === true) {
*/ let key = createKey(fingerprint);
this.deleteKey = function(fingerprint){ return key.delete();
if (isFingerprint(fingerprint) === true) { } else {
let key = createKey(fingerprint); return Promise.reject(gpgme_error('KEY_INVALID'));
return key.delete();
} else {
return Promise.reject(gpgme_error('KEY_INVALID'));
}
};
/**
* Generates a new Key pair directly in gpg, and returns a GPGME_Key
* representing that Key. Please note that due to security concerns, secret
* Keys can not be deleted or exported from inside gpgme.js.
*
* @param {String} userId The user Id, e.g. 'Foo Bar <foo@bar.baz>'
* @param {String} algo (optional) algorithm (and optionally key size) to
* be used. See {@link supportedKeyAlgos} below for supported values.
* @param {Date} expires (optional) Expiration date. If not set, expiration
* will be set to 'never'
*
* @return {Promise<Key|GPGME_Error>}
* @async
*/
this.generateKey = function (userId, algo = 'default', expires){
if (
typeof(userId) !== 'string' ||
supportedKeyAlgos.indexOf(algo) < 0 ||
(expires && !(expires instanceof Date))
){
return Promise.reject(gpgme_error('PARAM_WRONG'));
}
let me = this;
return new Promise(function(resolve, reject){
let msg = createMessage('createkey');
msg.setParameter('userid', userId);
msg.setParameter('algo', algo );
if (expires){
msg.setParameter('expires',
Math.floor(expires.valueOf()/1000));
} }
msg.post().then(function(response){ };
me.getKeys(response.fingerprint, true).then(
// TODO make prepare_sync (second parameter) optional here. /**
function(result){ * Generates a new Key pair directly in gpg, and returns a GPGME_Key
resolve(result); * representing that Key. Please note that due to security concerns,
}, function(error){ * secret Keys can not be deleted or exported from inside gpgme.js.
reject(error); *
}); * @param {String} userId The user Id, e.g. 'Foo Bar <foo@bar.baz>'
}, function(error) { * @param {String} algo (optional) algorithm (and optionally key size)
reject(error); * to be used. See {@link supportedKeyAlgos} below for supported
* values.
* @param {Date} expires (optional) Expiration date. If not set,
* expiration will be set to 'never'
*
* @return {Promise<Key|GPGME_Error>}
* @async
*/
this.generateKey = function (userId, algo = 'default', expires){
if (
typeof(userId) !== 'string' ||
supportedKeyAlgos.indexOf(algo) < 0 ||
(expires && !(expires instanceof Date))
){
return Promise.reject(gpgme_error('PARAM_WRONG'));
}
let me = this;
return new Promise(function(resolve, reject){
let msg = createMessage('createkey');
msg.setParameter('userid', userId);
msg.setParameter('algo', algo );
if (expires){
msg.setParameter('expires',
Math.floor(expires.valueOf()/1000));
}
msg.post().then(function(response){
me.getKeys(response.fingerprint, true).then(
// TODO prepare_sync?
function(result){
resolve(result);
}, function(error){
reject(error);
});
}, function(error) {
reject(error);
});
}); });
}); };
}; }
}
} }
/** /**

305
lang/js/src/Message.js
View File

@ -61,162 +61,162 @@ export class GPGME_Message {
return _msg.op; return _msg.op;
}; };
/** /**
* The maximum size of responses from gpgme in bytes. As of July 2018, * The maximum size of responses from gpgme in bytes. As of July 2018,
* most browsers will only accept answers up to 1 MB of size. Everything * most browsers will only accept answers up to 1 MB of size.
* above that threshold will not pass through nativeMessaging; answers that * Everything above that threshold will not pass through
* are larger need to be sent in parts. The lower limit is set to 10 KB. * nativeMessaging; answers that are larger need to be sent in parts.
* Messages smaller than the threshold will not encounter problems, larger * The lower limit is set to 10 KB. Messages smaller than the threshold
* messages will be received in chunks. * will not encounter problems, larger messages will be received in
* If the value is not explicitly specified, 1023 KB is used. * chunks. If the value is not explicitly specified, 1023 KB is used.
*/ */
this.setChunksize = function (value){ this.setChunksize = function (value){
if ( if (
Number.isInteger(value) && Number.isInteger(value) &&
value > 10 * 1024 && value > 10 * 1024 &&
value <= 1024 * 1024 value <= 1024 * 1024
){ ){
_msg.chunksize = value; _msg.chunksize = value;
}
};
this.getMsg = function(){
return _msg;
};
this.getChunksize= function() {
return _msg.chunksize;
};
/**
* Sets a parameter for the message. It validates with
* {@link permittedOperations}
* @param {String} param Parameter to set
* @param {any} value Value to set
* @returns {Boolean} If the parameter was set successfully
*/
this.setParameter = function ( param,value ){
if (!param || typeof(param) !== 'string'){
return gpgme_error('PARAM_WRONG');
}
let po = permittedOperations[_msg.op];
if (!po){
return gpgme_error('MSG_WRONG_OP');
}
let poparam = null;
if (po.required.hasOwnProperty(param)){
poparam = po.required[param];
} else if (po.optional.hasOwnProperty(param)){
poparam = po.optional[param];
} else {
return gpgme_error('PARAM_WRONG');
}
// check incoming value for correctness
let checktype = function(val){
switch(typeof(val)){
case 'string':
if (poparam.allowed.indexOf(typeof(val)) >= 0
&& val.length > 0) {
return true;
}
return gpgme_error('PARAM_WRONG');
case 'number':
if (
poparam.allowed.indexOf('number') >= 0
&& isNaN(value) === false){
return true;
}
return gpgme_error('PARAM_WRONG');
case 'boolean':
if (poparam.allowed.indexOf('boolean') >= 0){
return true;
}
return gpgme_error('PARAM_WRONG');
case 'object':
if (Array.isArray(val)){
if (poparam.array_allowed !== true){
return gpgme_error('PARAM_WRONG');
}
for (let i=0; i < val.length; i++){
let res = checktype(val[i]);
if (res !== true){
return res;
}
}
if (val.length > 0) {
return true;
}
} else if (val instanceof Uint8Array){
if (poparam.allowed.indexOf('Uint8Array') >= 0){
return true;
}
return gpgme_error('PARAM_WRONG');
} else {
return gpgme_error('PARAM_WRONG');
}
break;
default:
return gpgme_error('PARAM_WRONG');
} }
}; };
let typechecked = checktype(value);
if (typechecked !== true){ this.getMsg = function(){
return typechecked; return _msg;
} };
if (poparam.hasOwnProperty('allowed_data')){
if (poparam.allowed_data.indexOf(value) < 0){ this.getChunksize= function() {
return _msg.chunksize;
};
/**
* Sets a parameter for the message. It validates with
* {@link permittedOperations}
* @param {String} param Parameter to set
* @param {any} value Value to set
* @returns {Boolean} If the parameter was set successfully
*/
this.setParameter = function ( param,value ){
if (!param || typeof(param) !== 'string'){
return gpgme_error('PARAM_WRONG'); return gpgme_error('PARAM_WRONG');
} }
} let po = permittedOperations[_msg.op];
_msg[param] = value; if (!po){
return true; return gpgme_error('MSG_WRONG_OP');
}; }
let poparam = null;
if (po.required.hasOwnProperty(param)){
poparam = po.required[param];
} else if (po.optional.hasOwnProperty(param)){
poparam = po.optional[param];
} else {
return gpgme_error('PARAM_WRONG');
}
// check incoming value for correctness
let checktype = function(val){
switch(typeof(val)){
case 'string':
if (poparam.allowed.indexOf(typeof(val)) >= 0
&& val.length > 0) {
return true;
}
return gpgme_error('PARAM_WRONG');
case 'number':
if (
poparam.allowed.indexOf('number') >= 0
&& isNaN(value) === false){
return true;
}
return gpgme_error('PARAM_WRONG');
case 'boolean':
if (poparam.allowed.indexOf('boolean') >= 0){
return true;
}
return gpgme_error('PARAM_WRONG');
case 'object':
if (Array.isArray(val)){
if (poparam.array_allowed !== true){
return gpgme_error('PARAM_WRONG');
}
for (let i=0; i < val.length; i++){
let res = checktype(val[i]);
if (res !== true){
return res;
}
}
if (val.length > 0) {
return true;
}
} else if (val instanceof Uint8Array){
if (poparam.allowed.indexOf('Uint8Array') >= 0){
return true;
}
return gpgme_error('PARAM_WRONG');
} else {
return gpgme_error('PARAM_WRONG');
}
break;
default:
return gpgme_error('PARAM_WRONG');
}
};
let typechecked = checktype(value);
if (typechecked !== true){
return typechecked;
}
if (poparam.hasOwnProperty('allowed_data')){
if (poparam.allowed_data.indexOf(value) < 0){
return gpgme_error('PARAM_WRONG');
}
}
_msg[param] = value;
return true;
};
/** /**
* Check if the message has the minimum requirements to be sent, that is * Check if the message has the minimum requirements to be sent, that is
* all 'required' parameters according to {@link permittedOperations}. * all 'required' parameters according to {@link permittedOperations}.
* @returns {Boolean} true if message is complete. * @returns {Boolean} true if message is complete.
*/ */
this.isComplete = function(){ this.isComplete = function(){
if (!_msg.op){ if (!_msg.op){
return false;
}
let reqParams = Object.keys(
permittedOperations[_msg.op].required);
let msg_params = Object.keys(_msg);
for (let i=0; i < reqParams.length; i++){
if (msg_params.indexOf(reqParams[i]) < 0){
return false; return false;
} }
} let reqParams = Object.keys(
return true; permittedOperations[_msg.op].required);
}; let msg_params = Object.keys(_msg);
/** for (let i=0; i < reqParams.length; i++){
* Sends the Message via nativeMessaging and resolves with the answer. if (msg_params.indexOf(reqParams[i]) < 0){
* @returns {Promise<Object|GPGME_Error>} return false;
* @async }
*/ }
this.post = function(){ return true;
let me = this; };
return new Promise(function(resolve, reject) { /**
if (me.isComplete() === true) { * Sends the Message via nativeMessaging and resolves with the answer.
* @returns {Promise<Object|GPGME_Error>}
* @async
*/
this.post = function(){
let me = this;
return new Promise(function(resolve, reject) {
if (me.isComplete() === true) {
let conn = new Connection; let conn = new Connection;
conn.post(me).then(function(response) { conn.post(me).then(function(response) {
resolve(response); resolve(response);
}, function(reason) { }, function(reason) {
reject(reason); reject(reason);
}); });
} }
else { else {
reject(gpgme_error('MSG_INCOMPLETE')); reject(gpgme_error('MSG_INCOMPLETE'));
} }
}); });
}; };
} }
/** /**
* Returns the prepared message with parameters and completeness checked * Returns the prepared message with parameters and completeness checked
@ -231,11 +231,10 @@ export class GPGME_Message {
return null; return null;
} }
} }
get operation(){
get operation(){ return this.getOperation();
return this.getOperation(); }
} get chunksize(){
get chunksize(){ return this.getChunksize();
return this.getChunksize(); }
}
} }

116
lang/js/src/Signature.js
View File

@ -84,65 +84,65 @@ class GPGME_Signature {
constructor(sigObject){ constructor(sigObject){
let _rawSigObject = sigObject; let _rawSigObject = sigObject;
this.getFingerprint = function(){ this.getFingerprint = function(){
if (!_rawSigObject.fingerprint){ if (!_rawSigObject.fingerprint){
return gpgme_error('SIG_WRONG'); return gpgme_error('SIG_WRONG');
} else { } else {
return _rawSigObject.fingerprint; return _rawSigObject.fingerprint;
}
};
/**
* The expiration of this Signature as Javascript date, or null if
* signature does not expire
* @returns {Date | null}
*/
this.getExpiration = function(){
if (!_rawSigObject.exp_timestamp){
return null;
}
return new Date(_rawSigObject.exp_timestamp* 1000);
};
/**
* The creation date of this Signature in Javascript Date
* @returns {Date}
*/
this.getTimestamp= function (){
return new Date(_rawSigObject.timestamp * 1000);
};
/**
* The overall validity of the key. If false, errorDetails may contain
* additional information
*/
this.getValid= function() {
if (_rawSigObject.summary.valid === true){
return true;
} else {
return false;
}
};
/**
* gives more information on non-valid signatures. Refer to the gpgme docs
* https://www.gnupg.org/documentation/manuals/gpgme/Verify.html for
* details on the values
* @returns {Object} Object with boolean properties
*/
this.getErrorDetails = function (){
let properties = ['revoked', 'key-expired', 'sig-expired',
'key-missing', 'crl-missing', 'crl-too-old', 'bad-policy',
'sys-error'];
let result = {};
for (let i=0; i< properties.length; i++){
if ( _rawSigObject.hasOwnProperty(properties[i]) ){
result[properties[i]] = _rawSigObject[properties[i]];
} }
} };
return result;
}; /**
} * The expiration of this Signature as Javascript date, or null if
* signature does not expire
* @returns {Date | null}
*/
this.getExpiration = function(){
if (!_rawSigObject.exp_timestamp){
return null;
}
return new Date(_rawSigObject.exp_timestamp* 1000);
};
/**
* The creation date of this Signature in Javascript Date
* @returns {Date}
*/
this.getTimestamp= function (){
return new Date(_rawSigObject.timestamp * 1000);
};
/**
* The overall validity of the key. If false, errorDetails may contain
* additional information.
*/
this.getValid= function() {
if (_rawSigObject.summary.valid === true){
return true;
} else {
return false;
}
};
/**
* gives more information on non-valid signatures. Refer to the gpgme
* docs https://www.gnupg.org/documentation/manuals/gpgme/Verify.html
* for details on the values.
* @returns {Object} Object with boolean properties
*/
this.getErrorDetails = function (){
let properties = ['revoked', 'key-expired', 'sig-expired',
'key-missing', 'crl-missing', 'crl-too-old', 'bad-policy',
'sys-error'];
let result = {};
for (let i=0; i< properties.length; i++){
if ( _rawSigObject.hasOwnProperty(properties[i]) ){
result[properties[i]] = _rawSigObject[properties[i]];
}
}
return result;
};
}
/** /**
* Convenience getter for {@link getFingerprint} * Convenience getter for {@link getFingerprint}

387
lang/js/src/gpgmejs.js
View File

@ -107,204 +107,207 @@ export class GpgME {
return _Keyring; return _Keyring;
}; };
/** /**
* Encrypt (and optionally sign) data * Encrypt (and optionally sign) data
* @param {String|Object} data text/data to be encrypted as String. Also * @param {String|Object} data text/data to be encrypted as String. Also
* accepts Objects with a getText method * accepts Objects with a getText method
* @param {inputKeys} publicKeys * @param {inputKeys} publicKeys
* Keys used to encrypt the message * Keys used to encrypt the message
* @param {inputKeys} secretKeys (optional) Keys used to sign the message. * @param {inputKeys} secretKeys (optional) Keys used to sign the
* If Keys are present, the operation requested is assumed to be 'encrypt * message. If Keys are present, the operation requested is assumed
* and sign' * to be 'encrypt and sign'
* @param {Boolean} base64 (optional) The data will be interpreted as * @param {Boolean} base64 (optional) The data will be interpreted as
* base64 encoded data. * base64 encoded data.
* @param {Boolean} armor (optional) Request the output as armored block. * @param {Boolean} armor (optional) Request the output as armored
* @param {Boolean} wildcard (optional) If true, recipient information will * block.
* not be added to the message. * @param {Boolean} wildcard (optional) If true, recipient information
* @param {Object} additional use additional valid gpg options as defined * will not be added to the message.
* in {@link permittedOperations} * @param {Object} additional use additional valid gpg options as
* @returns {Promise<encrypt_result>} Object containing the encrypted * defined in {@link permittedOperations}
* message and additional info. * @returns {Promise<encrypt_result>} Object containing the encrypted
* @async * message and additional info.
*/ * @async
this.encrypt = function (data, publicKeys, secretKeys, base64=false, */
armor=true, wildcard=false, additional = {} this.encrypt = function (data, publicKeys, secretKeys, base64=false,
){ armor=true, wildcard=false, additional = {}
let msg = createMessage('encrypt'); ){
if (msg instanceof Error){ let msg = createMessage('encrypt');
return Promise.reject(msg); if (msg instanceof Error){
} return Promise.reject(msg);
msg.setParameter('armor', armor);
msg.setParameter('always-trust', true);
if (base64 === true) {
msg.setParameter('base64', true);
}
let pubkeys = toKeyIdArray(publicKeys);
msg.setParameter('keys', pubkeys);
let sigkeys = toKeyIdArray(secretKeys);
if (sigkeys.length > 0) {
msg.setParameter('signing_keys', sigkeys);
}
putData(msg, data);
if (wildcard === true){
msg.setParameter('throw-keyids', true);
}
if (additional){
let additional_Keys = Object.keys(additional);
for (let k = 0; k < additional_Keys.length; k++) {
msg.setParameter(additional_Keys[k],
additional[additional_Keys[k]]);
} }
} msg.setParameter('armor', armor);
if (msg.isComplete() === true){ msg.setParameter('always-trust', true);
return msg.post(); if (base64 === true) {
} else { msg.setParameter('base64', true);
return Promise.reject(gpgme_error('MSG_INCOMPLETE'));
}
};
/**
* Decrypts a Message
* @param {String|Object} data text/data to be decrypted. Accepts Strings
* and Objects with a getText method
* @param {Boolean} base64 (optional) false if the data is an armored block,
* true if it is base64 encoded binary data
* @returns {Promise<decrypt_result>} Decrypted Message and information
* @async
*/
this.decrypt = function (data, base64=false){
if (data === undefined){
return Promise.reject(gpgme_error('MSG_EMPTY'));
}
let msg = createMessage('decrypt');
if (msg instanceof Error){
return Promise.reject(msg);
}
if (base64 === true){
msg.setParameter('base64', true);
}
putData(msg, data);
if (base64 === true){
msg.setParameter('base64', true);
}
return new Promise(function(resolve, reject){
msg.post().then(function(result){
let _result = {data: result.data};
_result.base64 = result.base64 ? true: false;
_result.is_mime = result.mime ? true: false;
if (result.file_name){
_result.file_name = result.file_name;
}
if (
result.hasOwnProperty('signatures') &&
Array.isArray(result.signatures)
) {
_result.signatures = collectSignatures(result.signatures);
}
resolve(_result);
}, function(error){
reject(error);
});
});
};
/**
* Sign a Message
* @param {String|Object} data text/data to be signed. Accepts Strings
* and Objects with a getText method.
* @param {inputKeys} keys The key/keys to use for signing
* @param {String} mode The signing mode. Currently supported:
* 'clearsign':The Message is embedded into the signature;
* 'detached': The signature is stored separately
* @param {Boolean} base64 input is considered base64
* @returns {Promise<signResult>}
* @async
*/
this.sign = function (data, keys, mode='clearsign', base64=false) {
if (data === undefined){
return Promise.reject(gpgme_error('MSG_EMPTY'));
}
let key_arr = toKeyIdArray(keys);
if (key_arr.length === 0){
return Promise.reject(gpgme_error('MSG_NO_KEYS'));
}
let msg = createMessage('sign');
msg.setParameter('keys', key_arr);
if (base64 === true){
msg.setParameter('base64', true);
}
msg.setParameter('mode', mode);
putData(msg, data);
return new Promise(function(resolve,reject) {
if (mode ==='detached'){
msg.expect= 'base64';
} }
msg.post().then( function(message) { let pubkeys = toKeyIdArray(publicKeys);
if (mode === 'clearsign'){ msg.setParameter('keys', pubkeys);
resolve({ let sigkeys = toKeyIdArray(secretKeys);
data: message.data} if (sigkeys.length > 0) {
); msg.setParameter('signing_keys', sigkeys);
} else if (mode === 'detached') { }
resolve({ putData(msg, data);
data: data, if (wildcard === true){
signature: message.data msg.setParameter('throw-keyids', true);
}); }
if (additional){
let additional_Keys = Object.keys(additional);
for (let k = 0; k < additional_Keys.length; k++) {
msg.setParameter(additional_Keys[k],
additional[additional_Keys[k]]);
} }
}, function(error){ }
reject(error); if (msg.isComplete() === true){
}); return msg.post();
});
};
/**
* Verifies data.
* @param {String|Object} data text/data to be verified. Accepts Strings
* and Objects with a getText method
* @param {String} (optional) A detached signature. If not present, opaque
* mode is assumed
* @param {Boolean} (optional) Data and signature are base64 encoded
* @returns {Promise<verifyResult>}
*@async
*/
this.verify= function (data, signature, base64 = false){
let msg = createMessage('verify');
let dt = putData(msg, data);
if (dt instanceof Error){
return Promise.reject(dt);
}
if (signature){
if (typeof(signature)!== 'string'){
return Promise.reject(gpgme_error('PARAM_WRONG'));
} else { } else {
msg.setParameter('signature', signature); return Promise.reject(gpgme_error('MSG_INCOMPLETE'));
} }
} };
if (base64 === true){
msg.setParameter('base64', true);
}
return new Promise(function(resolve, reject){
msg.post().then(function (message){
if (!message.info || !message.info.signatures){
reject(gpgme_error('SIG_NO_SIGS'));
} else {
let _result = collectSignatures(message.info.signatures);
_result.is_mime = message.info.is_mime? true: false;
if (message.info.filename){
_result.file_name = message.info.filename;
}
_result.data = message.data;
resolve(_result);
}
}, function(error){
reject(error);
});
});
};
}
/** /**
* Decrypts a Message
* @param {String|Object} data text/data to be decrypted. Accepts
* Strings and Objects with a getText method
* @param {Boolean} base64 (optional) false if the data is an armored
* block, true if it is base64 encoded binary data
* @returns {Promise<decrypt_result>} Decrypted Message and information
* @async
*/
this.decrypt = function (data, base64=false){
if (data === undefined){
return Promise.reject(gpgme_error('MSG_EMPTY'));
}
let msg = createMessage('decrypt');
if (msg instanceof Error){
return Promise.reject(msg);
}
if (base64 === true){
msg.setParameter('base64', true);
}
putData(msg, data);
if (base64 === true){
msg.setParameter('base64', true);
}
return new Promise(function(resolve, reject){
msg.post().then(function(result){
let _result = {data: result.data};
_result.base64 = result.base64 ? true: false;
_result.is_mime = result.mime ? true: false;
if (result.file_name){
_result.file_name = result.file_name;
}
if (
result.hasOwnProperty('signatures') &&
Array.isArray(result.signatures)
) {
_result.signatures = collectSignatures(
result.signatures);
}
resolve(_result);
}, function(error){
reject(error);
});
});
};
/**
* Sign a Message
* @param {String|Object} data text/data to be signed. Accepts Strings
* and Objects with a getText method.
* @param {inputKeys} keys The key/keys to use for signing
* @param {String} mode The signing mode. Currently supported:
* 'clearsign':The Message is embedded into the signature;
* 'detached': The signature is stored separately
* @param {Boolean} base64 input is considered base64
* @returns {Promise<signResult>}
* @async
*/
this.sign = function (data, keys, mode='clearsign', base64=false) {
if (data === undefined){
return Promise.reject(gpgme_error('MSG_EMPTY'));
}
let key_arr = toKeyIdArray(keys);
if (key_arr.length === 0){
return Promise.reject(gpgme_error('MSG_NO_KEYS'));
}
let msg = createMessage('sign');
msg.setParameter('keys', key_arr);
if (base64 === true){
msg.setParameter('base64', true);
}
msg.setParameter('mode', mode);
putData(msg, data);
return new Promise(function(resolve,reject) {
if (mode ==='detached'){
msg.expect= 'base64';
}
msg.post().then( function(message) {
if (mode === 'clearsign'){
resolve({
data: message.data}
);
} else if (mode === 'detached') {
resolve({
data: data,
signature: message.data
});
}
}, function(error){
reject(error);
});
});
};
/**
* Verifies data.
* @param {String|Object} data text/data to be verified. Accepts Strings
* and Objects with a getText method
* @param {String} (optional) A detached signature. If not present,
* opaque mode is assumed
* @param {Boolean} (optional) Data and signature are base64 encoded
* @returns {Promise<verifyResult>}
*@async
*/
this.verify= function (data, signature, base64 = false){
let msg = createMessage('verify');
let dt = putData(msg, data);
if (dt instanceof Error){
return Promise.reject(dt);
}
if (signature){
if (typeof(signature)!== 'string'){
return Promise.reject(gpgme_error('PARAM_WRONG'));
} else {
msg.setParameter('signature', signature);
}
}
if (base64 === true){
msg.setParameter('base64', true);
}
return new Promise(function(resolve, reject){
msg.post().then(function (message){
if (!message.info || !message.info.signatures){
reject(gpgme_error('SIG_NO_SIGS'));
} else {
let _result = collectSignatures(
message.info.signatures);
_result.is_mime = message.info.is_mime? true: false;
if (message.info.filename){
_result.file_name = message.info.filename;
}
_result.data = message.data;
resolve(_result);
}
}, function(error){
reject(error);
});
});
};
}
/**
* setter for {@link setKeyring}. * setter for {@link setKeyring}.
* @param {GPGME_Keyring} keyring A Keyring to use * @param {GPGME_Keyring} keyring A Keyring to use
*/ */
@ -332,7 +335,7 @@ export class GpgME {
* @private * @private
*/ */
function putData(message, data){ function putData(message, data){
if (!message || !message instanceof GPGME_Message) { if (!message || !(message instanceof GPGME_Message)) {
return gpgme_error('PARAM_WRONG'); return gpgme_error('PARAM_WRONG');
} }
if (!data){ if (!data){