suzanne.soy/fork-openpgpjs
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Allow dead code elimination

Browse Source
This commit is contained in:
Daniel Huigens 2020-05-14 13:38:08 +02:00
parent c20b75252b
commit fb3d23427d
44 changed files with 682 additions and 600 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
package-lock.json generated
View File

@ -722,6 +722,15 @@
"integrity": "sha1-p9BVi9icQveV3UIyj3QIMcpTvCU=", "integrity": "sha1-p9BVi9icQveV3UIyj3QIMcpTvCU=",
"dev": true "dev": true
}, },
"commander": {
"version": "2.8.1",
"resolved": "https://registry.npmjs.org/commander/-/commander-2.8.1.tgz",
"integrity": "sha1-Br42f+v9oMMwqh4qBy09yXYkJdQ=",
"dev": true,
"requires": {
"graceful-readlink": ">= 1.0.0"
}
},
"commondir": { "commondir": {
"version": "1.0.1", "version": "1.0.1",
"resolved": "https://registry.npmjs.org/commondir/-/commondir-1.0.1.tgz", "resolved": "https://registry.npmjs.org/commondir/-/commondir-1.0.1.tgz",
@ -2815,9 +2824,8 @@
} }
}, },
"pako": { "pako": {
"version": "1.0.6", "version": "github:openpgpjs/pako#f38f7368a5fa511e54b95add2f04444c3a9d803f",
"resolved": "https://registry.npmjs.org/pako/-/pako-1.0.6.tgz", "from": "github:openpgpjs/pako#f38f7368a5fa511e54b95add2f04444c3a9d803f",
"integrity": "sha512-lQe48YPsMJAig+yngZ87Lus+NF+3mtu7DVOBu6b/gHO1YpKwIj5AWjZ/TOS7i46HD/UixzWb1zeWDZfGZ3iYcg==",
"dev": true "dev": true
}, },
"parse-json": { "parse-json": {
@ -3168,22 +3176,11 @@
"dev": true "dev": true
}, },
"seek-bzip": { "seek-bzip": {
"version": "github:openpgpjs/seek-bzip#6187fc025851d35c4e104a25ea15a10b9b8d6f7d", "version": "github:openpgpjs/seek-bzip#4b89457f20c0e1921b4689106a31c99782c29829",
"from": "github:openpgpjs/seek-bzip#6187fc025851d35c4e104a25ea15a10b9b8d6f7d", "from": "github:openpgpjs/seek-bzip#4b89457f20c0e1921b4689106a31c99782c29829",
"dev": true, "dev": true,
"requires": { "requires": {
"commander": "~2.8.1" "commander": "~2.8.1"
},
"dependencies": {
"commander": {
"version": "2.8.1",
"resolved": "https://registry.npmjs.org/commander/-/commander-2.8.1.tgz",
"integrity": "sha1-Br42f+v9oMMwqh4qBy09yXYkJdQ=",
"dev": true,
"requires": {
"graceful-readlink": ">= 1.0.0"
}
}
} }
}, },
"semver": { "semver": {

4
package.json
View File

@ -62,10 +62,10 @@
"jsdoc": "github:openpgpjs/jsdoc#0f1816eb4553856647b4ca9561b9307b11ec4f9e", "jsdoc": "github:openpgpjs/jsdoc#0f1816eb4553856647b4ca9561b9307b11ec4f9e",
"mocha": "^5.0.0", "mocha": "^5.0.0",
"nyc": "^14.1.1", "nyc": "^14.1.1",
"pako": "^1.0.6", "pako": "github:openpgpjs/pako#f38f7368a5fa511e54b95add2f04444c3a9d803f",
"rollup": "^2.7.2", "rollup": "^2.7.2",
"rollup-plugin-terser": "^5.3.0", "rollup-plugin-terser": "^5.3.0",
"seek-bzip": "github:openpgpjs/seek-bzip#6187fc025851d35c4e104a25ea15a10b9b8d6f7d", "seek-bzip": "github:openpgpjs/seek-bzip#4b89457f20c0e1921b4689106a31c99782c29829",
"sinon": "^4.3.0", "sinon": "^4.3.0",
"text-encoding-utf-8": "^1.0.2", "text-encoding-utf-8": "^1.0.2",
"tweetnacl": "github:openpgpjs/tweetnacl-js#3dae25bd3eaa77173f3405676b595721dde92eec", "tweetnacl": "github:openpgpjs/tweetnacl-js#3dae25bd3eaa77173f3405676b595721dde92eec",

4
rollup.config.js
View File

@ -20,6 +20,10 @@ const terserOptions = {
ecma: 2017, ecma: 2017,
compress: { compress: {
unsafe: true unsafe: true
},
output: {
comments: '/^(?:!|#__)/',
preserve_annotations: true
} }
}; };

14
src/cleartext.js
View File

@ -27,7 +27,7 @@
import armor from './encoding/armor'; import armor from './encoding/armor';
import enums from './enums'; import enums from './enums';
import util from './util'; import util from './util';
import packet from './packet'; import { PacketList, LiteralDataPacket, SignaturePacket } from './packet';
import { Signature } from './signature'; import { Signature } from './signature';
import { createVerificationObjects, createSignaturePackets } from './message'; import { createVerificationObjects, createSignaturePackets } from './message';
@ -47,7 +47,7 @@ export function CleartextMessage(text, signature) {
if (signature && !(signature instanceof Signature)) { if (signature && !(signature instanceof Signature)) {
throw new Error('Invalid signature input'); throw new Error('Invalid signature input');
} }
this.signature = signature || new Signature(new packet.List()); this.signature = signature || new Signature(new PacketList());
} }
/** /**
@ -86,7 +86,7 @@ CleartextMessage.prototype.sign = async function(privateKeys, signature = null,
* @async * @async
*/ */
CleartextMessage.prototype.signDetached = async function(privateKeys, signature = null, date = new Date(), userIds = []) { CleartextMessage.prototype.signDetached = async function(privateKeys, signature = null, date = new Date(), userIds = []) {
const literalDataPacket = new packet.Literal(); const literalDataPacket = new LiteralDataPacket();
literalDataPacket.setText(this.text); literalDataPacket.setText(this.text);
return new Signature(await createSignaturePackets(literalDataPacket, privateKeys, signature, date, userIds, true)); return new Signature(await createSignaturePackets(literalDataPacket, privateKeys, signature, date, userIds, true));
@ -112,7 +112,7 @@ CleartextMessage.prototype.verify = function(keys, date = new Date()) {
*/ */
CleartextMessage.prototype.verifyDetached = function(signature, keys, date = new Date()) { CleartextMessage.prototype.verifyDetached = function(signature, keys, date = new Date()) {
const signatureList = signature.packets; const signatureList = signature.packets;
const literalDataPacket = new packet.Literal(); const literalDataPacket = new LiteralDataPacket();
// we assume that cleartext signature is generated based on UTF8 cleartext // we assume that cleartext signature is generated based on UTF8 cleartext
literalDataPacket.setText(this.text); literalDataPacket.setText(this.text);
return createVerificationObjects(signatureList, [literalDataPacket], keys, date, true); return createVerificationObjects(signatureList, [literalDataPacket], keys, date, true);
@ -157,8 +157,8 @@ export async function readArmored(armoredText) {
if (input.type !== enums.armor.signed) { if (input.type !== enums.armor.signed) {
throw new Error('No cleartext signed message.'); throw new Error('No cleartext signed message.');
} }
const packetlist = new packet.List(); const packetlist = new PacketList();
await packetlist.read(input.data); await packetlist.read(input.data, { SignaturePacket });
verifyHeaders(input.headers, packetlist); verifyHeaders(input.headers, packetlist);
const signature = new Signature(packetlist); const signature = new Signature(packetlist);
return new CleartextMessage(input.text, signature); return new CleartextMessage(input.text, signature);
@ -167,7 +167,7 @@ export async function readArmored(armoredText) {
/** /**
* Compare hash algorithm specified in the armor header with signatures * Compare hash algorithm specified in the armor header with signatures
* @param {Array<String>} headers Armor headers * @param {Array<String>} headers Armor headers
* @param {module:packet.List} packetlist The packetlist with signature packets * @param {PacketList} packetlist The packetlist with signature packets
* @private * @private
*/ */
function verifyHeaders(headers, packetlist) { function verifyHeaders(headers, packetlist) {

2
src/crypto/pkcs1.js
View File

@ -19,7 +19,7 @@
* @fileoverview Provides EME-PKCS1-v1_5 encoding and decoding and EMSA-PKCS1-v1_5 encoding function * @fileoverview Provides EME-PKCS1-v1_5 encoding and decoding and EMSA-PKCS1-v1_5 encoding function
* @see module:crypto/public_key/rsa * @see module:crypto/public_key/rsa
* @see module:crypto/public_key/elliptic/ecdh * @see module:crypto/public_key/elliptic/ecdh
* @see module:packet.PublicKeyEncryptedSessionKey * @see PublicKeyEncryptedSessionKeyPacket
* @requires crypto/random * @requires crypto/random
* @requires crypto/hash * @requires crypto/hash
* @requires util * @requires util

2
src/crypto/pkcs5.js
View File

@ -17,7 +17,7 @@
/** /**
* @fileoverview Functions to add and remove PKCS5 padding * @fileoverview Functions to add and remove PKCS5 padding
* @see module:packet.PublicKeyEncryptedSessionKey * @see PublicKeyEncryptedSessionKeyPacket
* @module crypto/pkcs5 * @module crypto/pkcs5
*/ */

12
src/enums.js
View File

@ -196,17 +196,17 @@ export default {
secretKey: 5, secretKey: 5,
publicKey: 6, publicKey: 6,
secretSubkey: 7, secretSubkey: 7,
compressed: 8, compressedData: 8,
symmetricallyEncrypted: 9, symmetricallyEncryptedData: 9,
marker: 10, marker: 10,
literal: 11, literalData: 11,
trust: 12, trust: 12,
userid: 13, userID: 13,
publicSubkey: 14, publicSubkey: 14,
userAttribute: 17, userAttribute: 17,
symEncryptedIntegrityProtected: 18, symEncryptedIntegrityProtectedData: 18,
modificationDetectionCode: 19, modificationDetectionCode: 19,
symEncryptedAEADProtected: 20 // see IETF draft: https://tools.ietf.org/html/draft-ford-openpgp-format-00#section-2.1 symEncryptedAEADProtectedData: 20 // see IETF draft: https://tools.ietf.org/html/draft-ford-openpgp-format-00#section-2.1
}, },
/** Data types in the literal packet /** Data types in the literal packet

2
src/index.js
View File

@ -51,7 +51,7 @@ export { default as util } from './util';
* @see module:packet * @see module:packet
* @name module:openpgp.packet * @name module:openpgp.packet
*/ */
export { default as packet } from './packet'; export * from './packet';
/** /**
* @see module:type/mpi * @see module:type/mpi

16
src/key/factory.js
View File

@ -27,7 +27,7 @@
* @module key/factory * @module key/factory
*/ */
import packet from '../packet'; import { PacketList, UserIDPacket, SignaturePacket } from '../packet';
import Key from './key'; import Key from './key';
import * as helper from './helper'; import * as helper from './helper';
import enums from '../enums'; import enums from '../enums';
@ -147,7 +147,7 @@ async function wrapKeyObject(secretKeyPacket, secretSubkeyPackets, options) {
} }
})); }));
const packetlist = new packet.List(); const packetlist = new PacketList();
packetlist.push(secretKeyPacket); packetlist.push(secretKeyPacket);
@ -165,13 +165,13 @@ async function wrapKeyObject(secretKeyPacket, secretSubkeyPackets, options) {
return algos; return algos;
} }
const userIdPacket = new packet.Userid(); const userIdPacket = new UserIDPacket();
userIdPacket.format(userId); userIdPacket.format(userId);
const dataToSign = {}; const dataToSign = {};
dataToSign.userId = userIdPacket; dataToSign.userId = userIdPacket;
dataToSign.key = secretKeyPacket; dataToSign.key = secretKeyPacket;
const signaturePacket = new packet.Signature(options.date); const signaturePacket = new SignaturePacket(options.date);
signaturePacket.signatureType = enums.signature.certGeneric; signaturePacket.signatureType = enums.signature.certGeneric;
signaturePacket.publicKeyAlgorithm = secretKeyPacket.algorithm; signaturePacket.publicKeyAlgorithm = secretKeyPacket.algorithm;
signaturePacket.hashAlgorithm = await helper.getPreferredHashAlgo(null, secretKeyPacket); signaturePacket.hashAlgorithm = await helper.getPreferredHashAlgo(null, secretKeyPacket);
@ -270,8 +270,8 @@ async function wrapKeyObject(secretKeyPacket, secretSubkeyPackets, options) {
* @static * @static
*/ */
export async function read(data) { export async function read(data) {
const packetlist = new packet.List(); const packetlist = new PacketList();
await packetlist.read(data); await packetlist.read(data, helper.allowedKeyPackets);
return new Key(packetlist); return new Key(packetlist);
} }
@ -299,8 +299,8 @@ export async function readArmored(armoredKey) {
*/ */
export async function readAll(data) { export async function readAll(data) {
const keys = []; const keys = [];
const packetlist = new packet.List(); const packetlist = new PacketList();
await packetlist.read(data); await packetlist.read(data, helper.allowedKeyPackets);
const keyIndex = packetlist.indexOfTag(enums.packet.publicKey, enums.packet.secretKey); const keyIndex = packetlist.indexOfTag(enums.packet.publicKey, enums.packet.secretKey);
if (keyIndex.length === 0) { if (keyIndex.length === 0) {
throw new Error('No key packet found'); throw new Error('No key packet found');

68
src/key/helper.js
View File

@ -7,14 +7,32 @@
* @module key/helper * @module key/helper
*/ */
import packet from '../packet'; import {
PublicKeyPacket,
PublicSubkeyPacket,
SecretKeyPacket,
SecretSubkeyPacket,
UserIDPacket,
UserAttributePacket,
SignaturePacket
} from '../packet';
import enums from '../enums'; import enums from '../enums';
import config from '../config'; import config from '../config';
import crypto from '../crypto'; import crypto from '../crypto';
import util from '../util'; import util from '../util';
export const allowedKeyPackets = {
PublicKeyPacket,
PublicSubkeyPacket,
SecretKeyPacket,
SecretSubkeyPacket,
UserIDPacket,
UserAttributePacket,
SignaturePacket
};
export async function generateSecretSubkey(options) { export async function generateSecretSubkey(options) {
const secretSubkeyPacket = new packet.SecretSubkey(options.date); const secretSubkeyPacket = new SecretSubkeyPacket(options.date);
secretSubkeyPacket.packets = null; secretSubkeyPacket.packets = null;
secretSubkeyPacket.algorithm = enums.read(enums.publicKey, options.algorithm); secretSubkeyPacket.algorithm = enums.read(enums.publicKey, options.algorithm);
await secretSubkeyPacket.generate(options.rsaBits, options.curve); await secretSubkeyPacket.generate(options.rsaBits, options.curve);
@ -22,7 +40,7 @@ export async function generateSecretSubkey(options) {
} }
export async function generateSecretKey(options) { export async function generateSecretKey(options) {
const secretKeyPacket = new packet.SecretKey(options.date); const secretKeyPacket = new SecretKeyPacket(options.date);
secretKeyPacket.packets = null; secretKeyPacket.packets = null;
secretKeyPacket.algorithm = enums.read(enums.publicKey, options.algorithm); secretKeyPacket.algorithm = enums.read(enums.publicKey, options.algorithm);
await secretKeyPacket.generate(options.rsaBits, options.curve); await secretKeyPacket.generate(options.rsaBits, options.curve);
@ -31,9 +49,9 @@ export async function generateSecretKey(options) {
/** /**
* Returns the valid and non-expired signature that has the latest creation date, while ignoring signatures created in the future. * Returns the valid and non-expired signature that has the latest creation date, while ignoring signatures created in the future.
* @param {Array<module:packet.Signature>} signatures List of signatures * @param {Array<SignaturePacket>} signatures List of signatures
* @param {Date} date Use the given date instead of the current time * @param {Date} date Use the given date instead of the current time
* @returns {Promise<module:packet.Signature>} The latest valid signature * @returns {Promise<SignaturePacket>} The latest valid signature
* @async * @async
*/ */
export async function getLatestValidSignature(signatures, primaryKey, signatureType, dataToVerify, date = new Date()) { export async function getLatestValidSignature(signatures, primaryKey, signatureType, dataToVerify, date = new Date()) {
@ -76,15 +94,15 @@ export function isDataExpired(keyPacket, signature, date = new Date()) {
/** /**
* Create Binding signature to the key according to the {@link https://tools.ietf.org/html/rfc4880#section-5.2.1} * Create Binding signature to the key according to the {@link https://tools.ietf.org/html/rfc4880#section-5.2.1}
* @param {module:packet.SecretSubkey} subkey Subkey key packet * @param {SecretSubkeyPacket} subkey Subkey key packet
* @param {module:packet.SecretKey} primaryKey Primary key packet * @param {SecretKeyPacket} primaryKey Primary key packet
* @param {Object} options * @param {Object} options
*/ */
export async function createBindingSignature(subkey, primaryKey, options) { export async function createBindingSignature(subkey, primaryKey, options) {
const dataToSign = {}; const dataToSign = {};
dataToSign.key = primaryKey; dataToSign.key = primaryKey;
dataToSign.bind = subkey; dataToSign.bind = subkey;
const subkeySignaturePacket = new packet.Signature(options.date); const subkeySignaturePacket = new SignaturePacket(options.date);
subkeySignaturePacket.signatureType = enums.signature.subkeyBinding; subkeySignaturePacket.signatureType = enums.signature.subkeyBinding;
subkeySignaturePacket.publicKeyAlgorithm = primaryKey.algorithm; subkeySignaturePacket.publicKeyAlgorithm = primaryKey.algorithm;
subkeySignaturePacket.hashAlgorithm = await getPreferredHashAlgo(null, subkey); subkeySignaturePacket.hashAlgorithm = await getPreferredHashAlgo(null, subkey);
@ -107,7 +125,7 @@ export async function createBindingSignature(subkey, primaryKey, options) {
/** /**
* Returns the preferred signature hash algorithm of a key * Returns the preferred signature hash algorithm of a key
* @param {module:key.Key} key (optional) the key to get preferences from * @param {module:key.Key} key (optional) the key to get preferences from
* @param {module:packet.SecretKey|module:packet.SecretSubkey} keyPacket key packet used for signing * @param {SecretKeyPacket|SecretSubkeyPacket} keyPacket key packet used for signing
* @param {Date} date (optional) use the given date for verification instead of the current time * @param {Date} date (optional) use the given date for verification instead of the current time
* @param {Object} userId (optional) user ID * @param {Object} userId (optional) user ID
* @returns {Promise<String>} * @returns {Promise<String>}
@ -125,10 +143,10 @@ export async function getPreferredHashAlgo(key, keyPacket, date = new Date(), us
} }
} }
switch (Object.getPrototypeOf(keyPacket)) { switch (Object.getPrototypeOf(keyPacket)) {
case packet.SecretKey.prototype: case SecretKeyPacket.prototype:
case packet.PublicKey.prototype: case PublicKeyPacket.prototype:
case packet.SecretSubkey.prototype: case SecretSubkeyPacket.prototype:
case packet.PublicSubkey.prototype: case PublicSubkeyPacket.prototype:
switch (keyPacket.algorithm) { switch (keyPacket.algorithm) {
case 'ecdh': case 'ecdh':
case 'ecdsa': case 'ecdsa':
@ -182,8 +200,8 @@ export async function getPreferredAlgo(type, keys, date = new Date(), userIds =
/** /**
* Create signature packet * Create signature packet
* @param {Object} dataToSign Contains packets to be signed * @param {Object} dataToSign Contains packets to be signed
* @param {module:packet.SecretKey| * @param {SecretKeyPacket|
* module:packet.SecretSubkey} signingKeyPacket secret key packet for signing * SecretSubkeyPacket} signingKeyPacket secret key packet for signing
* @param {Object} signatureProperties (optional) properties to write on the signature packet before signing * @param {Object} signatureProperties (optional) properties to write on the signature packet before signing
* @param {Date} date (optional) override the creationtime of the signature * @param {Date} date (optional) override the creationtime of the signature
* @param {Object} userId (optional) user ID * @param {Object} userId (optional) user ID
@ -195,7 +213,7 @@ export async function createSignaturePacket(dataToSign, privateKey, signingKeyPa
if (!signingKeyPacket.isDecrypted()) { if (!signingKeyPacket.isDecrypted()) {
throw new Error('Private key is not decrypted.'); throw new Error('Private key is not decrypted.');
} }
const signaturePacket = new packet.Signature(date); const signaturePacket = new SignaturePacket(date);
Object.assign(signaturePacket, signatureProperties); Object.assign(signaturePacket, signatureProperties);
signaturePacket.publicKeyAlgorithm = signingKeyPacket.algorithm; signaturePacket.publicKeyAlgorithm = signingKeyPacket.algorithm;
signaturePacket.hashAlgorithm = await getPreferredHashAlgo(privateKey, signingKeyPacket, date, userId); signaturePacket.hashAlgorithm = await getPreferredHashAlgo(privateKey, signingKeyPacket, date, userId);
@ -231,15 +249,15 @@ export async function mergeSignatures(source, dest, attr, checkFn) {
/** /**
* Checks if a given certificate or binding signature is revoked * Checks if a given certificate or binding signature is revoked
* @param {module:packet.SecretKey| * @param {SecretKeyPacket|
* module:packet.PublicKey} primaryKey The primary key packet * PublicKeyPacket} primaryKey The primary key packet
* @param {Object} dataToVerify The data to check * @param {Object} dataToVerify The data to check
* @param {Array<module:packet.Signature>} revocations The revocation signatures to check * @param {Array<SignaturePacket>} revocations The revocation signatures to check
* @param {module:packet.Signature} signature The certificate or signature to check * @param {SignaturePacket} signature The certificate or signature to check
* @param {module:packet.PublicSubkey| * @param {PublicSubkeyPacket|
* module:packet.SecretSubkey| * SecretSubkeyPacket|
* module:packet.PublicKey| * PublicKeyPacket|
* module:packet.SecretKey} key, optional The key packet to check the signature * SecretKeyPacket} key, optional The key packet to check the signature
* @param {Date} date Use the given date instead of the current time * @param {Date} date Use the given date instead of the current time
* @returns {Promise<Boolean>} True if the signature revokes the data * @returns {Promise<Boolean>} True if the signature revokes the data
* @async * @async

60
src/key/key.js
View File

@ -26,7 +26,12 @@
*/ */
import armor from '../encoding/armor'; import armor from '../encoding/armor';
import packet from '../packet'; import {
PacketList,
PublicKeyPacket,
PublicSubkeyPacket,
SignaturePacket
} from '../packet';
import enums from '../enums'; import enums from '../enums';
import util from '../util'; import util from '../util';
import User from './user'; import User from './user';
@ -37,13 +42,13 @@ import * as helper from './helper';
* @class * @class
* @classdesc Class that represents an OpenPGP key. Must contain a primary key. * @classdesc Class that represents an OpenPGP key. Must contain a primary key.
* Can contain additional subkeys, signatures, user ids, user attributes. * Can contain additional subkeys, signatures, user ids, user attributes.
* @param {module:packet.List} packetlist The packets that form this key * @param {PacketList} packetlist The packets that form this key
* @borrows module:packet.PublicKey#getKeyId as Key#getKeyId * @borrows PublicKeyPacket#getKeyId as Key#getKeyId
* @borrows module:packet.PublicKey#getFingerprint as Key#getFingerprint * @borrows PublicKeyPacket#getFingerprint as Key#getFingerprint
* @borrows module:packet.PublicKey#hasSameFingerprintAs as Key#hasSameFingerprintAs * @borrows PublicKeyPacket#hasSameFingerprintAs as Key#hasSameFingerprintAs
* @borrows module:packet.PublicKey#getAlgorithmInfo as Key#getAlgorithmInfo * @borrows PublicKeyPacket#getAlgorithmInfo as Key#getAlgorithmInfo
* @borrows module:packet.PublicKey#getCreationTime as Key#getCreationTime * @borrows PublicKeyPacket#getCreationTime as Key#getCreationTime
* @borrows module:packet.PublicKey#isDecrypted as Key#isDecrypted * @borrows PublicKeyPacket#isDecrypted as Key#isDecrypted
*/ */
export default function Key(packetlist) { export default function Key(packetlist) {
if (!(this instanceof Key)) { if (!(this instanceof Key)) {
@ -71,7 +76,7 @@ Object.defineProperty(Key.prototype, 'primaryKey', {
/** /**
* Transforms packetlist to structured key data * Transforms packetlist to structured key data
* @param {module:packet.List} packetlist The packets that form a key * @param {PacketList} packetlist The packets that form a key
*/ */
Key.prototype.packetlist2structure = function(packetlist) { Key.prototype.packetlist2structure = function(packetlist) {
let user; let user;
@ -87,7 +92,7 @@ Key.prototype.packetlist2structure = function(packetlist) {
this.keyPacket = packetlist[i]; this.keyPacket = packetlist[i];
primaryKeyId = this.getKeyId(); primaryKeyId = this.getKeyId();
break; break;
case enums.packet.userid: case enums.packet.userID:
case enums.packet.userAttribute: case enums.packet.userAttribute:
user = new User(packetlist[i]); user = new User(packetlist[i]);
this.users.push(user); this.users.push(user);
@ -149,10 +154,10 @@ Key.prototype.packetlist2structure = function(packetlist) {
/** /**
* Transforms structured key data to packetlist * Transforms structured key data to packetlist
* @returns {module:packet.List} The packets that form a key * @returns {PacketList} The packets that form a key
*/ */
Key.prototype.toPacketlist = function() { Key.prototype.toPacketlist = function() {
const packetlist = new packet.List(); const packetlist = new PacketList();
packetlist.push(this.keyPacket); packetlist.push(this.keyPacket);
packetlist.concat(this.revocationSignatures); packetlist.concat(this.revocationSignatures);
packetlist.concat(this.directSignatures); packetlist.concat(this.directSignatures);
@ -169,8 +174,8 @@ Key.prototype.toPacketlist = function() {
*/ */
Key.prototype.clone = async function(deep = false) { Key.prototype.clone = async function(deep = false) {
if (deep) { if (deep) {
const packetlist = new packet.List(); const packetlist = new PacketList();
await packetlist.read(this.toPacketlist().write()); await packetlist.read(this.toPacketlist().write(), helper.allowedKeyPackets);
return new Key(packetlist); return new Key(packetlist);
} }
return new Key(this.toPacketlist()); return new Key(this.toPacketlist());
@ -245,7 +250,7 @@ Key.prototype.isPrivate = function() {
* @returns {module:key.Key} new public Key * @returns {module:key.Key} new public Key
*/ */
Key.prototype.toPublic = function() { Key.prototype.toPublic = function() {
const packetlist = new packet.List(); const packetlist = new PacketList();
const keyPackets = this.toPacketlist(); const keyPackets = this.toPacketlist();
let bytes; let bytes;
let pubKeyPacket; let pubKeyPacket;
@ -254,13 +259,13 @@ Key.prototype.toPublic = function() {
switch (keyPackets[i].tag) { switch (keyPackets[i].tag) {
case enums.packet.secretKey: case enums.packet.secretKey:
bytes = keyPackets[i].writePublicKey(); bytes = keyPackets[i].writePublicKey();
pubKeyPacket = new packet.PublicKey(); pubKeyPacket = new PublicKeyPacket();
pubKeyPacket.read(bytes); pubKeyPacket.read(bytes);
packetlist.push(pubKeyPacket); packetlist.push(pubKeyPacket);
break; break;
case enums.packet.secretSubkey: case enums.packet.secretSubkey:
bytes = keyPackets[i].writePublicKey(); bytes = keyPackets[i].writePublicKey();
pubSubkeyPacket = new packet.PublicSubkey(); pubSubkeyPacket = new PublicSubkeyPacket();
pubSubkeyPacket.read(bytes); pubSubkeyPacket.read(bytes);
packetlist.push(pubSubkeyPacket); packetlist.push(pubSubkeyPacket);
break; break;
@ -395,7 +400,7 @@ Key.prototype.getDecryptionKeys = async function(keyId, date = new Date(), userI
* Encrypts all secret key and subkey packets matching keyId * Encrypts all secret key and subkey packets matching keyId
* @param {String|Array<String>} passphrases - if multiple passphrases, then should be in same order as packets each should encrypt * @param {String|Array<String>} passphrases - if multiple passphrases, then should be in same order as packets each should encrypt
* @param {module:type/keyid} keyId * @param {module:type/keyid} keyId
* @returns {Promise<Array<module:packet.SecretKey|module:packet.SecretSubkey>>} * @returns {Promise<Array<SecretKeyPacket|SecretSubkeyPacket>>}
* @async * @async
*/ */
Key.prototype.encrypt = async function(passphrases, keyId = null) { Key.prototype.encrypt = async function(passphrases, keyId = null) {
@ -516,12 +521,11 @@ Key.prototype.clearPrivateParams = function () {
/** /**
* Checks if a signature on a key is revoked * Checks if a signature on a key is revoked
* @param {module:packet.SecretKey| * @param {SignaturePacket} signature The signature to verify
* @param {module:packet.Signature} signature The signature to verify * @param {PublicSubkeyPacket|
* @param {module:packet.PublicSubkey| * SecretSubkeyPacket|
* module:packet.SecretSubkey| * PublicKeyPacket|
* module:packet.PublicKey| * SecretKeyPacket} key, optional The key to verify the signature
* module:packet.SecretKey} key, optional The key to verify the signature
* @param {Date} date Use the given date instead of the current time * @param {Date} date Use the given date instead of the current time
* @returns {Promise<Boolean>} True if the certificate is revoked * @returns {Promise<Boolean>} True if the certificate is revoked
* @async * @async
@ -602,7 +606,7 @@ Key.prototype.getExpirationTime = async function(capabilities, keyId, userId) {
* @param {Date} date (optional) use the given date for verification instead of the current time * @param {Date} date (optional) use the given date for verification instead of the current time
* @param {Object} userId (optional) user ID to get instead of the primary user, if it exists * @param {Object} userId (optional) user ID to get instead of the primary user, if it exists
* @returns {Promise<{user: module:key.User, * @returns {Promise<{user: module:key.User,
* selfCertification: module:packet.Signature}>} The primary user and the self signature * selfCertification: SignaturePacket}>} The primary user and the self signature
* @async * @async
*/ */
Key.prototype.getPrimaryUser = async function(date = new Date(), userId = {}) { Key.prototype.getPrimaryUser = async function(date = new Date(), userId = {}) {
@ -750,7 +754,7 @@ Key.prototype.revoke = async function({
Key.prototype.getRevocationCertificate = async function(date = new Date()) { Key.prototype.getRevocationCertificate = async function(date = new Date()) {
const dataToVerify = { key: this.keyPacket }; const dataToVerify = { key: this.keyPacket };
const revocationSignature = await helper.getLatestValidSignature(this.revocationSignatures, this.keyPacket, enums.signature.keyRevocation, dataToVerify, date); const revocationSignature = await helper.getLatestValidSignature(this.revocationSignatures, this.keyPacket, enums.signature.keyRevocation, dataToVerify, date);
const packetlist = new packet.List(); const packetlist = new PacketList();
packetlist.push(revocationSignature); packetlist.push(revocationSignature);
return armor.encode(enums.armor.publicKey, packetlist.write(), null, null, 'This is a revocation certificate'); return armor.encode(enums.armor.publicKey, packetlist.write(), null, null, 'This is a revocation certificate');
}; };
@ -765,8 +769,8 @@ Key.prototype.getRevocationCertificate = async function(date = new Date()) {
*/ */
Key.prototype.applyRevocationCertificate = async function(revocationCertificate) { Key.prototype.applyRevocationCertificate = async function(revocationCertificate) {
const input = await armor.decode(revocationCertificate); const input = await armor.decode(revocationCertificate);
const packetlist = new packet.List(); const packetlist = new PacketList();
await packetlist.read(input.data); await packetlist.read(input.data, { SignaturePacket });
const revocationSignature = packetlist.findPacket(enums.packet.signature); const revocationSignature = packetlist.findPacket(enums.packet.signature);
if (!revocationSignature || revocationSignature.signatureType !== enums.signature.keyRevocation) { if (!revocationSignature || revocationSignature.signatureType !== enums.signature.keyRevocation) {
throw new Error('Could not find revocation signature packet'); throw new Error('Could not find revocation signature packet');

52
src/key/subkey.js
View File

@ -7,17 +7,17 @@
import enums from '../enums'; import enums from '../enums';
import * as helper from './helper'; import * as helper from './helper';
import packet from '../packet'; import { PacketList } from '../packet';
/** /**
* @class * @class
* @classdesc Class that represents a subkey packet and the relevant signatures. * @classdesc Class that represents a subkey packet and the relevant signatures.
* @borrows module:packet.PublicSubkey#getKeyId as SubKey#getKeyId * @borrows PublicSubkeyPacket#getKeyId as SubKey#getKeyId
* @borrows module:packet.PublicSubkey#getFingerprint as SubKey#getFingerprint * @borrows PublicSubkeyPacket#getFingerprint as SubKey#getFingerprint
* @borrows module:packet.PublicSubkey#hasSameFingerprintAs as SubKey#hasSameFingerprintAs * @borrows PublicSubkeyPacket#hasSameFingerprintAs as SubKey#hasSameFingerprintAs
* @borrows module:packet.PublicSubkey#getAlgorithmInfo as SubKey#getAlgorithmInfo * @borrows PublicSubkeyPacket#getAlgorithmInfo as SubKey#getAlgorithmInfo
* @borrows module:packet.PublicSubkey#getCreationTime as SubKey#getCreationTime * @borrows PublicSubkeyPacket#getCreationTime as SubKey#getCreationTime
* @borrows module:packet.PublicSubkey#isDecrypted as SubKey#isDecrypted * @borrows PublicSubkeyPacket#isDecrypted as SubKey#isDecrypted
*/ */
export default function SubKey(subKeyPacket) { export default function SubKey(subKeyPacket) {
if (!(this instanceof SubKey)) { if (!(this instanceof SubKey)) {
@ -30,10 +30,10 @@ export default function SubKey(subKeyPacket) {
/** /**
* Transforms structured subkey data to packetlist * Transforms structured subkey data to packetlist
* @returns {module:packet.List} * @returns {PacketListPacket}
*/ */
SubKey.prototype.toPacketlist = function() { SubKey.prototype.toPacketlist = function() {
const packetlist = new packet.List(); const packetlist = new PacketList();
packetlist.push(this.keyPacket); packetlist.push(this.keyPacket);
packetlist.concat(this.revocationSignatures); packetlist.concat(this.revocationSignatures);
packetlist.concat(this.bindingSignatures); packetlist.concat(this.bindingSignatures);
@ -42,13 +42,13 @@ SubKey.prototype.toPacketlist = function() {
/** /**
* Checks if a binding signature of a subkey is revoked * Checks if a binding signature of a subkey is revoked
* @param {module:packet.SecretKey| * @param {SecretKeyPacket|
* module:packet.PublicKey} primaryKey The primary key packet * PublicKeyPacket} primaryKey The primary key packet
* @param {module:packet.Signature} signature The binding signature to verify * @param {SignaturePacket} signature The binding signature to verify
* @param {module:packet.PublicSubkey| * @param {PublicSubkeyPacket|
* module:packet.SecretSubkey| * SecretSubkeyPacket|
* module:packet.PublicKey| * PublicKeyPacket|
* module:packet.SecretKey} key, optional The key to verify the signature * SecretKeyPacket} key, optional The key to verify the signature
* @param {Date} date Use the given date instead of the current time * @param {Date} date Use the given date instead of the current time
* @returns {Promise<Boolean>} True if the binding signature is revoked * @returns {Promise<Boolean>} True if the binding signature is revoked
* @async * @async
@ -66,9 +66,9 @@ SubKey.prototype.isRevoked = async function(primaryKey, signature, key, date = n
/** /**
* Verify subkey. Checks for revocation signatures, expiration time * Verify subkey. Checks for revocation signatures, expiration time
* and valid binding signature. Throws if the subkey is invalid. * and valid binding signature. Throws if the subkey is invalid.
* @param {module:packet.SecretKey| * @param {SecretKeyPacket|
* module:packet.PublicKey} primaryKey The primary key packet * PublicKeyPacket} primaryKey The primary key packet
* @param {Date} date Use the given date instead of the current time * @param {Date} date Use the given date instead of the current time
* @returns {Promise<undefined>} * @returns {Promise<undefined>}
* @async * @async
*/ */
@ -89,9 +89,9 @@ SubKey.prototype.verify = async function(primaryKey, date = new Date()) {
/** /**
* Returns the expiration time of the subkey or Infinity if key does not expire * Returns the expiration time of the subkey or Infinity if key does not expire
* Returns null if the subkey is invalid. * Returns null if the subkey is invalid.
* @param {module:packet.SecretKey| * @param {SecretKeyPacket|
* module:packet.PublicKey} primaryKey The primary key packet * PublicKeyPacket} primaryKey The primary key packet
* @param {Date} date Use the given date instead of the current time * @param {Date} date Use the given date instead of the current time
* @returns {Promise<Date | Infinity | null>} * @returns {Promise<Date | Infinity | null>}
* @async * @async
*/ */
@ -110,9 +110,9 @@ SubKey.prototype.getExpirationTime = async function(primaryKey, date = new Date(
/** /**
* Update subkey with new components from specified subkey * Update subkey with new components from specified subkey
* @param {module:key~SubKey} subKey Source subkey to merge * @param {module:key~SubKey} subKey Source subkey to merge
* @param {module:packet.SecretKey| * @param {SecretKeyPacket|
module:packet.SecretSubkey} primaryKey primary key used for validation SecretSubkeyPacket} primaryKey primary key used for validation
* @returns {Promise<undefined>} * @returns {Promise<undefined>}
* @async * @async
*/ */
@ -151,7 +151,7 @@ SubKey.prototype.update = async function(subKey, primaryKey) {
/** /**
* Revokes the subkey * Revokes the subkey
* @param {module:packet.SecretKey} primaryKey decrypted private primary key for revocation * @param {SecretKeyPacket} primaryKey decrypted private primary key for revocation
* @param {Object} reasonForRevocation optional, object indicating the reason for revocation * @param {Object} reasonForRevocation optional, object indicating the reason for revocation
* @param {module:enums.reasonForRevocation} reasonForRevocation.flag optional, flag indicating the reason for revocation * @param {module:enums.reasonForRevocation} reasonForRevocation.flag optional, flag indicating the reason for revocation
* @param {String} reasonForRevocation.string optional, string explaining the reason for revocation * @param {String} reasonForRevocation.string optional, string explaining the reason for revocation

50
src/key/user.js
View File

@ -8,7 +8,7 @@
import enums from '../enums'; import enums from '../enums';
import util from '../util'; import util from '../util';
import packet from '../packet'; import { PacketList } from '../packet';
import { mergeSignatures, isDataRevoked, createSignaturePacket } from './helper'; import { mergeSignatures, isDataRevoked, createSignaturePacket } from './helper';
/** /**
@ -19,7 +19,7 @@ export default function User(userPacket) {
if (!(this instanceof User)) { if (!(this instanceof User)) {
return new User(userPacket); return new User(userPacket);
} }
this.userId = userPacket.tag === enums.packet.userid ? userPacket : null; this.userId = userPacket.tag === enums.packet.userID ? userPacket : null;
this.userAttribute = userPacket.tag === enums.packet.userAttribute ? userPacket : null; this.userAttribute = userPacket.tag === enums.packet.userAttribute ? userPacket : null;
this.selfCertifications = []; this.selfCertifications = [];
this.otherCertifications = []; this.otherCertifications = [];
@ -28,10 +28,10 @@ export default function User(userPacket) {
/** /**
* Transforms structured user data to packetlist * Transforms structured user data to packetlist
* @returns {module:packet.List} * @returns {PacketList}
*/ */
User.prototype.toPacketlist = function() { User.prototype.toPacketlist = function() {
const packetlist = new packet.List(); const packetlist = new PacketList();
packetlist.push(this.userId || this.userAttribute); packetlist.push(this.userId || this.userAttribute);
packetlist.concat(this.revocationSignatures); packetlist.concat(this.revocationSignatures);
packetlist.concat(this.selfCertifications); packetlist.concat(this.selfCertifications);
@ -41,8 +41,8 @@ User.prototype.toPacketlist = function() {
/** /**
* Signs user * Signs user
* @param {module:packet.SecretKey| * @param {SecretKeyPacket|
* module:packet.PublicKey} primaryKey The primary key packet * PublicKeyPacket} primaryKey The primary key packet
* @param {Array<module:key.Key>} privateKeys Decrypted private keys for signing * @param {Array<module:key.Key>} privateKeys Decrypted private keys for signing
* @returns {Promise<module:key.Key>} New user with new certificate signatures * @returns {Promise<module:key.Key>} New user with new certificate signatures
* @async * @async
@ -74,13 +74,13 @@ User.prototype.sign = async function(primaryKey, privateKeys) {
/** /**
* Checks if a given certificate of the user is revoked * Checks if a given certificate of the user is revoked
* @param {module:packet.SecretKey| * @param {SecretKeyPacket|
* module:packet.PublicKey} primaryKey The primary key packet * PublicKeyPacket} primaryKey The primary key packet
* @param {module:packet.Signature} certificate The certificate to verify * @param {SignaturePacket} certificate The certificate to verify
* @param {module:packet.PublicSubkey| * @param {PublicSubkeyPacket|
* module:packet.SecretSubkey| * SecretSubkeyPacket|
* module:packet.PublicKey| * PublicKeyPacket|
* module:packet.SecretKey} key, optional The key to verify the signature * SecretKeyPacket} key, optional The key to verify the signature
* @param {Date} date Use the given date instead of the current time * @param {Date} date Use the given date instead of the current time
* @returns {Promise<Boolean>} True if the certificate is revoked * @returns {Promise<Boolean>} True if the certificate is revoked
* @async * @async
@ -98,9 +98,9 @@ User.prototype.isRevoked = async function(primaryKey, certificate, key, date = n
/** /**
* Verifies the user certificate. Throws if the user certificate is invalid. * Verifies the user certificate. Throws if the user certificate is invalid.
* @param {module:packet.SecretKey| * @param {SecretKeyPacket|
* module:packet.PublicKey} primaryKey The primary key packet * PublicKeyPacket} primaryKey The primary key packet
* @param {module:packet.Signature} certificate A certificate of this user * @param {SignaturePacket} certificate A certificate of this user
* @param {Array<module:key.Key>} keys Array of keys to verify certificate signatures * @param {Array<module:key.Key>} keys Array of keys to verify certificate signatures
* @param {Date} date Use the given date instead of the current time * @param {Date} date Use the given date instead of the current time
* @returns {Promise<true>} status of the certificate * @returns {Promise<true>} status of the certificate
@ -137,8 +137,8 @@ User.prototype.verifyCertificate = async function(primaryKey, certificate, keys,
/** /**
* Verifies all user certificates * Verifies all user certificates
* @param {module:packet.SecretKey| * @param {SecretKeyPacket|
* module:packet.PublicKey} primaryKey The primary key packet * PublicKeyPacket} primaryKey The primary key packet
* @param {Array<module:key.Key>} keys Array of keys to verify certificate signatures * @param {Array<module:key.Key>} keys Array of keys to verify certificate signatures
* @param {Date} date Use the given date instead of the current time * @param {Date} date Use the given date instead of the current time
* @returns {Promise<Array<{keyid: module:type/keyid, * @returns {Promise<Array<{keyid: module:type/keyid,
@ -159,10 +159,10 @@ User.prototype.verifyAllCertifications = async function(primaryKey, keys, date =
/** /**
* Verify User. Checks for existence of self signatures, revocation signatures * Verify User. Checks for existence of self signatures, revocation signatures
* and validity of self signature. Throws when there are no valid self signatures. * and validity of self signature. Throws when there are no valid self signatures.
* @param {module:packet.SecretKey| * @param {SecretKeyPacket|
* module:packet.PublicKey} primaryKey The primary key packet * PublicKeyPacket} primaryKey The primary key packet
* @param {Date} date Use the given date instead of the current time * @param {Date} date Use the given date instead of the current time
* @returns {Promise<true>} Status of user * @returns {Promise<true>} Status of user
* @async * @async
*/ */
User.prototype.verify = async function(primaryKey, date = new Date()) { User.prototype.verify = async function(primaryKey, date = new Date()) {
@ -201,9 +201,9 @@ User.prototype.verify = async function(primaryKey, date = new Date()) {
/** /**
* Update user with new components from specified user * Update user with new components from specified user
* @param {module:key.User} user Source user to merge * @param {module:key.User} user Source user to merge
* @param {module:packet.SecretKey| * @param {SecretKeyPacket|
* module:packet.SecretSubkey} primaryKey primary key used for validation * SecretSubkeyPacket} primaryKey primary key used for validation
* @returns {Promise<undefined>} * @returns {Promise<undefined>}
* @async * @async
*/ */

109
src/message.js
View File

@ -36,7 +36,18 @@ import config from './config';
import crypto from './crypto'; import crypto from './crypto';
import enums from './enums'; import enums from './enums';
import util from './util'; import util from './util';
import packet from './packet'; import {
PacketList,
LiteralDataPacket,
CompressedDataPacket,
SymEncryptedAEADProtectedDataPacket,
SymEncryptedIntegrityProtectedDataPacket,
SymmetricallyEncryptedDataPacket,
PublicKeyEncryptedSessionKeyPacket,
SymEncryptedSessionKeyPacket,
OnePassSignaturePacket,
SignaturePacket
} from './packet';
import { Signature } from './signature'; import { Signature } from './signature';
import { getPreferredHashAlgo, getPreferredAlgo, isAeadSupported, createSignaturePacket } from './key'; import { getPreferredHashAlgo, getPreferredAlgo, isAeadSupported, createSignaturePacket } from './key';
@ -45,7 +56,7 @@ import { getPreferredHashAlgo, getPreferredAlgo, isAeadSupported, createSignatur
* @class * @class
* @classdesc Class that represents an OpenPGP message. * @classdesc Class that represents an OpenPGP message.
* Can be an encrypted message, signed message, compressed message or literal message * Can be an encrypted message, signed message, compressed message or literal message
* @param {module:packet.List} packetlist The packets that form this message * @param {module:PacketList} packetlist The packets that form this message
* See {@link https://tools.ietf.org/html/rfc4880#section-11.3} * See {@link https://tools.ietf.org/html/rfc4880#section-11.3}
*/ */
@ -53,7 +64,7 @@ export function Message(packetlist) {
if (!(this instanceof Message)) { if (!(this instanceof Message)) {
return new Message(packetlist); return new Message(packetlist);
} }
this.packets = packetlist || new packet.List(); this.packets = packetlist || new PacketList();
} }
/** /**
@ -104,9 +115,9 @@ Message.prototype.decrypt = async function(privateKeys, passwords, sessionKeys,
const keyObjs = sessionKeys || await this.decryptSessionKeys(privateKeys, passwords); const keyObjs = sessionKeys || await this.decryptSessionKeys(privateKeys, passwords);
const symEncryptedPacketlist = this.packets.filterByTag( const symEncryptedPacketlist = this.packets.filterByTag(
enums.packet.symmetricallyEncrypted, enums.packet.symmetricallyEncryptedData,
enums.packet.symEncryptedIntegrityProtected, enums.packet.symEncryptedIntegrityProtectedData,
enums.packet.symEncryptedAEADProtected enums.packet.symEncryptedAEADProtectedData
); );
if (symEncryptedPacketlist.length === 0) { if (symEncryptedPacketlist.length === 0) {
@ -137,7 +148,7 @@ Message.prototype.decrypt = async function(privateKeys, passwords, sessionKeys,
} }
const resultMsg = new Message(symEncryptedPacket.packets); const resultMsg = new Message(symEncryptedPacket.packets);
symEncryptedPacket.packets = new packet.List(); // remove packets after decryption symEncryptedPacket.packets = new PacketList(); // remove packets after decryption
return resultMsg; return resultMsg;
}; };
@ -162,8 +173,8 @@ Message.prototype.decryptSessionKeys = async function(privateKeys, passwords) {
await Promise.all(passwords.map(async function(password, i) { await Promise.all(passwords.map(async function(password, i) {
let packets; let packets;
if (i) { if (i) {
packets = new packet.List(); packets = new PacketList();
await packets.read(symESKeyPacketlist.write()); await packets.read(symESKeyPacketlist.write(), { SymEncryptedSessionKeyPacket });
} else { } else {
packets = symESKeyPacketlist; packets = symESKeyPacketlist;
} }
@ -249,7 +260,7 @@ Message.prototype.decryptSessionKeys = async function(privateKeys, passwords) {
*/ */
Message.prototype.getLiteralData = function() { Message.prototype.getLiteralData = function() {
const msg = this.unwrapCompressed(); const msg = this.unwrapCompressed();
const literal = msg.packets.findPacket(enums.packet.literal); const literal = msg.packets.findPacket(enums.packet.literalData);
return (literal && literal.getBytes()) || null; return (literal && literal.getBytes()) || null;
}; };
@ -259,7 +270,7 @@ Message.prototype.getLiteralData = function() {
*/ */
Message.prototype.getFilename = function() { Message.prototype.getFilename = function() {
const msg = this.unwrapCompressed(); const msg = this.unwrapCompressed();
const literal = msg.packets.findPacket(enums.packet.literal); const literal = msg.packets.findPacket(enums.packet.literalData);
return (literal && literal.getFilename()) || null; return (literal && literal.getFilename()) || null;
}; };
@ -269,7 +280,7 @@ Message.prototype.getFilename = function() {
*/ */
Message.prototype.getText = function() { Message.prototype.getText = function() {
const msg = this.unwrapCompressed(); const msg = this.unwrapCompressed();
const literal = msg.packets.findPacket(enums.packet.literal); const literal = msg.packets.findPacket(enums.packet.literalData);
if (literal) { if (literal) {
return literal.getText(); return literal.getText();
} }
@ -324,19 +335,19 @@ Message.prototype.encrypt = async function(keys, passwords, sessionKey, wildcard
let symEncryptedPacket; let symEncryptedPacket;
if (aeadAlgorithm) { if (aeadAlgorithm) {
symEncryptedPacket = new packet.SymEncryptedAEADProtected(); symEncryptedPacket = new SymEncryptedAEADProtectedDataPacket();
symEncryptedPacket.aeadAlgorithm = aeadAlgorithm; symEncryptedPacket.aeadAlgorithm = aeadAlgorithm;
} else if (config.integrityProtect) { } else if (config.integrityProtect) {
symEncryptedPacket = new packet.SymEncryptedIntegrityProtected(); symEncryptedPacket = new SymEncryptedIntegrityProtectedDataPacket();
} else { } else {
symEncryptedPacket = new packet.SymmetricallyEncrypted(); symEncryptedPacket = new SymmetricallyEncryptedDataPacket();
} }
symEncryptedPacket.packets = this.packets; symEncryptedPacket.packets = this.packets;
await symEncryptedPacket.encrypt(algorithm, sessionKeyData, streaming); await symEncryptedPacket.encrypt(algorithm, sessionKeyData, streaming);
msg.packets.push(symEncryptedPacket); msg.packets.push(symEncryptedPacket);
symEncryptedPacket.packets = new packet.List(); // remove packets after encryption symEncryptedPacket.packets = new PacketList(); // remove packets after encryption
return msg; return msg;
}; };
@ -354,12 +365,12 @@ Message.prototype.encrypt = async function(keys, passwords, sessionKey, wildcard
* @async * @async
*/ */
export async function encryptSessionKey(sessionKey, algorithm, aeadAlgorithm, publicKeys, passwords, wildcard = false, date = new Date(), userIds = []) { export async function encryptSessionKey(sessionKey, algorithm, aeadAlgorithm, publicKeys, passwords, wildcard = false, date = new Date(), userIds = []) {
const packetlist = new packet.List(); const packetlist = new PacketList();
if (publicKeys) { if (publicKeys) {
const results = await Promise.all(publicKeys.map(async function(publicKey) { const results = await Promise.all(publicKeys.map(async function(publicKey) {
const encryptionKey = await publicKey.getEncryptionKey(undefined, date, userIds); const encryptionKey = await publicKey.getEncryptionKey(undefined, date, userIds);
const pkESKeyPacket = new packet.PublicKeyEncryptedSessionKey(); const pkESKeyPacket = new PublicKeyEncryptedSessionKeyPacket();
pkESKeyPacket.publicKeyId = wildcard ? type_keyid.wildcard() : encryptionKey.getKeyId(); pkESKeyPacket.publicKeyId = wildcard ? type_keyid.wildcard() : encryptionKey.getKeyId();
pkESKeyPacket.publicKeyAlgorithm = encryptionKey.keyPacket.algorithm; pkESKeyPacket.publicKeyAlgorithm = encryptionKey.keyPacket.algorithm;
pkESKeyPacket.sessionKey = sessionKey; pkESKeyPacket.sessionKey = sessionKey;
@ -383,7 +394,7 @@ export async function encryptSessionKey(sessionKey, algorithm, aeadAlgorithm, pu
const sum = (accumulator, currentValue) => accumulator + currentValue; const sum = (accumulator, currentValue) => accumulator + currentValue;
const encryptPassword = async function(sessionKey, algorithm, aeadAlgorithm, password) { const encryptPassword = async function(sessionKey, algorithm, aeadAlgorithm, password) {
const symEncryptedSessionKeyPacket = new packet.SymEncryptedSessionKey(); const symEncryptedSessionKeyPacket = new SymEncryptedSessionKeyPacket();
symEncryptedSessionKeyPacket.sessionKey = sessionKey; symEncryptedSessionKeyPacket.sessionKey = sessionKey;
symEncryptedSessionKeyPacket.sessionKeyAlgorithm = algorithm; symEncryptedSessionKeyPacket.sessionKeyAlgorithm = algorithm;
if (aeadAlgorithm) { if (aeadAlgorithm) {
@ -420,9 +431,9 @@ export async function encryptSessionKey(sessionKey, algorithm, aeadAlgorithm, pu
* @async * @async
*/ */
Message.prototype.sign = async function(privateKeys = [], signature = null, date = new Date(), userIds = [], streaming = false) { Message.prototype.sign = async function(privateKeys = [], signature = null, date = new Date(), userIds = [], streaming = false) {
const packetlist = new packet.List(); const packetlist = new PacketList();
const literalDataPacket = this.packets.findPacket(enums.packet.literal); const literalDataPacket = this.packets.findPacket(enums.packet.literalData);
if (!literalDataPacket) { if (!literalDataPacket) {
throw new Error('No literal data packet to sign.'); throw new Error('No literal data packet to sign.');
} }
@ -437,7 +448,7 @@ Message.prototype.sign = async function(privateKeys = [], signature = null, date
existingSigPacketlist = signature.packets.filterByTag(enums.packet.signature); existingSigPacketlist = signature.packets.filterByTag(enums.packet.signature);
for (i = existingSigPacketlist.length - 1; i >= 0; i--) { for (i = existingSigPacketlist.length - 1; i >= 0; i--) {
const signaturePacket = existingSigPacketlist[i]; const signaturePacket = existingSigPacketlist[i];
const onePassSig = new packet.OnePassSignature(); const onePassSig = new OnePassSignaturePacket();
onePassSig.signatureType = signaturePacket.signatureType; onePassSig.signatureType = signaturePacket.signatureType;
onePassSig.hashAlgorithm = signaturePacket.hashAlgorithm; onePassSig.hashAlgorithm = signaturePacket.hashAlgorithm;
onePassSig.publicKeyAlgorithm = signaturePacket.publicKeyAlgorithm; onePassSig.publicKeyAlgorithm = signaturePacket.publicKeyAlgorithm;
@ -454,7 +465,7 @@ Message.prototype.sign = async function(privateKeys = [], signature = null, date
throw new Error('Need private key for signing'); throw new Error('Need private key for signing');
} }
const signingKey = await privateKey.getSigningKey(undefined, date, userIds); const signingKey = await privateKey.getSigningKey(undefined, date, userIds);
const onePassSig = new packet.OnePassSignature(); const onePassSig = new OnePassSignaturePacket();
onePassSig.signatureType = signatureType; onePassSig.signatureType = signatureType;
onePassSig.hashAlgorithm = await getPreferredHashAlgo(privateKey, signingKey.keyPacket, date, userIds); onePassSig.hashAlgorithm = await getPreferredHashAlgo(privateKey, signingKey.keyPacket, date, userIds);
onePassSig.publicKeyAlgorithm = signingKey.keyPacket.algorithm; onePassSig.publicKeyAlgorithm = signingKey.keyPacket.algorithm;
@ -483,11 +494,11 @@ Message.prototype.compress = function(compression) {
return this; return this;
} }
const compressed = new packet.Compressed(); const compressed = new CompressedDataPacket();
compressed.packets = this.packets; compressed.packets = this.packets;
compressed.algorithm = enums.read(enums.compression, compression); compressed.algorithm = enums.read(enums.compression, compression);
const packetList = new packet.List(); const packetList = new PacketList();
packetList.push(compressed); packetList.push(compressed);
return new Message(packetList); return new Message(packetList);
@ -504,7 +515,7 @@ Message.prototype.compress = function(compression) {
* @async * @async
*/ */
Message.prototype.signDetached = async function(privateKeys = [], signature = null, date = new Date(), userIds = [], streaming = false) { Message.prototype.signDetached = async function(privateKeys = [], signature = null, date = new Date(), userIds = [], streaming = false) {
const literalDataPacket = this.packets.findPacket(enums.packet.literal); const literalDataPacket = this.packets.findPacket(enums.packet.literalData);
if (!literalDataPacket) { if (!literalDataPacket) {
throw new Error('No literal data packet to sign.'); throw new Error('No literal data packet to sign.');
} }
@ -513,18 +524,18 @@ Message.prototype.signDetached = async function(privateKeys = [], signature = nu
/** /**
* Create signature packets for the message * Create signature packets for the message
* @param {module:packet.Literal} literalDataPacket the literal data packet to sign * @param {LiteralDataPacket} literalDataPacket the literal data packet to sign
* @param {Array<module:key.Key>} privateKeys private keys with decrypted secret key data for signing * @param {Array<module:key.Key>} privateKeys private keys with decrypted secret key data for signing
* @param {Signature} signature (optional) any existing detached signature to append * @param {Signature} signature (optional) any existing detached signature to append
* @param {Date} date (optional) override the creationtime of the signature * @param {Date} date (optional) override the creationtime of the signature
* @param {Array} userIds (optional) user IDs to sign with, e.g. [{ name:'Steve Sender', email:'steve@openpgp.org' }] * @param {Array} userIds (optional) user IDs to sign with, e.g. [{ name:'Steve Sender', email:'steve@openpgp.org' }]
* @param {Boolean} detached (optional) whether to create detached signature packets * @param {Boolean} detached (optional) whether to create detached signature packets
* @param {Boolean} streaming (optional) whether to process data as a stream * @param {Boolean} streaming (optional) whether to process data as a stream
* @returns {Promise<module:packet.List>} list of signature packets * @returns {Promise<module:PacketList>} list of signature packets
* @async * @async
*/ */
export async function createSignaturePackets(literalDataPacket, privateKeys, signature = null, date = new Date(), userIds = [], detached = false, streaming = false) { export async function createSignaturePackets(literalDataPacket, privateKeys, signature = null, date = new Date(), userIds = [], detached = false, streaming = false) {
const packetlist = new packet.List(); const packetlist = new PacketList();
// If data packet was created from Uint8Array, use binary, otherwise use text // If data packet was created from Uint8Array, use binary, otherwise use text
const signatureType = literalDataPacket.text === null ? const signatureType = literalDataPacket.text === null ?
@ -558,7 +569,7 @@ export async function createSignaturePackets(literalDataPacket, privateKeys, sig
*/ */
Message.prototype.verify = async function(keys, date = new Date(), streaming) { Message.prototype.verify = async function(keys, date = new Date(), streaming) {
const msg = this.unwrapCompressed(); const msg = this.unwrapCompressed();
const literalDataList = msg.packets.filterByTag(enums.packet.literal); const literalDataList = msg.packets.filterByTag(enums.packet.literalData);
if (literalDataList.length !== 1) { if (literalDataList.length !== 1) {
throw new Error('Can only verify message with one literal data packet.'); throw new Error('Can only verify message with one literal data packet.');
} }
@ -610,7 +621,7 @@ Message.prototype.verify = async function(keys, date = new Date(), streaming) {
*/ */
Message.prototype.verifyDetached = function(signature, keys, date = new Date()) { Message.prototype.verifyDetached = function(signature, keys, date = new Date()) {
const msg = this.unwrapCompressed(); const msg = this.unwrapCompressed();
const literalDataList = msg.packets.filterByTag(enums.packet.literal); const literalDataList = msg.packets.filterByTag(enums.packet.literalData);
if (literalDataList.length !== 1) { if (literalDataList.length !== 1) {
throw new Error('Can only verify message with one literal data packet.'); throw new Error('Can only verify message with one literal data packet.');
} }
@ -620,8 +631,8 @@ Message.prototype.verifyDetached = function(signature, keys, date = new Date())
/** /**
* Create object containing signer's keyid and validity of signature * Create object containing signer's keyid and validity of signature
* @param {module:packet.Signature} signature signature packets * @param {SignaturePacket} signature signature packets
* @param {Array<module:packet.Literal>} literalDataList array of literal data packets * @param {Array<LiteralDataPacket>} literalDataList array of literal data packets
* @param {Array<module:key.Key>} keys array of keys to verify signatures * @param {Array<module:key.Key>} keys array of keys to verify signatures
* @param {Date} date Verify the signature against the given date, * @param {Date} date Verify the signature against the given date,
* i.e. check signature creation time < date < expiration time * i.e. check signature creation time < date < expiration time
@ -663,7 +674,7 @@ async function createVerificationObject(signature, literalDataList, keys, date =
})(), })(),
signature: (async () => { signature: (async () => {
const sig = await signaturePacket; const sig = await signaturePacket;
const packetlist = new packet.List(); const packetlist = new PacketList();
packetlist.push(sig); packetlist.push(sig);
return new Signature(packetlist); return new Signature(packetlist);
})() })()
@ -681,8 +692,8 @@ async function createVerificationObject(signature, literalDataList, keys, date =
/** /**
* Create list of objects containing signer's keyid and validity of signature * Create list of objects containing signer's keyid and validity of signature
* @param {Array<module:packet.Signature>} signatureList array of signature packets * @param {Array<SignaturePacket>} signatureList array of signature packets
* @param {Array<module:packet.Literal>} literalDataList array of literal data packets * @param {Array<LiteralDataPacket>} literalDataList array of literal data packets
* @param {Array<module:key.Key>} keys array of keys to verify signatures * @param {Array<module:key.Key>} keys array of keys to verify signatures
* @param {Date} date Verify the signature against the given date, * @param {Date} date Verify the signature against the given date,
* i.e. check signature creation time < date < expiration time * i.e. check signature creation time < date < expiration time
@ -704,7 +715,7 @@ export async function createVerificationObjects(signatureList, literalDataList,
* @returns {module:message.Message} message Content of compressed message * @returns {module:message.Message} message Content of compressed message
*/ */
Message.prototype.unwrapCompressed = function() { Message.prototype.unwrapCompressed = function() {
const compressed = this.packets.filterByTag(enums.packet.compressed); const compressed = this.packets.filterByTag(enums.packet.compressedData);
if (compressed.length) { if (compressed.length) {
return new Message(compressed[0].packets); return new Message(compressed[0].packets);
} }
@ -716,7 +727,7 @@ Message.prototype.unwrapCompressed = function() {
* @param {String|Uint8Array} detachedSignature The detached ASCII-armored or Uint8Array PGP signature * @param {String|Uint8Array} detachedSignature The detached ASCII-armored or Uint8Array PGP signature
*/ */
Message.prototype.appendSignature = async function(detachedSignature) { Message.prototype.appendSignature = async function(detachedSignature) {
await this.packets.read(util.isUint8Array(detachedSignature) ? detachedSignature : (await armor.decode(detachedSignature)).data); await this.packets.read(util.isUint8Array(detachedSignature) ? detachedSignature : (await armor.decode(detachedSignature)).data, { SignaturePacket });
}; };
/** /**
@ -766,8 +777,18 @@ export async function read(input, fromStream = util.isStream(input)) {
if (streamType === 'node') { if (streamType === 'node') {
input = stream.nodeToWeb(input); input = stream.nodeToWeb(input);
} }
const packetlist = new packet.List(); const packetlist = new PacketList();
await packetlist.read(input, fromStream); await packetlist.read(input, {
LiteralDataPacket,
CompressedDataPacket,
SymEncryptedAEADProtectedDataPacket,
SymEncryptedIntegrityProtectedDataPacket,
SymmetricallyEncryptedDataPacket,
PublicKeyEncryptedSessionKeyPacket,
SymEncryptedSessionKeyPacket,
OnePassSignaturePacket,
SignaturePacket
}, fromStream);
const message = new Message(packetlist); const message = new Message(packetlist);
message.fromStream = fromStream; message.fromStream = fromStream;
return message; return message;
@ -787,13 +808,13 @@ export function fromText(text, filename, date = new Date(), type = 'utf8') {
if (streamType === 'node') { if (streamType === 'node') {
text = stream.nodeToWeb(text); text = stream.nodeToWeb(text);
} }
const literalDataPacket = new packet.Literal(date); const literalDataPacket = new LiteralDataPacket(date);
// text will be converted to UTF8 // text will be converted to UTF8
literalDataPacket.setText(text, type); literalDataPacket.setText(text, type);
if (filename !== undefined) { if (filename !== undefined) {
literalDataPacket.setFilename(filename); literalDataPacket.setFilename(filename);
} }
const literalDataPacketlist = new packet.List(); const literalDataPacketlist = new PacketList();
literalDataPacketlist.push(literalDataPacket); literalDataPacketlist.push(literalDataPacket);
const message = new Message(literalDataPacketlist); const message = new Message(literalDataPacketlist);
message.fromStream = streamType; message.fromStream = streamType;
@ -818,12 +839,12 @@ export function fromBinary(bytes, filename, date = new Date(), type = 'binary')
bytes = stream.nodeToWeb(bytes); bytes = stream.nodeToWeb(bytes);
} }
const literalDataPacket = new packet.Literal(date); const literalDataPacket = new LiteralDataPacket(date);
literalDataPacket.setBytes(bytes, type); literalDataPacket.setBytes(bytes, type);
if (filename !== undefined) { if (filename !== undefined) {
literalDataPacket.setFilename(filename); literalDataPacket.setFilename(filename);
} }
const literalDataPacketlist = new packet.List(); const literalDataPacketlist = new PacketList();
literalDataPacketlist.push(literalDataPacket); literalDataPacketlist.push(literalDataPacket);
const message = new Message(literalDataPacketlist); const message = new Message(literalDataPacketlist);
message.fromStream = streamType; message.fromStream = streamType;

14
src/openpgp.js
View File

@ -40,7 +40,11 @@
import stream from 'web-stream-tools'; import stream from 'web-stream-tools';
import { createReadableStreamWrapper } from '@mattiasbuelens/web-streams-adapter'; import { createReadableStreamWrapper } from '@mattiasbuelens/web-streams-adapter';
import * as messageLib from './message'; import {
Message,
generateSessionKey as messageGenerateSessionKey,
encryptSessionKey as messageEncryptSessionKey
} from './message';
import { CleartextMessage } from './cleartext'; import { CleartextMessage } from './cleartext';
import { generate, reformat } from './key'; import { generate, reformat } from './key';
import config from './config/config'; import config from './config/config';
@ -407,7 +411,7 @@ export function generateSessionKey({ publicKeys, date = new Date(), toUserIds =
return Promise.resolve().then(async function() { return Promise.resolve().then(async function() {
return messageLib.generateSessionKey(publicKeys, date, toUserIds); return messageGenerateSessionKey(publicKeys, date, toUserIds);
}).catch(onError.bind(null, 'Error generating session key')); }).catch(onError.bind(null, 'Error generating session key'));
} }
@ -433,7 +437,7 @@ export function encryptSessionKey({ data, algorithm, aeadAlgorithm, publicKeys,
return Promise.resolve().then(async function() { return Promise.resolve().then(async function() {
const message = await messageLib.encryptSessionKey(data, algorithm, aeadAlgorithm, publicKeys, passwords, wildcard, date, toUserIds); const message = await messageEncryptSessionKey(data, algorithm, aeadAlgorithm, publicKeys, passwords, wildcard, date, toUserIds);
return armor ? message.armor() : message.write(); return armor ? message.armor() : message.write();
}).catch(onError.bind(null, 'Error encrypting session key')); }).catch(onError.bind(null, 'Error encrypting session key'));
@ -483,12 +487,12 @@ function checkBinary(data, name) {
} }
} }
function checkMessage(message) { function checkMessage(message) {
if (!(message instanceof messageLib.Message)) { if (!(message instanceof Message)) {
throw new Error('Parameter [message] needs to be of type Message'); throw new Error('Parameter [message] needs to be of type Message');
} }
} }
function checkCleartextOrMessage(message) { function checkCleartextOrMessage(message) {
if (!(message instanceof CleartextMessage) && !(message instanceof messageLib.Message)) { if (!(message instanceof CleartextMessage) && !(message instanceof Message)) {
throw new Error('Parameter [message] needs to be of type Message or CleartextMessage'); throw new Error('Parameter [message] needs to be of type Message or CleartextMessage');
} }
} }

90
src/packet/all_packets.js
View File

@ -4,75 +4,73 @@
* @module packet/all_packets * @module packet/all_packets
*/ */
import * as packets from './all_packets.js'; // re-import module to parse packets from tag
export { export {
/** @see module:packet.Compressed */ /** @see CompressedDataPacket */
default as Compressed default as CompressedDataPacket
} from './compressed.js'; } from './compressed_data.js';
export { export {
/** @see module:packet.SymEncryptedIntegrityProtected */ /** @see SymEncryptedIntegrityProtectedDataPacket */
default as SymEncryptedIntegrityProtected default as SymEncryptedIntegrityProtectedDataPacket
} from './sym_encrypted_integrity_protected.js'; } from './sym_encrypted_integrity_protected_data.js';
export { export {
/** @see module:packet.SymEncryptedAEADProtected */ /** @see SymEncryptedAEADProtectedDataPacket */
default as SymEncryptedAEADProtected default as SymEncryptedAEADProtectedDataPacket
} from './sym_encrypted_aead_protected.js'; } from './sym_encrypted_aead_protected_data.js';
export { export {
/** @see module:packet.PublicKeyEncryptedSessionKey */ /** @see PublicKeyEncryptedSessionKeyPacket */
default as PublicKeyEncryptedSessionKey default as PublicKeyEncryptedSessionKeyPacket
} from './public_key_encrypted_session_key.js'; } from './public_key_encrypted_session_key.js';
export { export {
/** @see module:packet.SymEncryptedSessionKey */ /** @see SymEncryptedSessionKeyPacket */
default as SymEncryptedSessionKey default as SymEncryptedSessionKeyPacket
} from './sym_encrypted_session_key.js'; } from './sym_encrypted_session_key.js';
export { export {
/** @see module:packet.Literal */ /** @see LiteralDataPacket */
default as Literal default as LiteralDataPacket
} from './literal.js'; } from './literal_data.js';
export { export {
/** @see module:packet.PublicKey */ /** @see PublicKeyPacket */
default as PublicKey default as PublicKeyPacket
} from './public_key.js'; } from './public_key.js';
export { export {
/** @see module:packet.SymmetricallyEncrypted */ /** @see SymmetricallyEncryptedDataPacket */
default as SymmetricallyEncrypted default as SymmetricallyEncryptedDataPacket
} from './symmetrically_encrypted.js'; } from './symmetrically_encrypted_data.js';
export { export {
/** @see module:packet.Marker */ /** @see MarkerPacket */
default as Marker default as MarkerPacket
} from './marker.js'; } from './marker.js';
export { export {
/** @see module:packet.PublicSubkey */ /** @see PublicSubkeyPacket */
default as PublicSubkey default as PublicSubkeyPacket
} from './public_subkey.js'; } from './public_subkey.js';
export { export {
/** @see module:packet.UserAttribute */ /** @see UserAttributePacket */
default as UserAttribute default as UserAttributePacket
} from './user_attribute.js'; } from './user_attribute.js';
export { export {
/** @see module:packet.OnePassSignature */ /** @see OnePassSignaturePacket */
default as OnePassSignature default as OnePassSignaturePacket
} from './one_pass_signature.js'; } from './one_pass_signature.js';
export { export {
/** @see module:packet.SecretKey */ /** @see SecretKeyPacket */
default as SecretKey default as SecretKeyPacket
} from './secret_key.js'; } from './secret_key.js';
export { export {
/** @see module:packet.Userid */ /** @see UserIDPacket */
default as Userid default as UserIDPacket
} from './userid.js'; } from './userid.js';
export { export {
/** @see module:packet.SecretSubkey */ /** @see SecretSubkeyPacket */
default as SecretSubkey default as SecretSubkeyPacket
} from './secret_subkey.js'; } from './secret_subkey.js';
export { export {
/** @see module:packet.Signature */ /** @see SignaturePacket */
default as Signature default as SignaturePacket
} from './signature.js'; } from './signature.js';
export { export {
/** @see module:packet.Trust */ /** @see TrustPacket */
default as Trust default as TrustPacket
} from './trust.js'; } from './trust.js';
/** /**
@ -82,8 +80,12 @@ export {
* @param {String} tag property name from {@link module:enums.packet} * @param {String} tag property name from {@link module:enums.packet}
* @returns {Object} new packet object with type based on tag * @returns {Object} new packet object with type based on tag
*/ */
export function newPacketFromTag(tag) { export function newPacketFromTag(tag, allowedPackets) {
return new packets[packetClassFromTagName(tag)](); const className = packetClassFromTagName(tag);
if (!allowedPackets[className]) {
throw new Error('Packet not allowed in this context: ' + className);
}
return new allowedPackets[className]();
} }
/** /**
@ -93,5 +95,5 @@ export function newPacketFromTag(tag) {
* @private * @private
*/ */
function packetClassFromTagName(tag) { function packetClassFromTagName(tag) {
return tag.substr(0, 1).toUpperCase() + tag.substr(1); return tag.substr(0, 1).toUpperCase() + tag.substr(1) + 'Packet';
} }

86
src/packet/compressed.js → src/packet/compressed_data.js
View File

@ -18,18 +18,26 @@
/** /**
* @requires web-stream-tools * @requires web-stream-tools
* @requires pako * @requires pako
* @requires seek-bzip
* @requires config * @requires config
* @requires enums * @requires enums
* @requires util * @requires util
* @requires compression/bzip2 * @requires packet
*/ */
import pako from 'pako'; import { Deflate } from 'pako/lib/deflate';
import Bunzip from 'seek-bzip'; import { Inflate } from 'pako/lib/inflate';
import { Z_SYNC_FLUSH, Z_FINISH } from 'pako/lib/zlib/constants';
import { decode as BunzipDecode } from 'seek-bzip';
import stream from 'web-stream-tools'; import stream from 'web-stream-tools';
import config from '../config'; import config from '../config';
import enums from '../enums'; import enums from '../enums';
import util from '../util'; import util from '../util';
import {
LiteralDataPacket,
OnePassSignaturePacket,
SignaturePacket
} from '../packet';
/** /**
* Implementation of the Compressed Data Packet (Tag 8) * Implementation of the Compressed Data Packet (Tag 8)
@ -41,15 +49,15 @@ import util from '../util';
* @memberof module:packet * @memberof module:packet
* @constructor * @constructor
*/ */
function Compressed() { function CompressedDataPacket() {
/** /**
* Packet type * Packet type
* @type {module:enums.packet} * @type {module:enums.packet}
*/ */
this.tag = enums.packet.compressed; this.tag = enums.packet.compressedData;
/** /**
* List of packets * List of packets
* @type {module:packet.List} * @type {PacketList}
*/ */
this.packets = null; this.packets = null;
/** /**
@ -69,7 +77,7 @@ function Compressed() {
* Parsing function for the packet. * Parsing function for the packet.
* @param {Uint8Array | ReadableStream<Uint8Array>} bytes Payload of a tag 8 packet * @param {Uint8Array | ReadableStream<Uint8Array>} bytes Payload of a tag 8 packet
*/ */
Compressed.prototype.read = async function (bytes, streaming) { CompressedDataPacket.prototype.read = async function (bytes, streaming) {
await stream.parse(bytes, async reader => { await stream.parse(bytes, async reader => {
// One octet that gives the algorithm used to compress the packet. // One octet that gives the algorithm used to compress the packet.
@ -87,7 +95,7 @@ Compressed.prototype.read = async function (bytes, streaming) {
* Return the compressed packet. * Return the compressed packet.
* @returns {Uint8Array | ReadableStream<Uint8Array>} binary compressed packet * @returns {Uint8Array | ReadableStream<Uint8Array>} binary compressed packet
*/ */
Compressed.prototype.write = function () { CompressedDataPacket.prototype.write = function () {
if (this.compressed === null) { if (this.compressed === null) {
this.compress(); this.compress();
} }
@ -100,19 +108,23 @@ Compressed.prototype.write = function () {
* Decompression method for decompressing the compressed data * Decompression method for decompressing the compressed data
* read by read_packet * read by read_packet
*/ */
Compressed.prototype.decompress = async function (streaming) { CompressedDataPacket.prototype.decompress = async function (streaming) {
if (!decompress_fns[this.algorithm]) { if (!decompress_fns[this.algorithm]) {
throw new Error(this.algorithm + ' decompression not supported'); throw new Error(this.algorithm + ' decompression not supported');
} }
await this.packets.read(decompress_fns[this.algorithm](this.compressed), streaming); await this.packets.read(decompress_fns[this.algorithm](this.compressed), {
LiteralDataPacket,
OnePassSignaturePacket,
SignaturePacket
}, streaming);
}; };
/** /**
* Compress the packet data (member decompressedData) * Compress the packet data (member decompressedData)
*/ */
Compressed.prototype.compress = function () { CompressedDataPacket.prototype.compress = function () {
if (!compress_fns[this.algorithm]) { if (!compress_fns[this.algorithm]) {
throw new Error(this.algorithm + ' compression not supported'); throw new Error(this.algorithm + ' compression not supported');
@ -121,7 +133,7 @@ Compressed.prototype.compress = function () {
this.compressed = compress_fns[this.algorithm](this.packets.write()); this.compressed = compress_fns[this.algorithm](this.packets.write());
}; };
export default Compressed; export default CompressedDataPacket;
////////////////////////// //////////////////////////
// // // //
@ -147,12 +159,12 @@ function pako_zlib(constructor, options = {}) {
const obj = new constructor(options); const obj = new constructor(options);
return stream.transform(data, value => { return stream.transform(data, value => {
if (value.length) { if (value.length) {
obj.push(value, pako.Z_SYNC_FLUSH); obj.push(value, Z_SYNC_FLUSH);
return obj.result; return obj.result;
} }
}, () => { }, () => {
if (constructor === pako.Deflate) { if (constructor === Deflate) {
obj.push([], pako.Z_FINISH); obj.push([], Z_FINISH);
return obj.result; return obj.result;
} }
}); });
@ -165,30 +177,22 @@ function bzip2(func) {
}; };
} }
let compress_fns; const compress_fns = nodeZlib ? {
let decompress_fns; zip: /*#__PURE__*/ node_zlib(nodeZlib.createDeflateRaw, { level: config.deflateLevel }),
if (nodeZlib) { // Use Node native zlib for DEFLATE compression/decompression zlib: /*#__PURE__*/ node_zlib(nodeZlib.createDeflate, { level: config.deflateLevel })
compress_fns = { } : {
zip: node_zlib(nodeZlib.createDeflateRaw, { level: config.deflateLevel }), zip: /*#__PURE__*/ pako_zlib(Deflate, { raw: true, level: config.deflateLevel }),
zlib: node_zlib(nodeZlib.createDeflate, { level: config.deflateLevel }) zlib: /*#__PURE__*/ pako_zlib(Deflate, { level: config.deflateLevel })
}; };
decompress_fns = { const decompress_fns = nodeZlib ? {
uncompressed: uncompressed, uncompressed: uncompressed,
zip: node_zlib(nodeZlib.createInflateRaw), zip: /*#__PURE__*/ node_zlib(nodeZlib.createInflateRaw),
zlib: node_zlib(nodeZlib.createInflate), zlib: /*#__PURE__*/ node_zlib(nodeZlib.createInflate),
bzip2: bzip2(Bunzip.decode) bzip2: /*#__PURE__*/ bzip2(BunzipDecode)
}; } : {
} else { // Use JS fallbacks uncompressed: uncompressed,
compress_fns = { zip: /*#__PURE__*/ pako_zlib(Inflate, { raw: true }),
zip: pako_zlib(pako.Deflate, { raw: true, level: config.deflateLevel }), zlib: /*#__PURE__*/ pako_zlib(Inflate),
zlib: pako_zlib(pako.Deflate, { level: config.deflateLevel }) bzip2: /*#__PURE__*/ bzip2(BunzipDecode)
}; };
decompress_fns = {
uncompressed: uncompressed,
zip: pako_zlib(pako.Inflate, { raw: true }),
zlib: pako_zlib(pako.Inflate),
bzip2: bzip2(Bunzip.decode)
};
}

14
src/packet/index.js
View File

@ -2,17 +2,9 @@
* @fileoverview OpenPGP packet types * @fileoverview OpenPGP packet types
* @see module:packet/all_packets * @see module:packet/all_packets
* @see module:packet/clone * @see module:packet/clone
* @see module:packet.List * @see PacketList
* @module packet * @module packet
*/ */
import * as packets from './all_packets'; export * from './all_packets';
import List from './packetlist'; export { default as PacketList } from './packetlist';
const mod = {
List
};
Object.assign(mod, packets);
export default mod;

26
src/packet/literal.js → src/packet/literal_data.js
View File

@ -35,8 +35,8 @@ import util from '../util';
* @memberof module:packet * @memberof module:packet
* @constructor * @constructor
*/ */
function Literal(date = new Date()) { function LiteralDataPacket(date = new Date()) {
this.tag = enums.packet.literal; this.tag = enums.packet.literalData;
this.format = 'utf8'; // default format for literal data packets this.format = 'utf8'; // default format for literal data packets
this.date = util.normalizeDate(date); this.date = util.normalizeDate(date);
this.text = null; // textual data representation this.text = null; // textual data representation
@ -50,7 +50,7 @@ function Literal(date = new Date()) {
* @param {String | ReadableStream<String>} text Any native javascript string * @param {String | ReadableStream<String>} text Any native javascript string
* @param {utf8|binary|text|mime} format (optional) The format of the string of bytes * @param {utf8|binary|text|mime} format (optional) The format of the string of bytes
*/ */
Literal.prototype.setText = function(text, format = 'utf8') { LiteralDataPacket.prototype.setText = function(text, format = 'utf8') {
this.format = format; this.format = format;
this.text = text; this.text = text;
this.data = null; this.data = null;
@ -62,7 +62,7 @@ Literal.prototype.setText = function(text, format = 'utf8') {
* @param {Boolean} clone (optional) Whether to return a clone so that getBytes/getText can be called again * @param {Boolean} clone (optional) Whether to return a clone so that getBytes/getText can be called again
* @returns {String | ReadableStream<String>} literal data as text * @returns {String | ReadableStream<String>} literal data as text
*/ */
Literal.prototype.getText = function(clone = false) { LiteralDataPacket.prototype.getText = function(clone = false) {
if (this.text === null || util.isStream(this.text)) { // Assume that this.text has been read if (this.text === null || util.isStream(this.text)) { // Assume that this.text has been read
this.text = util.decodeUtf8(util.nativeEOL(this.getBytes(clone))); this.text = util.decodeUtf8(util.nativeEOL(this.getBytes(clone)));
} }
@ -74,7 +74,7 @@ Literal.prototype.getText = function(clone = false) {
* @param {Uint8Array | ReadableStream<Uint8Array>} bytes The string of bytes * @param {Uint8Array | ReadableStream<Uint8Array>} bytes The string of bytes
* @param {utf8|binary|text|mime} format The format of the string of bytes * @param {utf8|binary|text|mime} format The format of the string of bytes
*/ */
Literal.prototype.setBytes = function(bytes, format) { LiteralDataPacket.prototype.setBytes = function(bytes, format) {
this.format = format; this.format = format;
this.data = bytes; this.data = bytes;
this.text = null; this.text = null;
@ -86,7 +86,7 @@ Literal.prototype.setBytes = function(bytes, format) {
* @param {Boolean} clone (optional) Whether to return a clone so that getBytes/getText can be called again * @param {Boolean} clone (optional) Whether to return a clone so that getBytes/getText can be called again
* @returns {Uint8Array | ReadableStream<Uint8Array>} A sequence of bytes * @returns {Uint8Array | ReadableStream<Uint8Array>} A sequence of bytes
*/ */
Literal.prototype.getBytes = function(clone = false) { LiteralDataPacket.prototype.getBytes = function(clone = false) {
if (this.data === null) { if (this.data === null) {
// encode UTF8 and normalize EOL to \r\n // encode UTF8 and normalize EOL to \r\n
this.data = util.canonicalizeEOL(util.encodeUtf8(this.text)); this.data = util.canonicalizeEOL(util.encodeUtf8(this.text));
@ -102,7 +102,7 @@ Literal.prototype.getBytes = function(clone = false) {
* Sets the filename of the literal packet data * Sets the filename of the literal packet data
* @param {String} filename Any native javascript string * @param {String} filename Any native javascript string
*/ */
Literal.prototype.setFilename = function(filename) { LiteralDataPacket.prototype.setFilename = function(filename) {
this.filename = filename; this.filename = filename;
}; };
@ -111,7 +111,7 @@ Literal.prototype.setFilename = function(filename) {
* Get the filename of the literal packet data * Get the filename of the literal packet data
* @returns {String} filename * @returns {String} filename
*/ */
Literal.prototype.getFilename = function() { LiteralDataPacket.prototype.getFilename = function() {
return this.filename; return this.filename;
}; };
@ -120,9 +120,9 @@ Literal.prototype.getFilename = function() {
* Parsing function for a literal data packet (tag 11). * Parsing function for a literal data packet (tag 11).
* *
* @param {Uint8Array | ReadableStream<Uint8Array>} input Payload of a tag 11 packet * @param {Uint8Array | ReadableStream<Uint8Array>} input Payload of a tag 11 packet
* @returns {module:packet.Literal} object representation * @returns {LiteralDataPacket} object representation
*/ */
Literal.prototype.read = async function(bytes) { LiteralDataPacket.prototype.read = async function(bytes) {
await stream.parse(bytes, async reader => { await stream.parse(bytes, async reader => {
// - A one-octet field that describes how the data is formatted. // - A one-octet field that describes how the data is formatted.
const format = enums.read(enums.literal, await reader.readByte()); const format = enums.read(enums.literal, await reader.readByte());
@ -143,7 +143,7 @@ Literal.prototype.read = async function(bytes) {
* *
* @returns {Uint8Array} Uint8Array representation of the packet * @returns {Uint8Array} Uint8Array representation of the packet
*/ */
Literal.prototype.writeHeader = function() { LiteralDataPacket.prototype.writeHeader = function() {
const filename = util.encodeUtf8(this.filename); const filename = util.encodeUtf8(this.filename);
const filename_length = new Uint8Array([filename.length]); const filename_length = new Uint8Array([filename.length]);
@ -158,11 +158,11 @@ Literal.prototype.writeHeader = function() {
* *
* @returns {Uint8Array | ReadableStream<Uint8Array>} Uint8Array representation of the packet * @returns {Uint8Array | ReadableStream<Uint8Array>} Uint8Array representation of the packet
*/ */
Literal.prototype.write = function() { LiteralDataPacket.prototype.write = function() {
const header = this.writeHeader(); const header = this.writeHeader();
const data = this.getBytes(); const data = this.getBytes();
return util.concat([header, data]); return util.concat([header, data]);
}; };
export default Literal; export default LiteralDataPacket;

8
src/packet/marker.js
View File

@ -34,7 +34,7 @@ import enums from '../enums';
* @memberof module:packet * @memberof module:packet
* @constructor * @constructor
*/ */
function Marker() { function MarkerPacket() {
this.tag = enums.packet.marker; this.tag = enums.packet.marker;
} }
@ -47,9 +47,9 @@ function Marker() {
* @param {Integer} len * @param {Integer} len
* Length of the packet or the remaining length of * Length of the packet or the remaining length of
* input at position * input at position
* @returns {module:packet.Marker} Object representation * @returns {MarkerPacket} Object representation
*/ */
Marker.prototype.read = function (bytes) { MarkerPacket.prototype.read = function (bytes) {
if (bytes[0] === 0x50 && // P if (bytes[0] === 0x50 && // P
bytes[1] === 0x47 && // G bytes[1] === 0x47 && // G
bytes[2] === 0x50) { // P bytes[2] === 0x50) { // P
@ -59,4 +59,4 @@ Marker.prototype.read = function (bytes) {
return false; return false;
}; };
export default Marker; export default MarkerPacket;

24
src/packet/one_pass_signature.js
View File

@ -24,7 +24,7 @@
*/ */
import stream from 'web-stream-tools'; import stream from 'web-stream-tools';
import Signature from './signature'; import SignaturePacket from './signature';
import type_keyid from '../type/keyid'; import type_keyid from '../type/keyid';
import enums from '../enums'; import enums from '../enums';
import util from '../util'; import util from '../util';
@ -41,7 +41,7 @@ import util from '../util';
* @memberof module:packet * @memberof module:packet
* @constructor * @constructor
*/ */
function OnePassSignature() { function OnePassSignaturePacket() {
/** /**
* Packet type * Packet type
* @type {module:enums.packet} * @type {module:enums.packet}
@ -78,9 +78,9 @@ function OnePassSignature() {
/** /**
* parsing function for a one-pass signature packet (tag 4). * parsing function for a one-pass signature packet (tag 4).
* @param {Uint8Array} bytes payload of a tag 4 packet * @param {Uint8Array} bytes payload of a tag 4 packet
* @returns {module:packet.OnePassSignature} object representation * @returns {OnePassSignaturePacket} object representation
*/ */
OnePassSignature.prototype.read = function (bytes) { OnePassSignaturePacket.prototype.read = function (bytes) {
let mypos = 0; let mypos = 0;
// A one-octet version number. The current version is 3. // A one-octet version number. The current version is 3.
this.version = bytes[mypos++]; this.version = bytes[mypos++];
@ -112,7 +112,7 @@ OnePassSignature.prototype.read = function (bytes) {
* creates a string representation of a one-pass signature packet * creates a string representation of a one-pass signature packet
* @returns {Uint8Array} a Uint8Array representation of a one-pass signature packet * @returns {Uint8Array} a Uint8Array representation of a one-pass signature packet
*/ */
OnePassSignature.prototype.write = function () { OnePassSignaturePacket.prototype.write = function () {
const start = new Uint8Array([3, enums.write(enums.signature, this.signatureType), const start = new Uint8Array([3, enums.write(enums.signature, this.signatureType),
enums.write(enums.hash, this.hashAlgorithm), enums.write(enums.hash, this.hashAlgorithm),
enums.write(enums.publicKey, this.publicKeyAlgorithm)]); enums.write(enums.publicKey, this.publicKeyAlgorithm)]);
@ -122,14 +122,14 @@ OnePassSignature.prototype.write = function () {
return util.concatUint8Array([start, this.issuerKeyId.write(), end]); return util.concatUint8Array([start, this.issuerKeyId.write(), end]);
}; };
OnePassSignature.prototype.hash = Signature.prototype.hash; OnePassSignaturePacket.prototype.hash = SignaturePacket.prototype.hash;
OnePassSignature.prototype.toHash = Signature.prototype.toHash; OnePassSignaturePacket.prototype.toHash = SignaturePacket.prototype.toHash;
OnePassSignature.prototype.toSign = Signature.prototype.toSign; OnePassSignaturePacket.prototype.toSign = SignaturePacket.prototype.toSign;
OnePassSignature.prototype.calculateTrailer = function(...args) { OnePassSignaturePacket.prototype.calculateTrailer = function(...args) {
return stream.fromAsync(async () => Signature.prototype.calculateTrailer.apply(await this.correspondingSig, args)); return stream.fromAsync(async () => SignaturePacket.prototype.calculateTrailer.apply(await this.correspondingSig, args));
}; };
OnePassSignature.prototype.verify = async function() { OnePassSignaturePacket.prototype.verify = async function() {
const correspondingSig = await this.correspondingSig; const correspondingSig = await this.correspondingSig;
if (!correspondingSig || correspondingSig.tag !== enums.packet.signature) { if (!correspondingSig || correspondingSig.tag !== enums.packet.signature) {
throw new Error('Corresponding signature packet missing'); throw new Error('Corresponding signature packet missing');
@ -146,4 +146,4 @@ OnePassSignature.prototype.verify = async function() {
return correspondingSig.verify.apply(correspondingSig, arguments); return correspondingSig.verify.apply(correspondingSig, arguments);
}; };
export default OnePassSignature; export default OnePassSignaturePacket;

10
src/packet/packet.js
View File

@ -105,11 +105,11 @@ export default {
*/ */
supportsStreaming: function(tag_type) { supportsStreaming: function(tag_type) {
return [ return [
enums.packet.literal, enums.packet.literalData,
enums.packet.compressed, enums.packet.compressedData,
enums.packet.symmetricallyEncrypted, enums.packet.symmetricallyEncryptedData,
enums.packet.symEncryptedIntegrityProtected, enums.packet.symEncryptedIntegrityProtectedData,
enums.packet.symEncryptedAEADProtected enums.packet.symEncryptedAEADProtectedData
].includes(tag_type); ].includes(tag_type);
}, },

28
src/packet/packetlist.js
View File

@ -23,7 +23,7 @@ import util from '../util';
* @constructor * @constructor
* @extends Array * @extends Array
*/ */
function List() { function PacketList() {
/** /**
* The number of packets contained within the list. * The number of packets contained within the list.
* @readonly * @readonly
@ -32,13 +32,13 @@ function List() {
this.length = 0; this.length = 0;
} }
List.prototype = []; PacketList.prototype = [];
/** /**
* Reads a stream of binary data and interprents it as a list of packets. * Reads a stream of binary data and interprents it as a list of packets.
* @param {Uint8Array | ReadableStream<Uint8Array>} A Uint8Array of bytes. * @param {Uint8Array | ReadableStream<Uint8Array>} A Uint8Array of bytes.
*/ */
List.prototype.read = async function (bytes, streaming) { PacketList.prototype.read = async function (bytes, allowedPackets, streaming) {
this.stream = stream.transformPair(bytes, async (readable, writable) => { this.stream = stream.transformPair(bytes, async (readable, writable) => {
const writer = stream.getWriter(writable); const writer = stream.getWriter(writable);
try { try {
@ -47,8 +47,8 @@ List.prototype.read = async function (bytes, streaming) {
const done = await packetParser.read(readable, streaming, async parsed => { const done = await packetParser.read(readable, streaming, async parsed => {
try { try {
const tag = enums.read(enums.packet, parsed.tag); const tag = enums.read(enums.packet, parsed.tag);
const packet = packets.newPacketFromTag(tag); const packet = packets.newPacketFromTag(tag, allowedPackets);
packet.packets = new List(); packet.packets = new PacketList();
packet.fromStream = util.isStream(parsed.packet); packet.fromStream = util.isStream(parsed.packet);
await packet.read(parsed.packet, streaming); await packet.read(parsed.packet, streaming);
await writer.write(packet); await writer.write(packet);
@ -94,7 +94,7 @@ List.prototype.read = async function (bytes, streaming) {
* class instance. * class instance.
* @returns {Uint8Array} A Uint8Array containing valid openpgp packets. * @returns {Uint8Array} A Uint8Array containing valid openpgp packets.
*/ */
List.prototype.write = function () { PacketList.prototype.write = function () {
const arr = []; const arr = [];
for (let i = 0; i < this.length; i++) { for (let i = 0; i < this.length; i++) {
@ -137,12 +137,12 @@ List.prototype.write = function () {
* writing to packetlist[i] directly will result in an error. * writing to packetlist[i] directly will result in an error.
* @param {Object} packet Packet to push * @param {Object} packet Packet to push
*/ */
List.prototype.push = function (packet) { PacketList.prototype.push = function (packet) {
if (!packet) { if (!packet) {
return; return;
} }
packet.packets = packet.packets || new List(); packet.packets = packet.packets || new PacketList();
this[this.length] = packet; this[this.length] = packet;
this.length++; this.length++;
@ -151,8 +151,8 @@ List.prototype.push = function (packet) {
/** /**
* Creates a new PacketList with all packets from the given types * Creates a new PacketList with all packets from the given types
*/ */
List.prototype.filterByTag = function (...args) { PacketList.prototype.filterByTag = function (...args) {
const filtered = new List(); const filtered = new PacketList();
const handle = tag => packetType => tag === packetType; const handle = tag => packetType => tag === packetType;
@ -170,14 +170,14 @@ List.prototype.filterByTag = function (...args) {
* @param {module:enums.packet} type The packet type * @param {module:enums.packet} type The packet type
* @returns {module:packet/packet|undefined} * @returns {module:packet/packet|undefined}
*/ */
List.prototype.findPacket = function (type) { PacketList.prototype.findPacket = function (type) {
return this.find(packet => packet.tag === type); return this.find(packet => packet.tag === type);
}; };
/** /**
* Returns array of found indices by tag * Returns array of found indices by tag
*/ */
List.prototype.indexOfTag = function (...args) { PacketList.prototype.indexOfTag = function (...args) {
const tagIndex = []; const tagIndex = [];
const that = this; const that = this;
@ -194,7 +194,7 @@ List.prototype.indexOfTag = function (...args) {
/** /**
* Concatenates packetlist or array of packets * Concatenates packetlist or array of packets
*/ */
List.prototype.concat = function (packetlist) { PacketList.prototype.concat = function (packetlist) {
if (packetlist) { if (packetlist) {
for (let i = 0; i < packetlist.length; i++) { for (let i = 0; i < packetlist.length; i++) {
this.push(packetlist[i]); this.push(packetlist[i]);
@ -203,4 +203,4 @@ List.prototype.concat = function (packetlist) {
return this; return this;
}; };
export default List; export default PacketList;

32
src/packet/public_key.js
View File

@ -46,7 +46,7 @@ import util from '../util';
* @memberof module:packet * @memberof module:packet
* @constructor * @constructor
*/ */
function PublicKey(date = new Date()) { function PublicKeyPacket(date = new Date()) {
/** /**
* Packet type * Packet type
* @type {module:enums.packet} * @type {module:enums.packet}
@ -95,7 +95,7 @@ function PublicKey(date = new Date()) {
* @param {Uint8Array} bytes Input array to read the packet from * @param {Uint8Array} bytes Input array to read the packet from
* @returns {Object} This object with attributes set by the parser * @returns {Object} This object with attributes set by the parser
*/ */
PublicKey.prototype.read = function (bytes) { PublicKeyPacket.prototype.read = function (bytes) {
let pos = 0; let pos = 0;
// A one-octet version number (3, 4 or 5). // A one-octet version number (3, 4 or 5).
this.version = bytes[pos++]; this.version = bytes[pos++];
@ -133,16 +133,16 @@ PublicKey.prototype.read = function (bytes) {
/** /**
* Alias of read() * Alias of read()
* @see module:packet.PublicKey#read * @see PublicKeyPacket#read
*/ */
PublicKey.prototype.readPublicKey = PublicKey.prototype.read; PublicKeyPacket.prototype.readPublicKey = PublicKeyPacket.prototype.read;
/** /**
* Same as write_private_key, but has less information because of * Same as write_private_key, but has less information because of
* public key. * public key.
* @returns {Uint8Array} OpenPGP packet body contents, * @returns {Uint8Array} OpenPGP packet body contents,
*/ */
PublicKey.prototype.write = function () { PublicKeyPacket.prototype.write = function () {
const arr = []; const arr = [];
// Version // Version
arr.push(new Uint8Array([this.version])); arr.push(new Uint8Array([this.version]));
@ -164,14 +164,14 @@ PublicKey.prototype.write = function () {
/** /**
* Alias of write() * Alias of write()
* @see module:packet.PublicKey#write * @see PublicKeyPacket#write
*/ */
PublicKey.prototype.writePublicKey = PublicKey.prototype.write; PublicKeyPacket.prototype.writePublicKey = PublicKeyPacket.prototype.write;
/** /**
* Write packet in order to be hashed; either for a signature or a fingerprint. * Write packet in order to be hashed; either for a signature or a fingerprint.
*/ */
PublicKey.prototype.writeForHash = function (version) { PublicKeyPacket.prototype.writeForHash = function (version) {
const bytes = this.writePublicKey(); const bytes = this.writePublicKey();
if (version === 5) { if (version === 5) {
@ -184,7 +184,7 @@ PublicKey.prototype.writeForHash = function (version) {
* Check whether secret-key data is available in decrypted form. Returns null for public keys. * Check whether secret-key data is available in decrypted form. Returns null for public keys.
* @returns {Boolean|null} * @returns {Boolean|null}
*/ */
PublicKey.prototype.isDecrypted = function() { PublicKeyPacket.prototype.isDecrypted = function() {
return null; return null;
}; };
@ -192,7 +192,7 @@ PublicKey.prototype.isDecrypted = function() {
* Returns the creation time of the key * Returns the creation time of the key
* @returns {Date} * @returns {Date}
*/ */
PublicKey.prototype.getCreationTime = function() { PublicKeyPacket.prototype.getCreationTime = function() {
return this.created; return this.created;
}; };
@ -200,7 +200,7 @@ PublicKey.prototype.getCreationTime = function() {
* Calculates the key id of the key * Calculates the key id of the key
* @returns {module:type/keyid} A 8 byte key id * @returns {module:type/keyid} A 8 byte key id
*/ */
PublicKey.prototype.getKeyId = function () { PublicKeyPacket.prototype.getKeyId = function () {
if (this.keyid) { if (this.keyid) {
return this.keyid; return this.keyid;
} }
@ -217,7 +217,7 @@ PublicKey.prototype.getKeyId = function () {
* Calculates the fingerprint of the key * Calculates the fingerprint of the key
* @returns {Uint8Array} A Uint8Array containing the fingerprint * @returns {Uint8Array} A Uint8Array containing the fingerprint
*/ */
PublicKey.prototype.getFingerprintBytes = function () { PublicKeyPacket.prototype.getFingerprintBytes = function () {
if (this.fingerprint) { if (this.fingerprint) {
return this.fingerprint; return this.fingerprint;
} }
@ -234,7 +234,7 @@ PublicKey.prototype.getFingerprintBytes = function () {
* Calculates the fingerprint of the key * Calculates the fingerprint of the key
* @returns {String} A string containing the fingerprint in lowercase hex * @returns {String} A string containing the fingerprint in lowercase hex
*/ */
PublicKey.prototype.getFingerprint = function() { PublicKeyPacket.prototype.getFingerprint = function() {
return util.uint8ArrayToHex(this.getFingerprintBytes()); return util.uint8ArrayToHex(this.getFingerprintBytes());
}; };
@ -242,7 +242,7 @@ PublicKey.prototype.getFingerprint = function() {
* Calculates whether two keys have the same fingerprint without actually calculating the fingerprint * Calculates whether two keys have the same fingerprint without actually calculating the fingerprint
* @returns {Boolean} Whether the two keys have the same version and public key data * @returns {Boolean} Whether the two keys have the same version and public key data
*/ */
PublicKey.prototype.hasSameFingerprintAs = function(other) { PublicKeyPacket.prototype.hasSameFingerprintAs = function(other) {
return this.version === other.version && util.equalsUint8Array(this.writePublicKey(), other.writePublicKey()); return this.version === other.version && util.equalsUint8Array(this.writePublicKey(), other.writePublicKey());
}; };
@ -250,7 +250,7 @@ PublicKey.prototype.hasSameFingerprintAs = function(other) {
* Returns algorithm information * Returns algorithm information
* @returns {Object} An object of the form {algorithm: String, rsaBits:int, curve:String} * @returns {Object} An object of the form {algorithm: String, rsaBits:int, curve:String}
*/ */
PublicKey.prototype.getAlgorithmInfo = function () { PublicKeyPacket.prototype.getAlgorithmInfo = function () {
const result = {}; const result = {};
result.algorithm = this.algorithm; result.algorithm = this.algorithm;
if (this.params[0] instanceof type_mpi) { if (this.params[0] instanceof type_mpi) {
@ -262,4 +262,4 @@ PublicKey.prototype.getAlgorithmInfo = function () {
return result; return result;
}; };
export default PublicKey; export default PublicKeyPacket;

18
src/packet/public_key_encrypted_session_key.js
View File

@ -46,7 +46,7 @@ import util from '../util';
* @memberof module:packet * @memberof module:packet
* @constructor * @constructor
*/ */
function PublicKeyEncryptedSessionKey() { function PublicKeyEncryptedSessionKeyPacket() {
this.tag = enums.packet.publicKeyEncryptedSessionKey; this.tag = enums.packet.publicKeyEncryptedSessionKey;
this.version = 3; this.version = 3;
@ -67,9 +67,9 @@ function PublicKeyEncryptedSessionKey() {
* @param {Integer} position Position to start reading from the input string * @param {Integer} position Position to start reading from the input string
* @param {Integer} len Length of the packet or the remaining length of * @param {Integer} len Length of the packet or the remaining length of
* input at position * input at position
* @returns {module:packet.PublicKeyEncryptedSessionKey} Object representation * @returns {PublicKeyEncryptedSessionKeyPacket} Object representation
*/ */
PublicKeyEncryptedSessionKey.prototype.read = function (bytes) { PublicKeyEncryptedSessionKeyPacket.prototype.read = function (bytes) {
this.version = bytes[0]; this.version = bytes[0];
this.publicKeyId.read(bytes.subarray(1, bytes.length)); this.publicKeyId.read(bytes.subarray(1, bytes.length));
this.publicKeyAlgorithm = enums.read(enums.publicKey, bytes[9]); this.publicKeyAlgorithm = enums.read(enums.publicKey, bytes[9]);
@ -90,7 +90,7 @@ PublicKeyEncryptedSessionKey.prototype.read = function (bytes) {
* *
* @returns {Uint8Array} The Uint8Array representation * @returns {Uint8Array} The Uint8Array representation
*/ */
PublicKeyEncryptedSessionKey.prototype.write = function () { PublicKeyEncryptedSessionKeyPacket.prototype.write = function () {
const arr = [new Uint8Array([this.version]), this.publicKeyId.write(), new Uint8Array([enums.write(enums.publicKey, this.publicKeyAlgorithm)])]; const arr = [new Uint8Array([this.version]), this.publicKeyId.write(), new Uint8Array([enums.write(enums.publicKey, this.publicKeyAlgorithm)])];
for (let i = 0; i < this.encrypted.length; i++) { for (let i = 0; i < this.encrypted.length; i++) {
@ -102,11 +102,11 @@ PublicKeyEncryptedSessionKey.prototype.write = function () {
/** /**
* Encrypt session key packet * Encrypt session key packet
* @param {module:packet.PublicKey} key Public key * @param {PublicKeyPacket} key Public key
* @returns {Promise<Boolean>} * @returns {Promise<Boolean>}
* @async * @async
*/ */
PublicKeyEncryptedSessionKey.prototype.encrypt = async function (key) { PublicKeyEncryptedSessionKeyPacket.prototype.encrypt = async function (key) {
let data = String.fromCharCode(enums.write(enums.symmetric, this.sessionKeyAlgorithm)); let data = String.fromCharCode(enums.write(enums.symmetric, this.sessionKeyAlgorithm));
data += util.uint8ArrayToStr(this.sessionKey); data += util.uint8ArrayToStr(this.sessionKey);
@ -121,12 +121,12 @@ PublicKeyEncryptedSessionKey.prototype.encrypt = async function (key) {
* Decrypts the session key (only for public key encrypted session key * Decrypts the session key (only for public key encrypted session key
* packets (tag 1) * packets (tag 1)
* *
* @param {module:packet.SecretKey} key * @param {SecretKeyPacket} key
* Private key with secret params unlocked * Private key with secret params unlocked
* @returns {Promise<Boolean>} * @returns {Promise<Boolean>}
* @async * @async
*/ */
PublicKeyEncryptedSessionKey.prototype.decrypt = async function (key) { PublicKeyEncryptedSessionKeyPacket.prototype.decrypt = async function (key) {
const algo = enums.write(enums.publicKey, this.publicKeyAlgorithm); const algo = enums.write(enums.publicKey, this.publicKeyAlgorithm);
const keyAlgo = enums.write(enums.publicKey, key.algorithm); const keyAlgo = enums.write(enums.publicKey, key.algorithm);
// check that session key algo matches the secret key algo // check that session key algo matches the secret key algo
@ -146,4 +146,4 @@ PublicKeyEncryptedSessionKey.prototype.decrypt = async function (key) {
return true; return true;
}; };
export default PublicKeyEncryptedSessionKey; export default PublicKeyEncryptedSessionKeyPacket;

14
src/packet/public_subkey.js
View File

@ -20,7 +20,7 @@
* @requires enums * @requires enums
*/ */
import PublicKey from './public_key'; import PublicKeyPacket from './public_key';
import enums from '../enums'; import enums from '../enums';
/** /**
@ -31,14 +31,14 @@ import enums from '../enums';
* services. * services.
* @memberof module:packet * @memberof module:packet
* @constructor * @constructor
* @extends module:packet.PublicKey * @extends PublicKeyPacket
*/ */
function PublicSubkey() { function PublicSubkeyPacket() {
PublicKey.call(this); PublicKeyPacket.call(this);
this.tag = enums.packet.publicSubkey; this.tag = enums.packet.publicSubkey;
} }
PublicSubkey.prototype = new PublicKey(); PublicSubkeyPacket.prototype = new PublicKeyPacket();
PublicSubkey.prototype.constructor = PublicSubkey; PublicSubkeyPacket.prototype.constructor = PublicSubkeyPacket;
export default PublicSubkey; export default PublicSubkeyPacket;

34
src/packet/secret_key.js
View File

@ -24,7 +24,7 @@
* @requires util * @requires util
*/ */
import PublicKey from './public_key'; import PublicKeyPacket from './public_key';
import type_s2k from '../type/s2k'; import type_s2k from '../type/s2k';
import crypto from '../crypto'; import crypto from '../crypto';
import enums from '../enums'; import enums from '../enums';
@ -36,10 +36,10 @@ import util from '../util';
* includes the secret-key material after all the public-key fields. * includes the secret-key material after all the public-key fields.
* @memberof module:packet * @memberof module:packet
* @constructor * @constructor
* @extends module:packet.PublicKey * @extends PublicKeyPacket
*/ */
function SecretKey(date = new Date()) { function SecretKeyPacket(date = new Date()) {
PublicKey.call(this, date); PublicKeyPacket.call(this, date);
/** /**
* Packet type * Packet type
* @type {module:enums.packet} * @type {module:enums.packet}
@ -75,8 +75,8 @@ function SecretKey(date = new Date()) {
this.aead = null; this.aead = null;
} }
SecretKey.prototype = new PublicKey(); SecretKeyPacket.prototype = new PublicKeyPacket();
SecretKey.prototype.constructor = SecretKey; SecretKeyPacket.prototype.constructor = SecretKeyPacket;
// Helper function // Helper function
@ -116,7 +116,7 @@ function write_cleartext_params(params, algorithm) {
* {@link https://tools.ietf.org/html/draft-ietf-openpgp-rfc4880bis-04#section-5.5.3|RFC4880bis-04 section 5.5.3} * {@link https://tools.ietf.org/html/draft-ietf-openpgp-rfc4880bis-04#section-5.5.3|RFC4880bis-04 section 5.5.3}
* @param {String} bytes Input string to read the packet from * @param {String} bytes Input string to read the packet from
*/ */
SecretKey.prototype.read = function (bytes) { SecretKeyPacket.prototype.read = function (bytes) {
// - A Public-Key or Public-Subkey packet, as described above. // - A Public-Key or Public-Subkey packet, as described above.
let i = this.readPublicKey(bytes); let i = this.readPublicKey(bytes);
@ -197,7 +197,7 @@ SecretKey.prototype.read = function (bytes) {
* Creates an OpenPGP key packet for the given key. * Creates an OpenPGP key packet for the given key.
* @returns {String} A string of bytes containing the secret key OpenPGP packet * @returns {String} A string of bytes containing the secret key OpenPGP packet
*/ */
SecretKey.prototype.write = function () { SecretKeyPacket.prototype.write = function () {
const arr = [this.writePublicKey()]; const arr = [this.writePublicKey()];
arr.push(new Uint8Array([this.s2k_usage])); arr.push(new Uint8Array([this.s2k_usage]));
@ -254,7 +254,7 @@ SecretKey.prototype.write = function () {
* Check whether secret-key data is available in decrypted form. Returns null for public keys. * Check whether secret-key data is available in decrypted form. Returns null for public keys.
* @returns {Boolean|null} * @returns {Boolean|null}
*/ */
SecretKey.prototype.isDecrypted = function() { SecretKeyPacket.prototype.isDecrypted = function() {
return this.isEncrypted === false; return this.isEncrypted === false;
}; };
@ -262,7 +262,7 @@ SecretKey.prototype.isDecrypted = function() {
* Check whether this is a gnu-dummy key * Check whether this is a gnu-dummy key
* @returns {Boolean} * @returns {Boolean}
*/ */
SecretKey.prototype.isDummy = function() { SecretKeyPacket.prototype.isDummy = function() {
return !!(this.s2k && this.s2k.type === 'gnu-dummy'); return !!(this.s2k && this.s2k.type === 'gnu-dummy');
}; };
@ -298,7 +298,7 @@ SecretKey.prototype.makeDummy = function () {
* @returns {Promise<Boolean>} * @returns {Promise<Boolean>}
* @async * @async
*/ */
SecretKey.prototype.encrypt = async function (passphrase) { SecretKeyPacket.prototype.encrypt = async function (passphrase) {
if (this.isDummy()) { if (this.isDummy()) {
return false; return false;
} }
@ -347,13 +347,13 @@ async function produceEncryptionKey(s2k, passphrase, algorithm) {
/** /**
* Decrypts the private key params which are needed to use the key. * Decrypts the private key params which are needed to use the key.
* {@link module:packet.SecretKey.isDecrypted} should be false, as * {@link SecretKeyPacket.isDecrypted} should be false, as
* otherwise calls to this function will throw an error. * otherwise calls to this function will throw an error.
* @param {String} passphrase The passphrase for this private key as string * @param {String} passphrase The passphrase for this private key as string
* @returns {Promise<Boolean>} * @returns {Promise<Boolean>}
* @async * @async
*/ */
SecretKey.prototype.decrypt = async function (passphrase) { SecretKeyPacket.prototype.decrypt = async function (passphrase) {
if (this.isDummy()) { if (this.isDummy()) {
this.isEncrypted = false; this.isEncrypted = false;
return false; return false;
@ -404,7 +404,7 @@ SecretKey.prototype.decrypt = async function (passphrase) {
return true; return true;
}; };
SecretKey.prototype.generate = async function (bits, curve) { SecretKeyPacket.prototype.generate = async function (bits, curve) {
const algo = enums.write(enums.publicKey, this.algorithm); const algo = enums.write(enums.publicKey, this.algorithm);
this.params = await crypto.generateParams(algo, bits, curve); this.params = await crypto.generateParams(algo, bits, curve);
this.isEncrypted = false; this.isEncrypted = false;
@ -415,7 +415,7 @@ SecretKey.prototype.generate = async function (bits, curve) {
* @throws {Error} if validation was not successful * @throws {Error} if validation was not successful
* @async * @async
*/ */
SecretKey.prototype.validate = async function () { SecretKeyPacket.prototype.validate = async function () {
if (this.isDummy()) { if (this.isDummy()) {
return; return;
} }
@ -434,7 +434,7 @@ SecretKey.prototype.validate = async function () {
/** /**
* Clear private key parameters * Clear private key parameters
*/ */
SecretKey.prototype.clearPrivateParams = function () { SecretKeyPacket.prototype.clearPrivateParams = function () {
if (this.s2k && this.s2k.type === 'gnu-dummy') { if (this.s2k && this.s2k.type === 'gnu-dummy') {
this.isEncrypted = true; this.isEncrypted = true;
return; return;
@ -449,4 +449,4 @@ SecretKey.prototype.clearPrivateParams = function () {
this.isEncrypted = true; this.isEncrypted = true;
}; };
export default SecretKey; export default SecretKeyPacket;

14
src/packet/secret_subkey.js
View File

@ -20,7 +20,7 @@
* @requires enums * @requires enums
*/ */
import SecretKey from './secret_key'; import SecretKeyPacket from './secret_key';
import enums from '../enums'; import enums from '../enums';
/** /**
@ -28,14 +28,14 @@ import enums from '../enums';
* Key packet and has exactly the same format. * Key packet and has exactly the same format.
* @memberof module:packet * @memberof module:packet
* @constructor * @constructor
* @extends module:packet.SecretKey * @extends SecretKeyPacket
*/ */
function SecretSubkey(date = new Date()) { function SecretSubkeyPacket(date = new Date()) {
SecretKey.call(this, date); SecretKeyPacket.call(this, date);
this.tag = enums.packet.secretSubkey; this.tag = enums.packet.secretSubkey;
} }
SecretSubkey.prototype = new SecretKey(); SecretSubkeyPacket.prototype = new SecretKeyPacket();
SecretSubkey.prototype.constructor = SecretSubkey; SecretSubkeyPacket.prototype.constructor = SecretSubkeyPacket;
export default SecretSubkey; export default SecretSubkeyPacket;

42
src/packet/signature.js
View File

@ -45,7 +45,7 @@ import config from '../config';
* @constructor * @constructor
* @param {Date} date the creation date of the signature * @param {Date} date the creation date of the signature
*/ */
function Signature(date = new Date()) { function SignaturePacket(date = new Date()) {
this.tag = enums.packet.signature; this.tag = enums.packet.signature;
this.version = 4; // This is set to 5 below if we sign with a V5 key. this.version = 4; // This is set to 5 below if we sign with a V5 key.
this.signatureType = null; this.signatureType = null;
@ -99,9 +99,9 @@ function Signature(date = new Date()) {
/** /**
* parsing function for a signature packet (tag 2). * parsing function for a signature packet (tag 2).
* @param {String} bytes payload of a tag 2 packet * @param {String} bytes payload of a tag 2 packet
* @returns {module:packet.Signature} object representation * @returns {SignaturePacket} object representation
*/ */
Signature.prototype.read = function (bytes) { SignaturePacket.prototype.read = function (bytes) {
let i = 0; let i = 0;
this.version = bytes[i++]; this.version = bytes[i++];
@ -134,7 +134,7 @@ Signature.prototype.read = function (bytes) {
this.signature = bytes.subarray(i, bytes.length); this.signature = bytes.subarray(i, bytes.length);
}; };
Signature.prototype.write = function () { SignaturePacket.prototype.write = function () {
const arr = []; const arr = [];
arr.push(this.signatureData); arr.push(this.signatureData);
arr.push(this.write_unhashed_sub_packets()); arr.push(this.write_unhashed_sub_packets());
@ -145,14 +145,14 @@ Signature.prototype.write = function () {
/** /**
* Signs provided data. This needs to be done prior to serialization. * Signs provided data. This needs to be done prior to serialization.
* @param {module:packet.SecretKey} key private key used to sign the message. * @param {SecretKeyPacket} key private key used to sign the message.
* @param {Object} data Contains packets to be signed. * @param {Object} data Contains packets to be signed.
* @param {Boolean} detached (optional) whether to create a detached signature * @param {Boolean} detached (optional) whether to create a detached signature
* @param {Boolean} streaming (optional) whether to process data as a stream * @param {Boolean} streaming (optional) whether to process data as a stream
* @returns {Promise<Boolean>} * @returns {Promise<Boolean>}
* @async * @async
*/ */
Signature.prototype.sign = async function (key, data, detached = false, streaming = false) { SignaturePacket.prototype.sign = async function (key, data, detached = false, streaming = false) {
const signatureType = enums.write(enums.signature, this.signatureType); const signatureType = enums.write(enums.signature, this.signatureType);
const publicKeyAlgorithm = enums.write(enums.publicKey, this.publicKeyAlgorithm); const publicKeyAlgorithm = enums.write(enums.publicKey, this.publicKeyAlgorithm);
const hashAlgorithm = enums.write(enums.hash, this.hashAlgorithm); const hashAlgorithm = enums.write(enums.hash, this.hashAlgorithm);
@ -197,7 +197,7 @@ Signature.prototype.sign = async function (key, data, detached = false, streamin
* Creates Uint8Array of bytes of all subpacket data except Issuer and Embedded Signature subpackets * Creates Uint8Array of bytes of all subpacket data except Issuer and Embedded Signature subpackets
* @returns {Uint8Array} subpacket data * @returns {Uint8Array} subpacket data
*/ */
Signature.prototype.write_hashed_sub_packets = function () { SignaturePacket.prototype.write_hashed_sub_packets = function () {
const sub = enums.signatureSubpacket; const sub = enums.signatureSubpacket;
const arr = []; const arr = [];
let bytes; let bytes;
@ -300,7 +300,7 @@ Signature.prototype.write_hashed_sub_packets = function () {
* Creates Uint8Array of bytes of Issuer and Embedded Signature subpackets * Creates Uint8Array of bytes of Issuer and Embedded Signature subpackets
* @returns {Uint8Array} subpacket data * @returns {Uint8Array} subpacket data
*/ */
Signature.prototype.write_unhashed_sub_packets = function() { SignaturePacket.prototype.write_unhashed_sub_packets = function() {
const sub = enums.signatureSubpacket; const sub = enums.signatureSubpacket;
const arr = []; const arr = [];
let bytes; let bytes;
@ -347,7 +347,7 @@ function write_sub_packet(type, data) {
// V4 signature sub packets // V4 signature sub packets
Signature.prototype.read_sub_packet = function (bytes, trusted = true) { SignaturePacket.prototype.read_sub_packet = function (bytes, trusted = true) {
let mypos = 0; let mypos = 0;
const read_array = (prop, bytes) => { const read_array = (prop, bytes) => {
@ -515,7 +515,7 @@ Signature.prototype.read_sub_packet = function (bytes, trusted = true) {
} }
case 32: case 32:
// Embedded Signature // Embedded Signature
this.embeddedSignature = new Signature(); this.embeddedSignature = new SignaturePacket();
this.embeddedSignature.read(bytes.subarray(mypos, bytes.length)); this.embeddedSignature.read(bytes.subarray(mypos, bytes.length));
break; break;
case 33: case 33:
@ -543,7 +543,7 @@ Signature.prototype.read_sub_packet = function (bytes, trusted = true) {
} }
}; };
Signature.prototype.read_sub_packets = function(bytes, trusted = true) { SignaturePacket.prototype.read_sub_packets = function(bytes, trusted = true) {
// Two-octet scalar octet count for following subpacket data. // Two-octet scalar octet count for following subpacket data.
const subpacket_length = util.readNumber(bytes.subarray(0, 2)); const subpacket_length = util.readNumber(bytes.subarray(0, 2));
@ -563,7 +563,7 @@ Signature.prototype.read_sub_packets = function(bytes, trusted = true) {
}; };
// Produces data to produce signature on // Produces data to produce signature on
Signature.prototype.toSign = function (type, data) { SignaturePacket.prototype.toSign = function (type, data) {
const t = enums.signature; const t = enums.signature;
switch (type) { switch (type) {
@ -632,7 +632,7 @@ Signature.prototype.toSign = function (type, data) {
}; };
Signature.prototype.calculateTrailer = function (data, detached) { SignaturePacket.prototype.calculateTrailer = function (data, detached) {
let length = 0; let length = 0;
return stream.transform(stream.clone(this.signatureData), value => { return stream.transform(stream.clone(this.signatureData), value => {
length += value.length; length += value.length;
@ -657,13 +657,13 @@ Signature.prototype.calculateTrailer = function (data, detached) {
}; };
Signature.prototype.toHash = function(signatureType, data, detached = false) { SignaturePacket.prototype.toHash = function(signatureType, data, detached = false) {
const bytes = this.toSign(signatureType, data); const bytes = this.toSign(signatureType, data);
return util.concat([bytes, this.signatureData, this.calculateTrailer(data, detached)]); return util.concat([bytes, this.signatureData, this.calculateTrailer(data, detached)]);
}; };
Signature.prototype.hash = async function(signatureType, data, toHash, detached = false, streaming = true) { SignaturePacket.prototype.hash = async function(signatureType, data, toHash, detached = false, streaming = true) {
const hashAlgorithm = enums.write(enums.hash, this.hashAlgorithm); const hashAlgorithm = enums.write(enums.hash, this.hashAlgorithm);
if (!toHash) toHash = this.toHash(signatureType, data, detached); if (!toHash) toHash = this.toHash(signatureType, data, detached);
if (!streaming && util.isStream(toHash)) { if (!streaming && util.isStream(toHash)) {
@ -675,15 +675,15 @@ Signature.prototype.hash = async function(signatureType, data, toHash, detached
/** /**
* verifies the signature packet. Note: not all signature types are implemented * verifies the signature packet. Note: not all signature types are implemented
* @param {module:packet.PublicSubkey|module:packet.PublicKey| * @param {PublicSubkeyPacket|PublicKeyPacket|
* module:packet.SecretSubkey|module:packet.SecretKey} key the public key to verify the signature * SecretSubkeyPacket|SecretKeyPacket} key the public key to verify the signature
* @param {module:enums.signature} signatureType expected signature type * @param {module:enums.signature} signatureType expected signature type
* @param {String|Object} data data which on the signature applies * @param {String|Object} data data which on the signature applies
* @param {Boolean} detached (optional) whether to verify a detached signature * @param {Boolean} detached (optional) whether to verify a detached signature
* @returns {Promise<Boolean>} True if message is verified, else false. * @returns {Promise<Boolean>} True if message is verified, else false.
* @async * @async
*/ */
Signature.prototype.verify = async function (key, signatureType, data, detached = false, streaming = false) { SignaturePacket.prototype.verify = async function (key, signatureType, data, detached = false, streaming = false) {
const publicKeyAlgorithm = enums.write(enums.publicKey, this.publicKeyAlgorithm); const publicKeyAlgorithm = enums.write(enums.publicKey, this.publicKeyAlgorithm);
const hashAlgorithm = enums.write(enums.hash, this.hashAlgorithm); const hashAlgorithm = enums.write(enums.hash, this.hashAlgorithm);
@ -757,7 +757,7 @@ Signature.prototype.verify = async function (key, signatureType, data, detached
* @param {Date} date (optional) use the given date for verification instead of the current time * @param {Date} date (optional) use the given date for verification instead of the current time
* @returns {Boolean} true if expired * @returns {Boolean} true if expired
*/ */
Signature.prototype.isExpired = function (date = new Date()) { SignaturePacket.prototype.isExpired = function (date = new Date()) {
const normDate = util.normalizeDate(date); const normDate = util.normalizeDate(date);
if (normDate !== null) { if (normDate !== null) {
const expirationTime = this.getExpirationTime(); const expirationTime = this.getExpirationTime();
@ -770,8 +770,8 @@ Signature.prototype.isExpired = function (date = new Date()) {
* Returns the expiration time of the signature or Infinity if signature does not expire * Returns the expiration time of the signature or Infinity if signature does not expire
* @returns {Date} expiration time * @returns {Date} expiration time
*/ */
Signature.prototype.getExpirationTime = function () { SignaturePacket.prototype.getExpirationTime = function () {
return !this.signatureNeverExpires ? new Date(this.created.getTime() + this.signatureExpirationTime * 1000) : Infinity; return !this.signatureNeverExpires ? new Date(this.created.getTime() + this.signatureExpirationTime * 1000) : Infinity;
}; };
export default Signature; export default SignaturePacket;

30
src/packet/sym_encrypted_aead_protected.js → src/packet/sym_encrypted_aead_protected_data.js
View File

@ -21,6 +21,7 @@
* @requires crypto * @requires crypto
* @requires enums * @requires enums
* @requires util * @requires util
* @requires packet
*/ */
import stream from 'web-stream-tools'; import stream from 'web-stream-tools';
@ -28,6 +29,12 @@ import config from '../config';
import crypto from '../crypto'; import crypto from '../crypto';
import enums from '../enums'; import enums from '../enums';
import util from '../util'; import util from '../util';
import {
LiteralDataPacket,
CompressedDataPacket,
OnePassSignaturePacket,
SignaturePacket
} from '../packet';
const VERSION = 1; // A one-octet version number of the data packet. const VERSION = 1; // A one-octet version number of the data packet.
@ -40,8 +47,8 @@ const VERSION = 1; // A one-octet version number of the data packet.
* @memberof module:packet * @memberof module:packet
* @constructor * @constructor
*/ */
function SymEncryptedAEADProtected() { function SymEncryptedAEADProtectedDataPacket() {
this.tag = enums.packet.symEncryptedAEADProtected; this.tag = enums.packet.symEncryptedAEADProtectedData;
this.version = VERSION; this.version = VERSION;
this.cipherAlgo = null; this.cipherAlgo = null;
this.aeadAlgorithm = 'eax'; this.aeadAlgorithm = 'eax';
@ -52,13 +59,13 @@ function SymEncryptedAEADProtected() {
this.packets = null; this.packets = null;
} }
export default SymEncryptedAEADProtected; export default SymEncryptedAEADProtectedDataPacket;
/** /**
* Parse an encrypted payload of bytes in the order: version, IV, ciphertext (see specification) * Parse an encrypted payload of bytes in the order: version, IV, ciphertext (see specification)
* @param {Uint8Array | ReadableStream<Uint8Array>} bytes * @param {Uint8Array | ReadableStream<Uint8Array>} bytes
*/ */
SymEncryptedAEADProtected.prototype.read = async function (bytes) { SymEncryptedAEADProtectedDataPacket.prototype.read = async function (bytes) {
await stream.parse(bytes, async reader => { await stream.parse(bytes, async reader => {
if (await reader.readByte() !== VERSION) { // The only currently defined value is 1. if (await reader.readByte() !== VERSION) { // The only currently defined value is 1.
throw new Error('Invalid packet version.'); throw new Error('Invalid packet version.');
@ -76,7 +83,7 @@ SymEncryptedAEADProtected.prototype.read = async function (bytes) {
* Write the encrypted payload of bytes in the order: version, IV, ciphertext (see specification) * Write the encrypted payload of bytes in the order: version, IV, ciphertext (see specification)
* @returns {Uint8Array | ReadableStream<Uint8Array>} The encrypted payload * @returns {Uint8Array | ReadableStream<Uint8Array>} The encrypted payload
*/ */
SymEncryptedAEADProtected.prototype.write = function () { SymEncryptedAEADProtectedDataPacket.prototype.write = function () {
return util.concat([new Uint8Array([this.version, this.cipherAlgo, this.aeadAlgo, this.chunkSizeByte]), this.iv, this.encrypted]); return util.concat([new Uint8Array([this.version, this.cipherAlgo, this.aeadAlgo, this.chunkSizeByte]), this.iv, this.encrypted]);
}; };
@ -88,8 +95,13 @@ SymEncryptedAEADProtected.prototype.write = function () {
* @returns {Boolean} * @returns {Boolean}
* @async * @async
*/ */
SymEncryptedAEADProtected.prototype.decrypt = async function (sessionKeyAlgorithm, key, streaming) { SymEncryptedAEADProtectedDataPacket.prototype.decrypt = async function (sessionKeyAlgorithm, key, streaming) {
await this.packets.read(await this.crypt('decrypt', key, stream.clone(this.encrypted), streaming), streaming); await this.packets.read(await this.crypt('decrypt', key, stream.clone(this.encrypted), streaming), {
LiteralDataPacket,
CompressedDataPacket,
OnePassSignaturePacket,
SignaturePacket
}, streaming);
return true; return true;
}; };
@ -100,7 +112,7 @@ SymEncryptedAEADProtected.prototype.decrypt = async function (sessionKeyAlgorith
* @param {Boolean} streaming Whether the top-level function will return a stream * @param {Boolean} streaming Whether the top-level function will return a stream
* @async * @async
*/ */
SymEncryptedAEADProtected.prototype.encrypt = async function (sessionKeyAlgorithm, key, streaming) { SymEncryptedAEADProtectedDataPacket.prototype.encrypt = async function (sessionKeyAlgorithm, key, streaming) {
this.cipherAlgo = enums.write(enums.symmetric, sessionKeyAlgorithm); this.cipherAlgo = enums.write(enums.symmetric, sessionKeyAlgorithm);
this.aeadAlgo = enums.write(enums.aead, this.aeadAlgorithm); this.aeadAlgo = enums.write(enums.aead, this.aeadAlgorithm);
const mode = crypto[enums.read(enums.aead, this.aeadAlgo)]; const mode = crypto[enums.read(enums.aead, this.aeadAlgo)];
@ -119,7 +131,7 @@ SymEncryptedAEADProtected.prototype.encrypt = async function (sessionKeyAlgorith
* @returns {Uint8Array | ReadableStream<Uint8Array>} * @returns {Uint8Array | ReadableStream<Uint8Array>}
* @async * @async
*/ */
SymEncryptedAEADProtected.prototype.crypt = async function (fn, key, data, streaming) { SymEncryptedAEADProtectedDataPacket.prototype.crypt = async function (fn, key, data, streaming) {
const cipher = enums.read(enums.symmetric, this.cipherAlgo); const cipher = enums.read(enums.symmetric, this.cipherAlgo);
const mode = crypto[enums.read(enums.aead, this.aeadAlgo)]; const mode = crypto[enums.read(enums.aead, this.aeadAlgo)];
const modeInstance = await mode(cipher, key); const modeInstance = await mode(cipher, key);

28
src/packet/sym_encrypted_integrity_protected.js → src/packet/sym_encrypted_integrity_protected_data.js
View File

@ -22,6 +22,7 @@
* @requires crypto * @requires crypto
* @requires enums * @requires enums
* @requires util * @requires util
* @requires packet
*/ */
import stream from 'web-stream-tools'; import stream from 'web-stream-tools';
@ -29,6 +30,12 @@ import config from '../config';
import crypto from '../crypto'; import crypto from '../crypto';
import enums from '../enums'; import enums from '../enums';
import util from '../util'; import util from '../util';
import {
LiteralDataPacket,
CompressedDataPacket,
OnePassSignaturePacket,
SignaturePacket
} from '../packet';
const VERSION = 1; // A one-octet version number of the data packet. const VERSION = 1; // A one-octet version number of the data packet.
@ -44,8 +51,8 @@ const VERSION = 1; // A one-octet version number of the data packet.
* @memberof module:packet * @memberof module:packet
* @constructor * @constructor
*/ */
function SymEncryptedIntegrityProtected() { function SymEncryptedIntegrityProtectedDataPacket() {
this.tag = enums.packet.symEncryptedIntegrityProtected; this.tag = enums.packet.symEncryptedIntegrityProtectedData;
this.version = VERSION; this.version = VERSION;
/** The encrypted payload. */ /** The encrypted payload. */
this.encrypted = null; // string this.encrypted = null; // string
@ -59,7 +66,7 @@ function SymEncryptedIntegrityProtected() {
this.packets = null; this.packets = null;
} }
SymEncryptedIntegrityProtected.prototype.read = async function (bytes) { SymEncryptedIntegrityProtectedDataPacket.prototype.read = async function (bytes) {
await stream.parse(bytes, async reader => { await stream.parse(bytes, async reader => {
// - A one-octet version number. The only currently defined value is 1. // - A one-octet version number. The only currently defined value is 1.
@ -74,7 +81,7 @@ SymEncryptedIntegrityProtected.prototype.read = async function (bytes) {
}); });
}; };
SymEncryptedIntegrityProtected.prototype.write = function () { SymEncryptedIntegrityProtectedDataPacket.prototype.write = function () {
return util.concat([new Uint8Array([VERSION]), this.encrypted]); return util.concat([new Uint8Array([VERSION]), this.encrypted]);
}; };
@ -86,7 +93,7 @@ SymEncryptedIntegrityProtected.prototype.write = function () {
* @returns {Promise<Boolean>} * @returns {Promise<Boolean>}
* @async * @async
*/ */
SymEncryptedIntegrityProtected.prototype.encrypt = async function (sessionKeyAlgorithm, key, streaming) { SymEncryptedIntegrityProtectedDataPacket.prototype.encrypt = async function (sessionKeyAlgorithm, key, streaming) {
let bytes = this.packets.write(); let bytes = this.packets.write();
if (!streaming) bytes = await stream.readToEnd(bytes); if (!streaming) bytes = await stream.readToEnd(bytes);
const prefix = await crypto.getPrefixRandom(sessionKeyAlgorithm); const prefix = await crypto.getPrefixRandom(sessionKeyAlgorithm);
@ -108,7 +115,7 @@ SymEncryptedIntegrityProtected.prototype.encrypt = async function (sessionKeyAlg
* @returns {Promise<Boolean>} * @returns {Promise<Boolean>}
* @async * @async
*/ */
SymEncryptedIntegrityProtected.prototype.decrypt = async function (sessionKeyAlgorithm, key, streaming) { SymEncryptedIntegrityProtectedDataPacket.prototype.decrypt = async function (sessionKeyAlgorithm, key, streaming) {
let encrypted = stream.clone(this.encrypted); let encrypted = stream.clone(this.encrypted);
if (!streaming) encrypted = await stream.readToEnd(encrypted); if (!streaming) encrypted = await stream.readToEnd(encrypted);
const decrypted = await crypto.cfb.decrypt(sessionKeyAlgorithm, key, encrypted, new Uint8Array(crypto.cipher[sessionKeyAlgorithm].blockSize)); const decrypted = await crypto.cfb.decrypt(sessionKeyAlgorithm, key, encrypted, new Uint8Array(crypto.cipher[sessionKeyAlgorithm].blockSize));
@ -132,8 +139,13 @@ SymEncryptedIntegrityProtected.prototype.decrypt = async function (sessionKeyAlg
if (!util.isStream(encrypted) || !config.allowUnauthenticatedStream) { if (!util.isStream(encrypted) || !config.allowUnauthenticatedStream) {
packetbytes = await stream.readToEnd(packetbytes); packetbytes = await stream.readToEnd(packetbytes);
} }
await this.packets.read(packetbytes, streaming); await this.packets.read(packetbytes, {
LiteralDataPacket,
CompressedDataPacket,
OnePassSignaturePacket,
SignaturePacket
}, streaming);
return true; return true;
}; };
export default SymEncryptedIntegrityProtected; export default SymEncryptedIntegrityProtectedDataPacket;

14
src/packet/sym_encrypted_session_key.js
View File

@ -47,7 +47,7 @@ import util from '../util';
* @memberof module:packet * @memberof module:packet
* @constructor * @constructor
*/ */
function SymEncryptedSessionKey() { function SymEncryptedSessionKeyPacket() {
this.tag = enums.packet.symEncryptedSessionKey; this.tag = enums.packet.symEncryptedSessionKey;
this.version = config.aeadProtect ? 5 : 4; this.version = config.aeadProtect ? 5 : 4;
this.sessionKey = null; this.sessionKey = null;
@ -67,9 +67,9 @@ function SymEncryptedSessionKey() {
* @param {Integer} len * @param {Integer} len
* Length of the packet or the remaining length of * Length of the packet or the remaining length of
* input at position * input at position
* @returns {module:packet.SymEncryptedSessionKey} Object representation * @returns {SymEncryptedSessionKeyPacket} Object representation
*/ */
SymEncryptedSessionKey.prototype.read = function(bytes) { SymEncryptedSessionKeyPacket.prototype.read = function(bytes) {
let offset = 0; let offset = 0;
// A one-octet version number. The only currently defined version is 4. // A one-octet version number. The only currently defined version is 4.
@ -105,7 +105,7 @@ SymEncryptedSessionKey.prototype.read = function(bytes) {
} }
}; };
SymEncryptedSessionKey.prototype.write = function() { SymEncryptedSessionKeyPacket.prototype.write = function() {
const algo = this.encrypted === null ? const algo = this.encrypted === null ?
this.sessionKeyAlgorithm : this.sessionKeyAlgorithm :
this.sessionKeyEncryptionAlgorithm; this.sessionKeyEncryptionAlgorithm;
@ -131,7 +131,7 @@ SymEncryptedSessionKey.prototype.write = function() {
* @returns {Promise<Boolean>} * @returns {Promise<Boolean>}
* @async * @async
*/ */
SymEncryptedSessionKey.prototype.decrypt = async function(passphrase) { SymEncryptedSessionKeyPacket.prototype.decrypt = async function(passphrase) {
const algo = this.sessionKeyEncryptionAlgorithm !== null ? const algo = this.sessionKeyEncryptionAlgorithm !== null ?
this.sessionKeyEncryptionAlgorithm : this.sessionKeyEncryptionAlgorithm :
this.sessionKeyAlgorithm; this.sessionKeyAlgorithm;
@ -162,7 +162,7 @@ SymEncryptedSessionKey.prototype.decrypt = async function(passphrase) {
* @returns {Promise<Boolean>} * @returns {Promise<Boolean>}
* @async * @async
*/ */
SymEncryptedSessionKey.prototype.encrypt = async function(passphrase) { SymEncryptedSessionKeyPacket.prototype.encrypt = async function(passphrase) {
const algo = this.sessionKeyEncryptionAlgorithm !== null ? const algo = this.sessionKeyEncryptionAlgorithm !== null ?
this.sessionKeyEncryptionAlgorithm : this.sessionKeyEncryptionAlgorithm :
this.sessionKeyAlgorithm; this.sessionKeyAlgorithm;
@ -194,4 +194,4 @@ SymEncryptedSessionKey.prototype.encrypt = async function(passphrase) {
return true; return true;
}; };
export default SymEncryptedSessionKey; export default SymEncryptedSessionKeyPacket;

30
src/packet/symmetrically_encrypted.js → src/packet/symmetrically_encrypted_data.js
View File

@ -21,6 +21,7 @@
* @requires crypto * @requires crypto
* @requires enums * @requires enums
* @requires util * @requires util
* @requires packet
*/ */
import stream from 'web-stream-tools'; import stream from 'web-stream-tools';
@ -28,6 +29,12 @@ import config from '../config';
import crypto from '../crypto'; import crypto from '../crypto';
import enums from '../enums'; import enums from '../enums';
import util from '../util'; import util from '../util';
import {
LiteralDataPacket,
CompressedDataPacket,
OnePassSignaturePacket,
SignaturePacket
} from '../packet';
/** /**
* Implementation of the Symmetrically Encrypted Data Packet (Tag 9) * Implementation of the Symmetrically Encrypted Data Packet (Tag 9)
@ -41,19 +48,19 @@ import util from '../util';
* @memberof module:packet * @memberof module:packet
* @constructor * @constructor
*/ */
function SymmetricallyEncrypted() { function SymmetricallyEncryptedDataPacket() {
/** /**
* Packet type * Packet type
* @type {module:enums.packet} * @type {module:enums.packet}
*/ */
this.tag = enums.packet.symmetricallyEncrypted; this.tag = enums.packet.symmetricallyEncryptedData;
/** /**
* Encrypted secret-key data * Encrypted secret-key data
*/ */
this.encrypted = null; this.encrypted = null;
/** /**
* Decrypted packets contained within. * Decrypted packets contained within.
* @type {module:packet.List} * @type {PacketList}
*/ */
this.packets = null; this.packets = null;
/** /**
@ -63,11 +70,11 @@ function SymmetricallyEncrypted() {
this.ignoreMdcError = config.ignoreMdcError; this.ignoreMdcError = config.ignoreMdcError;
} }
SymmetricallyEncrypted.prototype.read = function (bytes) { SymmetricallyEncryptedDataPacket.prototype.read = function (bytes) {
this.encrypted = bytes; this.encrypted = bytes;
}; };
SymmetricallyEncrypted.prototype.write = function () { SymmetricallyEncryptedDataPacket.prototype.write = function () {
return this.encrypted; return this.encrypted;
}; };
@ -79,7 +86,7 @@ SymmetricallyEncrypted.prototype.write = function () {
* @returns {Promise<Boolean>} * @returns {Promise<Boolean>}
* @async * @async
*/ */
SymmetricallyEncrypted.prototype.decrypt = async function (sessionKeyAlgorithm, key) { SymmetricallyEncryptedDataPacket.prototype.decrypt = async function (sessionKeyAlgorithm, key, streaming) {
// If MDC errors are not being ignored, all missing MDC packets in symmetrically encrypted data should throw an error // If MDC errors are not being ignored, all missing MDC packets in symmetrically encrypted data should throw an error
if (!this.ignoreMdcError) { if (!this.ignoreMdcError) {
throw new Error('Decryption failed due to missing MDC.'); throw new Error('Decryption failed due to missing MDC.');
@ -91,7 +98,12 @@ SymmetricallyEncrypted.prototype.decrypt = async function (sessionKeyAlgorithm,
this.encrypted.subarray(2, crypto.cipher[sessionKeyAlgorithm].blockSize + 2) this.encrypted.subarray(2, crypto.cipher[sessionKeyAlgorithm].blockSize + 2)
); );
await this.packets.read(decrypted); await this.packets.read(decrypted, {
LiteralDataPacket,
CompressedDataPacket,
OnePassSignaturePacket,
SignaturePacket
}, streaming);
return true; return true;
}; };
@ -104,7 +116,7 @@ SymmetricallyEncrypted.prototype.decrypt = async function (sessionKeyAlgorithm,
* @returns {Promise<Boolean>} * @returns {Promise<Boolean>}
* @async * @async
*/ */
SymmetricallyEncrypted.prototype.encrypt = async function (algo, key) { SymmetricallyEncryptedDataPacket.prototype.encrypt = async function (algo, key) {
const data = this.packets.write(); const data = this.packets.write();
const prefix = await crypto.getPrefixRandom(algo); const prefix = await crypto.getPrefixRandom(algo);
@ -115,4 +127,4 @@ SymmetricallyEncrypted.prototype.encrypt = async function (algo, key) {
return true; return true;
}; };
export default SymmetricallyEncrypted; export default SymmetricallyEncryptedDataPacket;

6
src/packet/trust.js
View File

@ -21,7 +21,7 @@ import enums from '../enums';
* @memberof module:packet * @memberof module:packet
* @constructor * @constructor
*/ */
function Trust() { function TrustPacket() {
this.tag = enums.packet.trust; this.tag = enums.packet.trust;
} }
@ -30,6 +30,6 @@ function Trust() {
* Currently not implemented as we ignore trust packets * Currently not implemented as we ignore trust packets
* @param {String} byptes payload of a tag 12 packet * @param {String} byptes payload of a tag 12 packet
*/ */
Trust.prototype.read = function () {}; // TODO TrustPacket.prototype.read = function () {}; // TODO
export default Trust; export default TrustPacket;

14
src/packet/user_attribute.js
View File

@ -44,7 +44,7 @@ import util from '../util';
* @memberof module:packet * @memberof module:packet
* @constructor * @constructor
*/ */
function UserAttribute() { function UserAttributePacket() {
this.tag = enums.packet.userAttribute; this.tag = enums.packet.userAttribute;
this.attributes = []; this.attributes = [];
} }
@ -53,7 +53,7 @@ function UserAttribute() {
* parsing function for a user attribute packet (tag 17). * parsing function for a user attribute packet (tag 17).
* @param {Uint8Array} input payload of a tag 17 packet * @param {Uint8Array} input payload of a tag 17 packet
*/ */
UserAttribute.prototype.read = function(bytes) { UserAttributePacket.prototype.read = function(bytes) {
let i = 0; let i = 0;
while (i < bytes.length) { while (i < bytes.length) {
const len = packet.readSimpleLength(bytes.subarray(i, bytes.length)); const len = packet.readSimpleLength(bytes.subarray(i, bytes.length));
@ -68,7 +68,7 @@ UserAttribute.prototype.read = function(bytes) {
* Creates a binary representation of the user attribute packet * Creates a binary representation of the user attribute packet
* @returns {Uint8Array} string representation * @returns {Uint8Array} string representation
*/ */
UserAttribute.prototype.write = function() { UserAttributePacket.prototype.write = function() {
const arr = []; const arr = [];
for (let i = 0; i < this.attributes.length; i++) { for (let i = 0; i < this.attributes.length; i++) {
arr.push(packet.writeSimpleLength(this.attributes[i].length)); arr.push(packet.writeSimpleLength(this.attributes[i].length));
@ -79,11 +79,11 @@ UserAttribute.prototype.write = function() {
/** /**
* Compare for equality * Compare for equality
* @param {module:packet.UserAttribute} usrAttr * @param {UserAttributePacket} usrAttr
* @returns {Boolean} true if equal * @returns {Boolean} true if equal
*/ */
UserAttribute.prototype.equals = function(usrAttr) { UserAttributePacket.prototype.equals = function(usrAttr) {
if (!usrAttr || !(usrAttr instanceof UserAttribute)) { if (!usrAttr || !(usrAttr instanceof UserAttributePacket)) {
return false; return false;
} }
return this.attributes.every(function(attr, index) { return this.attributes.every(function(attr, index) {
@ -91,4 +91,4 @@ UserAttribute.prototype.equals = function(usrAttr) {
}); });
}; };
export default UserAttribute; export default UserAttributePacket;

14
src/packet/userid.js
View File

@ -34,8 +34,8 @@ import util from '../util';
* @memberof module:packet * @memberof module:packet
* @constructor * @constructor
*/ */
function Userid() { function UserIDPacket() {
this.tag = enums.packet.userid; this.tag = enums.packet.userID;
/** A string containing the user id. Usually in the form /** A string containing the user id. Usually in the form
* John Doe <john@example.com> * John Doe <john@example.com>
* @type {String} * @type {String}
@ -51,14 +51,14 @@ function Userid() {
* Parsing function for a user id packet (tag 13). * Parsing function for a user id packet (tag 13).
* @param {Uint8Array} input payload of a tag 13 packet * @param {Uint8Array} input payload of a tag 13 packet
*/ */
Userid.prototype.read = function (bytes) { UserIDPacket.prototype.read = function (bytes) {
this.parse(util.decodeUtf8(bytes)); this.parse(util.decodeUtf8(bytes));
}; };
/** /**
* Parse userid string, e.g. 'John Doe <john@example.com>' * Parse userid string, e.g. 'John Doe <john@example.com>'
*/ */
Userid.prototype.parse = function (userid) { UserIDPacket.prototype.parse = function (userid) {
try { try {
Object.assign(this, util.parseUserId(userid)); Object.assign(this, util.parseUserId(userid));
} catch (e) {} } catch (e) {}
@ -69,14 +69,14 @@ Userid.prototype.parse = function (userid) {
* Creates a binary representation of the user id packet * Creates a binary representation of the user id packet
* @returns {Uint8Array} binary representation * @returns {Uint8Array} binary representation
*/ */
Userid.prototype.write = function () { UserIDPacket.prototype.write = function () {
return util.encodeUtf8(this.userid); return util.encodeUtf8(this.userid);
}; };
/** /**
* Set userid string from object, e.g. { name:'Phil Zimmermann', email:'phil@openpgp.org' } * Set userid string from object, e.g. { name:'Phil Zimmermann', email:'phil@openpgp.org' }
*/ */
Userid.prototype.format = function (userid) { UserIDPacket.prototype.format = function (userid) {
if (util.isString(userid)) { if (util.isString(userid)) {
userid = util.parseUserId(userid); userid = util.parseUserId(userid);
} }
@ -84,4 +84,4 @@ Userid.prototype.format = function (userid) {
this.userid = util.formatUserId(userid); this.userid = util.formatUserId(userid);
}; };
export default Userid; export default UserIDPacket;

10
src/signature.js
View File

@ -23,19 +23,19 @@
*/ */
import armor from './encoding/armor'; import armor from './encoding/armor';
import packet from './packet'; import { PacketList, SignaturePacket } from './packet';
import enums from './enums'; import enums from './enums';
/** /**
* @class * @class
* @classdesc Class that represents an OpenPGP signature. * @classdesc Class that represents an OpenPGP signature.
* @param {module:packet.List} packetlist The signature packets * @param {PacketList} packetlist The signature packets
*/ */
export function Signature(packetlist) { export function Signature(packetlist) {
if (!(this instanceof Signature)) { if (!(this instanceof Signature)) {
return new Signature(packetlist); return new Signature(packetlist);
} }
this.packets = packetlist || new packet.List(); this.packets = packetlist || new PacketList();
} }
@ -75,7 +75,7 @@ export async function readArmored(armoredText) {
* @static * @static
*/ */
export async function read(input) { export async function read(input) {
const packetlist = new packet.List(); const packetlist = new PacketList();
await packetlist.read(input); await packetlist.read(input, { SignaturePacket });
return new Signature(packetlist); return new Signature(packetlist);
} }

16
test/general/key.js
View File

@ -2609,8 +2609,8 @@ module.exports = () => describe('Key', function() {
43 ee 3b 24 06 43 ee 3b 24 06
`.replace(/\s+/g, '')); `.replace(/\s+/g, ''));
let packetlist = new openpgp.packet.List(); let packetlist = new openpgp.PacketList();
await packetlist.read(packetBytes); await packetlist.read(packetBytes, { PublicKeyPacket: openpgp.PublicKeyPacket });
let key = packetlist[0]; let key = packetlist[0];
expect(key).to.exist; expect(key).to.exist;
}); });
@ -2638,9 +2638,9 @@ module.exports = () => describe('Key', function() {
const pubKey = await openpgp.key.readArmored(pub_sig_test); const pubKey = await openpgp.key.readArmored(pub_sig_test);
expect(pubKey).to.exist; expect(pubKey).to.exist;
const packetlist = new openpgp.packet.List(); const packetlist = new openpgp.PacketList();
await packetlist.read((await openpgp.armor.decode(pub_sig_test)).data); await packetlist.read((await openpgp.armor.decode(pub_sig_test)).data, openpgp);
const subkeys = pubKey.getSubkeys(); const subkeys = pubKey.getSubkeys();
expect(subkeys).to.exist; expect(subkeys).to.exist;
@ -2886,7 +2886,7 @@ module.exports = () => describe('Key', function() {
expect(source.revocationSignatures).to.exist; expect(source.revocationSignatures).to.exist;
dest.revocationSignatures = []; dest.revocationSignatures = [];
return dest.update(source).then(() => { return dest.update(source).then(() => {
expect(dest.revocationSignatures[0]).to.exist.and.be.an.instanceof(openpgp.packet.Signature); expect(dest.revocationSignatures[0]).to.exist.and.be.an.instanceof(openpgp.SignaturePacket);
}); });
}); });
@ -3064,8 +3064,8 @@ module.exports = () => describe('Key', function() {
const revocationCertificate = await revKey.getRevocationCertificate(); const revocationCertificate = await revKey.getRevocationCertificate();
const input = await openpgp.armor.decode(revocation_certificate_arm4); const input = await openpgp.armor.decode(revocation_certificate_arm4);
const packetlist = new openpgp.packet.List(); const packetlist = new openpgp.PacketList();
await packetlist.read(input.data); await packetlist.read(input.data, { SignaturePacket: openpgp.SignaturePacket });
const armored = openpgp.armor.encode(openpgp.enums.armor.publicKey, packetlist.write()); const armored = openpgp.armor.encode(openpgp.enums.armor.publicKey, packetlist.write());
expect(revocationCertificate.replace(/^Comment: .*$\r\n/mg, '')).to.equal(armored.replace(/^Comment: .*$\r\n/mg, '')); expect(revocationCertificate.replace(/^Comment: .*$\r\n/mg, '')).to.equal(armored.replace(/^Comment: .*$\r\n/mg, ''));
@ -3158,7 +3158,7 @@ module.exports = () => describe('Key', function() {
expect(primUser.user.userId.name).to.equal('Signature Test'); expect(primUser.user.userId.name).to.equal('Signature Test');
expect(primUser.user.userId.email).to.equal('signature@test.com'); expect(primUser.user.userId.email).to.equal('signature@test.com');
expect(primUser.user.userId.comment).to.equal(''); expect(primUser.user.userId.comment).to.equal('');
expect(primUser.selfCertification).to.be.an.instanceof(openpgp.packet.Signature); expect(primUser.selfCertification).to.be.an.instanceof(openpgp.SignaturePacket);
}); });
it('getPrimaryUser() should throw if no UserIDs are bound', async function() { it('getPrimaryUser() should throw if no UserIDs are bound', async function() {

34
test/general/openpgp.js
View File

@ -452,8 +452,8 @@ function withCompression(tests) {
let decompressSpy; let decompressSpy;
beforeEach(function () { beforeEach(function () {
compressSpy = spy(openpgp.packet.Compressed.prototype, 'compress'); compressSpy = spy(openpgp.CompressedDataPacket.prototype, 'compress');
decompressSpy = spy(openpgp.packet.Compressed.prototype, 'decompress'); decompressSpy = spy(openpgp.CompressedDataPacket.prototype, 'decompress');
}); });
afterEach(function () { afterEach(function () {
@ -1080,7 +1080,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
return openpgp.encrypt(encOpt).then(async function (encrypted) { return openpgp.encrypt(encOpt).then(async function (encrypted) {
expect(encrypted).to.match(/^-----BEGIN PGP MESSAGE/); expect(encrypted).to.match(/^-----BEGIN PGP MESSAGE/);
decOpt.message = await openpgp.message.readArmored(encrypted); decOpt.message = await openpgp.message.readArmored(encrypted);
expect(!!decOpt.message.packets.findPacket(openpgp.enums.packet.symEncryptedAEADProtected)).to.equal(false); expect(!!decOpt.message.packets.findPacket(openpgp.enums.packet.symEncryptedAEADProtectedData)).to.equal(false);
return openpgp.decrypt(decOpt); return openpgp.decrypt(decOpt);
}).then(function (decrypted) { }).then(function (decrypted) {
expect(decrypted.data).to.equal(plaintext); expect(decrypted.data).to.equal(plaintext);
@ -1103,7 +1103,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
return openpgp.encrypt(encOpt).then(async function (encrypted) { return openpgp.encrypt(encOpt).then(async function (encrypted) {
expect(encrypted).to.match(/^-----BEGIN PGP MESSAGE/); expect(encrypted).to.match(/^-----BEGIN PGP MESSAGE/);
decOpt.message = await openpgp.message.readArmored(encrypted); decOpt.message = await openpgp.message.readArmored(encrypted);
expect(!!decOpt.message.packets.findPacket(openpgp.enums.packet.symEncryptedAEADProtected)).to.equal(false); expect(!!decOpt.message.packets.findPacket(openpgp.enums.packet.symEncryptedAEADProtectedData)).to.equal(false);
return openpgp.decrypt(decOpt); return openpgp.decrypt(decOpt);
}).then(function (decrypted) { }).then(function (decrypted) {
expect(decrypted.data).to.equal(plaintext); expect(decrypted.data).to.equal(plaintext);
@ -1122,7 +1122,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
}; };
return openpgp.encrypt(encOpt).then(async function (encrypted) { return openpgp.encrypt(encOpt).then(async function (encrypted) {
decOpt.message = await openpgp.message.readArmored(encrypted); decOpt.message = await openpgp.message.readArmored(encrypted);
expect(!!decOpt.message.packets.findPacket(openpgp.enums.packet.symEncryptedAEADProtected)).to.equal(openpgp.config.aeadProtect); expect(!!decOpt.message.packets.findPacket(openpgp.enums.packet.symEncryptedAEADProtectedData)).to.equal(openpgp.config.aeadProtect);
return openpgp.decrypt(decOpt); return openpgp.decrypt(decOpt);
}).then(async function (decrypted) { }).then(async function (decrypted) {
expect(decrypted.data).to.equal(plaintext); expect(decrypted.data).to.equal(plaintext);
@ -1145,7 +1145,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
}; };
return openpgp.encrypt(encOpt).then(async function (encrypted) { return openpgp.encrypt(encOpt).then(async function (encrypted) {
decOpt.message = await openpgp.message.readArmored(encrypted); decOpt.message = await openpgp.message.readArmored(encrypted);
expect(!!decOpt.message.packets.findPacket(openpgp.enums.packet.symEncryptedAEADProtected)).to.equal(false); expect(!!decOpt.message.packets.findPacket(openpgp.enums.packet.symEncryptedAEADProtectedData)).to.equal(false);
return openpgp.decrypt(decOpt); return openpgp.decrypt(decOpt);
}).then(async function (decrypted) { }).then(async function (decrypted) {
expect(decrypted.data).to.equal(plaintext); expect(decrypted.data).to.equal(plaintext);
@ -1176,7 +1176,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
}; };
return openpgp.encrypt(encOpt).then(async function (encrypted) { return openpgp.encrypt(encOpt).then(async function (encrypted) {
decOpt.message = await openpgp.message.readArmored(encrypted); decOpt.message = await openpgp.message.readArmored(encrypted);
expect(!!decOpt.message.packets.findPacket(openpgp.enums.packet.symEncryptedAEADProtected)).to.equal(openpgp.config.aeadProtect); expect(!!decOpt.message.packets.findPacket(openpgp.enums.packet.symEncryptedAEADProtectedData)).to.equal(openpgp.config.aeadProtect);
return openpgp.decrypt(decOpt); return openpgp.decrypt(decOpt);
}).then(async function (decrypted) { }).then(async function (decrypted) {
expect(decrypted.data).to.equal(plaintext); expect(decrypted.data).to.equal(plaintext);
@ -1205,7 +1205,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
detached: true detached: true
}); });
const message = await openpgp.message.readArmored(encrypted); const message = await openpgp.message.readArmored(encrypted);
expect(!!message.packets.findPacket(openpgp.enums.packet.symEncryptedAEADProtected)).to.equal(openpgp.config.aeadProtect); expect(!!message.packets.findPacket(openpgp.enums.packet.symEncryptedAEADProtectedData)).to.equal(openpgp.config.aeadProtect);
const decrypted = await openpgp.decrypt({ const decrypted = await openpgp.decrypt({
message, message,
signature: await openpgp.signature.readArmored(signed), signature: await openpgp.signature.readArmored(signed),
@ -2020,9 +2020,9 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
return openpgp.sign(signOpt).then(async function (signed) { return openpgp.sign(signOpt).then(async function (signed) {
const message = await openpgp.message.read(signed); const message = await openpgp.message.read(signed);
message.packets.concat(await openpgp.stream.readToEnd(message.packets.stream, _ => _)); message.packets.concat(await openpgp.stream.readToEnd(message.packets.stream, _ => _));
const packets = new openpgp.packet.List(); const packets = new openpgp.PacketList();
packets.push(message.packets.findPacket(openpgp.enums.packet.signature)); packets.push(message.packets.findPacket(openpgp.enums.packet.signature));
packets.push(message.packets.findPacket(openpgp.enums.packet.literal)); packets.push(message.packets.findPacket(openpgp.enums.packet.literalData));
verifyOpt.message = new openpgp.message.Message(packets); verifyOpt.message = new openpgp.message.Message(packets);
return openpgp.verify(verifyOpt); return openpgp.verify(verifyOpt);
}).then(async function (verified) { }).then(async function (verified) {
@ -2052,9 +2052,9 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
expect(openpgp.util.isStream(signed)).to.equal(useNativeStream ? 'web' : 'ponyfill'); expect(openpgp.util.isStream(signed)).to.equal(useNativeStream ? 'web' : 'ponyfill');
const message = await openpgp.message.read(signed); const message = await openpgp.message.read(signed);
message.packets.concat(await openpgp.stream.readToEnd(message.packets.stream, _ => _)); message.packets.concat(await openpgp.stream.readToEnd(message.packets.stream, _ => _));
const packets = new openpgp.packet.List(); const packets = new openpgp.PacketList();
packets.push(message.packets.findPacket(openpgp.enums.packet.signature)); packets.push(message.packets.findPacket(openpgp.enums.packet.signature));
packets.push(message.packets.findPacket(openpgp.enums.packet.literal)); packets.push(message.packets.findPacket(openpgp.enums.packet.literalData));
verifyOpt.message = new openpgp.message.Message(packets); verifyOpt.message = new openpgp.message.Message(packets);
return openpgp.verify(verifyOpt); return openpgp.verify(verifyOpt);
}).then(async function (verified) { }).then(async function (verified) {
@ -2080,7 +2080,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
const message = await openpgp.message.read(encrypted); const message = await openpgp.message.read(encrypted);
return message.decrypt([privateKey_2038_2045]); return message.decrypt([privateKey_2038_2045]);
}).then(async function (packets) { }).then(async function (packets) {
const literals = packets.packets.filterByTag(openpgp.enums.packet.literal); const literals = packets.packets.filterByTag(openpgp.enums.packet.literalData);
expect(literals.length).to.equal(1); expect(literals.length).to.equal(1);
expect(+literals[0].date).to.equal(+future); expect(+literals[0].date).to.equal(+future);
expect(await openpgp.stream.readToEnd(packets.getText())).to.equal(plaintext); expect(await openpgp.stream.readToEnd(packets.getText())).to.equal(plaintext);
@ -2101,7 +2101,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
const message = await openpgp.message.read(encrypted); const message = await openpgp.message.read(encrypted);
return message.decrypt([privateKey_2000_2008]); return message.decrypt([privateKey_2000_2008]);
}).then(async function (packets) { }).then(async function (packets) {
const literals = packets.packets.filterByTag(openpgp.enums.packet.literal); const literals = packets.packets.filterByTag(openpgp.enums.packet.literalData);
expect(literals.length).to.equal(1); expect(literals.length).to.equal(1);
expect(+literals[0].date).to.equal(+past); expect(+literals[0].date).to.equal(+past);
expect(await openpgp.stream.readToEnd(packets.getLiteralData())).to.deep.equal(data); expect(await openpgp.stream.readToEnd(packets.getLiteralData())).to.deep.equal(data);
@ -2122,7 +2122,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
const message = await openpgp.message.read(encrypted); const message = await openpgp.message.read(encrypted);
return message.decrypt([privateKey_2000_2008]); return message.decrypt([privateKey_2000_2008]);
}).then(async function (message) { }).then(async function (message) {
const literals = message.packets.filterByTag(openpgp.enums.packet.literal); const literals = message.packets.filterByTag(openpgp.enums.packet.literalData);
expect(literals.length).to.equal(1); expect(literals.length).to.equal(1);
expect(+literals[0].date).to.equal(+past); expect(+literals[0].date).to.equal(+past);
const signatures = await message.verify([publicKey_2000_2008], past); const signatures = await message.verify([publicKey_2000_2008], past);
@ -2150,7 +2150,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
const message = await openpgp.message.read(encrypted); const message = await openpgp.message.read(encrypted);
return message.decrypt([privateKey_2038_2045]); return message.decrypt([privateKey_2038_2045]);
}).then(async function (message) { }).then(async function (message) {
const literals = message.packets.filterByTag(openpgp.enums.packet.literal); const literals = message.packets.filterByTag(openpgp.enums.packet.literalData);
expect(literals.length).to.equal(1); expect(literals.length).to.equal(1);
expect(literals[0].format).to.equal('binary'); expect(literals[0].format).to.equal('binary');
expect(+literals[0].date).to.equal(+future); expect(+literals[0].date).to.equal(+future);
@ -2179,7 +2179,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
const message = await openpgp.message.read(encrypted); const message = await openpgp.message.read(encrypted);
return message.decrypt([privateKey_2038_2045]); return message.decrypt([privateKey_2038_2045]);
}).then(async function (message) { }).then(async function (message) {
const literals = message.packets.filterByTag(openpgp.enums.packet.literal); const literals = message.packets.filterByTag(openpgp.enums.packet.literalData);
expect(literals.length).to.equal(1); expect(literals.length).to.equal(1);
expect(literals[0].format).to.equal('mime'); expect(literals[0].format).to.equal('mime');
expect(+literals[0].date).to.equal(+future); expect(+literals[0].date).to.equal(+future);

190
test/general/packet.js
View File

@ -62,13 +62,13 @@ module.exports = () => describe("Packet", function() {
'-----END PGP PRIVATE KEY BLOCK-----'; '-----END PGP PRIVATE KEY BLOCK-----';
it('Symmetrically encrypted packet', async function() { it('Symmetrically encrypted packet', async function() {
const message = new openpgp.packet.List(); const message = new openpgp.PacketList();
const testText = input.createSomeMessage(); const testText = input.createSomeMessage();
const literal = new openpgp.packet.Literal(); const literal = new openpgp.LiteralDataPacket();
literal.setText(testText); literal.setText(testText);
const enc = new openpgp.packet.SymmetricallyEncrypted(); const enc = new openpgp.SymmetricallyEncryptedDataPacket();
message.push(enc); message.push(enc);
enc.packets.push(literal); enc.packets.push(literal);
@ -78,7 +78,7 @@ module.exports = () => describe("Packet", function() {
await enc.encrypt(algo, key); await enc.encrypt(algo, key);
const msg2 = new openpgp.message.Message(); const msg2 = new openpgp.message.Message();
await msg2.packets.read(message.write()); await msg2.packets.read(message.write(), { SymmetricallyEncryptedDataPacket: openpgp.SymmetricallyEncryptedDataPacket });
msg2.packets[0].ignoreMdcError = true; msg2.packets[0].ignoreMdcError = true;
const dec = await msg2.decrypt(null, null, [{ algorithm: algo, data: key }]); const dec = await msg2.decrypt(null, null, [{ algorithm: algo, data: key }]);
@ -86,13 +86,13 @@ module.exports = () => describe("Packet", function() {
}); });
it('Symmetrically encrypted packet - MDC error for modern cipher', async function() { it('Symmetrically encrypted packet - MDC error for modern cipher', async function() {
const message = new openpgp.packet.List(); const message = new openpgp.PacketList();
const testText = input.createSomeMessage(); const testText = input.createSomeMessage();
const literal = new openpgp.packet.Literal(); const literal = new openpgp.LiteralDataPacket();
literal.setText(testText); literal.setText(testText);
const enc = new openpgp.packet.SymmetricallyEncrypted(); const enc = new openpgp.SymmetricallyEncryptedDataPacket();
message.push(enc); message.push(enc);
await enc.packets.push(literal); await enc.packets.push(literal);
@ -101,8 +101,8 @@ module.exports = () => describe("Packet", function() {
await enc.encrypt(algo, key); await enc.encrypt(algo, key);
const msg2 = new openpgp.packet.List(); const msg2 = new openpgp.PacketList();
await msg2.read(message.write()); await msg2.read(message.write(), { SymmetricallyEncryptedDataPacket: openpgp.SymmetricallyEncryptedDataPacket });
await expect(msg2[0].decrypt(algo, key)).to.eventually.be.rejectedWith('Decryption failed due to missing MDC.'); await expect(msg2[0].decrypt(algo, key)).to.eventually.be.rejectedWith('Decryption failed due to missing MDC.');
}); });
@ -111,17 +111,17 @@ module.exports = () => describe("Packet", function() {
const algo = 'aes256'; const algo = 'aes256';
const testText = input.createSomeMessage(); const testText = input.createSomeMessage();
const literal = new openpgp.packet.Literal(); const literal = new openpgp.LiteralDataPacket();
const enc = new openpgp.packet.SymEncryptedIntegrityProtected(); const enc = new openpgp.SymEncryptedIntegrityProtectedDataPacket();
const msg = new openpgp.packet.List(); const msg = new openpgp.PacketList();
msg.push(enc); msg.push(enc);
literal.setText(testText); literal.setText(testText);
enc.packets.push(literal); enc.packets.push(literal);
await enc.encrypt(algo, key); await enc.encrypt(algo, key);
const msg2 = new openpgp.packet.List(); const msg2 = new openpgp.PacketList();
await msg2.read(msg.write()); await msg2.read(msg.write(), openpgp);
await msg2[0].decrypt(algo, key); await msg2[0].decrypt(algo, key);
@ -132,18 +132,18 @@ module.exports = () => describe("Packet", function() {
const key = new Uint8Array([1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2]); const key = new Uint8Array([1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2]);
const algo = 'aes256'; const algo = 'aes256';
const testText = input.createSomeMessage(); const testText = input.createSomeMessage();
const literal = new openpgp.packet.Literal(); const literal = new openpgp.LiteralDataPacket();
const enc = new openpgp.packet.SymEncryptedAEADProtected(); const enc = new openpgp.SymEncryptedAEADProtectedDataPacket();
const msg = new openpgp.packet.List(); const msg = new openpgp.PacketList();
msg.push(enc); msg.push(enc);
literal.setText(testText); literal.setText(testText);
enc.packets.push(literal); enc.packets.push(literal);
const msg2 = new openpgp.packet.List(); const msg2 = new openpgp.PacketList();
return enc.encrypt(algo, key).then(async function() { return enc.encrypt(algo, key).then(async function() {
await msg2.read(msg.write()); await msg2.read(msg.write(), openpgp);
return msg2[0].decrypt(algo, key); return msg2[0].decrypt(algo, key);
}).then(async function() { }).then(async function() {
expect(await openpgp.stream.readToEnd(msg2[0].packets[0].data)).to.deep.equal(literal.data); expect(await openpgp.stream.readToEnd(msg2[0].packets[0].data)).to.deep.equal(literal.data);
@ -158,19 +158,19 @@ module.exports = () => describe("Packet", function() {
const key = new Uint8Array([1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2]); const key = new Uint8Array([1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2]);
const algo = 'aes256'; const algo = 'aes256';
const literal = new openpgp.packet.Literal(); const literal = new openpgp.LiteralDataPacket();
const enc = new openpgp.packet.SymEncryptedAEADProtected(); const enc = new openpgp.SymEncryptedAEADProtectedDataPacket();
const msg = new openpgp.packet.List(); const msg = new openpgp.PacketList();
msg.push(enc); msg.push(enc);
literal.setText(testText); literal.setText(testText);
enc.packets.push(literal); enc.packets.push(literal);
const msg2 = new openpgp.packet.List(); const msg2 = new openpgp.PacketList();
try { try {
await enc.encrypt(algo, key); await enc.encrypt(algo, key);
await msg2.read(msg.write()); await msg2.read(msg.write(), openpgp);
await msg2[0].decrypt(algo, key); await msg2[0].decrypt(algo, key);
expect(await openpgp.stream.readToEnd(msg2[0].packets[0].data)).to.deep.equal(literal.data); expect(await openpgp.stream.readToEnd(msg2[0].packets[0].data)).to.deep.equal(literal.data);
} finally { } finally {
@ -213,20 +213,20 @@ module.exports = () => describe("Packet", function() {
const key = new Uint8Array([1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2]); const key = new Uint8Array([1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2]);
const algo = 'aes256'; const algo = 'aes256';
const literal = new openpgp.packet.Literal(); const literal = new openpgp.LiteralDataPacket();
const enc = new openpgp.packet.SymEncryptedAEADProtected(); const enc = new openpgp.SymEncryptedAEADProtectedDataPacket();
const msg = new openpgp.packet.List(); const msg = new openpgp.PacketList();
enc.aeadAlgorithm = 'experimentalGcm'; enc.aeadAlgorithm = 'experimentalGcm';
msg.push(enc); msg.push(enc);
literal.setText(testText); literal.setText(testText);
enc.packets.push(literal); enc.packets.push(literal);
const msg2 = new openpgp.packet.List(); const msg2 = new openpgp.PacketList();
try { try {
await enc.encrypt(algo, key); await enc.encrypt(algo, key);
await msg2.read(msg.write()); await msg2.read(msg.write(), openpgp);
await msg2[0].decrypt(algo, key); await msg2[0].decrypt(algo, key);
expect(await openpgp.stream.readToEnd(msg2[0].packets[0].data)).to.deep.equal(literal.data); expect(await openpgp.stream.readToEnd(msg2[0].packets[0].data)).to.deep.equal(literal.data);
expect(encryptStub.callCount > 1).to.be.true; expect(encryptStub.callCount > 1).to.be.true;
@ -259,16 +259,16 @@ module.exports = () => describe("Packet", function() {
const key = openpgp.util.hexToUint8Array('86 f1 ef b8 69 52 32 9f 24 ac d3 bf d0 e5 34 6d'.replace(/\s+/g, '')); const key = openpgp.util.hexToUint8Array('86 f1 ef b8 69 52 32 9f 24 ac d3 bf d0 e5 34 6d'.replace(/\s+/g, ''));
const algo = 'aes128'; const algo = 'aes128';
const literal = new openpgp.packet.Literal(0); const literal = new openpgp.LiteralDataPacket(0);
const enc = new openpgp.packet.SymEncryptedAEADProtected(); const enc = new openpgp.SymEncryptedAEADProtectedDataPacket();
const msg = new openpgp.packet.List(); const msg = new openpgp.PacketList();
msg.push(enc); msg.push(enc);
literal.setBytes(openpgp.util.strToUint8Array('Hello, world!\n'), openpgp.enums.literal.binary); literal.setBytes(openpgp.util.strToUint8Array('Hello, world!\n'), openpgp.enums.literal.binary);
literal.filename = ''; literal.filename = '';
enc.packets.push(literal); enc.packets.push(literal);
const msg2 = new openpgp.packet.List(); const msg2 = new openpgp.PacketList();
let randomBytesStub = stub(openpgp.crypto.random, 'getRandomBytes'); let randomBytesStub = stub(openpgp.crypto.random, 'getRandomBytes');
randomBytesStub.returns(resolves(iv)); randomBytesStub.returns(resolves(iv));
@ -277,7 +277,7 @@ module.exports = () => describe("Packet", function() {
await enc.encrypt(algo, key); await enc.encrypt(algo, key);
const data = msg.write(); const data = msg.write();
expect(await openpgp.stream.readToEnd(openpgp.stream.clone(data))).to.deep.equal(packetBytes); expect(await openpgp.stream.readToEnd(openpgp.stream.clone(data))).to.deep.equal(packetBytes);
await msg2.read(data); await msg2.read(data, openpgp);
await msg2[0].decrypt(algo, key); await msg2[0].decrypt(algo, key);
expect(await openpgp.stream.readToEnd(msg2[0].packets[0].data)).to.deep.equal(literal.data); expect(await openpgp.stream.readToEnd(msg2[0].packets[0].data)).to.deep.equal(literal.data);
} finally { } finally {
@ -299,8 +299,8 @@ module.exports = () => describe("Packet", function() {
const msgbytes = (await openpgp.armor.decode(msg)).data; const msgbytes = (await openpgp.armor.decode(msg)).data;
const parsed = new openpgp.packet.List(); const parsed = new openpgp.PacketList();
await parsed.read(msgbytes); await parsed.read(msgbytes, openpgp);
return parsed[0].decrypt('test').then(() => { return parsed[0].decrypt('test').then(() => {
const key = parsed[0].sessionKey; const key = parsed[0].sessionKey;
@ -325,9 +325,9 @@ module.exports = () => describe("Packet", function() {
return new openpgp.MPI(k); return new openpgp.MPI(k);
}); });
const enc = new openpgp.packet.PublicKeyEncryptedSessionKey(); const enc = new openpgp.PublicKeyEncryptedSessionKeyPacket();
const msg = new openpgp.packet.List(); const msg = new openpgp.PacketList();
const msg2 = new openpgp.packet.List(); const msg2 = new openpgp.PacketList();
enc.sessionKey = new Uint8Array([1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2]); enc.sessionKey = new Uint8Array([1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2]);
enc.publicKeyAlgorithm = 'rsaEncryptSign'; enc.publicKeyAlgorithm = 'rsaEncryptSign';
@ -337,7 +337,7 @@ module.exports = () => describe("Packet", function() {
msg.push(enc); msg.push(enc);
await msg2.read(msg.write()); await msg2.read(msg.write(), openpgp);
return msg2[0].decrypt({ algorithm: 'rsaEncryptSign', params: mpi, getFingerprintBytes() {} }).then(() => { return msg2[0].decrypt({ algorithm: 'rsaEncryptSign', params: mpi, getFingerprintBytes() {} }).then(() => {
@ -371,11 +371,11 @@ module.exports = () => describe("Packet", function() {
'=lKiS\n' + '=lKiS\n' +
'-----END PGP PRIVATE KEY BLOCK-----'; '-----END PGP PRIVATE KEY BLOCK-----';
let key = new openpgp.packet.List(); let key = new openpgp.PacketList();
await key.read((await openpgp.armor.decode(armored_key)).data); await key.read((await openpgp.armor.decode(armored_key)).data, openpgp);
key = key[0]; key = key[0];
const enc = new openpgp.packet.PublicKeyEncryptedSessionKey(); const enc = new openpgp.PublicKeyEncryptedSessionKeyPacket();
const secret = new Uint8Array([1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2]); const secret = new Uint8Array([1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2]);
enc.sessionKey = secret; enc.sessionKey = secret;
@ -438,12 +438,12 @@ module.exports = () => describe("Packet", function() {
'=iSaK\n' + '=iSaK\n' +
'-----END PGP MESSAGE-----'; '-----END PGP MESSAGE-----';
let key = new openpgp.packet.List(); let key = new openpgp.PacketList();
await key.read((await openpgp.armor.decode(armored_key)).data); await key.read((await openpgp.armor.decode(armored_key)).data, openpgp);
key = key[3]; key = key[3];
const msg = new openpgp.packet.List(); const msg = new openpgp.PacketList();
await msg.read((await openpgp.armor.decode(armored_msg)).data); await msg.read((await openpgp.armor.decode(armored_msg)).data, openpgp);
return msg[0].decrypt(key).then(async () => { return msg[0].decrypt(key).then(async () => {
await msg[1].decrypt(msg[0].sessionKeyAlgorithm, msg[0].sessionKey); await msg[1].decrypt(msg[0].sessionKeyAlgorithm, msg[0].sessionKey);
@ -459,10 +459,10 @@ module.exports = () => describe("Packet", function() {
const algo = 'aes256'; const algo = 'aes256';
const testText = input.createSomeMessage(); const testText = input.createSomeMessage();
const literal = new openpgp.packet.Literal(); const literal = new openpgp.LiteralDataPacket();
const key_enc = new openpgp.packet.SymEncryptedSessionKey(); const key_enc = new openpgp.SymEncryptedSessionKeyPacket();
const enc = new openpgp.packet.SymEncryptedIntegrityProtected(); const enc = new openpgp.SymEncryptedIntegrityProtectedDataPacket();
const msg = new openpgp.packet.List(); const msg = new openpgp.PacketList();
msg.push(key_enc); msg.push(key_enc);
msg.push(enc); msg.push(enc);
@ -476,8 +476,8 @@ module.exports = () => describe("Packet", function() {
enc.packets.push(literal); enc.packets.push(literal);
await enc.encrypt(algo, key); await enc.encrypt(algo, key);
const msg2 = new openpgp.packet.List(); const msg2 = new openpgp.PacketList();
await msg2.read(msg.write()); await msg2.read(msg.write(), openpgp);
await msg2[0].decrypt(passphrase); await msg2[0].decrypt(passphrase);
const key2 = msg2[0].sessionKey; const key2 = msg2[0].sessionKey;
@ -495,10 +495,10 @@ module.exports = () => describe("Packet", function() {
const algo = 'aes256'; const algo = 'aes256';
const testText = input.createSomeMessage(); const testText = input.createSomeMessage();
const literal = new openpgp.packet.Literal(); const literal = new openpgp.LiteralDataPacket();
const key_enc = new openpgp.packet.SymEncryptedSessionKey(); const key_enc = new openpgp.SymEncryptedSessionKeyPacket();
const enc = new openpgp.packet.SymEncryptedAEADProtected(); const enc = new openpgp.SymEncryptedAEADProtectedDataPacket();
const msg = new openpgp.packet.List(); const msg = new openpgp.PacketList();
msg.push(key_enc); msg.push(key_enc);
msg.push(enc); msg.push(enc);
@ -512,8 +512,8 @@ module.exports = () => describe("Packet", function() {
enc.packets.push(literal); enc.packets.push(literal);
await enc.encrypt(algo, key); await enc.encrypt(algo, key);
const msg2 = new openpgp.packet.List(); const msg2 = new openpgp.PacketList();
await msg2.read(msg.write()); await msg2.read(msg.write(), openpgp);
await msg2[0].decrypt(passphrase); await msg2[0].decrypt(passphrase);
const key2 = msg2[0].sessionKey; const key2 = msg2[0].sessionKey;
@ -563,10 +563,10 @@ module.exports = () => describe("Packet", function() {
const passphrase = 'password'; const passphrase = 'password';
const algo = 'aes128'; const algo = 'aes128';
const literal = new openpgp.packet.Literal(0); const literal = new openpgp.LiteralDataPacket(0);
const key_enc = new openpgp.packet.SymEncryptedSessionKey(); const key_enc = new openpgp.SymEncryptedSessionKeyPacket();
const enc = new openpgp.packet.SymEncryptedAEADProtected(); const enc = new openpgp.SymEncryptedAEADProtectedDataPacket();
const msg = new openpgp.packet.List(); const msg = new openpgp.PacketList();
msg.push(key_enc); msg.push(key_enc);
msg.push(enc); msg.push(enc);
@ -584,8 +584,8 @@ module.exports = () => describe("Packet", function() {
const data = msg.write(); const data = msg.write();
expect(await openpgp.stream.readToEnd(openpgp.stream.clone(data))).to.deep.equal(packetBytes); expect(await openpgp.stream.readToEnd(openpgp.stream.clone(data))).to.deep.equal(packetBytes);
const msg2 = new openpgp.packet.List(); const msg2 = new openpgp.PacketList();
await msg2.read(data); await msg2.read(data, openpgp);
await msg2[0].decrypt(passphrase); await msg2[0].decrypt(passphrase);
const key2 = msg2[0].sessionKey; const key2 = msg2[0].sessionKey;
@ -638,10 +638,10 @@ module.exports = () => describe("Packet", function() {
const passphrase = 'password'; const passphrase = 'password';
const algo = 'aes128'; const algo = 'aes128';
const literal = new openpgp.packet.Literal(0); const literal = new openpgp.LiteralDataPacket(0);
const key_enc = new openpgp.packet.SymEncryptedSessionKey(); const key_enc = new openpgp.SymEncryptedSessionKeyPacket();
const enc = new openpgp.packet.SymEncryptedAEADProtected(); const enc = new openpgp.SymEncryptedAEADProtectedDataPacket();
const msg = new openpgp.packet.List(); const msg = new openpgp.PacketList();
enc.aeadAlgorithm = key_enc.aeadAlgorithm = 'ocb'; enc.aeadAlgorithm = key_enc.aeadAlgorithm = 'ocb';
msg.push(key_enc); msg.push(key_enc);
@ -660,8 +660,8 @@ module.exports = () => describe("Packet", function() {
const data = msg.write(); const data = msg.write();
expect(await openpgp.stream.readToEnd(openpgp.stream.clone(data))).to.deep.equal(packetBytes); expect(await openpgp.stream.readToEnd(openpgp.stream.clone(data))).to.deep.equal(packetBytes);
const msg2 = new openpgp.packet.List(); const msg2 = new openpgp.PacketList();
await msg2.read(data); await msg2.read(data, openpgp);
await msg2[0].decrypt(passphrase); await msg2[0].decrypt(passphrase);
const key2 = msg2[0].sessionKey; const key2 = msg2[0].sessionKey;
@ -689,13 +689,13 @@ module.exports = () => describe("Packet", function() {
'=pR+C\n' + '=pR+C\n' +
'-----END PGP MESSAGE-----'; '-----END PGP MESSAGE-----';
let key = new openpgp.packet.List(); let key = new openpgp.PacketList();
await key.read((await openpgp.armor.decode(armored_key)).data); await key.read((await openpgp.armor.decode(armored_key)).data, openpgp);
key = key[3]; key = key[3];
await key.decrypt('test'); await key.decrypt('test');
const msg = new openpgp.packet.List(); const msg = new openpgp.PacketList();
await msg.read((await openpgp.armor.decode(armored_msg)).data); await msg.read((await openpgp.armor.decode(armored_msg)).data, openpgp);
return msg[0].decrypt(key).then(async () => { return msg[0].decrypt(key).then(async () => {
await msg[1].decrypt(msg[0].sessionKeyAlgorithm, msg[0].sessionKey); await msg[1].decrypt(msg[0].sessionKeyAlgorithm, msg[0].sessionKey);
@ -707,8 +707,8 @@ module.exports = () => describe("Packet", function() {
}); });
it('Secret key reading with signature verification.', async function() { it('Secret key reading with signature verification.', async function() {
const key = new openpgp.packet.List(); const key = new openpgp.PacketList();
await key.read((await openpgp.armor.decode(armored_key)).data); await key.read((await openpgp.armor.decode(armored_key)).data, openpgp);
return Promise.all([ return Promise.all([
expect(key[2].verify(key[0], expect(key[2].verify(key[0],
openpgp.enums.signature.certGeneric, openpgp.enums.signature.certGeneric,
@ -742,12 +742,12 @@ module.exports = () => describe("Packet", function() {
'=htrB\n' + '=htrB\n' +
'-----END PGP MESSAGE-----'; '-----END PGP MESSAGE-----';
const key = new openpgp.packet.List(); const key = new openpgp.PacketList();
await key.read((await openpgp.armor.decode(armored_key)).data); await key.read((await openpgp.armor.decode(armored_key)).data, openpgp);
await key[3].decrypt('test'); await key[3].decrypt('test');
const msg = new openpgp.packet.List(); const msg = new openpgp.PacketList();
await msg.read((await openpgp.armor.decode(armored_msg)).data); await msg.read((await openpgp.armor.decode(armored_msg)).data, openpgp);
return msg[0].decrypt(key[3]).then(async () => { return msg[0].decrypt(key[3]).then(async () => {
await msg[1].decrypt(msg[0].sessionKeyAlgorithm, msg[0].sessionKey); await msg[1].decrypt(msg[0].sessionKeyAlgorithm, msg[0].sessionKey);
@ -842,8 +842,8 @@ V+HOQJQxXJkVRYa3QrFUehiMzTeqqMdgC6ZqJy7+
}); });
it('Writing and encryption of a secret key packet.', function() { it('Writing and encryption of a secret key packet.', function() {
const key = new openpgp.packet.List(); const key = new openpgp.PacketList();
key.push(new openpgp.packet.SecretKey()); key.push(new openpgp.SecretKeyPacket());
const rsa = openpgp.crypto.publicKey.rsa; const rsa = openpgp.crypto.publicKey.rsa;
const keySize = openpgp.util.getWebCryptoAll() ? 2048 : 512; // webkit webcrypto accepts minimum 2048 bit keys const keySize = openpgp.util.getWebCryptoAll() ? 2048 : 512; // webkit webcrypto accepts minimum 2048 bit keys
@ -861,8 +861,8 @@ V+HOQJQxXJkVRYa3QrFUehiMzTeqqMdgC6ZqJy7+
const raw = key.write(); const raw = key.write();
const key2 = new openpgp.packet.List(); const key2 = new openpgp.PacketList();
await key2.read(raw); await key2.read(raw, openpgp);
await key2[0].decrypt('hello'); await key2[0].decrypt('hello');
expect(key[0].params.toString()).to.equal(key2[0].params.toString()); expect(key[0].params.toString()).to.equal(key2[0].params.toString());
@ -873,8 +873,8 @@ V+HOQJQxXJkVRYa3QrFUehiMzTeqqMdgC6ZqJy7+
let aeadProtectVal = openpgp.config.aeadProtect; let aeadProtectVal = openpgp.config.aeadProtect;
openpgp.config.aeadProtect = true; openpgp.config.aeadProtect = true;
const key = new openpgp.packet.List(); const key = new openpgp.PacketList();
key.push(new openpgp.packet.SecretKey()); key.push(new openpgp.SecretKeyPacket());
const rsa = openpgp.crypto.publicKey.rsa; const rsa = openpgp.crypto.publicKey.rsa;
const keySize = openpgp.util.getWebCryptoAll() ? 2048 : 512; // webkit webcrypto accepts minimum 2048 bit keys const keySize = openpgp.util.getWebCryptoAll() ? 2048 : 512; // webkit webcrypto accepts minimum 2048 bit keys
@ -893,8 +893,8 @@ V+HOQJQxXJkVRYa3QrFUehiMzTeqqMdgC6ZqJy7+
const raw = key.write(); const raw = key.write();
const key2 = new openpgp.packet.List(); const key2 = new openpgp.PacketList();
await key2.read(raw); await key2.read(raw, openpgp);
await key2[0].decrypt('hello'); await key2[0].decrypt('hello');
expect(key[0].params.toString()).to.equal(key2[0].params.toString()); expect(key[0].params.toString()).to.equal(key2[0].params.toString());
@ -904,7 +904,7 @@ V+HOQJQxXJkVRYa3QrFUehiMzTeqqMdgC6ZqJy7+
}); });
it('Writing and verification of a signature packet.', function() { it('Writing and verification of a signature packet.', function() {
const key = new openpgp.packet.SecretKey(); const key = new openpgp.SecretKeyPacket();
const rsa = openpgp.crypto.publicKey.rsa; const rsa = openpgp.crypto.publicKey.rsa;
const keySize = openpgp.util.getWebCryptoAll() ? 2048 : 512; // webkit webcrypto accepts minimum 2048 bit keys const keySize = openpgp.util.getWebCryptoAll() ? 2048 : 512; // webkit webcrypto accepts minimum 2048 bit keys
@ -919,9 +919,9 @@ V+HOQJQxXJkVRYa3QrFUehiMzTeqqMdgC6ZqJy7+
key.params = mpi; key.params = mpi;
key.algorithm = "rsaSign"; key.algorithm = "rsaSign";
const signed = new openpgp.packet.List(); const signed = new openpgp.PacketList();
const literal = new openpgp.packet.Literal(); const literal = new openpgp.LiteralDataPacket();
const signature = new openpgp.packet.Signature(); const signature = new openpgp.SignaturePacket();
literal.setText(testText); literal.setText(testText);
@ -936,8 +936,8 @@ V+HOQJQxXJkVRYa3QrFUehiMzTeqqMdgC6ZqJy7+
const raw = signed.write(); const raw = signed.write();
const signed2 = new openpgp.packet.List(); const signed2 = new openpgp.PacketList();
await signed2.read(raw); await signed2.read(raw, openpgp);
signed2.concat(await openpgp.stream.readToEnd(signed2.stream, arr => arr)); signed2.concat(await openpgp.stream.readToEnd(signed2.stream, arr => arr));
await Promise.all([ await Promise.all([

4
test/security/message_signature_bypass.js
View File

@ -1,6 +1,6 @@
const openpgp = typeof window !== 'undefined' && window.openpgp ? window.openpgp : require('../..'); const openpgp = typeof window !== 'undefined' && window.openpgp ? window.openpgp : require('../..');
const { key, cleartext, util, packet: { Signature } } = openpgp; const { key, cleartext, util, SignaturePacket } = openpgp;
const chai = require('chai'); const chai = require('chai');
chai.use(require('chai-as-promised')); chai.use(require('chai-as-promised'));
@ -89,7 +89,7 @@ async function fakeSignature() {
'You owe me', 'You owe me',
'I owe you')); 'I owe you'));
// read the standalone signature packet // read the standalone signature packet
const tmp = new Signature(); const tmp = new SignaturePacket();
await tmp.read(STANDALONE_PKT); await tmp.read(STANDALONE_PKT);
// replace the "text" signature with the // replace the "text" signature with the

2
test/security/preferred_algo_mismatch.js
View File

@ -1,6 +1,6 @@
const openpgp = typeof window !== 'undefined' && window.openpgp ? window.openpgp : require('../..'); const openpgp = typeof window !== 'undefined' && window.openpgp ? window.openpgp : require('../..');
const { key, cleartext, enums, packet: { List, Signature } } = openpgp; const { key, cleartext, enums, PacketList, SignaturePacket } = openpgp;
const chai = require('chai'); const chai = require('chai');
chai.use(require('chai-as-promised')); chai.use(require('chai-as-promised'));

6
test/security/subkey_trust.js
View File

@ -1,6 +1,6 @@
const openpgp = typeof window !== 'undefined' && window.openpgp ? window.openpgp : require('../..'); const openpgp = typeof window !== 'undefined' && window.openpgp ? window.openpgp : require('../..');
const { key, cleartext, enums, packet: { List, Signature } } = openpgp; const { key, cleartext, enums, PacketList, SignaturePacket } = openpgp;
const chai = require('chai'); const chai = require('chai');
chai.use(require('chai-as-promised')); chai.use(require('chai-as-promised'));
@ -48,13 +48,13 @@ async function testSubkeyTrust() {
key: attackerPrivKey.toPublic().keyPacket, key: attackerPrivKey.toPublic().keyPacket,
bind: pktPubVictim[3] // victim subkey bind: pktPubVictim[3] // victim subkey
}; };
const fakeBindingSignature = new Signature(); const fakeBindingSignature = new SignaturePacket();
fakeBindingSignature.signatureType = enums.signature.subkeyBinding; fakeBindingSignature.signatureType = enums.signature.subkeyBinding;
fakeBindingSignature.publicKeyAlgorithm = attackerPrivKey.keyPacket.algorithm; fakeBindingSignature.publicKeyAlgorithm = attackerPrivKey.keyPacket.algorithm;
fakeBindingSignature.hashAlgorithm = enums.hash.sha256; fakeBindingSignature.hashAlgorithm = enums.hash.sha256;
fakeBindingSignature.keyFlags = [enums.keyFlags.signData]; fakeBindingSignature.keyFlags = [enums.keyFlags.signData];
await fakeBindingSignature.sign(attackerPrivKey.keyPacket, dataToSign); await fakeBindingSignature.sign(attackerPrivKey.keyPacket, dataToSign);
const newList = new List(); const newList = new PacketList();
newList.concat([ newList.concat([
pktPrivAttacker[0], // attacker private key pktPrivAttacker[0], // attacker private key
pktPrivAttacker[1], // attacker user pktPrivAttacker[1], // attacker user

6
test/security/unsigned_subpackets.js
View File

@ -1,6 +1,6 @@
const openpgp = typeof window !== 'undefined' && window.openpgp ? window.openpgp : require('../..'); const openpgp = typeof window !== 'undefined' && window.openpgp ? window.openpgp : require('../..');
const { key, message, enums, packet: { List, Signature } } = openpgp; const { key, message, enums, PacketList, SignaturePacket } = openpgp;
const chai = require('chai'); const chai = require('chai');
chai.use(require('chai-as-promised')); chai.use(require('chai-as-promised'));
@ -70,7 +70,7 @@ async function makeKeyValid() {
// deconstruct invalid key // deconstruct invalid key
const [pubkey, puser, pusersig] = invalidkey.toPacketlist().map(i => i); const [pubkey, puser, pusersig] = invalidkey.toPacketlist().map(i => i);
// create a fake signature // create a fake signature
const fake = new Signature(); const fake = new SignaturePacket();
Object.assign(fake, pusersig); Object.assign(fake, pusersig);
// extend expiration times // extend expiration times
fake.keyExpirationTime = 0x7FFFFFFF; fake.keyExpirationTime = 0x7FFFFFFF;
@ -80,7 +80,7 @@ async function makeKeyValid() {
// create modified subpacket data // create modified subpacket data
pusersig.read_sub_packets(fake.write_hashed_sub_packets(), false); pusersig.read_sub_packets(fake.write_hashed_sub_packets(), false);
// reconstruct the modified key // reconstruct the modified key
const newlist = new List(); const newlist = new PacketList();
newlist.concat([pubkey, puser, pusersig]); newlist.concat([pubkey, puser, pusersig]);
let modifiedkey = new key.Key(newlist); let modifiedkey = new key.Key(newlist);
// re-read the message to eliminate any // re-read the message to eliminate any