diff options
Diffstat (limited to 'lang/js/src')
| -rw-r--r-- | lang/js/src/Keyring.js | 143 | ||||
| -rw-r--r-- | lang/js/src/gpgmejs.js | 147 |
2 files changed, 172 insertions, 118 deletions
diff --git a/lang/js/src/Keyring.js b/lang/js/src/Keyring.js index cb053ba1..d6ba1d6f 100644 --- a/lang/js/src/Keyring.js +++ b/lang/js/src/Keyring.js @@ -35,27 +35,38 @@ export class GPGME_Keyring { /** * Queries Keys (all Keys or a subset) from gnupg. * - * @param {String | Array<String>} pattern (optional) A pattern to + * @param {Object} options + * @param {String | Array<String>} options.pattern (optional) A pattern to * search for in userIds or KeyIds. - * @param {Boolean} prepare_sync (optional) if set to true, most data - * (with the exception of armored Key blocks) will be cached for the + * @param {Boolean} options.prepare_sync (optional) if set to true, most + * data (with the exception of armored Key blocks) will be cached for the * Keys. This enables direct, synchronous use of these properties for * all keys. It does not check for changes on the backend. The cached * information can be updated with the {@link Key.refresh} method. - * @param {Boolean} search (optional) retrieve Keys from external + * @param {Boolean} options.search (optional) retrieve Keys from external * servers with the method(s) defined in gnupg (e.g. WKD/HKP lookup) * @returns {Promise<Array<GPGME_Key>>} * @static * @async */ - getKeys (pattern, prepare_sync=false, search=false){ + getKeys (options){ + if (options && typeof options !== 'object'){ + return Promise.reject(gpgme_error('PARAM_WRONG')); + } return new Promise(function (resolve, reject) { let msg = createMessage('keylist'); - if (pattern !== undefined && pattern !== null){ - msg.setParameter('keys', pattern); + if (options && options.pattern) { + if ( + typeof options.pattern === 'string' + || Array.isArray(options.pattern) + ){ + msg.setParameter('keys', options.pattern); + } else { + reject(gpgme_error('PARAM_WRONG')); + } } msg.setParameter('sigs', true); - if (search === true){ + if (options && options.search === true){ msg.setParameter('locate', true); } msg.post().then(function (result){ @@ -64,11 +75,11 @@ export class GPGME_Keyring { resolve([]); } else { let secondrequest; - if (prepare_sync === true) { + if (options && options.prepare_sync === true) { secondrequest = function () { let msg2 = createMessage('keylist'); - if (pattern){ - msg2.setParameter('keys', pattern); + if (options.pattern){ + msg2.setParameter('keys', options.pattern); } msg2.setParameter('secret', true); return msg2.post(); @@ -80,7 +91,7 @@ export class GPGME_Keyring { } secondrequest().then(function (answer) { for (let i=0; i < result.keys.length; i++){ - if (prepare_sync === true){ + if (options.prepare_sync === true){ if (answer && answer.keys) { for (let j=0; j < answer.keys.length; j++ ){ @@ -100,7 +111,7 @@ export class GPGME_Keyring { } } let k = createKey(result.keys[i].fingerprint, - !prepare_sync, result.keys[i]); + !options.prepare_sync, result.keys[i]); resultset.push(k); } resolve(resultset); @@ -126,31 +137,42 @@ export class GPGME_Keyring { /** * 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 + * @param {Object} options (optional) + * @param {String|Array<String>} options.pattern The Pattern to * search for - * @param {Boolean} with_secret_fpr (optional) also return a list of + * @param {Boolean} options.with_secret_fpr 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 */ - getKeysArmored (pattern, with_secret_fpr) { + getKeysArmored (options) { + if (options && typeof options !== 'object'){ + return Promise.reject(gpgme_error('PARAM_WRONG')); + } return new Promise(function (resolve, reject) { let msg = createMessage('export'); msg.setParameter('armor', true); - if (with_secret_fpr === true) { + if (options.with_secret_fpr === true) { msg.setParameter('with-sec-fprs', true); } - if (pattern !== undefined && pattern !== null){ - msg.setParameter('keys', pattern); + if (options.pattern){ + if ( + typeof options.pattern === 'string' + || Array.isArray(options.pattern) + ){ + msg.setParameter('keys', options.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']; + if (options.with_secret_fpr === true){ + if (answer.hasOwnProperty('sec-fprs')){ + result.secret_fprs = answer['sec-fprs']; + } else { + result.secret_fprs = []; + } } resolve(result); }, function (error){ @@ -300,7 +322,6 @@ export class GPGME_Keyring { 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, @@ -309,19 +330,20 @@ export class GPGME_Keyring { } 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 - }); - } - resolve({ Keys:resultset,summary: summary }); - }, function (error){ - reject(error); - }); + me.getKeys({ pattern: fprs, prepare_sync: 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 + }); + } + resolve({ Keys:resultset,summary: summary }); + }, function (error){ + reject(error); + }); } else { for (let i=0; i < fprs.length; i++) { resultset.push({ @@ -364,42 +386,49 @@ export class GPGME_Keyring { * 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 <[email protected]>' - * @param {String} algo (optional) algorithm (and optionally key size) - * to be used. See {@link supportedKeyAlgos} below for supported + * @param {Object} options + * @param {String} option.userId The user Id, e.g. 'Foo Bar <[email protected]>' + * @param {String} option.algo (optional) algorithm (and optionally key + * size) to be used. See {@link supportedKeyAlgos} below for supported * values. If ommitted, 'default' is used. - * @param {Number} expires (optional) Expiration time in seconds from now. - * If not set or set to 0, expiration will be 'never' - * @param {String} subkey_algo (optional) algorithm of the encryption - * subkey. If ommited the same as algo is used. + * @param {Number} option.expires (optional) Expiration time in seconds + * from now. If not set or set to 0, expiration will be 'never' + * @param {String} options.subkey_algo (optional) algorithm of the + * encryption subkey. If ommited the same as algo is used. * * @return {Promise<Key|GPGME_Error>} * @async */ - generateKey (userId, algo = 'default', expires, subkey_algo){ - if ( - typeof (userId) !== 'string' || + generateKey (options){ + if (!options + || typeof options !== 'object' + || typeof options.userId !== 'string' // eslint-disable-next-line no-use-before-define - supportedKeyAlgos.indexOf(algo) < 0 || - (expires && !( Number.isInteger(expires) || expires < 0 )) + || ( options.algo && supportedKeyAlgos.indexOf(options.algo) < 0 ) + || ( options.expires && !( + Number.isInteger(options.expires) || options.expires < 0 ) ) ){ return Promise.reject(gpgme_error('PARAM_WRONG')); } // eslint-disable-next-line no-use-before-define - if (subkey_algo && supportedKeyAlgos.indexOf(subkey_algo) < 0 ){ + if (options.subkey_algo && supportedKeyAlgos.indexOf( + options.subkey_algo) < 0 + ){ 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 (subkey_algo) { - msg.setParameter('subkey-algo', subkey_algo ); + msg.setParameter('userid', options.userId); + if (!options.algo){ + options.algo === 'default'; + } + msg.setParameter('algo', options.algo); + if (options.subkey_algo) { + msg.setParameter('subkey-algo', options.subkey_algo ); } - if (expires){ - msg.setParameter('expires', expires); + if (options.expires){ + msg.setParameter('expires', options.expires); } else { msg.setParameter('expires', 0); } diff --git a/lang/js/src/gpgmejs.js b/lang/js/src/gpgmejs.js index 513e4a56..e0398423 100644 --- a/lang/js/src/gpgmejs.js +++ b/lang/js/src/gpgmejs.js @@ -110,52 +110,63 @@ export class GpgME { /** * Encrypt (and optionally sign) data - * @param {String|Object} data text/data to be encrypted as String. Also - * accepts Objects with a getText method - * @param {inputKeys} publicKeys + * @param {Object} options + * @param {String|Object} options.data text/data to be encrypted as String. + * Also accepts Objects with a getText method + * @param {inputKeys} options.publicKeys * Keys used to encrypt the message - * @param {inputKeys} secretKeys (optional) Keys used to sign the + * @param {inputKeys} opions.secretKeys (optional) Keys used to sign the * message. If Keys are present, the operation requested is assumed * to be 'encrypt and sign' - * @param {Boolean} base64 (optional) The data will be interpreted as - * base64 encoded data. - * @param {Boolean} armor (optional) Request the output as armored + * @param {Boolean} options.base64 (optional) The data will be interpreted + * as base64 encoded data. + * @param {Boolean} options.armor (optional) Request the output as armored * block. - * @param {Boolean} wildcard (optional) If true, recipient information - * will not be added to the message. + * @param {Boolean} options.wildcard (optional) If true, recipient + * information will not be added to the message. * @param {Object} additional use additional valid gpg options as * defined in {@link permittedOperations} * @returns {Promise<encrypt_result>} Object containing the encrypted * message and additional info. * @async */ - encrypt (data, publicKeys, secretKeys, base64=false, armor=true, - wildcard=false, additional = {}){ + encrypt (options){ + if (!options || (typeof options !== 'object')){ + return Promise.reject(gpgme_error('PARAM_WRONG')); + } + if (!options.hasOwnProperty('data') + || !options.hasOwnProperty('publicKeys') + ){ + return Promise.reject(gpgme_error('MSG_INCOMPLETE')); + } let msg = createMessage('encrypt'); if (msg instanceof Error){ return Promise.reject(msg); } - msg.setParameter('armor', armor); - msg.setParameter('always-trust', true); - if (base64 === true) { + if (!options.hasOwnProperty('armor')){ + options.armor = true; + } + msg.setParameter('armor', options.armor); + + if (options.base64 === true) { msg.setParameter('base64', true); } - let pubkeys = toKeyIdArray(publicKeys); + let pubkeys = toKeyIdArray(options.publicKeys); msg.setParameter('keys', pubkeys); - let sigkeys = toKeyIdArray(secretKeys); + let sigkeys = toKeyIdArray(options.secretKeys); if (sigkeys.length > 0) { msg.setParameter('signing_keys', sigkeys); } - putData(msg, data); - if (wildcard === true){ + putData(msg, options.data); + if (options.wildcard === true){ msg.setParameter('throw-keyids', true); } - if (additional){ - let additional_Keys = Object.keys(additional); + if (options.additional){ + let additional_Keys = Object.keys(options.additional); for (let k = 0; k < additional_Keys.length; k++) { try { msg.setParameter(additional_Keys[k], - additional[additional_Keys[k]]); + options.additional[additional_Keys[k]]); } catch (error){ return Promise.reject(error); @@ -171,17 +182,21 @@ export class GpgME { /** * Decrypts a Message - * @param {String|Object} data text/data to be decrypted. Accepts + * @param {Object} options + * @param {String|Object} options.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 - * @param {Boolean} binary (optional) if true, treat the decoded data as - * binary, and return the data as Uint8Array + * @param {Boolean} options.base64 (optional) false if the data is an + * armored block, true if it is base64 encoded binary data + * @param {Boolean} options.binary (optional) if true, treat the decoded + * data as binary, and return the data as Uint8Array * @returns {Promise<decrypt_result>} Decrypted Message and information * @async */ - decrypt (data, base64=false, binary){ - if (data === undefined){ + decrypt (options){ + if (!options || (typeof options !== 'object')){ + return Promise.reject('PARAM_WRONG'); + } + if (!options.data){ return Promise.reject(gpgme_error('MSG_EMPTY')); } let msg = createMessage('decrypt'); @@ -189,13 +204,13 @@ export class GpgME { if (msg instanceof Error){ return Promise.reject(msg); } - if (base64 === true){ + if (options.base64 === true){ msg.setParameter('base64', true); } - if (binary === true){ + if (options.binary === true){ msg.expected = 'binary'; } - putData(msg, data); + putData(msg, options.data); return new Promise(function (resolve, reject){ msg.post().then(function (result){ let _result = { data: result.data }; @@ -229,44 +244,49 @@ export class GpgME { /** * 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: + * @param {Object} options Signing options + * @param {String|Object} options.data text/data to be signed. Accepts + * Strings and Objects with a getText method. + * @param {inputKeys} options.keys The key/keys to use for signing + * @param {String} options.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 + * @param {Boolean} options.base64 input is considered base64 * @returns {Promise<signResult>} * @async */ - sign (data, keys, mode='clearsign', base64=false) { - if (data === undefined){ + sign (options){ + if ( + !options || (typeof options !== 'object')){ + return Promise.reject(gpgme_error('PARAM_WRONG')); + } + if (!options.data){ return Promise.reject(gpgme_error('MSG_EMPTY')); } - let key_arr = toKeyIdArray(keys); + if (!options.mode) { + options.mode = 'clearsign'; + } + let key_arr = toKeyIdArray(options.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){ + if (options.base64 === true){ msg.setParameter('base64', true); } - msg.setParameter('mode', mode); - putData(msg, data); + msg.setParameter('mode', options.mode); + putData(msg, options.data); return new Promise(function (resolve,reject) { - if (mode ==='detached'){ - msg.expected ='binary'; - } msg.post().then( function (message) { - if (mode === 'clearsign'){ + if (options.mode === 'clearsign'){ resolve({ data: message.data } ); - } else if (mode === 'detached') { + } else if (options.mode === 'detached') { resolve({ - data: data, + data: options.data, signature: message.data }); } @@ -278,28 +298,33 @@ export class GpgME { /** * 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, + * @param {Object} options + * @param {String|Object} options.data text/data to be verified. Accepts + * Strings and Objects with a getText method + * @param {String} options.signature A detached signature. If not present, * opaque mode is assumed - * @param {Boolean} (optional) Data and signature are base64 encoded + * @param {Boolean} options.base64 Indicating that data and signature are + * base64 encoded * @returns {Promise<verifyResult>} *@async */ - verify (data, signature, base64 = false){ + verify (options){ + if (!options || (typeof options !== 'object') || !options.data){ + return Promise.reject(gpgme_error('PARAM_WRONG')); + } let msg = createMessage('verify'); - let dt = putData(msg, data); + let dt = putData(msg, options.data); if (dt instanceof Error){ return Promise.reject(dt); } - if (signature){ - if (typeof (signature)!== 'string'){ + if (options.signature){ + if (typeof signature !== 'string'){ return Promise.reject(gpgme_error('PARAM_WRONG')); } else { msg.setParameter('signature', signature); } } - if (base64 === true){ + if (options.base64 === true){ msg.setParameter('base64', true); } return new Promise(function (resolve, reject){ @@ -342,14 +367,14 @@ function putData (message, data){ } if (!data){ return gpgme_error('PARAM_WRONG'); - } else if (typeof (data) === 'string') { + } else if (typeof data === 'string') { message.setParameter('data', data); } else if ( - typeof (data) === 'object' && - typeof (data.getText) === 'function' + (typeof data === 'object') && + (typeof data.getText === 'function') ){ let txt = data.getText(); - if (typeof (txt) === 'string'){ + if (typeof txt === 'string'){ message.setParameter('data', txt); } else { return gpgme_error('PARAM_WRONG'); |