diff --git a/src/key.js b/src/key.js index 138933e9..b33edd97 100644 --- a/src/key.js +++ b/src/key.js @@ -43,17 +43,25 @@ export function Key(packetlist) { return new Key(packetlist); } // same data as in packetlist but in structured form - this.primaryKey = null; + this.keyPacket = null; this.revocationSignatures = []; this.directSignatures = []; this.users = []; this.subKeys = []; this.packetlist2structure(packetlist); - if (!this.primaryKey || !this.users.length) { + if (!this.keyPacket || !this.users.length) { throw new Error('Invalid key: need at least key and user ID packet'); } } +Object.defineProperty(Key.prototype, 'primaryKey', { + get() { + return this.keyPacket; + }, + configurable: true, + enumerable: true +}); + /** * Transforms packetlist to structured key data * @param {module:packet.List} packetlist The packets that form a key @@ -66,8 +74,8 @@ Key.prototype.packetlist2structure = function(packetlist) { switch (packetlist[i].tag) { case enums.packet.publicKey: case enums.packet.secretKey: - this.primaryKey = packetlist[i]; - primaryKeyId = this.primaryKey.getKeyId(); + this.keyPacket = packetlist[i]; + primaryKeyId = this.getKeyId(); break; case enums.packet.userid: case enums.packet.userAttribute: @@ -135,7 +143,7 @@ Key.prototype.packetlist2structure = function(packetlist) { */ Key.prototype.toPacketlist = function() { const packetlist = new packet.List(); - packetlist.push(this.primaryKey); + packetlist.push(this.keyPacket); packetlist.concat(this.revocationSignatures); packetlist.concat(this.directSignatures); this.users.map(user => packetlist.concat(user.toPacketlist())); @@ -147,31 +155,30 @@ Key.prototype.toPacketlist = function() { * Returns packetlist containing all public or private subkey packets matching keyId; * If keyId is not present, returns all subkey packets. * @param {type/keyid} keyId - * @returns {module:packet.List} + * @returns {Array} */ -Key.prototype.getSubkeyPackets = function(keyId=null) { - const packets = new packet.List(); +Key.prototype.getSubkeys = function(keyId=null) { + const subKeys = []; this.subKeys.forEach(subKey => { - if (!keyId || subKey.subKey.getKeyId().equals(keyId, true)) { - packets.push(subKey.subKey); + if (!keyId || subKey.getKeyId().equals(keyId, true)) { + subKeys.push(subKey); } }); - return packets; + return subKeys; }; /** * Returns a packetlist containing all public or private key packets matching keyId. * If keyId is not present, returns all key packets starting with the primary key. * @param {type/keyid} keyId - * @returns {module:packet.List} + * @returns {Array} */ -Key.prototype.getKeyPackets = function(keyId=null) { - const packets = new packet.List(); - if (!keyId || this.primaryKey.getKeyId().equals(keyId, true)) { - packets.push(this.primaryKey); +Key.prototype.getKeys = function(keyId=null) { + const keys = []; + if (!keyId || this.getKeyId().equals(keyId, true)) { + keys.push(this); } - packets.concat(this.getSubkeyPackets(keyId)); - return packets; + return keys.concat(this.getSubkeys(keyId)); }; /** @@ -179,7 +186,7 @@ Key.prototype.getKeyPackets = function(keyId=null) { * @returns {Array} */ Key.prototype.getKeyIds = function() { - return this.getKeyPackets().map(keyPacket => keyPacket.getKeyId()); + return this.getKeys().map(key => key.getKeyId()); }; /** @@ -197,7 +204,7 @@ Key.prototype.getUserIds = function() { * @returns {Boolean} */ Key.prototype.isPublic = function() { - return this.primaryKey.tag === enums.packet.publicKey; + return this.keyPacket.tag === enums.packet.publicKey; }; /** @@ -205,7 +212,7 @@ Key.prototype.isPublic = function() { * @returns {Boolean} */ Key.prototype.isPrivate = function() { - return this.primaryKey.tag === enums.packet.secretKey; + return this.keyPacket.tag === enums.packet.secretKey; }; /** @@ -276,24 +283,24 @@ function isValidSigningKeyPacket(keyPacket, signature, date=new Date()) { } /** - * Returns first key packet or key packet by given keyId that is available for signing and verification + * Returns last created key or key by given keyId that is available for signing and verification * @param {module:type/keyid} keyId, optional * @param {Date} date use the given date for verification instead of the current time * @param {Object} userId, optional user ID - * @returns {Promise} key packet or null if no signing key has been found + * @returns {Promise} key or null if no signing key has been found * @async */ -Key.prototype.getSigningKeyPacket = async function (keyId=null, date=new Date(), userId={}) { - const primaryKey = this.primaryKey; +Key.prototype.getSigningKey = async function (keyId=null, date=new Date(), userId={}) { + const primaryKey = this.keyPacket; if (await this.verifyPrimaryKey(date, userId) === enums.keyStatus.valid) { - for (let i = 0; i < this.subKeys.length; i++) { - if (!keyId || this.subKeys[i].subKey.getKeyId().equals(keyId)) { + const subKeys = this.subKeys.slice().sort((a, b) => b.created - a.created); + for (let i = 0; i < subKeys.length; i++) { + if (!keyId || subKeys[i].getKeyId().equals(keyId)) { // eslint-disable-next-line no-await-in-loop - if (await this.subKeys[i].verify(primaryKey, date) === enums.keyStatus.valid) { - const bindingSignature = getLatestSignature(this.subKeys[i].bindingSignatures, date); - if (isValidSigningKeyPacket(this.subKeys[i].subKey, bindingSignature, date)) { - return this.subKeys[i].subKey; + if (await subKeys[i].verify(primaryKey, date) === enums.keyStatus.valid) { + const bindingSignature = getLatestSignature(subKeys[i].bindingSignatures, date); + if (isValidSigningKeyPacket(subKeys[i].keyPacket, bindingSignature, date)) { + return subKeys[i]; } } } @@ -301,7 +308,7 @@ Key.prototype.getSigningKeyPacket = async function (keyId=null, date=new Date(), const primaryUser = await this.getPrimaryUser(date, userId); if (primaryUser && (!keyId || primaryKey.getKeyId().equals(keyId)) && isValidSigningKeyPacket(primaryKey, primaryUser.selfCertification, date)) { - return primaryKey; + return this; } } return null; @@ -320,28 +327,26 @@ function isValidEncryptionKeyPacket(keyPacket, signature, date=new Date()) { } /** - * Returns first key packet or key packet by given keyId that is available for encryption or decryption + * Returns last created key or key by given keyId that is available for encryption or decryption * @param {module:type/keyid} keyId, optional * @param {Date} date, optional * @param {String} userId, optional - * @returns {Promise} key packet or null if no encryption key has been found + * @returns {Promise} key or null if no encryption key has been found * @async */ -Key.prototype.getEncryptionKeyPacket = async function(keyId, date=new Date(), userId={}) { - const primaryKey = this.primaryKey; +Key.prototype.getEncryptionKey = async function(keyId, date=new Date(), userId={}) { + const primaryKey = this.keyPacket; if (await this.verifyPrimaryKey(date, userId) === enums.keyStatus.valid) { // V4: by convention subkeys are preferred for encryption service // V3: keys MUST NOT have subkeys - for (let i = 0; i < this.subKeys.length; i++) { - if (!keyId || this.subKeys[i].subKey.getKeyId().equals(keyId)) { + const subKeys = this.subKeys.slice().sort((a, b) => b.created - a.created); + for (let i = 0; i < subKeys.length; i++) { + if (!keyId || subKeys[i].getKeyId().equals(keyId)) { // eslint-disable-next-line no-await-in-loop - if (await this.subKeys[i].verify(primaryKey, date) === enums.keyStatus.valid) { - const bindingSignature = getLatestSignature(this.subKeys[i].bindingSignatures, date); - if (isValidEncryptionKeyPacket(this.subKeys[i].subKey, bindingSignature, date)) { - return this.subKeys[i].subKey; + if (await subKeys[i].verify(primaryKey, date) === enums.keyStatus.valid) { + const bindingSignature = getLatestSignature(subKeys[i].bindingSignatures, date); + if (isValidEncryptionKeyPacket(subKeys[i].keyPacket, bindingSignature, date)) { + return subKeys[i]; } } } @@ -350,7 +355,7 @@ Key.prototype.getEncryptionKeyPacket = async function(keyId, date=new Date(), us const primaryUser = await this.getPrimaryUser(date, userId); if (primaryUser && (!keyId || primaryKey.getKeyId().equals(keyId)) && isValidEncryptionKeyPacket(primaryKey, primaryUser.selfCertification, date)) { - return primaryKey; + return this; } } return null; @@ -368,15 +373,16 @@ Key.prototype.encrypt = async function(passphrases, keyId=null) { throw new Error("Nothing to encrypt in a public key"); } - const keyPackets = this.getKeyPackets(keyId); - passphrases = util.isArray(passphrases) ? passphrases : new Array(keyPackets.length).fill(passphrases); - if (passphrases.length !== keyPackets.length) { + const keys = this.getKeys(keyId); + passphrases = util.isArray(passphrases) ? passphrases : new Array(keys.length).fill(passphrases); + if (passphrases.length !== keys.length) { throw new Error("Invalid number of passphrases for key"); } - return Promise.all(keyPackets.map(async function(keyPacket, i) { + return Promise.all(keys.map(async function(key, i) { + const { keyPacket } = key; await keyPacket.encrypt(passphrases[i]); - await keyPacket.clearPrivateParams(); + keyPacket.clearPrivateParams(); return keyPacket; })); }; @@ -394,12 +400,12 @@ Key.prototype.decrypt = async function(passphrases, keyId=null) { } passphrases = util.isArray(passphrases) ? passphrases : [passphrases]; - const results = await Promise.all(this.getKeyPackets(keyId).map(async function(keyPacket) { + const results = await Promise.all(this.getKeys(keyId).map(async function(key) { let decrypted = false; let error = null; await Promise.all(passphrases.map(async function(passphrase) { try { - await keyPacket.decrypt(passphrase); + await key.keyPacket.decrypt(passphrase); decrypted = true; } catch (e) { error = e; @@ -427,7 +433,7 @@ Key.prototype.decrypt = async function(passphrases, keyId=null) { */ Key.prototype.isRevoked = async function(signature, key, date=new Date()) { return isDataRevoked( - this.primaryKey, { key: this.primaryKey }, this.revocationSignatures, signature, key, date + this.keyPacket, { key: this.keyPacket }, this.revocationSignatures, signature, key, date ); }; @@ -440,7 +446,7 @@ Key.prototype.isRevoked = async function(signature, key, date=new Date()) { * @async */ Key.prototype.verifyPrimaryKey = async function(date=new Date(), userId={}) { - const primaryKey = this.primaryKey; + const primaryKey = this.keyPacket; // check for key revocation signatures if (await this.isRevoked(null, null, date)) { return enums.keyStatus.revoked; @@ -463,20 +469,34 @@ Key.prototype.verifyPrimaryKey = async function(date=new Date(), userId={}) { }; /** - * Returns the expiration time of the primary key or Infinity if key does not expire + * Returns the latest date when the key can be used for encrypting, signing, or both, depending on the `capabilities` paramater. + * When `capabilities` is null, defaults to returning the expiry date of the primary key. + * Returns Infinity if the key doesn't expire. + * @param {encrypt|sign|encrypt_sign} capabilities, optional + * @param {module:type/keyid} keyId, optional + * @param {Object} userId, optional user ID * @returns {Promise} * @async */ -Key.prototype.getExpirationTime = async function() { - if (this.primaryKey.version === 3) { - return getExpirationTime(this.primaryKey); +Key.prototype.getExpirationTime = async function(capabilities, keyId, userId) { + if (this.keyPacket.version === 3) { + return getExpirationTime(this.keyPacket); } - if (this.primaryKey.version >= 4) { + if (this.keyPacket.version >= 4) { const primaryUser = await this.getPrimaryUser(null); const selfCert = primaryUser.selfCertification; - const keyExpiry = getExpirationTime(this.primaryKey, selfCert); + const keyExpiry = getExpirationTime(this.keyPacket, selfCert); const sigExpiry = selfCert.getExpirationTime(); - return keyExpiry < sigExpiry ? keyExpiry : sigExpiry; + let expiry = keyExpiry < sigExpiry ? keyExpiry : sigExpiry; + if (capabilities === 'encrypt' || capabilities === 'encrypt_sign') { + const encryptExpiry = (await this.getEncryptionKey(keyId, null, userId)).getExpirationTime(); + if (encryptExpiry < expiry) expiry = encryptExpiry; + } + if (capabilities === 'sign' || capabilities === 'encrypt_sign') { + const signExpiry = (await this.getSigningKey(keyId, null, userId)).getExpirationTime(); + if (signExpiry < expiry) expiry = signExpiry; + } + return expiry; } }; @@ -515,7 +535,7 @@ Key.prototype.getPrimaryUser = async function(date=new Date(), userId={}) { return A.isPrimaryUserID - B.isPrimaryUserID || A.created - B.created; }).pop(); const { user, selfCertification: cert } = primaryUser; - const { primaryKey } = this; + const primaryKey = this.keyPacket; const dataToVerify = { userid: user.userId , key: primaryKey }; // skip if certificates is invalid, revoked, or expired // eslint-disable-next-line no-await-in-loop @@ -545,7 +565,7 @@ Key.prototype.update = async function(key) { if (await key.verifyPrimaryKey() === enums.keyStatus.invalid) { return; } - if (this.primaryKey.getFingerprint() !== key.primaryKey.getFingerprint()) { + if (this.getFingerprint() !== key.getFingerprint()) { throw new Error('Key update method: fingerprints of keys not equal'); } if (this.isPublic() && key.isPrivate()) { @@ -553,17 +573,17 @@ Key.prototype.update = async function(key) { const equal = (this.subKeys.length === key.subKeys.length) && (this.subKeys.every(destSubKey => { return key.subKeys.some(srcSubKey => { - return destSubKey.subKey.getFingerprint() === srcSubKey.subKey.getFingerprint(); + return destSubKey.getFingerprint() === srcSubKey.getFingerprint(); }); })); if (!equal) { throw new Error('Cannot update public key with private key if subkey mismatch'); } - this.primaryKey = key.primaryKey; + this.keyPacket = key.keyPacket; } // revocation signatures await mergeSignatures(key, this, 'revocationSignatures', srcRevSig => { - return isDataRevoked(this.primaryKey, this, [srcRevSig], null, key.primaryKey); + return isDataRevoked(this.keyPacket, this, [srcRevSig], null, key.keyPacket); }); // direct signatures await mergeSignatures(key, this, 'directSignatures'); @@ -575,7 +595,7 @@ Key.prototype.update = async function(key) { if ((srcUser.userId && dstUser.userId && (srcUser.userId.userid === dstUser.userId.userid)) || (srcUser.userAttribute && (srcUser.userAttribute.equals(dstUser.userAttribute)))) { - await dstUser.update(srcUser, this.primaryKey); + await dstUser.update(srcUser, this.keyPacket); found = true; } })); @@ -588,8 +608,8 @@ Key.prototype.update = async function(key) { await Promise.all(key.subKeys.map(async srcSubKey => { let found = false; await Promise.all(this.subKeys.map(async dstSubKey => { - if (srcSubKey.subKey.getFingerprint() === dstSubKey.subKey.getFingerprint()) { - await dstSubKey.update(srcSubKey, this.primaryKey); + if (srcSubKey.getFingerprint() === dstSubKey.getFingerprint()) { + await dstSubKey.update(srcSubKey, this.keyPacket); found = true; } })); @@ -640,9 +660,9 @@ Key.prototype.revoke = async function({ if (this.isPublic()) { throw new Error('Need private key for revoking'); } - const dataToSign = { key: this.primaryKey }; + const dataToSign = { key: this.keyPacket }; const key = new Key(this.toPacketlist()); - key.revocationSignatures.push(await createSignaturePacket(dataToSign, null, this.primaryKey, { + key.revocationSignatures.push(await createSignaturePacket(dataToSign, null, this.keyPacket, { signatureType: enums.signature.key_revocation, reasonForRevocationFlag: enums.write(enums.reasonForRevocation, reasonForRevocationFlag), reasonForRevocationString @@ -678,13 +698,13 @@ Key.prototype.applyRevocationCertificate = async function(revocationCertificate) if (!revocationSignature || revocationSignature.signatureType !== enums.signature.key_revocation) { throw new Error('Could not find revocation signature packet'); } - if (!revocationSignature.issuerKeyId.equals(this.primaryKey.getKeyId())) { + if (!revocationSignature.issuerKeyId.equals(this.getKeyId())) { throw new Error('Revocation signature does not match key'); } if (revocationSignature.isExpired()) { throw new Error('Revocation signature is expired'); } - if (!await revocationSignature.verify(this.primaryKey, { key: this.primaryKey })) { + if (!await revocationSignature.verify(this.keyPacket, { key: this.keyPacket })) { throw new Error('Could not verify revocation signature'); } const key = new Key(this.toPacketlist()); @@ -703,7 +723,7 @@ Key.prototype.signPrimaryUser = async function(privateKeys) { if (!user) { throw new Error('Could not find primary user'); } - const userSign = await user.sign(this.primaryKey, privateKeys); + const userSign = await user.sign(this.keyPacket, privateKeys); const key = new Key(this.toPacketlist()); key.users[index] = userSign; return key; @@ -719,7 +739,7 @@ Key.prototype.signAllUsers = async function(privateKeys) { const that = this; const key = new Key(this.toPacketlist()); key.users = await Promise.all(this.users.map(function(user) { - return user.sign(that.primaryKey, privateKeys); + return user.sign(that.keyPacket, privateKeys); })); return key; }; @@ -734,7 +754,7 @@ Key.prototype.signAllUsers = async function(privateKeys) { * @async */ Key.prototype.verifyPrimaryUser = async function(keys) { - const primaryKey = this.primaryKey; + const primaryKey = this.keyPacket; const { user } = await this.getPrimaryUser() || {}; if (!user) { throw new Error('Could not find primary user'); @@ -756,7 +776,7 @@ Key.prototype.verifyPrimaryUser = async function(keys) { */ Key.prototype.verifyAllUsers = async function(keys) { const results = []; - const { primaryKey } = this; + const primaryKey = this.keyPacket; await Promise.all(this.users.map(async function(user) { const signatures = keys ? await user.verifyAllCertifications(primaryKey, keys) : [{ keyid: primaryKey.keyid, valid: await user.verify(primaryKey) === enums.keyStatus.valid }]; @@ -814,18 +834,15 @@ User.prototype.sign = async function(primaryKey, privateKeys) { if (privateKey.isPublic()) { throw new Error('Need private key for signing'); } - if (privateKey.primaryKey.getFingerprint() === primaryKey.getFingerprint()) { + if (privateKey.getFingerprint() === primaryKey.getFingerprint()) { throw new Error('Not implemented for self signing'); } - const signingKeyPacket = await privateKey.getSigningKeyPacket(); - if (!signingKeyPacket) { + const signingKey = await privateKey.getSigningKey(); + if (!signingKey) { throw new Error('Could not find valid signing key packet in key ' + - privateKey.primaryKey.getKeyId().toHex()); + privateKey.getKeyId().toHex()); } - if (!signingKeyPacket.isDecrypted) { - throw new Error('Private key is not decrypted.'); - } - return createSignaturePacket(dataToSign, privateKey, signingKeyPacket, { + return createSignaturePacket(dataToSign, privateKey, signingKey.keyPacket, { // Most OpenPGP implementations use generic certification (0x10) signatureType: enums.signature.cert_generic, keyFlags: [enums.keyFlags.certify_keys | enums.keyFlags.sign_data] @@ -868,7 +885,7 @@ User.prototype.isRevoked = async function(primaryKey, certificate, key, date=new * @return {module:packet/signature} signature packet */ export async function createSignaturePacket(dataToSign, privateKey, signingKeyPacket, signatureProperties, date, userId) { - if (!signingKeyPacket.isDecrypted) { + if (!signingKeyPacket.isDecrypted()) { throw new Error('Private key is not decrypted.'); } const signaturePacket = new packet.Signature(date); @@ -895,11 +912,11 @@ User.prototype.verifyCertificate = async function(primaryKey, certificate, keys, const dataToVerify = { userid: this.userId || this.userAttribute, key: primaryKey }; const results = await Promise.all(keys.map(async function(key) { if (!key.getKeyIds().some(id => id.equals(keyid))) { return; } - const keyPacket = await key.getSigningKeyPacket(keyid, date); - if (certificate.revoked || await that.isRevoked(primaryKey, certificate, keyPacket)) { + const signingKey = await key.getSigningKey(keyid, date); + if (certificate.revoked || await that.isRevoked(primaryKey, certificate, signingKey.keyPacket)) { return enums.keyStatus.revoked; } - if (!(certificate.verified || await certificate.verify(keyPacket, dataToVerify))) { + if (!(certificate.verified || await certificate.verify(signingKey.keyPacket, dataToVerify))) { return enums.keyStatus.invalid; } if (certificate.isExpired()) { @@ -991,7 +1008,7 @@ function SubKey(subKeyPacket) { if (!(this instanceof SubKey)) { return new SubKey(subKeyPacket); } - this.subKey = subKeyPacket; + this.keyPacket = subKeyPacket; this.bindingSignatures = []; this.revocationSignatures = []; } @@ -1002,7 +1019,7 @@ function SubKey(subKeyPacket) { */ SubKey.prototype.toPacketlist = function() { const packetlist = new packet.List(); - packetlist.push(this.subKey); + packetlist.push(this.keyPacket); packetlist.concat(this.revocationSignatures); packetlist.concat(this.bindingSignatures); return packetlist; @@ -1025,7 +1042,7 @@ SubKey.prototype.isRevoked = async function(primaryKey, signature, key, date=new return isDataRevoked( primaryKey, { key: primaryKey, - bind: this.subKey + bind: this.keyPacket }, this.revocationSignatures, signature, key, date ); }; @@ -1041,9 +1058,9 @@ SubKey.prototype.isRevoked = async function(primaryKey, signature, key, date=new */ SubKey.prototype.verify = async function(primaryKey, date=new Date()) { const that = this; - const dataToVerify = { key: primaryKey, bind: this.subKey }; + const dataToVerify = { key: primaryKey, bind: this.keyPacket }; // check for V3 expiration time - if (this.subKey.version === 3 && isDataExpired(this.subKey, null, date)) { + if (this.keyPacket.version === 3 && isDataExpired(this.keyPacket, null, date)) { return enums.keyStatus.expired; } // check subkey binding signatures @@ -1070,7 +1087,7 @@ SubKey.prototype.verify = async function(primaryKey, date=new Date()) { */ SubKey.prototype.getExpirationTime = function(date=new Date()) { const bindingSignature = getLatestSignature(this.bindingSignatures, date); - const keyExpiry = getExpirationTime(this.subKey, bindingSignature); + const keyExpiry = getExpirationTime(this.keyPacket, bindingSignature); const sigExpiry = bindingSignature.getExpirationTime(); return keyExpiry < sigExpiry ? keyExpiry : sigExpiry; }; @@ -1085,17 +1102,17 @@ SubKey.prototype.update = async function(subKey, primaryKey) { if (await subKey.verify(primaryKey) === enums.keyStatus.invalid) { return; } - if (this.subKey.getFingerprint() !== subKey.subKey.getFingerprint()) { + if (this.getFingerprint() !== subKey.getFingerprint()) { throw new Error('SubKey update method: fingerprints of subkeys not equal'); } // key packet - if (this.subKey.tag === enums.packet.publicSubkey && - subKey.subKey.tag === enums.packet.secretSubkey) { - this.subKey = subKey.subKey; + if (this.keyPacket.tag === enums.packet.publicSubkey && + subKey.keyPacket.tag === enums.packet.secretSubkey) { + this.keyPacket = subKey.keyPacket; } // update missing binding signatures const that = this; - const dataToVerify = { key: primaryKey, bind: that.subKey }; + const dataToVerify = { key: primaryKey, bind: that.keyPacket }; await mergeSignatures(subKey, this, 'bindingSignatures', async function(srcBindSig) { if (!(srcBindSig.verified || await srcBindSig.verify(primaryKey, dataToVerify))) { return false; @@ -1129,8 +1146,8 @@ SubKey.prototype.revoke = async function(primaryKey, { flag: reasonForRevocationFlag=enums.reasonForRevocation.no_reason, string: reasonForRevocationString='' } = {}, date=new Date()) { - const dataToSign = { key: primaryKey, bind: this.subKey }; - const subKey = new SubKey(this.subKey); + const dataToSign = { key: primaryKey, bind: this.keyPacket }; + const subKey = new SubKey(this.keyPacket); subKey.revocationSignatures.push(await createSignaturePacket(dataToSign, null, primaryKey, { signatureType: enums.signature.subkey_revocation, reasonForRevocationFlag: enums.write(enums.reasonForRevocation, reasonForRevocationFlag), @@ -1140,6 +1157,14 @@ SubKey.prototype.revoke = async function(primaryKey, { return subKey; }; +['getKeyId', 'getFingerprint', 'getAlgorithmInfo', 'getCreationTime', 'isDecrypted'].forEach(name => { + Key.prototype[name] = + SubKey.prototype[name] = + function() { + return this.keyPacket[name](); + }; +}); + /** * Reads an unarmored OpenPGP key list and returns one or multiple key objects * @param {Uint8Array} data to be parsed @@ -1301,7 +1326,7 @@ export async function reformat(options) { options = sanitizeKeyOptions(options); try { - const isDecrypted = options.privateKey.getKeyPackets().every(keyPacket => keyPacket.isDecrypted); + const isDecrypted = options.privateKey.getKeys().every(key => key.isDecrypted()); if (!isDecrypted) { await options.privateKey.decrypt(); } diff --git a/src/keyring/keyring.js b/src/keyring/keyring.js index 51d155a7..d71c021b 100644 --- a/src/keyring/keyring.js +++ b/src/keyring/keyring.js @@ -138,14 +138,14 @@ function emailCheck(email, key) { * @private * @param {String} keyId provided as string of lowercase hex number * withouth 0x prefix (can be 16-character key ID or fingerprint) - * @param {module:packet.SecretKey|public_key|public_subkey|secret_subkey} keypacket The keypacket to be checked - * @returns {Boolean} True if keypacket has the specified keyid + * @param {module:key.Key|module:key.SubKey} key The key to be checked + * @returns {Boolean} True if key has the specified keyid */ -function keyIdCheck(keyId, keypacket) { +function keyIdCheck(keyId, key) { if (keyId.length === 16) { - return keyId === keypacket.getKeyId().toHex(); + return keyId === key.getKeyId().toHex(); } - return keyId === keypacket.getFingerprint(); + return keyId === key.getFingerprint(); } /** @@ -157,12 +157,12 @@ function keyIdCheck(keyId, keypacket) { */ KeyArray.prototype.getForId = function (keyId, deep) { for (let i = 0; i < this.keys.length; i++) { - if (keyIdCheck(keyId, this.keys[i].primaryKey)) { + if (keyIdCheck(keyId, this.keys[i])) { return this.keys[i]; } if (deep && this.keys[i].subKeys.length) { for (let j = 0; j < this.keys[i].subKeys.length; j++) { - if (keyIdCheck(keyId, this.keys[i].subKeys[j].subKey)) { + if (keyIdCheck(keyId, this.keys[i].subKeys[j])) { return this.keys[i]; } } @@ -182,7 +182,7 @@ KeyArray.prototype.importKey = async function (armored) { for (let i = 0; i < imported.keys.length; i++) { const key = imported.keys[i]; // check if key already in key array - const keyidHex = key.primaryKey.getKeyId().toHex(); + const keyidHex = key.getKeyId().toHex(); const keyFound = this.getForId(keyidHex); if (keyFound) { // eslint-disable-next-line no-await-in-loop @@ -211,7 +211,7 @@ KeyArray.prototype.push = function (key) { */ KeyArray.prototype.removeForId = function (keyId) { for (let i = 0; i < this.keys.length; i++) { - if (keyIdCheck(keyId, this.keys[i].primaryKey)) { + if (keyIdCheck(keyId, this.keys[i])) { return this.keys.splice(i, 1)[0]; } } diff --git a/src/message.js b/src/message.js index cdeb888f..3116fbe2 100644 --- a/src/message.js +++ b/src/message.js @@ -168,15 +168,15 @@ Message.prototype.decryptSessionKeys = async function(privateKeys, passwords) { throw new Error('No public key encrypted session key packet found.'); } await Promise.all(pkESKeyPacketlist.map(async function(keyPacket) { - // TODO improve this - const privateKeyPackets = privateKeys.reduce(function(acc, privateKey) { - return acc.concat(privateKey.getKeyPackets(keyPacket.publicKeyId)); - }, new packet.List()); + const privateKeyPackets = new packet.List(); + privateKeys.forEach(privateKey => { + privateKeyPackets.concat(privateKey.getKeys(keyPacket.publicKeyId).map(key => key.keyPacket)); + }); await Promise.all(privateKeyPackets.map(async function(privateKeyPacket) { if (!privateKeyPacket) { return; } - if (!privateKeyPacket.isDecrypted) { + if (!privateKeyPacket.isDecrypted()) { throw new Error('Private key is not decrypted.'); } try { @@ -323,17 +323,17 @@ export async function encryptSessionKey(sessionKey, symAlgo, aeadAlgo, publicKey if (publicKeys) { const results = await Promise.all(publicKeys.map(async function(publicKey) { - const encryptionKeyPacket = await publicKey.getEncryptionKeyPacket(undefined, date, userId); - if (!encryptionKeyPacket) { + const encryptionKey = await publicKey.getEncryptionKey(undefined, date, userId); + if (!encryptionKey) { throw new Error('Could not find valid key packet for encryption in key ' + - publicKey.primaryKey.getKeyId().toHex()); + publicKey.getKeyId().toHex()); } const pkESKeyPacket = new packet.PublicKeyEncryptedSessionKey(); - pkESKeyPacket.publicKeyId = wildcard ? type_keyid.wildcard() : encryptionKeyPacket.getKeyId(); - pkESKeyPacket.publicKeyAlgorithm = encryptionKeyPacket.algorithm; + pkESKeyPacket.publicKeyId = wildcard ? type_keyid.wildcard() : encryptionKey.getKeyId(); + pkESKeyPacket.publicKeyAlgorithm = encryptionKey.keyPacket.algorithm; pkESKeyPacket.sessionKey = sessionKey; pkESKeyPacket.sessionKeyAlgorithm = symAlgo; - await pkESKeyPacket.encrypt(encryptionKeyPacket); + await pkESKeyPacket.encrypt(encryptionKey.keyPacket); delete pkESKeyPacket.sessionKey; // delete plaintext session key after encryption return pkESKeyPacket; })); @@ -421,16 +421,16 @@ Message.prototype.sign = async function(privateKeys=[], signature=null, date=new if (privateKey.isPublic()) { throw new Error('Need private key for signing'); } - const signingKeyPacket = await privateKey.getSigningKeyPacket(undefined, date, userId); - if (!signingKeyPacket) { + const signingKey = await privateKey.getSigningKey(undefined, date, userId); + if (!signingKey) { throw new Error('Could not find valid key packet for signing in key ' + - privateKey.primaryKey.getKeyId().toHex()); + privateKey.getKeyId().toHex()); } const onePassSig = new packet.OnePassSignature(); onePassSig.type = signatureType; - onePassSig.hashAlgorithm = await getPreferredHashAlgo(privateKey, signingKeyPacket, date, userId); - onePassSig.publicKeyAlgorithm = signingKeyPacket.algorithm; - onePassSig.signingKeyId = signingKeyPacket.getKeyId(); + onePassSig.hashAlgorithm = await getPreferredHashAlgo(privateKey, signingKey.keyPacket, date, userId); + onePassSig.publicKeyAlgorithm = signingKey.keyPacket.algorithm; + onePassSig.signingKeyId = signingKey.getKeyId(); if (i === privateKeys.length - 1) { onePassSig.flags = 1; } @@ -503,12 +503,12 @@ export async function createSignaturePackets(literalDataPacket, privateKeys, sig if (privateKey.isPublic()) { throw new Error('Need private key for signing'); } - const signingKeyPacket = await privateKey.getSigningKeyPacket(undefined, date, userId); - if (!signingKeyPacket) { + const signingKey = await privateKey.getSigningKey(undefined, date, userId); + if (!signingKey) { throw new Error(`Could not find valid signing key packet in key ${ - privateKey.primaryKey.getKeyId().toHex()}`); + privateKey.getKeyId().toHex()}`); } - return createSignaturePacket(literalDataPacket, privateKey, signingKeyPacket, {signatureType}, date, userId); + return createSignaturePacket(literalDataPacket, privateKey, signingKey.keyPacket, {signatureType}, date, userId); })).then(signatureList => { signatureList.forEach(signaturePacket => packetlist.push(signaturePacket)); }); @@ -570,10 +570,10 @@ export async function createVerificationObjects(signatureList, literalDataList, return Promise.all(signatureList.map(async function(signature) { let keyPacket = null; await Promise.all(keys.map(async function(key) { - // Look for the unique key packet that matches issuerKeyId of signature - const result = await key.getSigningKeyPacket(signature.issuerKeyId, date); + // Look for the unique key that matches issuerKeyId of signature + const result = await key.getSigningKey(signature.issuerKeyId, date); if (result) { - keyPacket = result; + keyPacket = result.keyPacket; } })); diff --git a/src/packet/public_key.js b/src/packet/public_key.js index 939689c7..f1a07891 100644 --- a/src/packet/public_key.js +++ b/src/packet/public_key.js @@ -180,6 +180,22 @@ PublicKey.prototype.writeOld = function () { return util.concatUint8Array([new Uint8Array([0x99]), util.writeNumber(bytes.length, 2), bytes]); }; +/** + * Check whether secret-key data is available in decrypted form. Returns null for public keys. + * @returns {Boolean|null} + */ +PublicKey.prototype.isDecrypted = function() { + return null; +}; + +/** + * Returns the creation time of the key + * @returns {Date} + */ +PublicKey.prototype.getCreationTime = function() { + return this.created; +}; + /** * Calculates the key id of the key * @returns {String} A 8 byte key id diff --git a/src/packet/secret_key.js b/src/packet/secret_key.js index 8a6fe012..ccfec0b7 100644 --- a/src/packet/secret_key.js +++ b/src/packet/secret_key.js @@ -51,9 +51,9 @@ function SecretKey(date=new Date()) { */ this.encrypted = null; /** - * Indicator if secret-key data is available in decrypted form + * Indicator if secret-key data is encrypted. `this.isEncrypted === false` means data is available in decrypted form. */ - this.isDecrypted = false; + this.isEncrypted = null; } SecretKey.prototype = new publicKey(); @@ -149,13 +149,14 @@ SecretKey.prototype.read = function (bytes) { if (isEncrypted) { this.encrypted = bytes; + this.isEncrypted = true; } else { // - Plain or encrypted multiprecision integers comprising the secret // key data. These algorithm-specific fields are as described // below. const privParams = parse_cleartext_params('mod', bytes.subarray(1, bytes.length), this.algorithm); this.params = this.params.concat(privParams); - this.isDecrypted = true; + this.isEncrypted = false; } }; @@ -176,10 +177,17 @@ SecretKey.prototype.write = function () { return util.concatUint8Array(arr); }; +/** + * Check whether secret-key data is available in decrypted form. Returns null for public keys. + * @returns {Boolean|null} + */ +SecretKey.prototype.isDecrypted = function() { + return this.isEncrypted === false; +}; /** * Encrypt the payload. By default, we use aes256 and iterated, salted string - * to key specifier. If the key is in a decrypted state (isDecrypted === true) + * to key specifier. If the key is in a decrypted state (isEncrypted === false) * and the passphrase is empty or undefined, the key will be set as not encrypted. * This can be used to remove passphrase protection after calling decrypt(). * @param {String} passphrase @@ -187,7 +195,7 @@ SecretKey.prototype.write = function () { * @async */ SecretKey.prototype.encrypt = async function (passphrase) { - if (this.isDecrypted && !passphrase) { + if (this.isDecrypted() && !passphrase) { this.encrypted = null; return false; } else if (!passphrase) { @@ -242,7 +250,7 @@ function produceEncryptionKey(s2k, passphrase, algorithm) { * @async */ SecretKey.prototype.decrypt = async function (passphrase) { - if (this.isDecrypted) { + if (this.isDecrypted()) { throw new Error('Key packet is already decrypted.'); } @@ -323,7 +331,7 @@ SecretKey.prototype.decrypt = async function (passphrase) { const privParams = parse_cleartext_params(hash, cleartext, this.algorithm); this.params = this.params.concat(privParams); - this.isDecrypted = true; + this.isEncrypted = false; this.encrypted = null; return true; @@ -332,7 +340,7 @@ SecretKey.prototype.decrypt = async function (passphrase) { SecretKey.prototype.generate = async function (bits, curve) { const algo = enums.write(enums.publicKey, this.algorithm); this.params = await crypto.generateParams(algo, bits, curve); - this.isDecrypted = true; + this.isEncrypted = false; }; /** @@ -344,7 +352,7 @@ SecretKey.prototype.clearPrivateParams = function () { } const algo = enums.write(enums.publicKey, this.algorithm); this.params = this.params.slice(0, crypto.getPubKeyParamTypes(algo).length); - this.isDecrypted = false; + this.isEncrypted = true; }; /** diff --git a/test/general/brainpool.js b/test/general/brainpool.js index af5a398b..627a8907 100644 --- a/test/general/brainpool.js +++ b/test/general/brainpool.js @@ -134,7 +134,7 @@ describe('Brainpool Cryptography', function () { expect(pub).to.exist; expect(pub.err).to.not.exist; expect(pub.keys).to.have.length(1); - expect(pub.keys[0].primaryKey.getKeyId().toHex()).to.equal(data[name].id); + expect(pub.keys[0].getKeyId().toHex()).to.equal(data[name].id); data[name].pub_key = pub.keys[0]; return data[name].pub_key; } @@ -146,7 +146,7 @@ describe('Brainpool Cryptography', function () { expect(pk).to.exist; expect(pk.err).to.not.exist; expect(pk.keys).to.have.length(1); - expect(pk.keys[0].primaryKey.getKeyId().toHex()).to.equal(data[name].id); + expect(pk.keys[0].getKeyId().toHex()).to.equal(data[name].id); expect(await pk.keys[0].decrypt(data[name].pass)).to.be.true; data[name].priv_key = pk.keys[0]; return data[name].priv_key; diff --git a/test/general/ecc_nist.js b/test/general/ecc_nist.js index 42083e72..89c27fdd 100644 --- a/test/general/ecc_nist.js +++ b/test/general/ecc_nist.js @@ -139,7 +139,7 @@ describe('Elliptic Curve Cryptography', function () { expect(pub).to.exist; expect(pub.err).to.not.exist; expect(pub.keys).to.have.length(1); - expect(pub.keys[0].primaryKey.getKeyId().toHex()).to.equal(data[name].id); + expect(pub.keys[0].getKeyId().toHex()).to.equal(data[name].id); data[name].pub_key = pub.keys[0]; return data[name].pub_key; } @@ -151,7 +151,7 @@ describe('Elliptic Curve Cryptography', function () { expect(pk).to.exist; expect(pk.err).to.not.exist; expect(pk.keys).to.have.length(1); - expect(pk.keys[0].primaryKey.getKeyId().toHex()).to.equal(data[name].id); + expect(pk.keys[0].getKeyId().toHex()).to.equal(data[name].id); expect(await pk.keys[0].decrypt(data[name].pass)).to.be.true; data[name].priv_key = pk.keys[0]; return data[name].priv_key; diff --git a/test/general/key.js b/test/general/key.js index 1e7991be..5e412006 100644 --- a/test/general/key.js +++ b/test/general/key.js @@ -866,7 +866,7 @@ zoGJ6s48HcP591pN93uAitCcYcinY2ZslmdiCXw+zbeoX4spNrV4T4CYxBjNQdIa expect(pubKeys).to.exist; expect(pubKeys.err).to.not.exist; expect(pubKeys.keys).to.have.length(1); - expect(pubKeys.keys[0].primaryKey.getKeyId().toHex()).to.equal('b8e4105cc9dedc77'); + expect(pubKeys.keys[0].getKeyId().toHex()).to.equal('b8e4105cc9dedc77'); done(); }); @@ -1248,14 +1248,70 @@ const mergeKey2 = '-----BEGIN PGP PUBLIC KEY BLOCK-----\n' + '=REGo\n' + '-----END PGP PUBLIC KEY BLOCK-----\n'; +const priv_key_2000_2008 = `-----BEGIN PGP PRIVATE KEY BLOCK----- + +xcEYBDioN2gBBACy5VEu8/dlQHOd12v8tNY2Aic+C+k6yyKe7eHRf1Pqwd0d +OdMk+0EvMi1Z+i0x/cQj89te81F7TCmVd+qrIWR6rKc/6WQzg9FQ0h1WQKxD +YizEIyia0ZNEuYd7F1H6ycx352tymepAth05i6t1LxI5jExFDq+d8z8L5ezq ++/6BZQARAQABAAP5AY01ySGNEQKq2LY0WyaqCqG1+5azW72aIS+WKztpO9VE +HhuGXmD+gFK1VtKHFKgAjOucc2RKszYmey56ftL6kdvBs404GEFGCtZOkr4a +PcnSBM7SNZrUlOIBN9u6U4McnNYdEhyARIf+Qm9NGTbzZCoZ13f40/QjX2TG +2T6cTwECAOeTJBaIinz+OInqPzWbEndnbWKIXbPhPtpvU/D2OyLquwMmma8r +khX78V9ZduLVwtzP2DyGnQ+yHBmLCgjxEQECAMXDxAlcx3LbAGew6OA2u938 +Cf+O0fJWid3/e0gNppvnbayTtisXF0uENX4pJv82S02QgqxFL3FYrdON5KVW +zGUB/3rtIzMQJaSYZAJFc4SDOn1RNkl4nUroPf1IbB17nDX/GcB6acquJxQq +0q5FtJCrnNR2K25u6t2AGDcZLleSaFSamc0TdGVzdCA8dGVzdEBleGFtcGxl +PsKtBBMBCgAXBQI4qDdoAhsvAwsJBwMVCggCHgECF4AACgkQXPAg04i7hHT2 +rwQAip3cACXdbShpxvKEsQs0oBN1H5PAx1BAGXanw+jxDFUkrDk1DOSrZFnM +aohuoJrYyoE/RkLz061g8tFc/KETmnyJAcXL/PPic3tPCCs1cphVAsAjELsY +wPL4UQpFnRU2e+phgzX9M/G78wvqiOGcM/K0SZTnyRvYaAHHuLFE2xnHwRgE +OKg3aAEEALOt5AUdDf7fz0DwOkIokGj4zeiFuphsTPwpRAS6c1o9xAzS/C8h +LFShhTKL4Z9znYkdaMHuFIs7AJ3P5tKlvG0/cZAl3u286lz0aTtQluHMCKNy +UyhuZ0K1VgZOj+HcDKo8jQ+aejcwjHDg02yPvfzrXHBjWAJMjglV4W+YPFYj +ABEBAAEAA/9FbqPXagPXgssG8A3DNQOg3MxM1yhk8CzLoHKdVSNwMsAIqJs0 +5x/HUGc1QiKcyEOPEaNClWqw5sr1MLqkmdD2y9xU6Ys1VyJY92GKQyVAgLej +tAvgeUb7NoHKU7b8F/oDfZezY8rs5fBRNVO5hHd+aAD4gcAAfIeAmy7AHRU9 +wQIA7UPEpAI/lil5fDByHz7wyo1k/7yLqY18tHEAcUbPwUWvYCuvv3ASts78 +0kQETsqn0bZZuuiR+IRdFxZzsElLAwIAwd4M85ewucF2tsyJYWJq4A+dETJC +WJfcSboagENXUYjOsLgtU/H8b9JD9CWpsd0DkcPshKAjuum6c3cUaTROYQIA +lp2kWrnzdLZxXELA2RDTaqsp/M+XhwKhChuG53FH+AKMVrwDImG7qVVL07gI +Rv+gGkG79PGvej7YZLZvHIq/+qTWwsCDBBgBCgAPBQI4qDdoBQkPCZwAAhsu +AKgJEFzwINOIu4R0nSAEGQEKAAYFAjioN2gACgkQ4fPj4++ExKB1EQP+Ppm5 +hmv2c04836wMXHjjCIX1fsBhJNSeWNZljxPOcPgb0kAd2hY1S/Vn9ZDogeYm +DBUQ/JHj42Edda2IYax/74dAwUTV2KnDsdBT8Tb9ljHnY3GM7JqEKi/u09u7 +Zfwq3auRDH8RW/hRHQ058dfkSoorpN5iCUfzYJemM4ZmA7NPCwP+PsQ63uIP +mDB49M2sQwV1GsBc+YB+aD3hggsRv7UHh4gvr2GCcukRlHDi/pOEO/ZTaoyS +un3m7b2M4n31bEj1lknZBtMZLo0uWww6YpAQEwFFXhVcAOYQqOb2KfF1rJGB +6w10tmpXdNWm5JPANu6RqaXIzkuMcRUqlYcNLfz6SUHHwRgEOKg3aAEEALfQ +/ENJxzybgdKLQBhF8RN3xb1V8DiYFtfgDkboavjiSD7PVEDNO286cLoe/uAk +E+Dgm2oEFmZ/IJShX+BL1JkHreNKuWTW0Gz0jkqYbE44Kssy5ywCXc0ItW4y +rMtabXPI5zqXzePd9Fwp7ZOt8QN/jU+TUfGUMwEv2tDKq/+7ABEBAAEAA/4l +tAGSQbdSqKj7ySE3+Vyl/Bq8p7xyt0t0Mxpqk/ChJTThYUBsXExVF70YiBQK +YIwNQ7TNDZKUqn3BzsnuJU+xTHKx8/mg7cGo+EzBstLMz7tGQJ9GN2LwrTZj +/yA2JZk3t54Ip/eNCkg7j5OaJG9l3RaW3DKPskRFY63gnitC8QIA745VRJmw +FwmHQ0H4ZoggO26+Q77ViYn84s8gio7AWkrFlt5sWhSdkrGcy/IIeSqzq0ZU +2p7zsXR8qz85+RyTcQIAxG8mwRGHkboHVa6qKt+lAxpqCuxe/buniw0LZuzu +wJQU+E6Y0oybSAcOjleIMkxULljc3Us7a5/HDKdQi4mX6wH/bVPlW8koygus +mDVIPSP2rmjBA9YVLn5CBPG+u0oGAMY9tfJ848V22S/ZPYNZe9ksFSjEuFDL +Xnmz/O1jI3Xht6IGwsCDBBgBCgAPBQI4qDdoBQkPCZwAAhsuAKgJEFzwINOI +u4R0nSAEGQEKAAYFAjioN2gACgkQJVG+vfNJQKhK6gP+LB5qXTJKCduuqZm7 +VhFvPeOu4W0pyORo29zZI0owKZnD2ZKZrZhKXZC/1+xKXi8aX4V2ygRth2P1 +tGFLJRqRiA3C20NVewdI4tQtEqWWSlfNFDz4EsbNspyodQ4jPsKPk2R8pFjA +wmpXLizPg2UyPKUJ/2GnNWjleP0UNyUXgD1MkgP+IkxXTYgDF5/LrOlrq7Th +WqFqQ/prQCBy7xxNLjpVKLDxGYbXVER6p0pkD6DXlaOgSB3i32dQJnU96l44 +TlUyaUK/dJP7JPbVUOFq/awSxJiCxFxF6Oarc10qQ+OG5ESdJAjpCMHGCzlb +t/ia1kMpSEiOVLlX5dfHZzhR3WNtBqU= +=C0fJ +-----END PGP PRIVATE KEY BLOCK-----`; + it('Parsing armored text with two keys', function(done) { const pubKeys = openpgp.key.readArmored(twoKeys); expect(pubKeys).to.exist; expect(pubKeys.err).to.not.exist; expect(pubKeys.keys).to.have.length(2); - expect(pubKeys.keys[0].primaryKey.getKeyId().toHex()).to.equal('4a63613a4d6e4094'); - expect(pubKeys.keys[1].primaryKey.getKeyId().toHex()).to.equal('dbf223e870534df4'); + expect(pubKeys.keys[0].getKeyId().toHex()).to.equal('4a63613a4d6e4094'); + expect(pubKeys.keys[1].getKeyId().toHex()).to.equal('dbf223e870534df4'); done(); }); @@ -1292,21 +1348,21 @@ const mergeKey2 = '-----BEGIN PGP PUBLIC KEY BLOCK-----\n' + const pubKeyV3 = pubKeysV3.keys[0]; expect(pubKeyV3).to.exist; - expect(pubKeyV4.primaryKey.getKeyId().toHex()).to.equal('4a63613a4d6e4094'); - expect(pubKeyV4.primaryKey.getFingerprint()).to.equal('f470e50dcb1ad5f1e64e08644a63613a4d6e4094'); - expect(pubKeyV3.primaryKey.getKeyId().toHex()).to.equal('e5b7a014a237ba9d'); - expect(pubKeyV3.primaryKey.getFingerprint()).to.equal('a44fcee620436a443bc4913640ab3e49'); + expect(pubKeyV4.getKeyId().toHex()).to.equal('4a63613a4d6e4094'); + expect(pubKeyV4.getFingerprint()).to.equal('f470e50dcb1ad5f1e64e08644a63613a4d6e4094'); + expect(pubKeyV3.getKeyId().toHex()).to.equal('e5b7a014a237ba9d'); + expect(pubKeyV3.getFingerprint()).to.equal('a44fcee620436a443bc4913640ab3e49'); done(); }); it('Create new key ID with fromId()', function() { const pubKeyV4 = openpgp.key.readArmored(twoKeys).keys[0]; - const keyId = pubKeyV4.primaryKey.getKeyId(); + const keyId = pubKeyV4.getKeyId(); const newKeyId = keyId.constructor.fromId(keyId.toHex()); expect(newKeyId.toHex()).to.equal(keyId.toHex()); }); - it('Testing key method getSubkeyPackets', function(done) { + it('Testing key method getSubkeys', function(done) { const pubKeys = openpgp.key.readArmored(pub_sig_test); expect(pubKeys).to.exist; @@ -1320,7 +1376,7 @@ const mergeKey2 = '-----BEGIN PGP PUBLIC KEY BLOCK-----\n' + packetlist.read(openpgp.armor.decode(pub_sig_test).data); - const subkeys = pubKey.getSubkeyPackets(); + const subkeys = pubKey.getSubkeys(); expect(subkeys).to.exist; expect(subkeys).to.have.length(2); expect(subkeys[0].getKeyId().equals(packetlist[8].getKeyId())).to.be.true; @@ -1359,8 +1415,8 @@ const mergeKey2 = '-----BEGIN PGP PUBLIC KEY BLOCK-----\n' + // remove subkeys pubKey.subKeys = []; // primary key has only key flags for signing - const keyPacket = await pubKey.getEncryptionKeyPacket(); - expect(keyPacket).to.not.exist; + const encryptionKey = await pubKey.getEncryptionKey(); + expect(encryptionKey).to.not.exist; }); it('Method getExpirationTime V4 Key', async function() { @@ -1387,6 +1443,16 @@ const mergeKey2 = '-----BEGIN PGP PUBLIC KEY BLOCK-----\n' + expect(expirationTime.toISOString()).to.be.equal('2018-11-26T10:58:29.000Z'); }); + it('Method getExpirationTime V4 Key with capabilities', async function() { + const pubKey = openpgp.key.readArmored(priv_key_2000_2008).keys[0]; + expect(pubKey).to.exist; + expect(pubKey).to.be.an.instanceof(openpgp.key.Key); + const expirationTime = await pubKey.getExpirationTime(); + expect(expirationTime).to.equal(Infinity); + const encryptExpirationTime = await pubKey.getExpirationTime('encrypt_sign'); + expect(encryptExpirationTime.toISOString()).to.equal('2008-02-12T17:12:08.000Z'); + }); + it('update() - throw error if fingerprints not equal', function(done) { const keys = openpgp.key.readArmored(twoKeys).keys; expect(keys[0].update.bind( @@ -1440,8 +1506,8 @@ const mergeKey2 = '-----BEGIN PGP PUBLIC KEY BLOCK-----\n' + dest.update(source).then(() => { expect(dest.subKeys[1]).to.exist; expect( - dest.subKeys[1].subKey.getKeyId().toHex() - ).to.equal(source.subKeys[1].subKey.getKeyId().toHex()); + dest.subKeys[1].getKeyId().toHex() + ).to.equal(source.subKeys[1].getKeyId().toHex()); done(); }); }); @@ -1751,8 +1817,8 @@ VYGdb3eNlV8CfoEC return openpgp.generateKey(opt).then(function(newKey) { expect(newKey.key).to.exist; - expect(+newKey.key.primaryKey.created).to.equal(+past); - expect(+newKey.key.subKeys[0].subKey.created).to.equal(+past); + expect(+newKey.key.getCreationTime()).to.equal(+past); + expect(+newKey.key.subKeys[0].getCreationTime()).to.equal(+past); expect(+newKey.key.subKeys[0].bindingSignatures[0].created).to.equal(+past); }); }) @@ -1781,8 +1847,8 @@ VYGdb3eNlV8CfoEC expect(key.users[0].userId.userid).to.equal(userId); expect(key.users[0].selfCertifications[0].isPrimaryUserID).to.be.true; expect(key.subKeys).to.have.lengthOf(2); - expect(key.subKeys[0].subKey.algorithm).to.equal('ecdh'); - expect(key.subKeys[1].subKey.algorithm).to.equal('ecdh'); + expect(key.subKeys[0].getAlgorithmInfo().algorithm).to.equal('ecdh'); + expect(key.subKeys[1].getAlgorithmInfo().algorithm).to.equal('ecdh'); }); }); @@ -1795,8 +1861,8 @@ VYGdb3eNlV8CfoEC expect(key.users[0].userId.userid).to.equal(userId); expect(key.users[0].selfCertifications[0].isPrimaryUserID).to.be.true; expect(key.subKeys).to.have.lengthOf(2); - expect(key.subKeys[0].subKey.algorithm).to.equal('ecdh'); - expect(key.subKeys[1].subKey.algorithm).to.equal('eddsa'); + expect(key.subKeys[0].getAlgorithmInfo().algorithm).to.equal('ecdh'); + expect(key.subKeys[1].getAlgorithmInfo().algorithm).to.equal('eddsa'); }); }); @@ -1808,8 +1874,8 @@ VYGdb3eNlV8CfoEC expect(key.users.length).to.equal(1); expect(key.users[0].userId.userid).to.equal(userId); expect(key.users[0].selfCertifications[0].isPrimaryUserID).to.be.true; - expect(key.primaryKey.algorithm).to.equal('rsa_encrypt_sign'); - expect(key.subKeys[0].subKey.algorithm).to.equal('ecdh'); + expect(key.getAlgorithmInfo().algorithm).to.equal('rsa_encrypt_sign'); + expect(key.subKeys[0].getAlgorithmInfo().algorithm).to.equal('ecdh'); }); }); @@ -1822,13 +1888,13 @@ VYGdb3eNlV8CfoEC const armor2 = key.armor(); expect(armor1).to.equal(armor2); expect(await key.decrypt('passphrase')).to.be.true; - expect(key.primaryKey.isDecrypted).to.be.true; + expect(key.isDecrypted()).to.be.true; await key.encrypt('new_passphrase'); - expect(key.primaryKey.isDecrypted).to.be.false; + expect(key.isDecrypted()).to.be.false; await expect(key.decrypt('passphrase')).to.eventually.be.rejectedWith('Incorrect key passphrase'); - expect(key.primaryKey.isDecrypted).to.be.false; + expect(key.isDecrypted()).to.be.false; expect(await key.decrypt('new_passphrase')).to.be.true; - expect(key.primaryKey.isDecrypted).to.be.true; + expect(key.isDecrypted()).to.be.true; const armor3 = key.armor(); expect(armor3).to.not.equal(armor1); }); @@ -1861,12 +1927,12 @@ VYGdb3eNlV8CfoEC await privateKey.decrypt('hello world'); publicKey = await publicKey.signPrimaryUser([privateKey]); const signatures = await publicKey.verifyPrimaryUser([privateKey]); - const publicKeyPacket = await publicKey.getSigningKeyPacket(); - const privateKeyPacket = await privateKey.getSigningKeyPacket(); + const publicSigningKey = await publicKey.getSigningKey(); + const privateSigningKey = await privateKey.getSigningKey(); expect(signatures.length).to.equal(2); - expect(signatures[0].keyid.toHex()).to.equal(publicKeyPacket.getKeyId().toHex()); + expect(signatures[0].keyid.toHex()).to.equal(publicSigningKey.getKeyId().toHex()); expect(signatures[0].valid).to.be.null; - expect(signatures[1].keyid.toHex()).to.equal(privateKeyPacket.getKeyId().toHex()); + expect(signatures[1].keyid.toHex()).to.equal(privateSigningKey.getKeyId().toHex()); expect(signatures[1].valid).to.be.true; }); @@ -1877,12 +1943,12 @@ VYGdb3eNlV8CfoEC await privateKey.decrypt('hello world'); publicKey = await publicKey.signPrimaryUser([privateKey]); const signatures = await publicKey.verifyPrimaryUser([wrongKey]); - const publicKeyPacket = await publicKey.getSigningKeyPacket(); - const privateKeyPacket = await privateKey.getSigningKeyPacket(); + const publicSigningKey = await publicKey.getSigningKey(); + const privateSigningKey = await privateKey.getSigningKey(); expect(signatures.length).to.equal(2); - expect(signatures[0].keyid.toHex()).to.equal(publicKeyPacket.getKeyId().toHex()); + expect(signatures[0].keyid.toHex()).to.equal(publicSigningKey.getKeyId().toHex()); expect(signatures[0].valid).to.be.null; - expect(signatures[1].keyid.toHex()).to.equal(privateKeyPacket.getKeyId().toHex()); + expect(signatures[1].keyid.toHex()).to.equal(privateSigningKey.getKeyId().toHex()); expect(signatures[1].valid).to.be.null; }); @@ -1892,20 +1958,20 @@ VYGdb3eNlV8CfoEC await privateKey.decrypt('hello world'); publicKey = await publicKey.signAllUsers([privateKey]); const signatures = await publicKey.verifyAllUsers([privateKey]); - const publicKeyPacket = await publicKey.getSigningKeyPacket(); - const privateKeyPacket = await privateKey.getSigningKeyPacket(); + const publicSigningKey = await publicKey.getSigningKey(); + const privateSigningKey = await privateKey.getSigningKey(); expect(signatures.length).to.equal(4); expect(signatures[0].userid).to.equal(publicKey.users[0].userId.userid); - expect(signatures[0].keyid.toHex()).to.equal(publicKeyPacket.getKeyId().toHex()); + expect(signatures[0].keyid.toHex()).to.equal(publicSigningKey.getKeyId().toHex()); expect(signatures[0].valid).to.be.null; expect(signatures[1].userid).to.equal(publicKey.users[0].userId.userid); - expect(signatures[1].keyid.toHex()).to.equal(privateKeyPacket.getKeyId().toHex()); + expect(signatures[1].keyid.toHex()).to.equal(privateSigningKey.getKeyId().toHex()); expect(signatures[1].valid).to.be.true; expect(signatures[2].userid).to.equal(publicKey.users[1].userId.userid); - expect(signatures[2].keyid.toHex()).to.equal(publicKeyPacket.getKeyId().toHex()); + expect(signatures[2].keyid.toHex()).to.equal(publicSigningKey.getKeyId().toHex()); expect(signatures[2].valid).to.be.null; expect(signatures[3].userid).to.equal(publicKey.users[1].userId.userid); - expect(signatures[3].keyid.toHex()).to.equal(privateKeyPacket.getKeyId().toHex()); + expect(signatures[3].keyid.toHex()).to.equal(privateSigningKey.getKeyId().toHex()); expect(signatures[3].valid).to.be.true; }); @@ -1916,20 +1982,20 @@ VYGdb3eNlV8CfoEC await privateKey.decrypt('hello world'); publicKey = await publicKey.signAllUsers([privateKey]); const signatures = await publicKey.verifyAllUsers([wrongKey]); - const publicKeyPacket = await publicKey.getSigningKeyPacket(); - const privateKeyPacket = await privateKey.getSigningKeyPacket() + const publicSigningKey = await publicKey.getSigningKey(); + const privateSigningKey = await privateKey.getSigningKey(); expect(signatures.length).to.equal(4); expect(signatures[0].userid).to.equal(publicKey.users[0].userId.userid); - expect(signatures[0].keyid.toHex()).to.equal(publicKeyPacket.getKeyId().toHex()); + expect(signatures[0].keyid.toHex()).to.equal(publicSigningKey.getKeyId().toHex()); expect(signatures[0].valid).to.be.null; expect(signatures[1].userid).to.equal(publicKey.users[0].userId.userid); - expect(signatures[1].keyid.toHex()).to.equal(privateKeyPacket.getKeyId().toHex()); + expect(signatures[1].keyid.toHex()).to.equal(privateSigningKey.getKeyId().toHex()); expect(signatures[1].valid).to.be.null; expect(signatures[2].userid).to.equal(publicKey.users[1].userId.userid); - expect(signatures[2].keyid.toHex()).to.equal(publicKeyPacket.getKeyId().toHex()); + expect(signatures[2].keyid.toHex()).to.equal(publicSigningKey.getKeyId().toHex()); expect(signatures[2].valid).to.be.null; expect(signatures[3].userid).to.equal(publicKey.users[1].userId.userid); - expect(signatures[3].keyid.toHex()).to.equal(privateKeyPacket.getKeyId().toHex()); + expect(signatures[3].keyid.toHex()).to.equal(privateSigningKey.getKeyId().toHex()); expect(signatures[3].valid).to.be.null; }); @@ -1997,14 +2063,14 @@ VYGdb3eNlV8CfoEC key = key.key; expect(key.users.length).to.equal(1); expect(key.users[0].userId.userid).to.equal(userId1); - expect(key.primaryKey.isDecrypted).to.be.true; + expect(key.isDecrypted()).to.be.true; opt.privateKey = key; opt.userIds = userId2; return openpgp.reformatKey(opt).then(function(newKey) { newKey = newKey.key; expect(newKey.users.length).to.equal(1); expect(newKey.users[0].userId.userid).to.equal(userId2); - expect(newKey.primaryKey.isDecrypted).to.be.true; + expect(newKey.isDecrypted()).to.be.true; }); }); }); @@ -2017,7 +2083,7 @@ VYGdb3eNlV8CfoEC newKey = newKey.key; expect(newKey.users.length).to.equal(1); expect(newKey.users[0].userId.userid).to.equal(userId); - expect(newKey.primaryKey.isDecrypted).to.be.false; + expect(newKey.isDecrypted()).to.be.false; }); }); @@ -2030,8 +2096,8 @@ VYGdb3eNlV8CfoEC return openpgp.generateKey(opt1).then(function(newKey) { newKey = newKey.key; expect(newKey.users[0].userId.userid).to.equal(userId1); - expect(+newKey.primaryKey.created).to.equal(+now); - expect(+newKey.subKeys[0].subKey.created).to.equal(+now); + expect(+newKey.getCreationTime()).to.equal(+now); + expect(+newKey.subKeys[0].getCreationTime()).to.equal(+now); expect(+newKey.subKeys[0].bindingSignatures[0].created).to.equal(+now); const opt2 = {privateKey: newKey, userIds: [userId2], date: before}; return openpgp.reformatKey(opt2).then(function(refKey) { @@ -2051,14 +2117,14 @@ VYGdb3eNlV8CfoEC newKey = newKey.key; expect(newKey.users.length).to.equal(1); expect(newKey.users[0].userId.userid).to.equal(userId); - expect(newKey.primaryKey.isDecrypted).to.be.true; + expect(newKey.isDecrypted()).to.be.true; return openpgp.sign({data: 'hello', privateKeys: newKey, armor: true}).then(function(signed) { return openpgp.verify( {message: openpgp.cleartext.readArmored(signed.data), publicKeys: newKey.toPublic()} ).then(async function(verified) { expect(verified.signatures[0].valid).to.be.true; - const newKeyPacket = await newKey.getSigningKeyPacket(); - expect(verified.signatures[0].keyid.toHex()).to.equal(newKeyPacket.getKeyId().toHex()); + const newSigningKey = await newKey.getSigningKey(); + expect(verified.signatures[0].keyid.toHex()).to.equal(newSigningKey.getKeyId().toHex()); expect(verified.signatures[0].signature.packets.length).to.equal(1); }); }); @@ -2080,9 +2146,9 @@ VYGdb3eNlV8CfoEC newKey = newKey.key; expect(newKey.users.length).to.equal(2); expect(newKey.users[0].userId.userid).to.equal(userId2); - expect(newKey.primaryKey.isDecrypted).to.be.false; + expect(newKey.isDecrypted()).to.be.false; await newKey.decrypt('123'); - expect(newKey.primaryKey.isDecrypted).to.be.true; + expect(newKey.isDecrypted()).to.be.true; }); }); }); @@ -2122,7 +2188,7 @@ VYGdb3eNlV8CfoEC it('Find a valid subkey binding signature among many invalid ones', async function() { const key = openpgp.key.readArmored(valid_binding_sig_among_many_expired_sigs_pub).keys[0]; - expect(await key.getEncryptionKeyPacket()).to.not.be.null; + expect(await key.getEncryptionKey()).to.not.be.null; }); it('Selects the most recent subkey binding signature', async function() { @@ -2135,7 +2201,7 @@ VYGdb3eNlV8CfoEC return openpgp.encrypt({publicKeys: [key], data: 'random data'}).then(() => { throw new Error('encryptSessionKey should not encrypt with revoked public key'); }).catch(function(error) { - expect(error.message).to.equal('Error encrypting message: Could not find valid key packet for encryption in key ' + key.primaryKey.getKeyId().toHex()); + expect(error.message).to.equal('Error encrypting message: Could not find valid key packet for encryption in key ' + key.getKeyId().toHex()); }); }); @@ -2144,7 +2210,7 @@ VYGdb3eNlV8CfoEC return openpgp.encrypt({publicKeys: [key], data: 'random data'}).then(() => { throw new Error('encryptSessionKey should not encrypt with revoked public key'); }).catch(function(error) { - expect(error.message).to.equal('Error encrypting message: Could not find valid key packet for encryption in key ' + key.primaryKey.getKeyId().toHex()); + expect(error.message).to.equal('Error encrypting message: Could not find valid key packet for encryption in key ' + key.getKeyId().toHex()); }); }); @@ -2186,8 +2252,8 @@ VYGdb3eNlV8CfoEC expect(updateKey).to.exist; expect(key.users).to.have.length(1); key.update(updateKey).then(() => { - expect(key.primaryKey.getFingerprint()).to.equal( - updateKey.primaryKey.getFingerprint()); + expect(key.getFingerprint()).to.equal( + updateKey.getFingerprint()); expect(key.users).to.have.length(2); expect(key.users[1].userId).to.be.null; done(); diff --git a/test/general/keyring.js b/test/general/keyring.js index 44566aad..41ca05af 100644 --- a/test/general/keyring.js +++ b/test/general/keyring.js @@ -123,7 +123,7 @@ describe("Keyring", function() { const keys = keyring.getKeysForId(keyId); // we get public and private key expect(keys).to.exist.and.have.length(2); - expect(keys[0].primaryKey.getKeyId().toHex()).equals(keyId); + expect(keys[0].getKeyId().toHex()).equals(keyId); }); it('publicKeys.getForId() - unknown id', function() { @@ -134,7 +134,7 @@ describe("Keyring", function() { it('publicKeys.getForId() - valid id', function() { const key = keyring.publicKeys.getForId(keyId); expect(key).to.exist.and.be.an.instanceof(openpgp.key.Key); - expect(key.primaryKey.getKeyId().toHex()).equals(keyId); + expect(key.getKeyId().toHex()).equals(keyId); }); it('privateKeys.getForId() - unknown id', function() { @@ -145,7 +145,7 @@ describe("Keyring", function() { it('privateKeys.getForId() - valid id', function() { const key = keyring.privateKeys.getForId(keyId); expect(key).to.exist.and.be.an.instanceof(openpgp.key.Key); - expect(key.primaryKey.getKeyId().toHex()).equals(keyId); + expect(key.getKeyId().toHex()).equals(keyId); }); it('publicKeys.getForId() - subkey id', function() { @@ -156,7 +156,7 @@ describe("Keyring", function() { it('publicKeys.getForId() - deep, including subkeys - subkey id', function() { const key = keyring.publicKeys.getForId(subkeyId2, true); expect(key).to.exist.and.be.an.instanceof(openpgp.key.Key); - expect(key.primaryKey.getKeyId().toHex()).equals(keyId2); + expect(key.getKeyId().toHex()).equals(keyId2); }); it('getKeysForId() - unknown fingerprint', function() { @@ -167,7 +167,7 @@ describe("Keyring", function() { it('getKeysForId() - valid fingerprint', function() { const keys = keyring.getKeysForId(keyFingerP2); expect(keys).to.exist.and.have.length(1); - expect(keys[0].primaryKey.getKeyId().toHex()).equals(keyId2); + expect(keys[0].getKeyId().toHex()).equals(keyId2); }); it('publicKeys.getForId() - unknown fingerprint', function() { @@ -178,7 +178,7 @@ describe("Keyring", function() { it('publicKeys.getForId() - valid fingerprint', function() { const key = keyring.publicKeys.getForId(keyFingerP2); expect(key).to.exist.and.be.an.instanceof(openpgp.key.Key); - expect(key.primaryKey.getKeyId().toHex()).equals(keyId2); + expect(key.getKeyId().toHex()).equals(keyId2); }); it('publicKeys.getForId() - subkey fingerprint', function() { @@ -189,7 +189,7 @@ describe("Keyring", function() { it('publicKeys.getForId() - deep, including subkeys - subkey fingerprint', function() { const key = keyring.publicKeys.getForId(subkeyFingerP2, true); expect(key).to.exist.and.be.an.instanceof(openpgp.key.Key); - expect(key.primaryKey.getKeyId().toHex()).equals(keyId2); + expect(key.getKeyId().toHex()).equals(keyId2); }); it('publicKeys.getForAddress() - unknown address', function() { @@ -248,7 +248,7 @@ describe("Keyring", function() { it('publicKeys.removeForId() - valid id', function() { const key = keyring.publicKeys.removeForId(keyId); expect(key).to.exist.and.be.an.instanceof(openpgp.key.Key); - expect(key.primaryKey.getKeyId().toHex()).equals(keyId); + expect(key.getKeyId().toHex()).equals(keyId); expect(keyring.publicKeys.keys).to.exist.and.have.length(1); }); @@ -261,7 +261,7 @@ describe("Keyring", function() { it('publicKeys.removeForId() - valid fingerprint', function() { const key = keyring.publicKeys.removeForId(keyFingerP2); expect(key).to.exist.and.be.an.instanceof(openpgp.key.Key); - expect(key.primaryKey.getKeyId().toHex()).equals(keyId2); + expect(key.getKeyId().toHex()).equals(keyId2); expect(keyring.publicKeys.keys).to.be.empty; }); @@ -272,7 +272,7 @@ describe("Keyring", function() { localstore3.storePublic([]); const key = openpgp.key.readArmored(pubkey).keys[0]; localstore1.storePublic([key]); - expect(localstore2.loadPublic()[0].primaryKey.getKeyId().equals(key.primaryKey.getKeyId())).to.be.true; + expect(localstore2.loadPublic()[0].getKeyId().equals(key.getKeyId())).to.be.true; expect(localstore3.loadPublic()).to.have.length(0); }); diff --git a/test/general/openpgp.js b/test/general/openpgp.js index 536a12be..bb4a860e 100644 --- a/test/general/openpgp.js +++ b/test/general/openpgp.js @@ -766,8 +766,8 @@ describe('OpenPGP.js public api tests', function() { privateKey: privateKey.keys[0], passphrase: passphrase }).then(function(unlocked){ - expect(unlocked.key.primaryKey.getKeyId().toHex()).to.equal(privateKey.keys[0].primaryKey.getKeyId().toHex()); - expect(unlocked.key.primaryKey.isDecrypted).to.be.true; + expect(unlocked.key.getKeyId().toHex()).to.equal(privateKey.keys[0].getKeyId().toHex()); + expect(unlocked.key.isDecrypted()).to.be.true; }); }); @@ -1121,8 +1121,8 @@ describe('OpenPGP.js public api tests', function() { }).then(async function (decrypted) { expect(decrypted.data).to.equal(plaintext); expect(decrypted.signatures[0].valid).to.be.true; - const keyPacket = await privateKey.keys[0].getSigningKeyPacket(); - expect(decrypted.signatures[0].keyid.toHex()).to.equal(keyPacket.getKeyId().toHex()); + const signingKey = await privateKey.keys[0].getSigningKey(); + expect(decrypted.signatures[0].keyid.toHex()).to.equal(signingKey.getKeyId().toHex()); expect(decrypted.signatures[0].signature.packets.length).to.equal(1); }); }); @@ -1144,8 +1144,8 @@ describe('OpenPGP.js public api tests', function() { }).then(async function (decrypted) { expect(decrypted.data).to.equal(plaintext); expect(decrypted.signatures[0].valid).to.be.true; - const keyPacket = await privateKey.keys[0].getSigningKeyPacket(); - expect(decrypted.signatures[0].keyid.toHex()).to.equal(keyPacket.getKeyId().toHex()); + const signingKey = await privateKey.keys[0].getSigningKey(); + expect(decrypted.signatures[0].keyid.toHex()).to.equal(signingKey.getKeyId().toHex()); expect(decrypted.signatures[0].signature.packets.length).to.equal(1); }); }); @@ -1177,8 +1177,8 @@ describe('OpenPGP.js public api tests', function() { }).then(async function (decrypted) { expect(decrypted.data).to.equal(plaintext); expect(decrypted.signatures[0].valid).to.be.true; - const keyPacket = await newPrivateKey.keys[0].getSigningKeyPacket(); - expect(decrypted.signatures[0].keyid.toHex()).to.equal(keyPacket.getKeyId().toHex()); + const signingKey = await newPrivateKey.keys[0].getSigningKey(); + expect(decrypted.signatures[0].keyid.toHex()).to.equal(signingKey.getKeyId().toHex()); expect(decrypted.signatures[0].signature.packets.length).to.equal(1); }); }); @@ -1200,8 +1200,8 @@ describe('OpenPGP.js public api tests', function() { }).then(async function (decrypted) { expect(decrypted.data).to.equal(''); expect(decrypted.signatures[0].valid).to.be.true; - const keyPacket = await privateKey.keys[0].getSigningKeyPacket(); - expect(decrypted.signatures[0].keyid.toHex()).to.equal(keyPacket.getKeyId().toHex()); + const signingKey = await privateKey.keys[0].getSigningKey(); + expect(decrypted.signatures[0].keyid.toHex()).to.equal(signingKey.getKeyId().toHex()); expect(decrypted.signatures[0].signature.packets.length).to.equal(1); }); }); @@ -1224,8 +1224,8 @@ describe('OpenPGP.js public api tests', function() { }).then(async function (decrypted) { expect(decrypted.data).to.equal(plaintext); expect(decrypted.signatures[0].valid).to.be.true; - const keyPacket = await privateKey.keys[0].getSigningKeyPacket(); - expect(decrypted.signatures[0].keyid.toHex()).to.equal(keyPacket.getKeyId().toHex()); + const signingKey = await privateKey.keys[0].getSigningKey(); + expect(decrypted.signatures[0].keyid.toHex()).to.equal(signingKey.getKeyId().toHex()); expect(decrypted.signatures[0].signature.packets.length).to.equal(1); }); }); @@ -1258,8 +1258,8 @@ describe('OpenPGP.js public api tests', function() { }).then(async function (decrypted) { expect(decrypted.data).to.equal(plaintext); expect(decrypted.signatures[0].valid).to.be.true; - const keyPacket = await privateKey.keys[0].getSigningKeyPacket(); - expect(decrypted.signatures[0].keyid.toHex()).to.equal(keyPacket.getKeyId().toHex()); + const signingKey = await privateKey.keys[0].getSigningKey(); + expect(decrypted.signatures[0].keyid.toHex()).to.equal(signingKey.getKeyId().toHex()); expect(decrypted.signatures[0].signature.packets.length).to.equal(1); }); }); @@ -1294,15 +1294,15 @@ describe('OpenPGP.js public api tests', function() { decOpt.message = openpgp.message.readArmored(encrypted.data); return openpgp.decrypt(decOpt); }).then(async function (decrypted) { - let keyPacket; + let signingKey; expect(decrypted.data).to.equal(plaintext); expect(decrypted.signatures[0].valid).to.be.true; - keyPacket = await privateKey.keys[0].getSigningKeyPacket(); - expect(decrypted.signatures[0].keyid.toHex()).to.equal(keyPacket.getKeyId().toHex()); + signingKey = await privateKey.keys[0].getSigningKey(); + expect(decrypted.signatures[0].keyid.toHex()).to.equal(signingKey.getKeyId().toHex()); expect(decrypted.signatures[0].signature.packets.length).to.equal(1); expect(decrypted.signatures[1].valid).to.be.true; - keyPacket = await privKeyDE.getSigningKeyPacket(); - expect(decrypted.signatures[1].keyid.toHex()).to.equal(keyPacket.getKeyId().toHex()); + signingKey = await privKeyDE.getSigningKey(); + expect(decrypted.signatures[1].keyid.toHex()).to.equal(signingKey.getKeyId().toHex()); expect(decrypted.signatures[1].signature.packets.length).to.equal(1); }); }); @@ -1335,8 +1335,8 @@ describe('OpenPGP.js public api tests', function() { }).then(async function (decrypted) { expect(decrypted.data).to.equal(plaintext); expect(decrypted.signatures[0].valid).to.be.null; - const keyPacket = await privateKey.keys[0].getSigningKeyPacket(); - expect(decrypted.signatures[0].keyid.toHex()).to.equal(keyPacket.getKeyId().toHex()); + const signingKey = await privateKey.keys[0].getSigningKey(); + expect(decrypted.signatures[0].keyid.toHex()).to.equal(signingKey.getKeyId().toHex()); expect(decrypted.signatures[0].signature.packets.length).to.equal(1); }); }); @@ -1367,8 +1367,8 @@ describe('OpenPGP.js public api tests', function() { }).then(async function (decrypted) { expect(decrypted.data).to.equal(plaintext); expect(decrypted.signatures[0].valid).to.be.null; - const keyPacket = await privateKey.keys[0].getSigningKeyPacket(); - expect(decrypted.signatures[0].keyid.toHex()).to.equal(keyPacket.getKeyId().toHex()); + const signingKey = await privateKey.keys[0].getSigningKey(); + expect(decrypted.signatures[0].keyid.toHex()).to.equal(signingKey.getKeyId().toHex()); expect(decrypted.signatures[0].signature.packets.length).to.equal(1); }); }); @@ -1389,8 +1389,8 @@ describe('OpenPGP.js public api tests', function() { }).then(async function (decrypted) { expect(decrypted.data).to.equal(plaintext); expect(decrypted.signatures[0].valid).to.be.null; - const keyPacket = await privateKey.keys[0].getSigningKeyPacket(); - expect(decrypted.signatures[0].keyid.toHex()).to.equal(keyPacket.getKeyId().toHex()); + const signingKey = await privateKey.keys[0].getSigningKey(); + expect(decrypted.signatures[0].keyid.toHex()).to.equal(signingKey.getKeyId().toHex()); expect(decrypted.signatures[0].signature.packets.length).to.equal(1); }); }); @@ -1411,8 +1411,8 @@ describe('OpenPGP.js public api tests', function() { }).then(async function (decrypted) { expect(decrypted.data).to.equal(''); expect(decrypted.signatures[0].valid).to.be.null; - const keyPacket = await privateKey.keys[0].getSigningKeyPacket(); - expect(decrypted.signatures[0].keyid.toHex()).to.equal(keyPacket.getKeyId().toHex()); + const signingKey = await privateKey.keys[0].getSigningKey(); + expect(decrypted.signatures[0].keyid.toHex()).to.equal(signingKey.getKeyId().toHex()); expect(decrypted.signatures[0].signature.packets.length).to.equal(1); }); }); @@ -1432,8 +1432,8 @@ describe('OpenPGP.js public api tests', function() { }).then(async function (decrypted) { expect(decrypted.data).to.equal(plaintext); expect(decrypted.signatures[0].valid).to.be.null; - const keyPacket = await privateKey.keys[0].getSigningKeyPacket(); - expect(decrypted.signatures[0].keyid.toHex()).to.equal(keyPacket.getKeyId().toHex()); + const signingKey = await privateKey.keys[0].getSigningKey(); + expect(decrypted.signatures[0].keyid.toHex()).to.equal(signingKey.getKeyId().toHex()); expect(decrypted.signatures[0].signature.packets.length).to.equal(1); }); }); @@ -1456,8 +1456,8 @@ describe('OpenPGP.js public api tests', function() { }).then(async function (decrypted) { expect(decrypted.data).to.equal(plaintext); expect(decrypted.signatures[0].valid).to.be.null; - const keyPacket = await privateKey.keys[0].getSigningKeyPacket(); - expect(decrypted.signatures[0].keyid.toHex()).to.equal(keyPacket.getKeyId().toHex()); + const signingKey = await privateKey.keys[0].getSigningKey(); + expect(decrypted.signatures[0].keyid.toHex()).to.equal(signingKey.getKeyId().toHex()); expect(decrypted.signatures[0].signature.packets.length).to.equal(1); }); }); @@ -1483,15 +1483,15 @@ describe('OpenPGP.js public api tests', function() { decOpt.message = openpgp.message.readArmored(encrypted.data); return openpgp.decrypt(decOpt); }).then(async function (decrypted) { - let keyPacket; + let signingKey; expect(decrypted.data).to.equal(plaintext); expect(decrypted.signatures[0].valid).to.be.true; - keyPacket = await privateKey.keys[0].getSigningKeyPacket(); - expect(decrypted.signatures[0].keyid.toHex()).to.equal(keyPacket.getKeyId().toHex()); + signingKey = await privateKey.keys[0].getSigningKey(); + expect(decrypted.signatures[0].keyid.toHex()).to.equal(signingKey.getKeyId().toHex()); expect(decrypted.signatures[0].signature.packets.length).to.equal(1); expect(decrypted.signatures[1].valid).to.be.true; - keyPacket = await privKeyDE.getSigningKeyPacket(); - expect(decrypted.signatures[1].keyid.toHex()).to.equal(keyPacket.getKeyId().toHex()); + signingKey = await privKeyDE.getSigningKey(); + expect(decrypted.signatures[1].keyid.toHex()).to.equal(signingKey.getKeyId().toHex()); expect(decrypted.signatures[1].signature.packets.length).to.equal(1); }); }); @@ -1511,8 +1511,8 @@ describe('OpenPGP.js public api tests', function() { }).then(async function (verified) { expect(verified.data).to.equal(plaintext); expect(verified.signatures[0].valid).to.be.true; - const keyPacket = await privateKey.keys[0].getSigningKeyPacket(); - expect(verified.signatures[0].keyid.toHex()).to.equal(keyPacket.getKeyId().toHex()); + const signingKey = await privateKey.keys[0].getSigningKey(); + expect(verified.signatures[0].keyid.toHex()).to.equal(signingKey.getKeyId().toHex()); expect(verified.signatures[0].signature.packets.length).to.equal(1); }); }); @@ -1533,15 +1533,15 @@ describe('OpenPGP.js public api tests', function() { verifyOpt.message = openpgp.cleartext.readArmored(signed.data); return openpgp.verify(verifyOpt); }).then(async function (verified) { - let keyPacket; + let signingKey; expect(verified.data).to.equal(plaintext); expect(verified.signatures[0].valid).to.be.true; - keyPacket = await privateKey.keys[0].getSigningKeyPacket(); - expect(verified.signatures[0].keyid.toHex()).to.equal(keyPacket.getKeyId().toHex()); + signingKey = await privateKey.keys[0].getSigningKey(); + expect(verified.signatures[0].keyid.toHex()).to.equal(signingKey.getKeyId().toHex()); expect(verified.signatures[0].signature.packets.length).to.equal(1); expect(verified.signatures[1].valid).to.be.true; - keyPacket = await privKeyDE.getSigningKeyPacket(); - expect(verified.signatures[1].keyid.toHex()).to.equal(keyPacket.getKeyId().toHex()); + signingKey = await privKeyDE.getSigningKey(); + expect(verified.signatures[1].keyid.toHex()).to.equal(signingKey.getKeyId().toHex()); expect(verified.signatures[1].signature.packets.length).to.equal(1); }); }); @@ -1562,8 +1562,8 @@ describe('OpenPGP.js public api tests', function() { }).then(async function (verified) { expect(verified.data).to.equal(plaintext); expect(verified.signatures[0].valid).to.be.true; - const keyPacket = await privateKey.keys[0].getSigningKeyPacket(); - expect(verified.signatures[0].keyid.toHex()).to.equal(keyPacket.getKeyId().toHex()); + const signingKey = await privateKey.keys[0].getSigningKey(); + expect(verified.signatures[0].keyid.toHex()).to.equal(signingKey.getKeyId().toHex()); expect(verified.signatures[0].signature.packets.length).to.equal(1); }); }); @@ -1582,8 +1582,8 @@ describe('OpenPGP.js public api tests', function() { }).then(async function (verified) { expect(verified.data).to.equal(plaintext); expect(verified.signatures[0].valid).to.be.null; - const keyPacket = await privateKey.keys[0].getSigningKeyPacket(); - expect(verified.signatures[0].keyid.toHex()).to.equal(keyPacket.getKeyId().toHex()); + const signingKey = await privateKey.keys[0].getSigningKey(); + expect(verified.signatures[0].keyid.toHex()).to.equal(signingKey.getKeyId().toHex()); expect(verified.signatures[0].signature.packets.length).to.equal(1); }); }); @@ -1604,8 +1604,8 @@ describe('OpenPGP.js public api tests', function() { }).then(async function (verified) { expect(verified.data).to.equal(plaintext); expect(verified.signatures[0].valid).to.be.null; - const keyPacket = await privateKey.keys[0].getSigningKeyPacket(); - expect(verified.signatures[0].keyid.toHex()).to.equal(keyPacket.getKeyId().toHex()); + const signingKey = await privateKey.keys[0].getSigningKey(); + expect(verified.signatures[0].keyid.toHex()).to.equal(signingKey.getKeyId().toHex()); expect(verified.signatures[0].signature.packets.length).to.equal(1); }); }); @@ -1625,8 +1625,8 @@ describe('OpenPGP.js public api tests', function() { }).then(async function (verified) { expect(verified.data).to.equal(plaintext); expect(verified.signatures[0].valid).to.be.true; - const keyPacket = await privateKey.keys[0].getSigningKeyPacket(); - expect(verified.signatures[0].keyid.toHex()).to.equal(keyPacket.getKeyId().toHex()); + const signingKey = await privateKey.keys[0].getSigningKey(); + expect(verified.signatures[0].keyid.toHex()).to.equal(signingKey.getKeyId().toHex()); expect(verified.signatures[0].signature.packets.length).to.equal(1); }); }); @@ -1651,8 +1651,8 @@ describe('OpenPGP.js public api tests', function() { expect(+verified.signatures[0].signature.packets[0].created).to.be.lte(+openpgp.util.normalizeDate()); expect(+verified.signatures[0].signature.packets[0].created).to.be.gte(+start); expect(verified.signatures[0].valid).to.be.true; - const keyPacket = await privateKey.keys[0].getSigningKeyPacket(); - expect(verified.signatures[0].keyid.toHex()).to.equal(keyPacket.getKeyId().toHex()); + const signingKey = await privateKey.keys[0].getSigningKey(); + expect(verified.signatures[0].keyid.toHex()).to.equal(signingKey.getKeyId().toHex()); expect(verified.signatures[0].signature.packets.length).to.equal(1); }); }); @@ -1677,7 +1677,7 @@ describe('OpenPGP.js public api tests', function() { expect(+verified.signatures[0].signature.packets[0].created).to.equal(+past); expect(verified.data).to.equal(plaintext); expect(verified.signatures[0].valid).to.be.true; - expect(signOpt.privateKeys[0].getSigningKeyPacket(verified.signatures[0].keyid, past)) + expect(signOpt.privateKeys[0].getSigningKey(verified.signatures[0].keyid, past)) .to.be.not.null; expect(verified.signatures[0].signature.packets.length).to.equal(1); // now check with expiration checking disabled @@ -1687,7 +1687,7 @@ describe('OpenPGP.js public api tests', function() { expect(+verified.signatures[0].signature.packets[0].created).to.equal(+past); expect(verified.data).to.equal(plaintext); expect(verified.signatures[0].valid).to.be.true; - expect(signOpt.privateKeys[0].getSigningKeyPacket(verified.signatures[0].keyid, null)) + expect(signOpt.privateKeys[0].getSigningKey(verified.signatures[0].keyid, null)) .to.be.not.null; expect(verified.signatures[0].signature.packets.length).to.equal(1); }); @@ -1716,7 +1716,7 @@ describe('OpenPGP.js public api tests', function() { expect(+verified.signatures[0].signature.packets[0].created).to.equal(+future); expect([].slice.call(verified.data)).to.deep.equal([].slice.call(data)); expect(verified.signatures[0].valid).to.be.true; - expect(signOpt.privateKeys[0].getSigningKeyPacket(verified.signatures[0].keyid, future)) + expect(signOpt.privateKeys[0].getSigningKey(verified.signatures[0].keyid, future)) .to.be.not.null; expect(verified.signatures[0].signature.packets.length).to.equal(1); }); @@ -1792,7 +1792,7 @@ describe('OpenPGP.js public api tests', function() { }).then(function (signatures) { expect(+signatures[0].signature.packets[0].created).to.equal(+past); expect(signatures[0].valid).to.be.true; - expect(encryptOpt.privateKeys[0].getSigningKeyPacket(signatures[0].keyid, past)) + expect(encryptOpt.privateKeys[0].getSigningKey(signatures[0].keyid, past)) .to.be.not.null; expect(signatures[0].signature.packets.length).to.equal(1); }); @@ -1821,7 +1821,7 @@ describe('OpenPGP.js public api tests', function() { }).then(function (signatures) { expect(+signatures[0].signature.packets[0].created).to.equal(+future); expect(signatures[0].valid).to.be.true; - expect(encryptOpt.privateKeys[0].getSigningKeyPacket(signatures[0].keyid, future)) + expect(encryptOpt.privateKeys[0].getSigningKey(signatures[0].keyid, future)) .to.be.not.null; expect(signatures[0].signature.packets.length).to.equal(1); }); @@ -1851,7 +1851,7 @@ describe('OpenPGP.js public api tests', function() { }).then(function (signatures) { expect(+signatures[0].signature.packets[0].created).to.equal(+future); expect(signatures[0].valid).to.be.true; - expect(encryptOpt.privateKeys[0].getSigningKeyPacket(signatures[0].keyid, future)) + expect(encryptOpt.privateKeys[0].getSigningKey(signatures[0].keyid, future)) .to.be.not.null; expect(signatures[0].signature.packets.length).to.equal(1); }); @@ -1911,8 +1911,8 @@ describe('OpenPGP.js public api tests', function() { expect(decrypted.data).to.exist; expect(decrypted.data).to.equal(plaintext); expect(decrypted.signatures[0].valid).to.be.true; - const keyPacket = await privKeyDE.getSigningKeyPacket(); - expect(decrypted.signatures[0].keyid.toHex()).to.equal(keyPacket.getKeyId().toHex()); + const signingKey = await privKeyDE.getSigningKey(); + expect(decrypted.signatures[0].keyid.toHex()).to.equal(signingKey.getKeyId().toHex()); expect(decrypted.signatures[0].signature.packets.length).to.equal(1); }); }); diff --git a/test/general/signature.js b/test/general/signature.js index 53c5ab07..039b230e 100644 --- a/test/general/signature.js +++ b/test/general/signature.js @@ -369,7 +369,7 @@ describe("Signature", function() { const pub_key = openpgp.key.readArmored(pub_key_arm1).keys[0]; const msg = openpgp.message.readArmored(msg_arm1); - await priv_key_gnupg_ext.subKeys[0].subKey.decrypt("abcd"); + await priv_key_gnupg_ext.subKeys[0].keyPacket.decrypt("abcd"); return msg.decrypt([priv_key_gnupg_ext]).then(function(msg) { return msg.verify([pub_key]).then(verified => { expect(verified).to.exist; @@ -520,8 +520,8 @@ describe("Signature", function() { const keyids = sMsg.getSigningKeyIds(); - expect(pubKey2.getKeyPackets(keyids[1])).to.not.be.empty; - expect(pubKey3.getKeyPackets(keyids[0])).to.not.be.empty; + expect(pubKey2.getKeys(keyids[1])).to.not.be.empty; + expect(pubKey3.getKeys(keyids[0])).to.not.be.empty; expect(sMsg.getText()).to.equal(plaintext); @@ -566,8 +566,8 @@ describe("Signature", function() { const keyids = csMsg.getSigningKeyIds(); - expect(pubKey2.getKeyPackets(keyids[0])).to.not.be.empty; - expect(pubKey3.getKeyPackets(keyids[1])).to.not.be.empty; + expect(pubKey2.getKeys(keyids[0])).to.not.be.empty; + expect(pubKey3.getKeys(keyids[1])).to.not.be.empty; return openpgp.verify({ publicKeys:[pubKey2, pubKey3], message:csMsg }).then(function(cleartextSig) { expect(cleartextSig).to.exist; @@ -607,7 +607,7 @@ zmuVOdNuWQqxT9Sqa84= const keyids = csMsg.getSigningKeyIds(); - expect(pubKey.getKeyPackets(keyids[0])).to.not.be.empty; + expect(pubKey.getKeys(keyids[0])).to.not.be.empty; return openpgp.verify({ publicKeys:[pubKey], message:csMsg }).then(function(cleartextSig) { expect(cleartextSig).to.exist; @@ -638,7 +638,7 @@ yYDnCgA= const keyids = sMsg.getSigningKeyIds(); - expect(pubKey.getKeyPackets(keyids[0])).to.not.be.empty; + expect(pubKey.getKeys(keyids[0])).to.not.be.empty; return openpgp.verify({ publicKeys:[pubKey], message:sMsg }).then(function(cleartextSig) { expect(cleartextSig).to.exist; @@ -786,7 +786,7 @@ yYDnCgA= const plaintext = 'short message\nnext line\n한국어/조선말'; const pubKey = openpgp.key.readArmored(pub_key_arm2).keys[0]; const privKey = openpgp.key.readArmored(priv_key_arm2).keys[0]; - await Promise.all([privKey.primaryKey.decrypt('hello world'), privKey.subKeys[0].subKey.decrypt('hello world')]); + await Promise.all([privKey.primaryKey.decrypt('hello world'), privKey.subKeys[0].keyPacket.decrypt('hello world')]); return openpgp.sign({ privateKeys:[privKey], data: plaintext, detached: true}).then(function(signed) { const signature = openpgp.signature.readArmored(signed.signature); return openpgp.encrypt({ data: openpgp.util.str_to_Uint8Array(openpgp.util.encode_utf8(plaintext)), publicKeys: [pubKey], signature }) @@ -861,7 +861,7 @@ yYDnCgA= it('Verify subkey revocation signatures', function(done) { const pubKey = openpgp.key.readArmored(pub_revoked).keys[0]; expect(pubKey.subKeys[0].revocationSignatures[0].verify( - pubKey.primaryKey, {key: pubKey.primaryKey, bind: pubKey.subKeys[0].subKey} + pubKey.primaryKey, {key: pubKey.primaryKey, bind: pubKey.subKeys[0].keyPacket} )).to.eventually.be.true.notify(done); }); @@ -1009,9 +1009,9 @@ yYDnCgA= const signerKey = openpgp.key.readArmored(priv_key_arm1).keys[0]; return signedKey.verifyPrimaryUser([signerKey]).then(signatures => { expect(signatures[0].valid).to.be.null; - expect(signatures[0].keyid.toHex()).to.equal(signedKey.primaryKey.getKeyId().toHex()); + expect(signatures[0].keyid.toHex()).to.equal(signedKey.getKeyId().toHex()); expect(signatures[1].valid).to.be.true; - expect(signatures[1].keyid.toHex()).to.equal(signerKey.primaryKey.getKeyId().toHex()); + expect(signatures[1].keyid.toHex()).to.equal(signerKey.getKeyId().toHex()); }); }); diff --git a/test/general/x25519.js b/test/general/x25519.js index 1a3d9154..4d3890cb 100644 --- a/test/general/x25519.js +++ b/test/general/x25519.js @@ -123,7 +123,7 @@ describe('X25519 Cryptography', function () { expect(pub).to.exist; expect(pub.err).to.not.exist; expect(pub.keys).to.have.length(1); - expect(pub.keys[0].primaryKey.getKeyId().toHex()).to.equal(data[name].id); + expect(pub.keys[0].getKeyId().toHex()).to.equal(data[name].id); data[name].pub_key = pub.keys[0]; return data[name].pub_key; } @@ -136,7 +136,7 @@ describe('X25519 Cryptography', function () { expect(pk).to.exist; expect(pk.err).to.not.exist; expect(pk.keys).to.have.length(1); - expect(pk.keys[0].primaryKey.getKeyId().toHex()).to.equal(data[name].id); + expect(pk.keys[0].getKeyId().toHex()).to.equal(data[name].id); expect(await pk.keys[0].decrypt(data[name].pass)).to.be.true; data[name].priv_key = pk.keys[0]; return data[name].priv_key; @@ -227,15 +227,15 @@ describe('X25519 Cryptography', function () { expect(firstKey.key).to.exist; expect(firstKey.key.primaryKey).to.exist; expect(firstKey.key.subKeys).to.have.length(1); - expect(firstKey.key.subKeys[0].subKey).to.exist; + expect(firstKey.key.subKeys[0].keyPacket).to.exist; const hi = firstKey.key; const primaryKey = hi.primaryKey; - const subKey = hi.subKeys[0].subKey; - expect(primaryKey.params[0].getName()).to.equal("ed25519"); - expect(primaryKey.algorithm).to.equal('eddsa'); - expect(subKey.params[0].getName()).to.equal('curve25519'); - expect(subKey.algorithm).to.equal('ecdh'); + const subKey = hi.subKeys[0]; + expect(hi.getAlgorithmInfo().curve).to.equal('ed25519'); + expect(hi.getAlgorithmInfo().algorithm).to.equal('eddsa'); + expect(subKey.getAlgorithmInfo().curve).to.equal('curve25519'); + expect(subKey.getAlgorithmInfo().algorithm).to.equal('ecdh'); // Self Certificate is valid const user = hi.users[0]; @@ -252,10 +252,10 @@ describe('X25519 Cryptography', function () { }; return openpgp.generateKey(options).then(async function (secondKey) { const bye = secondKey.key; - expect(bye.primaryKey.params[0].getName()).to.equal('ed25519'); - expect(bye.primaryKey.algorithm).to.equal('eddsa'); - expect(bye.subKeys[0].subKey.params[0].getName()).to.equal('curve25519'); - expect(bye.subKeys[0].subKey.algorithm).to.equal('ecdh'); + expect(bye.getAlgorithmInfo().curve).to.equal('ed25519'); + expect(bye.getAlgorithmInfo().algorithm).to.equal('eddsa'); + expect(bye.subKeys[0].getAlgorithmInfo().curve).to.equal('curve25519'); + expect(bye.subKeys[0].getAlgorithmInfo().algorithm).to.equal('ecdh'); // Self Certificate is valid const user = bye.users[0];