} (if in async
* mode)
*
* Returns the value of the property requested. If the Key is set to async,
* the value will be fetched from gnupg and resolved as a Promise. If Key
* is not async, the armored property is not available (it can still be
* retrieved asynchronously by [getArmor]{@link GPGME_Key#getArmor})
*/
get (property) {
if (this._async === true) {
switch (property){
case 'armored':
return this.getArmor();
case 'hasSecret':
return this.getGnupgSecretState();
default:
return getGnupgState(this.fingerprint, property);
}
} else {
if (property === 'armored') {
throw gpgme_error('KEY_ASYNC_ONLY');
}
// eslint-disable-next-line no-use-before-define
if (!validKeyProperties.hasOwnProperty(property)){
throw gpgme_error('PARAM_WRONG');
} else {
return (this._data[property]);
}
}
}
/**
* Reloads the Key information from gnupg. This is only useful if the Key
* 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 [Keyring.getKeys]{@link Keyring#getKeys} instead.
* @returns {Promise}
* @async
*/
refreshKey () {
let me = this;
return new Promise(function (resolve, reject) {
if (!me._data.fingerprint){
reject(gpgme_error('KEY_INVALID'));
}
let msg = createMessage('keylist');
msg.setParameter('sigs', true);
msg.setParameter('keys', me._data.fingerprint);
msg.post().then(function (result){
if (result.keys.length === 1){
const newdata = validateKeyData(
me._data.fingerprint, result.keys[0]);
if (newdata instanceof Error){
reject(gpgme_error('KEY_INVALID'));
} else {
me._data = newdata;
me.getGnupgSecretState().then(function (){
me.getArmor().then(function (){
resolve(me);
}, function (error){
reject(error);
});
}, function (error){
reject(error);
});
}
} else {
reject(gpgme_error('KEY_NOKEY'));
}
}, function (error) {
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}
* @async
*/
getArmor () {
const me = this;
return new Promise(function (resolve, reject) {
if (!me._data.fingerprint){
reject(gpgme_error('KEY_INVALID'));
}
let msg = createMessage('export');
msg.setParameter('armor', true);
msg.setParameter('keys', me._data.fingerprint);
msg.post().then(function (result){
resolve(result.data);
}, function (error){
reject(error);
});
});
}
/**
* Find out if the Key is part of a Key pair including public and
* private key(s). If you want this information about more than a few
* Keys in synchronous mode, it may be advisable to run
* [Keyring.getKeys]{@link Keyring#getKeys} instead, as it performs faster
* in bulk querying.
* @returns {Promise} True if a private Key is available in the
* gnupg Keyring.
* @async
*/
getGnupgSecretState (){
const me = this;
return new Promise(function (resolve, reject) {
if (!me._data.fingerprint){
reject(gpgme_error('KEY_INVALID'));
} else {
let msg = createMessage('keylist');
msg.setParameter('keys', me._data.fingerprint);
msg.setParameter('secret', true);
msg.post().then(function (result){
me._data.hasSecret = null;
if (
result.keys &&
result.keys.length === 1 &&
result.keys[0].secret === true
) {
me._data.hasSecret = true;
resolve(true);
} else {
me._data.hasSecret = false;
resolve(false);
}
}, function (error){
reject(error);
});
}
});
}
/**
* Deletes the (public) Key from the GPG Keyring. Note that a deletion
* of a secret key is not supported by the native backend, and gnupg will
* refuse to delete a Key if there is still a secret/private Key present
* to that public Key
* @returns {Promise} Success if key was deleted.
*/
delete (){
const me = this;
return new Promise(function (resolve, reject){
if (!me._data.fingerprint){
reject(gpgme_error('KEY_INVALID'));
}
let msg = createMessage('delete');
msg.setParameter('key', me._data.fingerprint);
msg.post().then(function (result){
resolve(result.success);
}, function (error){
reject(error);
});
});
}
/**
* @returns {String} The fingerprint defining this Key. Convenience getter
*/
get fingerprint (){
return this._data.fingerprint;
}
}
/**
* Representing a subkey of a Key. See {@link validSubKeyProperties} for
* possible properties.
* @class
* @protected
*/
class GPGME_Subkey {
/**
* Initializes with the json data sent by gpgme-json
* @param {Object} data
* @private
*/
constructor (data){
this._data = {};
let keys = Object.keys(data);
const me = this;
/**
* Validates a subkey property against {@link validSubKeyProperties} and
* sets it if validation is successful
* @param {String} property
* @param {*} value
* @param private
*/
const setProperty = function (property, value){
// eslint-disable-next-line no-use-before-define
if (validSubKeyProperties.hasOwnProperty(property)){
// eslint-disable-next-line no-use-before-define
if (validSubKeyProperties[property](value) === true) {
if (property === 'timestamp' || property === 'expires'){
me._data[property] = new Date(value * 1000);
} else {
me._data[property] = value;
}
}
}
};
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}
*/
get (property) {
if (this._data.hasOwnProperty(property)){
return (this._data[property]);
}
}
}
/**
* Representing user attributes associated with a Key or subkey. See
* {@link validUserIdProperties} for possible properties.
* @class
* @protected
*/
class GPGME_UserId {
/**
* Initializes with the json data sent by gpgme-json
* @param {Object} data
* @private
*/
constructor (data){
this._data = {};
const me = this;
let keys = Object.keys(data);
const setProperty = function (property, value){
// eslint-disable-next-line no-use-before-define
if (validUserIdProperties.hasOwnProperty(property)){
// eslint-disable-next-line no-use-before-define
if (validUserIdProperties[property](value) === true) {
if (property === 'last_update'){
me._data[property] = new Date(value*1000);
} else {
me._data[property] = value;
}
}
}
};
for (let i=0; i< keys.length; i++) {
setProperty(keys[i], data[keys[i]]);
}
}
/**
* Fetches information about the user
* @param {String} property Information to request
* @returns {String | Number}
*/
get (property) {
if (this._data.hasOwnProperty(property)){
return (this._data[property]);
}
}
}
/**
* Validation definition for userIds. Each valid userId property is represented
* as a key- Value pair, with their value being a validation function to check
* against
* @protected
* @const
*/
const validUserIdProperties = {
'revoked': function (value){
return typeof (value) === 'boolean';
},
'invalid': function (value){
return typeof (value) === 'boolean';
},
'uid': function (value){
if (typeof (value) === 'string' || value === ''){
return true;
}
return false;
},
'validity': function (value){
if (typeof (value) === 'string'){
return true;
}
return false;
},
'name': function (value){
if (typeof (value) === 'string' || value === ''){
return true;
}
return false;
},
'email': function (value){
if (typeof (value) === 'string' || value === ''){
return true;
}
return false;
},
'address': function (value){
if (typeof (value) === 'string' || value === ''){
return true;
}
return false;
},
'comment': function (value){
if (typeof (value) === 'string' || value === ''){
return true;
}
return false;
},
'origin': function (value){
return Number.isInteger(value);
},
'last_update': function (value){
return Number.isInteger(value);
}
};
/**
* Validation definition for subKeys. Each valid userId property is represented
* as a key-value pair, with the value being a validation function
* @protected
* @const
*/
const validSubKeyProperties = {
'invalid': function (value){
return typeof (value) === 'boolean';
},
'can_encrypt': function (value){
return typeof (value) === 'boolean';
},
'can_sign': function (value){
return typeof (value) === 'boolean';
},
'can_certify': function (value){
return typeof (value) === 'boolean';
},
'can_authenticate': function (value){
return typeof (value) === 'boolean';
},
'secret': function (value){
return typeof (value) === 'boolean';
},
'is_qualified': function (value){
return typeof (value) === 'boolean';
},
'is_cardkey': function (value){
return typeof (value) === 'boolean';
},
'is_de_vs': function (value){
return typeof (value) === 'boolean';
},
'pubkey_algo_name': function (value){
return typeof (value) === 'string';
// TODO: check against list of known?['']
},
'pubkey_algo_string': function (value){
return typeof (value) === 'string';
// TODO: check against list of known?['']
},
'keyid': function (value){
return isLongId(value);
},
'pubkey_algo': function (value) {
return (Number.isInteger(value) && value >= 0);
},
'length': function (value){
return (Number.isInteger(value) && value > 0);
},
'timestamp': function (value){
return (Number.isInteger(value) && value > 0);
},
'expires': function (value){
return (Number.isInteger(value) && value > 0);
}
};
/**
* Validation definition for Keys. Each valid Key property is represented
* as a key-value pair, with their value being a validation function. For
* details on the meanings, please refer to the gpgme documentation
* https://www.gnupg.org/documentation/manuals/gpgme/Key-objects.html#Key-objects
* @param {String} fingerprint
* @param {Boolean} revoked
* @param {Boolean} expired
* @param {Boolean} disabled
* @param {Boolean} invalid
* @param {Boolean} can_encrypt
* @param {Boolean} can_sign
* @param {Boolean} can_certify
* @param {Boolean} can_authenticate
* @param {Boolean} secret
* @param {Boolean}is_qualified
* @param {String} protocol
* @param {String} issuer_serial
* @param {String} issuer_name
* @param {Boolean} chain_id
* @param {String} owner_trust
* @param {Date} last_update
* @param {String} origin
* @param {Array} subkeys
* @param {Array} userids
* @param {Array} tofu
* @param {Boolean} hasSecret
* @protected
* @const
*/
const validKeyProperties = {
'fingerprint': function (value){
return isFingerprint(value);
},
'revoked': function (value){
return typeof (value) === 'boolean';
},
'expired': function (value){
return typeof (value) === 'boolean';
},
'disabled': function (value){
return typeof (value) === 'boolean';
},
'invalid': function (value){
return typeof (value) === 'boolean';
},
'can_encrypt': function (value){
return typeof (value) === 'boolean';
},
'can_sign': function (value){
return typeof (value) === 'boolean';
},
'can_certify': function (value){
return typeof (value) === 'boolean';
},
'can_authenticate': function (value){
return typeof (value) === 'boolean';
},
'secret': function (value){
return typeof (value) === 'boolean';
},
'is_qualified': function (value){
return typeof (value) === 'boolean';
},
'protocol': function (value){
return typeof (value) === 'string';
// TODO check for implemented ones
},
'issuer_serial': function (value){
return typeof (value) === 'string';
},
'issuer_name': function (value){
return typeof (value) === 'string';
},
'chain_id': function (value){
return typeof (value) === 'string';
},
'owner_trust': function (value){
return typeof (value) === 'string';
},
'last_update': function (value){
return (Number.isInteger(value));
// TODO undefined/null possible?
},
'origin': function (value){
return (Number.isInteger(value));
},
'subkeys': function (value){
return (Array.isArray(value));
},
'userids': function (value){
return (Array.isArray(value));
},
'tofu': function (value){
return (Array.isArray(value));
},
'hasSecret': function (value){
return typeof (value) === 'boolean';
}
};
/**
* sets the Key data in bulk. It can only be used from inside a Key, either
* during construction or on a refresh callback.
* @param {Object} key the original internal key data.
* @param {Object} data Bulk set the data for this key, with an Object structure
* as sent by gpgme-json.
* @returns {Object|GPGME_Error} the changed data after values have been set,
* an error if something went wrong.
* @private
*/
function validateKeyData (fingerprint, data){
const key = {};
if (!fingerprint || typeof (data) !== 'object' || !data.fingerprint
|| fingerprint !== data.fingerprint.toUpperCase()
){
return gpgme_error('KEY_INVALID');
}
let props = Object.keys(data);
for (let i=0; i< props.length; i++){
if (!validKeyProperties.hasOwnProperty(props[i])){
return gpgme_error('KEY_INVALID');
}
// running the defined validation function
if (validKeyProperties[props[i]](data[props[i]]) !== true ){
return gpgme_error('KEY_INVALID');
}
switch (props[i]){
case 'subkeys':
key.subkeys = [];
for (let i=0; i< data.subkeys.length; i++) {
key.subkeys.push(
new GPGME_Subkey(data.subkeys[i]));
}
break;
case 'userids':
key.userids = [];
for (let i=0; i< data.userids.length; i++) {
key.userids.push(
new GPGME_UserId(data.userids[i]));
}
break;
case 'last_update':
key[props[i]] = new Date( data[props[i]] * 1000 );
break;
default:
key[props[i]] = data[props[i]];
}
}
return key;
}
/**
* Fetches and sets properties from gnupg
* @param {String} fingerprint
* @param {String} property to search for.
* @private
* @async
*/
function getGnupgState (fingerprint, property){
return new Promise(function (resolve, reject) {
if (!isFingerprint(fingerprint)) {
reject(gpgme_error('KEY_INVALID'));
} else {
let msg = createMessage('keylist');
msg.setParameter('keys', fingerprint);
msg.post().then(function (res){
if (!res.keys || res.keys.length !== 1){
reject(gpgme_error('KEY_INVALID'));
} else {
const key = res.keys[0];
let result;
switch (property){
case 'subkeys':
result = [];
if (key.subkeys.length){
for (let i=0; i < key.subkeys.length; i++) {
result.push(
new GPGME_Subkey(key.subkeys[i]));
}
}
resolve(result);
break;
case 'userids':
result = [];
if (key.userids.length){
for (let i=0; i< key.userids.length; i++) {
result.push(
new GPGME_UserId(key.userids[i]));
}
}
resolve(result);
break;
case 'last_update':
if (key.last_update === undefined){
reject(gpgme_error('CONN_UNEXPECTED_ANSWER'));
} else if (key.last_update !== null){
resolve(new Date( key.last_update * 1000));
} else {
resolve(null);
}
break;
default:
if (!validKeyProperties.hasOwnProperty(property)){
reject(gpgme_error('PARAM_WRONG'));
} else {
if (key.hasOwnProperty(property)){
resolve(key[property]);
} else {
reject(gpgme_error(
'CONN_UNEXPECTED_ANSWER'));
}
}
break;
}
}
}, function (error){
reject(gpgme_error(error));
});
}
});
-}
\ No newline at end of file
+}
diff --git a/lang/js/src/Keyring.js b/lang/js/src/Keyring.js
index 850f9f18..9f313577 100644
--- a/lang/js/src/Keyring.js
+++ b/lang/js/src/Keyring.js
@@ -1,439 +1,439 @@
/* gpgme.js - Javascript integration for gpgme
* Copyright (C) 2018 Bundesamt für Sicherheit in der Informationstechnik
*
* This file is part of GPGME.
*
* GPGME is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* GPGME is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this program; if not, see .
* SPDX-License-Identifier: LGPL-2.1+
*
* Author(s):
* Maximilian Krambach
*/
import { createMessage } from './Message';
import { createKey } from './Key';
import { isFingerprint } from './Helpers';
import { gpgme_error } from './Errors';
/**
* This class offers access to the gnupg keyring
*/
export class GPGME_Keyring {
/**
* Queries Keys (all Keys or a subset) from gnupg.
*
* @param {Object} options:
* @param {String | Array} options.pattern (optional) A pattern to
* search for in userIds or KeyIds.
* @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} options.search (optional) retrieve Keys from external
* servers with the method(s) defined in gnupg (e.g. WKD/HKP lookup)
* @returns {Promise}
* @static
* @async
*/
getKeys ({ pattern, prepare_sync = false, search = false } = {}){
if (typeof arguments[0] !== 'object') {
return Promise.reject(gpgme_error('PARAM_WRONG'));
}
if (arguments.length && typeof arguments[0] !== 'object') {
return Promise.reject(gpgme_error('PARAM_WRONG'));
}
return new Promise(function (resolve, reject) {
let msg = createMessage('keylist');
if (pattern) {
msg.setParameter('keys', pattern);
}
msg.setParameter('sigs', true);
if (search === true){
msg.setParameter('locate', true);
}
msg.post().then(function (result){
let resultset = [];
if (result.keys.length === 0){
resolve([]);
} else {
let secondrequest;
if (prepare_sync === true) {
secondrequest = function () {
let msg2 = createMessage('keylist');
if (pattern){
msg2.setParameter('keys', pattern);
}
msg2.setParameter('secret', true);
return msg2.post();
};
} else {
secondrequest = function () {
return Promise.resolve(true);
};
}
secondrequest().then(function (answer) {
for (let i=0; i < result.keys.length; i++){
if (prepare_sync === true){
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){
b.hasSecret = true;
} else {
b.hasSecret = false;
}
break;
}
}
}
}
let k = createKey(result.keys[i].fingerprint,
!prepare_sync, 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} 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 {Object} options (optional)
* @param {String|Array} options.pattern The Pattern to
* search for
* @param {Boolean} options.with_secret_fpr also return a list of
* fingerprints for the keys that have a secret key available
* @returns {Promise} Object containing the
* armored Key(s) and additional information.
* @static
* @async
*/
getKeysArmored ({ 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){
msg.setParameter('keys', pattern);
}
msg.post().then(function (answer){
const result = { armored: answer.data };
if (with_secret_fpr === true){
if (answer.hasOwnProperty('sec-fprs')){
result.secret_fprs = answer['sec-fprs'];
} else {
result.secret_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}
* @async
* @static
*/
getDefaultKey (prepare_sync = false) {
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 (resp){
if (resp.option !== undefined
&& resp.option.hasOwnProperty('value')
&& resp.option.value.length === 1
&& resp.option.value[0].hasOwnProperty('string')
&& typeof (resp.option.value[0].string) === 'string'){
me.getKeys({ pattern: resp.option.value[0].string,
prepare_sync: true }).then(
function (keys){
if (keys.length === 1){
resolve(keys[0]);
} else {
reject(gpgme_error('KEY_NO_DEFAULT'));
}
}, function (error){
reject(error);
});
} else {
let msg = createMessage('keylist');
msg.setParameter('secret', true);
msg.post().then(function (result){
if (result.keys.length === 0){
reject(gpgme_error('KEY_NO_DEFAULT'));
} else {
for (let i=0; i< result.keys.length; i++ ) {
if (
result.keys[i].invalid === false &&
result.keys[i].expired === false &&
result.keys[i].revoked === false &&
result.keys[i].can_sign === true
) {
let k = createKey(
result.keys[i].fingerprint,
!prepare_sync,
result.keys[i]);
resolve(k);
break;
} else if (i === result.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} 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} A summary and Keys considered.
* @async
* @static
*/
importKey (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 = [];
let summary = {};
for (let i=0; i < feedbackValues.length; i++ ){
summary[feedbackValues[i]] =
response.result[feedbackValues[i]];
}
if (!response.result.hasOwnProperty('imports') ||
response.result.imports.length === 0
){
resolve({ Keys:[],summary: summary });
return;
}
for (let res=0; res}
* @async
* @static
*/
deleteKey (fingerprint){
if (isFingerprint(fingerprint) === true) {
let key = createKey(fingerprint);
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 {Object} options
* @param {String} option.userId The user Id, e.g. 'Foo Bar '
* @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.
+ * values. If omitted, 'default' is used.
* @param {Number} option.expires (optional) Expiration time in seconds
* from now. If not set or set to 0, expiration will be 'never'
*
* @return {Promise}
* @async
*/
generateKey ({ userId, algo = 'default', expires= 0 } = {}){
if (typeof userId !== 'string'
// eslint-disable-next-line no-use-before-define
|| (algo && supportedKeyAlgos.indexOf(algo) < 0 )
|| (!Number.isInteger(expires) || expires < 0 )
){
return Promise.reject(gpgme_error('PARAM_WRONG'));
}
// eslint-disable-next-line no-use-before-define
let me = this;
return new Promise(function (resolve, reject){
let msg = createMessage('createkey');
msg.setParameter('userid', userId);
msg.setParameter('algo', algo);
msg.setParameter('expires', expires);
msg.post().then(function (response){
me.getKeys({
pattern: response.fingerprint,
prepare_sync: true
}).then(function (result){
resolve(result);
}, function (error){
reject(error);
});
}, function (error) {
reject(error);
});
});
}
}
/**
* List of algorithms supported for key generation. Please refer to the gnupg
* documentation for details
*/
const supportedKeyAlgos = [
'default', 'future-default',
'rsa', 'rsa2048', 'rsa3072', 'rsa4096',
'dsa', 'dsa2048', 'dsa3072', 'dsa4096',
'elg', 'elg2048', 'elg3072', 'elg4096',
'ed25519',
'cv25519',
'brainpoolP256r1', 'brainpoolP384r1', 'brainpoolP512r1',
'NIST P-256', 'NIST P-384', 'NIST P-521'
];
diff --git a/lang/python/doc/meta/old-commits.log b/lang/python/doc/meta/old-commits.log
index 93661e35..eb870cda 100644
--- a/lang/python/doc/meta/old-commits.log
+++ b/lang/python/doc/meta/old-commits.log
@@ -1,2445 +1,2445 @@
commit 2145348ec54c6027f2ea20f695de0277e2871405
Merge: 348ba88 2036f1a
Author: Ben McGinnes
Date: Wed May 6 03:04:19 2015 +1000
Merge pull request #4 from Hasimir/master
history
commit 2036f1a0a670a0561993e195c458059220b36114
Merge: dbabf0c 348ba88
Author: Ben McGinnes
Date: Wed May 6 02:57:44 2015 +1000
Merge branch 'master' of github:adversary-org/pyme3
commit dbabf0cf1f2985755c2293b619011832e34faa9c
Author: Ben McGinnes
Date: Wed May 6 02:52:23 2015 +1000
Added a short history
* A (very) brief summary of the project's history since 2002.
* Deals with why the commit log in the GPGME repo does not include the
history of PyME.
* Mentions that intact git repos will be maintained, but not where they
are (one will be on github, another will be in a user directory on
playfair.gnupg.org).
docs/Short_History.rst | 57 ++++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 57 insertions(+)
commit 348ba883424778c711c04ae9b66035ccdb36eb8c
Merge: 127d0a5 7c37a27
Author: Ben McGinnes
Date: Wed May 6 02:21:34 2015 +1000
Merge pull request #3 from Hasimir/master
Version release preparation
commit 7c37a27a6845c58222d4d947c2efbe38e955b612
Merge: f692cff 127d0a5
Author: Ben McGinnes
Date: Wed May 6 02:17:14 2015 +1000
Merge branch 'master' of github:adversary-org/pyme3
commit f692cff50a89c2c61acdbd3d7dd60f5ce3cd15af
Author: Ben McGinnes
Date: Wed May 6 02:09:44 2015 +1000
TODO update
* Removed reference to GitHub, replaced with impending new home at gnupg.org.
docs/TODO.rst | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
commit bd5ccf9e3bfe69fa681613757577e87b72ca08ec
Author: Ben McGinnes
Date: Wed May 6 02:00:44 2015 +1000
Version bump
* Bumped version number to 0.9.1 to keep it somewhat in line with the
existing PyME project, even though there will be some divergence at
some point (or even re-merging, depending on how many of the Python 3
modifications can be back-ported to the Python 2 version).
* Updated the author and copyright information to reflect the two
current authors (Martin and I).
* Replaced Igor's contact details with mine.
* Replaced project home page with the GnuPG one.
pyme/version.py | 16 +++++++++-------
1 file changed, 9 insertions(+), 7 deletions(-)
commit ec167512f4ca88d8f6e89e2ae831798c8283b4df
Author: Ben McGinnes
Date: Wed May 6 01:48:01 2015 +1000
README preparation.
* Changes in preparation for impending move of code to the GnuPG git
server as a part of GPGME.
README.rst | 14 +++++++-------
1 file changed, 7 insertions(+), 7 deletions(-)
commit 8a48515e884c36b5bdb24a13cb4d2e49f4ee6f17
Author: Ben McGinnes
Date: Wed May 6 01:43:53 2015 +1000
TODO moved to docs
* As it says.
TODO.rst | 25 -------------------------
docs/TODO.rst | 25 +++++++++++++++++++++++++
2 files changed, 25 insertions(+), 25 deletions(-)
commit f968c777472f01f308f6e57eac1740bf5c76c205
Author: Ben McGinnes
Date: Sun May 3 16:52:13 2015 +1000
Started another TODO file.
TODO.rst | 25 +++++++++++++++++++++++++
1 file changed, 25 insertions(+)
commit 127d0a56fa9f7ad1d4fb39d0b529b890a8d67365
Merge: db72dea 44837f6
Author: Ben McGinnes
Date: Sun May 3 14:59:44 2015 +1000
Merge pull request #2 from Hasimir/master
Minor editing.
commit 44837f6e50fc539c86aef1f75a6a3538b02029ea
Author: Ben McGinnes
Date: Sun May 3 14:56:55 2015 +1000
Minor editing.
* Fixed another URL.
* Changed Py3 version's version number to v0.9.1-beta0.
README.rst | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
commit db72deaae19c3513391df040bcaf66a88d9213af
Merge: db34286 48eb185
Author: Ben McGinnes
Date: Sun May 3 14:26:11 2015 +1000
Merge pull request #1 from Hasimir/master
Links
commit 48eb1856cb0739cc9f0b9084da9d965e1fc7fddd
Author: Ben McGinnes
Date: Sun May 3 14:22:30 2015 +1000
Links
* Fixed URLs for authors.
* Updated my entry to point to github location.
** I strongly suspect the result of this work will be concurrent
projects, so preparing for that eventuality with this repo.
README.rst | 8 ++++----
1 file changed, 4 insertions(+), 4 deletions(-)
commit db3428659783f30b9a76204403daedf9fc4cf7cf
Author: Ben McGinnes
Date: Sun May 3 11:29:00 2015 +1000
Explicit over Implicit ...
... isn't just for code.
* Removed the 2to3 working directory and its contents.
* Made the README.rst file a little more clear that this branch is for
Python 3 (set Python 3.2 as a fairly arbitrary requirement for the
moment, but will probably raise this to 3.3).
2to3/2to3-output-remaining.log | 60 ---
2to3/2to3-output-setup.log | 35 --
2to3/2to3-output.log | 950 -----------------------------------------
README.rst | 10 +-
4 files changed, 7 insertions(+), 1048 deletions(-)
commit 3edf07a4ba8a86af3a33246234d6e133074862af
Author: Ben McGinnes
Date: Sun May 3 11:19:41 2015 +1000
Added authors.
* In alphabetical order.
* Mine will need updating once Martin and I have decided what to do
regarding the two main branches.
README.rst | 12 ++++++++++++
1 file changed, 12 insertions(+)
commit 811eb14b53e8856312d99f46b77215f7f9bd672c
Author: Ben McGinnes
Date: Sun May 3 10:23:00 2015 +1000
Docs and other things.
* Now able to import pyme.core without error, indicates port process is
successful.
* Code is *not* compatible with the Python 2 version.
* Will need to consider making this a parallel project with the master
branch.
* Got rid of the .org TODO file.
* Changed the README to use the reST file extension since it's full of
reST anyway.
2to3/TODO.org | 5 -----
README.rst | 32 ++++++++++++++++++++++++++++++++
README.txt | 32 --------------------------------
3 files changed, 32 insertions(+), 37 deletions(-)
commit 79e784bdcce1de6f7856921b5431044c62c6f015
Author: Ben McGinnes
Date: Sun May 3 10:18:40 2015 +1000
Fixed another implicit import by making it explicit. Hopefully this is the last one.
pyme/util.py | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
commit 2b52b46ccda3e7abcc50eed0745062259d698661
Author: Ben McGinnes
Date: Sun May 3 10:16:01 2015 +1000
Fixed another implicit import by making it explicit.
pyme/errors.py | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
commit 409c8fd565e21f23cd41daaeffc867e6d23a0863
Author: Ben McGinnes
Date: Sun May 3 10:08:22 2015 +1000
Bytes vs. Unicode
* Trying PyBytes instead of PyUnicode.
gpgme.i | 14 +++++++-------
helpers.c | 8 ++++----
2 files changed, 11 insertions(+), 11 deletions(-)
commit d8164aa2ae98bf8c807c16e2d9be12c5fbea7cfd
Author: Ben McGinnes
Date: Sun May 3 09:22:58 2015 +1000
String to Unicode
* Replaced all instances of PyString with PyUnicode (and hoping there's
no byte data in there).
gpgme.i | 14 +++++++-------
helpers.c | 8 ++++----
2 files changed, 11 insertions(+), 11 deletions(-)
commit bd99b7865656e559b17c419c6b64b412a22c6c44
Author: Ben McGinnes
Date: Sun May 3 09:17:06 2015 +1000
PyInt_AsLong
* Replaced all instances of PyInt with PyLong, as per C API docs.
gpgme.i | 4 ++--
helpers.c | 8 ++++----
2 files changed, 6 insertions(+), 6 deletions(-)
commit 3c91e2ccf8ca788b51e3308e292c6b64888fdb15
Author: Ben McGinnes
Date: Sun May 3 05:59:36 2015 +1000
Import correction
* Once pygpgme.py is generated and moved, it will be in the right
directory for the explicit "from . import pygpgme" to be correct.
pyme/core.py | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
commit 23a49e7070812ff1ce138d8d4cc46d0b80328897
Author: Ben McGinnes