spelling: fix misspellings
[gpgme.git] / lang / js / src / Key.js
index ea6fd88..a3f5204 100644 (file)
  * 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 <http://www.gnu.org/licenses/>.
+ * License along with this program; if not, see <https://www.gnu.org/licenses/>.
  * SPDX-License-Identifier: LGPL-2.1+
  *
  * Author(s):
  *     Maximilian Krambach <mkrambach@intevation.de>
  */
 
+
 import { isFingerprint, isLongId } from './Helpers';
 import { gpgme_error } from './Errors';
 import { createMessage } from './Message';
@@ -33,221 +34,240 @@ import { createMessage } from './Message';
  * answers will be Promises, and the performance will likely suffer
  * @param {Object} data additional initial properties this Key will have. Needs
  * a full object as delivered by gpgme-json
- * @returns {Object|GPGME_Error} The verified and updated data
+ * @returns {Object} The verified and updated data
  */
-export function createKey(fingerprint, async = false, data){
-    if (!isFingerprint(fingerprint) || typeof(async) !== 'boolean'){
-        return gpgme_error('PARAM_WRONG');
+export function createKey (fingerprint, async = false, data){
+    if (!isFingerprint(fingerprint) || typeof (async) !== 'boolean'){
+        throw gpgme_error('PARAM_WRONG');
     }
     if (data !== undefined){
-        data = validateKeyData(data);
+        data = validateKeyData(fingerprint, data);
     }
     if (data instanceof Error){
-        return gpgme_error('KEY_INVALID');
+        throw gpgme_error('KEY_INVALID');
     } else {
-        return Object.freeze(new GPGME_Key(fingerprint, async, data));
+        return new GPGME_Key(fingerprint, async, data);
     }
 }
 
 /**
- * Represents the Keys as stored in the gnupg backend
- * It allows to query almost all information defined in gpgme Key Objects
- * Refer to {@link validKeyProperties} for available information, and the gpgme
- * documentation on their meaning
- * (https://www.gnupg.org/documentation/manuals/gpgme/Key-objects.html)
+ * Represents the Keys as stored in the gnupg backend. A key is defined by a
+ * fingerprint.
+ * A key cannot be directly created via the new operator, please use
+ * {@link createKey} instead.
+ * A GPGME_Key object allows to query almost all information defined in gpgme
+ * Keys. It offers two modes, async: true/false. In async mode, Key properties
+ * with the exception of the fingerprint will be queried from gnupg on each
+ * call, making the operation up-to-date, the answers will be Promises, and
+ * the performance will likely suffer. In Sync modes, all information except
+ * for the armored Key export will be cached and can be refreshed by
+ * [refreshKey]{@link GPGME_Key#refreshKey}.
+ *
+ * <pre>
+ * see also:
+ *      {@link GPGME_UserId} user Id objects
+ *      {@link GPGME_Subkey} subKey objects
+ * </pre>
+ * For other Key properteis, refer to {@link validKeyProperties},
+ * and to the [gpgme documentation]{@link https://www.gnupg.org/documentation/manuals/gpgme/Key-objects.html}
+ * for meanings and further details.
  *
  * @class
  */
 class GPGME_Key {
 
-    constructor(fingerprint, async, data){
+    constructor (fingerprint, async, data){
 
         /**
-         * @property {Boolean} If true, most answers will be asynchronous
+         * @property {Boolean} _async If true, the Key was initialized without
+         * cached data
          */
-        this.isAsync = async;
+        this._async = async;
 
-        let _data = {fingerprint: fingerprint.toUpperCase()};
+        this._data = { fingerprint: fingerprint.toUpperCase() };
         if (data !== undefined
-            && data.fingerprint.toUpperCase() === _data.fingerprint
+            && data.fingerprint.toUpperCase() === this._data.fingerprint
         ) {
-            _data = data;
+            this._data = data;
         }
-        this.getFingerprint = function(){
-            if (!_data.fingerprint || !isFingerprint(_data.fingerprint)){
-                return gpgme_error('KEY_INVALID');
-            }
-            return _data.fingerprint;
-        };
+    }
 
-        /**
-         * Query any property of the Key listed in {@link validKeyProperties}
-         * @param {String} property property to be retreived
-         * @returns {Boolean| String | Date | Array | Object |GPGME_Error}
-         * the value of the property. 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 {@link Key.getArmor})
-         */
-        this.get = function(property) {
-            if (this.isAsync === true) {
-                switch (property){
-                case 'armored':
-                    return this.getArmor();
-                case 'hasSecret':
-                    return this.getGnupgSecretState();
-                default:
-                    return getGnupgState(property);
-                }
+    /**
+     * Query any property of the Key listed in {@link validKeyProperties}
+     * @param {String} property property to be retrieved
+     * @returns {Boolean| String | Date | Array | Object}
+     * @returns {Promise<Boolean| String | Date | Array | Object>} (if in async
+     * mode)
+     * <pre>
+     * 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 {
-                if (property === 'armored') {
-                    return gpgme_error('KEY_ASYNC_ONLY');
-                }
-                if (!validKeyProperties.hasOwnProperty(property)){
-                    return gpgme_error('PARAM_WRONG');
-                } else {
-                    return (_data[property]);
-                }
+                return (this._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;
-            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){
-                        const newdata = validateKeyData(
-                            _data.fingerprint, result.keys[0]);
-                        if (newdata instanceof Error){
-                            reject(gpgme_error('KEY_INVALID'));
-                        } else {
-                            _data = newdata;
-                            me.getGnupgSecretState().then(function(){
-                                me.getArmor().then(function(){
-                                    resolve(me);
-                                }, function(error){
-                                    reject(error);
-                                });
-                            }, function(error){
+    /**
+     * 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<GPGME_Key>}
+     * @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);
                             });
-                        }
-                    } else {
-                        reject(gpgme_error('KEY_NOKEY'));
+                        }, function (error){
+                            reject(error);
+                        });
                     }
-                }, 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<String|GPGME_Error>}
-         * @async
-         */
-        this.getArmor = function(){
-            return new Promise(function(resolve, reject) {
-                if (!_data.fingerprint){
-                    reject(gpgme_error('KEY_INVALID'));
+                } else {
+                    reject(gpgme_error('KEY_NOKEY'));
                 }
-                let msg = createMessage('export');
-                msg.setParameter('armor', true);
-                msg.setParameter('keys', _data.fingerprint);
-                msg.post().then(function(result){
-                    resolve(result.data);
-                }, function(error){
-                    reject(error);
-                });
+            }, function (error) {
+                reject(gpgme_error('GNUPG_ERROR'), 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
-         * {@link Keyring.getKeys} instead, as it performs faster in bulk
-         * querying this state.
-         * @returns {Promise<Boolean|GPGME_Error>} True if a private Key is
-         * available in the gnupg Keyring.
-         * @async
-         */
-        this.getGnupgSecretState = function (){
-            return new Promise(function(resolve, reject) {
-                if (!_data.fingerprint){
-                    reject(gpgme_error('KEY_INVALID'));
-                } else {
-                    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){
-                        reject(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>}
+     * @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);
             });
-        };
+        });
+    }
 
-        /**
-         * Deletes the (public) Key from the GPG Keyring. Note that a deletion
-         * of a secret key is not supported by the native backend.
-         * @returns {Promise<Boolean|GPGME_Error>} Success if key was deleted,
-         * rejects with a GPG error otherwise.
-         */
-        this.delete= function (){
-            return new Promise(function(resolve, reject){
-                if (!_data.fingerprint){
-                    reject(gpgme_error('KEY_INVALID'));
-                }
-                let msg = createMessage('delete');
-                msg.setParameter('key', _data.fingerprint);
-                msg.post().then(function(result){
-                    resolve(result.success);
-                }, function(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<Boolean>} 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<Boolean>} 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.getFingerprint();
+    get fingerprint (){
+        return this._data.fingerprint;
     }
 }
 
 /**
- * Representing a subkey of a Key.
+ * Representing a subkey of a Key. See {@link validSubKeyProperties} for
+ * possible properties.
  * @class
  * @protected
  */
@@ -258,9 +278,10 @@ class GPGME_Subkey {
      * @param {Object} data
      * @private
      */
-    constructor(data){
-        let _data = {};
+    constructor (data){
+        this._data = {};
         let keys = Object.keys(data);
+        const me = this;
 
         /**
          * Validates a subkey property against {@link validSubKeyProperties} and
@@ -270,12 +291,14 @@ class GPGME_Subkey {
          * @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'){
-                        _data[property] = new Date(value * 1000);
+                        me._data[property] = new Date(value * 1000);
                     } else {
-                        _data[property] = value;
+                        me._data[property] = value;
                     }
                 }
             }
@@ -283,22 +306,24 @@ class GPGME_Subkey {
         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}
+     */
+    get (property) {
+        if (this._data.hasOwnProperty(property)){
+            return (this._data[property]);
+        }
     }
+
 }
 
 /**
- * Representing user attributes associated with a Key or subkey
+ * Representing user attributes associated with a Key or subkey. See
+ * {@link validUserIdProperties} for possible properties.
  * @class
  * @protected
  */
@@ -309,16 +334,19 @@ class GPGME_UserId {
      * @param {Object} data
      * @private
      */
-    constructor(data){
-        let _data = {};
+    constructor (data){
+        this._data = {};
+        const me = this;
         let keys = Object.keys(data);
-        const setProperty = function(property, value){
+        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'){
-                        _data[property] = new Date(value*1000);
+                        me._data[property] = new Date(value*1000);
                     } else {
-                        _data[property] = value;
+                        me._data[property] = value;
                     }
                 }
             }
@@ -326,18 +354,19 @@ class GPGME_UserId {
         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}
-         */
-        this.get = function (property) {
-            if (_data.hasOwnProperty(property)){
-                return (_data[property]);
-            }
-        };
+    /**
+     * 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]);
+        }
     }
+
 }
 
 /**
@@ -348,52 +377,52 @@ class GPGME_UserId {
  * @const
  */
 const validUserIdProperties = {
-    'revoked': function(value){
-        return typeof(value) === 'boolean';
+    'revoked': function (value){
+        return typeof (value) === 'boolean';
     },
-    'invalid':  function(value){
-        return typeof(value) === 'boolean';
+    'invalid':  function (value){
+        return typeof (value) === 'boolean';
     },
-    'uid': function(value){
-        if (typeof(value) === 'string' || value === ''){
+    'uid': function (value){
+        if (typeof (value) === 'string' || value === ''){
             return true;
         }
         return false;
     },
-    'validity': function(value){
-        if (typeof(value) === 'string'){
+    'validity': function (value){
+        if (typeof (value) === 'string'){
             return true;
         }
         return false;
     },
-    'name': function(value){
-        if (typeof(value) === 'string' || value === ''){
+    'name': function (value){
+        if (typeof (value) === 'string' || value === ''){
             return true;
         }
         return false;
     },
-    'email': function(value){
-        if (typeof(value) === 'string' || value === ''){
+    'email': function (value){
+        if (typeof (value) === 'string' || value === ''){
             return true;
         }
         return false;
     },
-    'address': function(value){
-        if (typeof(value) === 'string' || value === ''){
+    'address': function (value){
+        if (typeof (value) === 'string' || value === ''){
             return true;
         }
         return false;
     },
-    'comment': function(value){
-        if (typeof(value) === 'string' || value === ''){
+    'comment': function (value){
+        if (typeof (value) === 'string' || value === ''){
             return true;
         }
         return false;
     },
-    'origin':  function(value){
+    'origin':  function (value){
         return Number.isInteger(value);
     },
-    'last_update':  function(value){
+    'last_update':  function (value){
         return Number.isInteger(value);
     }
 };
@@ -405,54 +434,54 @@ const validUserIdProperties = {
  * @const
  */
 const validSubKeyProperties = {
-    'invalid': function(value){
-        return typeof(value) === 'boolean';
+    'invalid': function (value){
+        return typeof (value) === 'boolean';
     },
-    'can_encrypt': function(value){
-        return typeof(value) === 'boolean';
+    'can_encrypt': function (value){
+        return typeof (value) === 'boolean';
     },
-    'can_sign': function(value){
-        return typeof(value) === 'boolean';
+    'can_sign': function (value){
+        return typeof (value) === 'boolean';
     },
-    'can_certify':  function(value){
-        return typeof(value) === 'boolean';
+    'can_certify':  function (value){
+        return typeof (value) === 'boolean';
     },
-    'can_authenticate':  function(value){
-        return typeof(value) === 'boolean';
+    'can_authenticate':  function (value){
+        return typeof (value) === 'boolean';
     },
-    'secret': function(value){
-        return typeof(value) === 'boolean';
+    'secret': function (value){
+        return typeof (value) === 'boolean';
     },
-    'is_qualified': function(value){
-        return typeof(value) === 'boolean';
+    'is_qualified': function (value){
+        return typeof (value) === 'boolean';
     },
-    'is_cardkey':  function(value){
-        return typeof(value) === 'boolean';
+    'is_cardkey':  function (value){
+        return typeof (value) === 'boolean';
     },
-    'is_de_vs':  function(value){
-        return typeof(value) === 'boolean';
+    'is_de_vs':  function (value){
+        return typeof (value) === 'boolean';
     },
-    'pubkey_algo_name': function(value){
-        return typeof(value) === 'string';
+    'pubkey_algo_name': function (value){
+        return typeof (value) === 'string';
         // TODO: check against list of known?['']
     },
-    'pubkey_algo_string': function(value){
-        return typeof(value) === 'string';
+    'pubkey_algo_string': function (value){
+        return typeof (value) === 'string';
         // TODO: check against list of known?['']
     },
-    'keyid': function(value){
+    'keyid': function (value){
         return isLongId(value);
     },
-    'pubkey_algo': function(value) {
+    'pubkey_algo': function (value) {
         return (Number.isInteger(value) && value >= 0);
     },
-    'length': function(value){
+    'length': function (value){
         return (Number.isInteger(value) && value > 0);
     },
-    'timestamp': function(value){
+    'timestamp': function (value){
         return (Number.isInteger(value) && value > 0);
     },
-    'expires': function(value){
+    'expires': function (value){
         return (Number.isInteger(value) && value > 0);
     }
 };
@@ -488,73 +517,73 @@ const validSubKeyProperties = {
  * @const
  */
 const validKeyProperties = {
-    'fingerprint': function(value){
+    'fingerprint': function (value){
         return isFingerprint(value);
     },
-    'revoked': function(value){
-        return typeof(value) === 'boolean';
+    'revoked': function (value){
+        return typeof (value) === 'boolean';
     },
-    'expired': function(value){
-        return typeof(value) === 'boolean';
+    'expired': function (value){
+        return typeof (value) === 'boolean';
     },
-    'disabled': function(value){
-        return typeof(value) === 'boolean';
+    'disabled': function (value){
+        return typeof (value) === 'boolean';
     },
-    'invalid': function(value){
-        return typeof(value) === 'boolean';
+    'invalid': function (value){
+        return typeof (value) === 'boolean';
     },
-    'can_encrypt': function(value){
-        return typeof(value) === 'boolean';
+    'can_encrypt': function (value){
+        return typeof (value) === 'boolean';
     },
-    'can_sign': function(value){
-        return typeof(value) === 'boolean';
+    'can_sign': function (value){
+        return typeof (value) === 'boolean';
     },
-    'can_certify': function(value){
-        return typeof(value) === 'boolean';
+    'can_certify': function (value){
+        return typeof (value) === 'boolean';
     },
-    'can_authenticate': function(value){
-        return typeof(value) === 'boolean';
+    'can_authenticate': function (value){
+        return typeof (value) === 'boolean';
     },
-    'secret': function(value){
-        return typeof(value) === 'boolean';
+    'secret': function (value){
+        return typeof (value) === 'boolean';
     },
-    'is_qualified': 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
+    'protocol': function (value){
+        return typeof (value) === 'string';
+        // TODO check for implemented ones
     },
-    'issuer_serial': function(value){
-        return typeof(value) === 'string';
+    'issuer_serial': function (value){
+        return typeof (value) === 'string';
     },
-    'issuer_name': function(value){
-        return typeof(value) === 'string';
+    'issuer_name': function (value){
+        return typeof (value) === 'string';
     },
-    'chain_id': function(value){
-        return typeof(value) === 'string';
+    'chain_id': function (value){
+        return typeof (value) === 'string';
     },
-    'owner_trust': function(value){
-        return typeof(value) === 'string';
+    'owner_trust': function (value){
+        return typeof (value) === 'string';
     },
-    'last_update': function(value){
+    'last_update': function (value){
         return (Number.isInteger(value));
-        //TODO undefined/null possible?
+        // TODO undefined/null possible?
     },
-    'origin': function(value){
+    'origin': function (value){
         return (Number.isInteger(value));
     },
-    'subkeys': function(value){
+    'subkeys': function (value){
         return (Array.isArray(value));
     },
-    'userids': function(value){
+    'userids': function (value){
         return (Array.isArray(value));
     },
-    'tofu': function(value){
+    'tofu': function (value){
         return (Array.isArray(value));
     },
-    'hasSecret': function(value){
-        return typeof(value) === 'boolean';
+    'hasSecret': function (value){
+        return typeof (value) === 'boolean';
     }
 
 };
@@ -569,10 +598,11 @@ const validKeyProperties = {
 * an error if something went wrong.
 * @private
 */
-function validateKeyData(data){
+function validateKeyData (fingerprint, data){
     const key = {};
-    if ( typeof(data) !== 'object'
-    || !data.fingerprint){
+    if (!fingerprint || typeof (data) !== 'object' || !data.fingerprint
+     || fingerprint !== data.fingerprint.toUpperCase()
+    ){
         return gpgme_error('KEY_INVALID');
     }
     let props = Object.keys(data);
@@ -588,15 +618,15 @@ function validateKeyData(data){
         case 'subkeys':
             key.subkeys = [];
             for (let i=0; i< data.subkeys.length; i++) {
-                key.subkeys.push(Object.freeze(
-                    new GPGME_Subkey(data.subkeys[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(Object.freeze(
-                    new GPGME_UserId(data.userids[i])));
+                key.userids.push(
+                    new GPGME_UserId(data.userids[i]));
             }
             break;
         case 'last_update':
@@ -617,25 +647,25 @@ function validateKeyData(data){
  * @async
  */
 function getGnupgState (fingerprint, property){
-    return new Promise(function(resolve, reject) {
+    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(result){
-                if (!result.keys || result.keys.length !== 1){
+            msg.post().then(function (res){
+                if (!res.keys || res.keys.length !== 1){
                     reject(gpgme_error('KEY_INVALID'));
                 } else {
-                    const key = result.keys[0];
+                    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(Object.freeze(
-                                    new GPGME_Subkey(key.subkeys[i])));
+                                result.push(
+                                    new GPGME_Subkey(key.subkeys[i]));
                             }
                         }
                         resolve(result);
@@ -644,8 +674,8 @@ function getGnupgState (fingerprint, property){
                         result = [];
                         if (key.userids.length){
                             for (let i=0; i< key.userids.length; i++) {
-                                result.push(Object.freeze(
-                                    new GPGME_UserId(key.userids[i])));
+                                result.push(
+                                    new GPGME_UserId(key.userids[i]));
                             }
                         }
                         resolve(result);
@@ -673,9 +703,9 @@ function getGnupgState (fingerprint, property){
                         break;
                     }
                 }
-            }, function(error){
+            }, function (error){
                 reject(gpgme_error(error));
             });
         }
     });
-}
\ No newline at end of file
+}