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

Lint: enforce single quotes and do not error on class methods without this (#1341)

Browse Source
This commit is contained in:
larabr 2021-06-24 22:58:15 +02:00 committed by GitHub
parent d238a023c1
commit ab22fe86da
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
43 changed files with 333 additions and 344 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
.eslintrc.js
View File

@ -72,7 +72,7 @@ module.exports = {
} }
], ],
"capitalized-comments": "off", "capitalized-comments": "off",
"class-methods-use-this": "error", "class-methods-use-this": "off",
"comma-dangle": [ "error", "never" ], "comma-dangle": [ "error", "never" ],
"comma-spacing": "off", "comma-spacing": "off",
"comma-style": [ "comma-style": [
@ -278,7 +278,7 @@ module.exports = {
"prefer-spread": "off", "prefer-spread": "off",
"prefer-template": "off", "prefer-template": "off",
"quote-props": "off", "quote-props": "off",
"quotes": "off", "quotes": ["error", "single", { "avoidEscape": true }],
"require-await": "error", "require-await": "error",
"require-jsdoc": "off", "require-jsdoc": "off",
"semi-spacing": [ "semi-spacing": [

4
rollup.config.js
View File

@ -5,7 +5,7 @@ import { builtinModules } from 'module';
import resolve from '@rollup/plugin-node-resolve'; import resolve from '@rollup/plugin-node-resolve';
import commonjs from '@rollup/plugin-commonjs'; import commonjs from '@rollup/plugin-commonjs';
import replace from '@rollup/plugin-replace'; import replace from '@rollup/plugin-replace';
import { terser } from "rollup-plugin-terser"; import { terser } from 'rollup-plugin-terser';
import pkg from './package.json'; import pkg from './package.json';
@ -16,7 +16,7 @@ const banner =
`${new Date().toISOString().split('T')[0]} - ` + `${new Date().toISOString().split('T')[0]} - ` +
`this is LGPL licensed code, see LICENSE/our website ${pkg.homepage} for more information. */`; `this is LGPL licensed code, see LICENSE/our website ${pkg.homepage} for more information. */`;
const intro = `const globalThis = typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};`; const intro = "const globalThis = typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};";
const terserOptions = { const terserOptions = {
ecma: 2017, ecma: 2017,

4
src/biginteger/native.interface.js
View File

@ -155,9 +155,9 @@ export default class BigInteger {
* @returns {BigInteger} this ** e mod n. * @returns {BigInteger} this ** e mod n.
*/ */
modExp(e, n) { modExp(e, n) {
if (n.isZero()) throw Error("Modulo cannot be zero"); if (n.isZero()) throw Error('Modulo cannot be zero');
if (n.isOne()) return new BigInteger(0); if (n.isOne()) return new BigInteger(0);
if (e.isNegative()) throw Error("Unsopported negative exponent"); if (e.isNegative()) throw Error('Unsopported negative exponent');
let exp = e.value; let exp = e.value;
let x = this.value; let x = this.value;

6
src/config/config.js
View File

@ -154,12 +154,12 @@ export default {
* @memberof module:config * @memberof module:config
* @property {String} versionString A version string to be included in armored messages * @property {String} versionString A version string to be included in armored messages
*/ */
versionString: "OpenPGP.js VERSION", versionString: 'OpenPGP.js VERSION',
/** /**
* @memberof module:config * @memberof module:config
* @property {String} commentString A comment string to be included in armored messages * @property {String} commentString A comment string to be included in armored messages
*/ */
commentString: "https://openpgpjs.org", commentString: 'https://openpgpjs.org',
/** /**
* Max userID string length (used for parsing) * Max userID string length (used for parsing)
@ -173,7 +173,7 @@ export default {
* @memberof module:config * @memberof module:config
* @property {Array} knownNotations * @property {Array} knownNotations
*/ */
knownNotations: ["preferred-email-encoding@pgp.com", "pka-address@gnupg.org"], knownNotations: ['preferred-email-encoding@pgp.com', 'pka-address@gnupg.org'],
/** /**
* @memberof module:config * @memberof module:config
* @property {Boolean} useIndutnyElliptic Whether to use the indutny/elliptic library. When false, certain curves will not be supported. * @property {Boolean} useIndutnyElliptic Whether to use the indutny/elliptic library. When false, certain curves will not be supported.

6
src/crypto/aes_kw.js
View File

@ -33,7 +33,7 @@ import util from '../util';
* @returns {Uint8Array} * @returns {Uint8Array}
*/ */
export function wrap(key, data) { export function wrap(key, data) {
const aes = new cipher["aes" + (key.length * 8)](key); const aes = new cipher['aes' + (key.length * 8)](key);
const IV = new Uint32Array([0xA6A6A6A6, 0xA6A6A6A6]); const IV = new Uint32Array([0xA6A6A6A6, 0xA6A6A6A6]);
const P = unpack(data); const P = unpack(data);
let A = IV; let A = IV;
@ -73,7 +73,7 @@ export function wrap(key, data) {
* @throws {Error} * @throws {Error}
*/ */
export function unwrap(key, data) { export function unwrap(key, data) {
const aes = new cipher["aes" + (key.length * 8)](key); const aes = new cipher['aes' + (key.length * 8)](key);
const IV = new Uint32Array([0xA6A6A6A6, 0xA6A6A6A6]); const IV = new Uint32Array([0xA6A6A6A6, 0xA6A6A6A6]);
const C = unpack(data); const C = unpack(data);
let A = C.subarray(0, 2); let A = C.subarray(0, 2);
@ -102,7 +102,7 @@ export function unwrap(key, data) {
if (A[0] === IV[0] && A[1] === IV[1]) { if (A[0] === IV[0] && A[1] === IV[1]) {
return pack(R); return pack(R);
} }
throw new Error("Key Data Integrity failed"); throw new Error('Key Data Integrity failed');
} }
function createArrayBuffer(data) { function createArrayBuffer(data) {

4
src/crypto/cipher/des.js
View File

@ -384,7 +384,7 @@ function desAddPadding(message, padding) {
let pad; let pad;
if (padding === 2 && (padLength < 8)) { //pad the message with spaces if (padding === 2 && (padLength < 8)) { //pad the message with spaces
pad = " ".charCodeAt(0); pad = ' '.charCodeAt(0);
} else if (padding === 1) { //PKCS7 padding } else if (padding === 1) { //PKCS7 padding
pad = padLength; pad = padLength;
} else if (!padding && (padLength < 8)) { //pad the message out with null bytes } else if (!padding && (padLength < 8)) { //pad the message out with null bytes
@ -410,7 +410,7 @@ function desRemovePadding(message, padding) {
let padLength = null; let padLength = null;
let pad; let pad;
if (padding === 2) { // space padded if (padding === 2) { // space padded
pad = " ".charCodeAt(0); pad = ' '.charCodeAt(0);
} else if (padding === 1) { // PKCS7 } else if (padding === 1) { // PKCS7
padLength = message[message.length - 1]; padLength = message[message.length - 1];
} else if (!padding) { // null padding } else if (!padding) { // null padding

2
src/crypto/cipher/twofish.js
View File

@ -318,7 +318,7 @@ function createTwofish() {
} }
return { return {
name: "twofish", name: 'twofish',
blocksize: 128 / 8, blocksize: 128 / 8,
open: tfsInit, open: tfsInit,
close: tfsClose, close: tfsClose,

4
src/crypto/public_key/dsa.js
View File

@ -113,13 +113,13 @@ export async function verify(hashAlgo, r, s, hashed, g, p, q, y) {
if (r.lte(zero) || r.gte(q) || if (r.lte(zero) || r.gte(q) ||
s.lte(zero) || s.gte(q)) { s.lte(zero) || s.gte(q)) {
util.printDebug("invalid DSA Signature"); util.printDebug('invalid DSA Signature');
return false; return false;
} }
const h = new BigInteger(hashed.subarray(0, q.byteLength())).imod(q); const h = new BigInteger(hashed.subarray(0, q.byteLength())).imod(q);
const w = s.modInv(q); // s**-1 mod q const w = s.modInv(q); // s**-1 mod q
if (w.isZero()) { if (w.isZero()) {
util.printDebug("invalid DSA Signature"); util.printDebug('invalid DSA Signature');
return false; return false;
} }

10
src/crypto/public_key/elliptic/curves.js
View File

@ -175,7 +175,7 @@ class Curve {
try { try {
return await webGenKeyPair(this.name); return await webGenKeyPair(this.name);
} catch (err) { } catch (err) {
util.printDebugError("Browser did not support generating ec key " + err.message); util.printDebugError('Browser did not support generating ec key ' + err.message);
break; break;
} }
case 'node': case 'node':
@ -299,10 +299,10 @@ export {
async function webGenKeyPair(name) { async function webGenKeyPair(name) {
// Note: keys generated with ECDSA and ECDH are structurally equivalent // Note: keys generated with ECDSA and ECDH are structurally equivalent
const webCryptoKey = await webCrypto.generateKey({ name: "ECDSA", namedCurve: webCurves[name] }, true, ["sign", "verify"]); const webCryptoKey = await webCrypto.generateKey({ name: 'ECDSA', namedCurve: webCurves[name] }, true, ['sign', 'verify']);
const privateKey = await webCrypto.exportKey("jwk", webCryptoKey.privateKey); const privateKey = await webCrypto.exportKey('jwk', webCryptoKey.privateKey);
const publicKey = await webCrypto.exportKey("jwk", webCryptoKey.publicKey); const publicKey = await webCrypto.exportKey('jwk', webCryptoKey.publicKey);
return { return {
publicKey: jwkToRawPublic(publicKey), publicKey: jwkToRawPublic(publicKey),
@ -354,7 +354,7 @@ function rawPublicToJWK(payloadSize, name, publicKey) {
const bufY = publicKey.slice(len + 1, len * 2 + 1); const bufY = publicKey.slice(len + 1, len * 2 + 1);
// https://www.rfc-editor.org/rfc/rfc7518.txt // https://www.rfc-editor.org/rfc/rfc7518.txt
const jwk = { const jwk = {
kty: "EC", kty: 'EC',
crv: name, crv: name,
x: uint8ArrayToB64(bufX, true), x: uint8ArrayToB64(bufX, true),
y: uint8ArrayToB64(bufY, true), y: uint8ArrayToB64(bufY, true),

28
src/crypto/public_key/elliptic/ecdh.js
View File

@ -54,7 +54,7 @@ function buildEcdhParam(public_algo, oid, kdfParams, fingerprint) {
oid.write(), oid.write(),
new Uint8Array([public_algo]), new Uint8Array([public_algo]),
kdfParams.write(), kdfParams.write(),
util.stringToUint8Array("Anonymous Sender "), util.stringToUint8Array('Anonymous Sender '),
fingerprint.subarray(0, 20) fingerprint.subarray(0, 20)
]); ]);
} }
@ -219,21 +219,21 @@ export async function decrypt(oid, kdfParams, V, C, Q, d, fingerprint) {
async function webPrivateEphemeralKey(curve, V, Q, d) { async function webPrivateEphemeralKey(curve, V, Q, d) {
const recipient = privateToJWK(curve.payloadSize, curve.web.web, Q, d); const recipient = privateToJWK(curve.payloadSize, curve.web.web, Q, d);
let privateKey = webCrypto.importKey( let privateKey = webCrypto.importKey(
"jwk", 'jwk',
recipient, recipient,
{ {
name: "ECDH", name: 'ECDH',
namedCurve: curve.web.web namedCurve: curve.web.web
}, },
true, true,
["deriveKey", "deriveBits"] ['deriveKey', 'deriveBits']
); );
const jwk = rawPublicToJWK(curve.payloadSize, curve.web.web, V); const jwk = rawPublicToJWK(curve.payloadSize, curve.web.web, V);
let sender = webCrypto.importKey( let sender = webCrypto.importKey(
"jwk", 'jwk',
jwk, jwk,
{ {
name: "ECDH", name: 'ECDH',
namedCurve: curve.web.web namedCurve: curve.web.web
}, },
true, true,
@ -242,7 +242,7 @@ async function webPrivateEphemeralKey(curve, V, Q, d) {
[privateKey, sender] = await Promise.all([privateKey, sender]); [privateKey, sender] = await Promise.all([privateKey, sender]);
let S = webCrypto.deriveBits( let S = webCrypto.deriveBits(
{ {
name: "ECDH", name: 'ECDH',
namedCurve: curve.web.web, namedCurve: curve.web.web,
public: sender public: sender
}, },
@ -250,7 +250,7 @@ async function webPrivateEphemeralKey(curve, V, Q, d) {
curve.web.sharedSize curve.web.sharedSize
); );
let secret = webCrypto.exportKey( let secret = webCrypto.exportKey(
"jwk", 'jwk',
privateKey privateKey
); );
[S, secret] = await Promise.all([S, secret]); [S, secret] = await Promise.all([S, secret]);
@ -271,17 +271,17 @@ async function webPublicEphemeralKey(curve, Q) {
const jwk = rawPublicToJWK(curve.payloadSize, curve.web.web, Q); const jwk = rawPublicToJWK(curve.payloadSize, curve.web.web, Q);
let keyPair = webCrypto.generateKey( let keyPair = webCrypto.generateKey(
{ {
name: "ECDH", name: 'ECDH',
namedCurve: curve.web.web namedCurve: curve.web.web
}, },
true, true,
["deriveKey", "deriveBits"] ['deriveKey', 'deriveBits']
); );
let recipient = webCrypto.importKey( let recipient = webCrypto.importKey(
"jwk", 'jwk',
jwk, jwk,
{ {
name: "ECDH", name: 'ECDH',
namedCurve: curve.web.web namedCurve: curve.web.web
}, },
false, false,
@ -290,7 +290,7 @@ async function webPublicEphemeralKey(curve, Q) {
[keyPair, recipient] = await Promise.all([keyPair, recipient]); [keyPair, recipient] = await Promise.all([keyPair, recipient]);
let s = webCrypto.deriveBits( let s = webCrypto.deriveBits(
{ {
name: "ECDH", name: 'ECDH',
namedCurve: curve.web.web, namedCurve: curve.web.web,
public: recipient public: recipient
}, },
@ -298,7 +298,7 @@ async function webPublicEphemeralKey(curve, Q) {
curve.web.sharedSize curve.web.sharedSize
); );
let p = webCrypto.exportKey( let p = webCrypto.exportKey(
"jwk", 'jwk',
keyPair.publicKey keyPair.publicKey
); );
[s, p] = await Promise.all([s, p]); [s, p] = await Promise.all([s, p]);

36
src/crypto/public_key/elliptic/ecdsa.js
View File

@ -62,7 +62,7 @@ export async function sign(oid, hashAlgo, message, publicKey, privateKey, hashed
if (curve.name !== 'p521' && (err.name === 'DataError' || err.name === 'OperationError')) { if (curve.name !== 'p521' && (err.name === 'DataError' || err.name === 'OperationError')) {
throw err; throw err;
} }
util.printDebugError("Browser did not support signing: " + err.message); util.printDebugError('Browser did not support signing: ' + err.message);
} }
break; break;
} }
@ -105,7 +105,7 @@ export async function verify(oid, hashAlgo, signature, message, publicKey, hashe
if (curve.name !== 'p521' && (err.name === 'DataError' || err.name === 'OperationError')) { if (curve.name !== 'p521' && (err.name === 'DataError' || err.name === 'OperationError')) {
throw err; throw err;
} }
util.printDebugError("Browser did not support verifying: " + err.message); util.printDebugError('Browser did not support verifying: ' + err.message);
} }
break; break;
case 'node': case 'node':
@ -178,22 +178,22 @@ async function webSign(curve, hashAlgo, message, keyPair) {
const len = curve.payloadSize; const len = curve.payloadSize;
const jwk = privateToJWK(curve.payloadSize, webCurves[curve.name], keyPair.publicKey, keyPair.privateKey); const jwk = privateToJWK(curve.payloadSize, webCurves[curve.name], keyPair.publicKey, keyPair.privateKey);
const key = await webCrypto.importKey( const key = await webCrypto.importKey(
"jwk", 'jwk',
jwk, jwk,
{ {
"name": "ECDSA", 'name': 'ECDSA',
"namedCurve": webCurves[curve.name], 'namedCurve': webCurves[curve.name],
"hash": { name: enums.read(enums.webHash, curve.hash) } 'hash': { name: enums.read(enums.webHash, curve.hash) }
}, },
false, false,
["sign"] ['sign']
); );
const signature = new Uint8Array(await webCrypto.sign( const signature = new Uint8Array(await webCrypto.sign(
{ {
"name": 'ECDSA', 'name': 'ECDSA',
"namedCurve": webCurves[curve.name], 'namedCurve': webCurves[curve.name],
"hash": { name: enums.read(enums.webHash, hashAlgo) } 'hash': { name: enums.read(enums.webHash, hashAlgo) }
}, },
key, key,
message message
@ -208,24 +208,24 @@ async function webSign(curve, hashAlgo, message, keyPair) {
async function webVerify(curve, hashAlgo, { r, s }, message, publicKey) { async function webVerify(curve, hashAlgo, { r, s }, message, publicKey) {
const jwk = rawPublicToJWK(curve.payloadSize, webCurves[curve.name], publicKey); const jwk = rawPublicToJWK(curve.payloadSize, webCurves[curve.name], publicKey);
const key = await webCrypto.importKey( const key = await webCrypto.importKey(
"jwk", 'jwk',
jwk, jwk,
{ {
"name": "ECDSA", 'name': 'ECDSA',
"namedCurve": webCurves[curve.name], 'namedCurve': webCurves[curve.name],
"hash": { name: enums.read(enums.webHash, curve.hash) } 'hash': { name: enums.read(enums.webHash, curve.hash) }
}, },
false, false,
["verify"] ['verify']
); );
const signature = util.concatUint8Array([r, s]).buffer; const signature = util.concatUint8Array([r, s]).buffer;
return webCrypto.verify( return webCrypto.verify(
{ {
"name": 'ECDSA', 'name': 'ECDSA',
"namedCurve": webCurves[curve.name], 'namedCurve': webCurves[curve.name],
"hash": { name: enums.read(enums.webHash, hashAlgo) } 'hash': { name: enums.read(enums.webHash, hashAlgo) }
}, },
key, key,
signature, signature,

14
src/crypto/public_key/rsa.js
View File

@ -318,12 +318,12 @@ async function webSign(hashName, data, n, e, d, p, q, u) {
*/ */
const jwk = await privateToJWK(n, e, d, p, q, u); const jwk = await privateToJWK(n, e, d, p, q, u);
const algo = { const algo = {
name: "RSASSA-PKCS1-v1_5", name: 'RSASSA-PKCS1-v1_5',
hash: { name: hashName } hash: { name: hashName }
}; };
const key = await webCrypto.importKey("jwk", jwk, algo, false, ["sign"]); const key = await webCrypto.importKey('jwk', jwk, algo, false, ['sign']);
// add hash field for ms edge support // add hash field for ms edge support
return new Uint8Array(await webCrypto.sign({ "name": "RSASSA-PKCS1-v1_5", "hash": hashName }, key, data)); return new Uint8Array(await webCrypto.sign({ 'name': 'RSASSA-PKCS1-v1_5', 'hash': hashName }, key, data));
} }
async function nodeSign(hashAlgo, data, n, e, d, p, q, u) { async function nodeSign(hashAlgo, data, n, e, d, p, q, u) {
@ -374,12 +374,12 @@ async function bnVerify(hashAlgo, s, n, e, hashed) {
async function webVerify(hashName, data, s, n, e) { async function webVerify(hashName, data, s, n, e) {
const jwk = publicToJWK(n, e); const jwk = publicToJWK(n, e);
const key = await webCrypto.importKey("jwk", jwk, { const key = await webCrypto.importKey('jwk', jwk, {
name: "RSASSA-PKCS1-v1_5", name: 'RSASSA-PKCS1-v1_5',
hash: { name: hashName } hash: { name: hashName }
}, false, ["verify"]); }, false, ['verify']);
// add hash field for ms edge support // add hash field for ms edge support
return webCrypto.verify({ "name": "RSASSA-PKCS1-v1_5", "hash": hashName }, key, s, data); return webCrypto.verify({ 'name': 'RSASSA-PKCS1-v1_5', 'hash': hashName }, key, s, data);
} }
async function nodeVerify(hashAlgo, data, s, n, e) { async function nodeVerify(hashAlgo, data, s, n, e) {

60
src/encoding/armor.js
View File

@ -93,15 +93,15 @@ function getType(text) {
* @private * @private
*/ */
function addheader(customComment, config) { function addheader(customComment, config) {
let result = ""; let result = '';
if (config.showVersion) { if (config.showVersion) {
result += "Version: " + config.versionString + '\n'; result += 'Version: ' + config.versionString + '\n';
} }
if (config.showComment) { if (config.showComment) {
result += "Comment: " + config.commentString + '\n'; result += 'Comment: ' + config.commentString + '\n';
} }
if (customComment) { if (customComment) {
result += "Comment: " + customComment + '\n'; result += 'Comment: ' + customComment + '\n';
} }
result += '\n'; result += '\n';
return result; return result;
@ -207,9 +207,9 @@ function verifyHeaders(headers) {
*/ */
function splitChecksum(text) { function splitChecksum(text) {
let body = text; let body = text;
let checksum = ""; let checksum = '';
const lastEquals = text.lastIndexOf("="); const lastEquals = text.lastIndexOf('=');
if (lastEquals >= 0 && lastEquals !== text.length - 1) { // '=' as the last char means no checksum if (lastEquals >= 0 && lastEquals !== text.length - 1) { // '=' as the last char means no checksum
body = text.slice(0, lastEquals); body = text.slice(0, lastEquals);
@ -371,56 +371,56 @@ export function armor(messageType, body, partIndex, partTotal, customComment, co
const result = []; const result = [];
switch (messageType) { switch (messageType) {
case enums.armor.multipartSection: case enums.armor.multipartSection:
result.push("-----BEGIN PGP MESSAGE, PART " + partIndex + "/" + partTotal + "-----\n"); result.push('-----BEGIN PGP MESSAGE, PART ' + partIndex + '/' + partTotal + '-----\n');
result.push(addheader(customComment, config)); result.push(addheader(customComment, config));
result.push(base64.encode(body)); result.push(base64.encode(body));
result.push("=", getCheckSum(bodyClone)); result.push('=', getCheckSum(bodyClone));
result.push("-----END PGP MESSAGE, PART " + partIndex + "/" + partTotal + "-----\n"); result.push('-----END PGP MESSAGE, PART ' + partIndex + '/' + partTotal + '-----\n');
break; break;
case enums.armor.multipartLast: case enums.armor.multipartLast:
result.push("-----BEGIN PGP MESSAGE, PART " + partIndex + "-----\n"); result.push('-----BEGIN PGP MESSAGE, PART ' + partIndex + '-----\n');
result.push(addheader(customComment, config)); result.push(addheader(customComment, config));
result.push(base64.encode(body)); result.push(base64.encode(body));
result.push("=", getCheckSum(bodyClone)); result.push('=', getCheckSum(bodyClone));
result.push("-----END PGP MESSAGE, PART " + partIndex + "-----\n"); result.push('-----END PGP MESSAGE, PART ' + partIndex + '-----\n');
break; break;
case enums.armor.signed: case enums.armor.signed:
result.push("\n-----BEGIN PGP SIGNED MESSAGE-----\n"); result.push('\n-----BEGIN PGP SIGNED MESSAGE-----\n');
result.push("Hash: " + hash + "\n\n"); result.push('Hash: ' + hash + '\n\n');
result.push(text.replace(/^-/mg, "- -")); result.push(text.replace(/^-/mg, '- -'));
result.push("\n-----BEGIN PGP SIGNATURE-----\n"); result.push('\n-----BEGIN PGP SIGNATURE-----\n');
result.push(addheader(customComment, config)); result.push(addheader(customComment, config));
result.push(base64.encode(body)); result.push(base64.encode(body));
result.push("=", getCheckSum(bodyClone)); result.push('=', getCheckSum(bodyClone));
result.push("-----END PGP SIGNATURE-----\n"); result.push('-----END PGP SIGNATURE-----\n');
break; break;
case enums.armor.message: case enums.armor.message:
result.push("-----BEGIN PGP MESSAGE-----\n"); result.push('-----BEGIN PGP MESSAGE-----\n');
result.push(addheader(customComment, config)); result.push(addheader(customComment, config));
result.push(base64.encode(body)); result.push(base64.encode(body));
result.push("=", getCheckSum(bodyClone)); result.push('=', getCheckSum(bodyClone));
result.push("-----END PGP MESSAGE-----\n"); result.push('-----END PGP MESSAGE-----\n');
break; break;
case enums.armor.publicKey: case enums.armor.publicKey:
result.push("-----BEGIN PGP PUBLIC KEY BLOCK-----\n"); result.push('-----BEGIN PGP PUBLIC KEY BLOCK-----\n');
result.push(addheader(customComment, config)); result.push(addheader(customComment, config));
result.push(base64.encode(body)); result.push(base64.encode(body));
result.push("=", getCheckSum(bodyClone)); result.push('=', getCheckSum(bodyClone));
result.push("-----END PGP PUBLIC KEY BLOCK-----\n"); result.push('-----END PGP PUBLIC KEY BLOCK-----\n');
break; break;
case enums.armor.privateKey: case enums.armor.privateKey:
result.push("-----BEGIN PGP PRIVATE KEY BLOCK-----\n"); result.push('-----BEGIN PGP PRIVATE KEY BLOCK-----\n');
result.push(addheader(customComment, config)); result.push(addheader(customComment, config));
result.push(base64.encode(body)); result.push(base64.encode(body));
result.push("=", getCheckSum(bodyClone)); result.push('=', getCheckSum(bodyClone));
result.push("-----END PGP PRIVATE KEY BLOCK-----\n"); result.push('-----END PGP PRIVATE KEY BLOCK-----\n');
break; break;
case enums.armor.signature: case enums.armor.signature:
result.push("-----BEGIN PGP SIGNATURE-----\n"); result.push('-----BEGIN PGP SIGNATURE-----\n');
result.push(addheader(customComment, config)); result.push(addheader(customComment, config));
result.push(base64.encode(body)); result.push(base64.encode(body));
result.push("=", getCheckSum(bodyClone)); result.push('=', getCheckSum(bodyClone));
result.push("-----END PGP SIGNATURE-----\n"); result.push('-----END PGP SIGNATURE-----\n');
break; break;
} }

96
src/enums.js
View File

@ -13,70 +13,70 @@ export default {
*/ */
curve: { curve: {
/** NIST P-256 Curve */ /** NIST P-256 Curve */
"p256": "p256", 'p256': 'p256',
"P-256": "p256", 'P-256': 'p256',
"secp256r1": "p256", 'secp256r1': 'p256',
"prime256v1": "p256", 'prime256v1': 'p256',
"1.2.840.10045.3.1.7": "p256", '1.2.840.10045.3.1.7': 'p256',
"2a8648ce3d030107": "p256", '2a8648ce3d030107': 'p256',
"2A8648CE3D030107": "p256", '2A8648CE3D030107': 'p256',
/** NIST P-384 Curve */ /** NIST P-384 Curve */
"p384": "p384", 'p384': 'p384',
"P-384": "p384", 'P-384': 'p384',
"secp384r1": "p384", 'secp384r1': 'p384',
"1.3.132.0.34": "p384", '1.3.132.0.34': 'p384',
"2b81040022": "p384", '2b81040022': 'p384',
"2B81040022": "p384", '2B81040022': 'p384',
/** NIST P-521 Curve */ /** NIST P-521 Curve */
"p521": "p521", 'p521': 'p521',
"P-521": "p521", 'P-521': 'p521',
"secp521r1": "p521", 'secp521r1': 'p521',
"1.3.132.0.35": "p521", '1.3.132.0.35': 'p521',
"2b81040023": "p521", '2b81040023': 'p521',
"2B81040023": "p521", '2B81040023': 'p521',
/** SECG SECP256k1 Curve */ /** SECG SECP256k1 Curve */
"secp256k1": "secp256k1", 'secp256k1': 'secp256k1',
"1.3.132.0.10": "secp256k1", '1.3.132.0.10': 'secp256k1',
"2b8104000a": "secp256k1", '2b8104000a': 'secp256k1',
"2B8104000A": "secp256k1", '2B8104000A': 'secp256k1',
/** Ed25519 */ /** Ed25519 */
"ED25519": "ed25519", 'ED25519': 'ed25519',
"ed25519": "ed25519", 'ed25519': 'ed25519',
"Ed25519": "ed25519", 'Ed25519': 'ed25519',
"1.3.6.1.4.1.11591.15.1": "ed25519", '1.3.6.1.4.1.11591.15.1': 'ed25519',
"2b06010401da470f01": "ed25519", '2b06010401da470f01': 'ed25519',
"2B06010401DA470F01": "ed25519", '2B06010401DA470F01': 'ed25519',
/** Curve25519 */ /** Curve25519 */
"X25519": "curve25519", 'X25519': 'curve25519',
"cv25519": "curve25519", 'cv25519': 'curve25519',
"curve25519": "curve25519", 'curve25519': 'curve25519',
"Curve25519": "curve25519", 'Curve25519': 'curve25519',
"1.3.6.1.4.1.3029.1.5.1": "curve25519", '1.3.6.1.4.1.3029.1.5.1': 'curve25519',
"2b060104019755010501": "curve25519", '2b060104019755010501': 'curve25519',
"2B060104019755010501": "curve25519", '2B060104019755010501': 'curve25519',
/** BrainpoolP256r1 Curve */ /** BrainpoolP256r1 Curve */
"brainpoolP256r1": "brainpoolP256r1", 'brainpoolP256r1': 'brainpoolP256r1',
"1.3.36.3.3.2.8.1.1.7": "brainpoolP256r1", '1.3.36.3.3.2.8.1.1.7': 'brainpoolP256r1',
"2b2403030208010107": "brainpoolP256r1", '2b2403030208010107': 'brainpoolP256r1',
"2B2403030208010107": "brainpoolP256r1", '2B2403030208010107': 'brainpoolP256r1',
/** BrainpoolP384r1 Curve */ /** BrainpoolP384r1 Curve */
"brainpoolP384r1": "brainpoolP384r1", 'brainpoolP384r1': 'brainpoolP384r1',
"1.3.36.3.3.2.8.1.1.11": "brainpoolP384r1", '1.3.36.3.3.2.8.1.1.11': 'brainpoolP384r1',
"2b240303020801010b": "brainpoolP384r1", '2b240303020801010b': 'brainpoolP384r1',
"2B240303020801010B": "brainpoolP384r1", '2B240303020801010B': 'brainpoolP384r1',
/** BrainpoolP512r1 Curve */ /** BrainpoolP512r1 Curve */
"brainpoolP512r1": "brainpoolP512r1", 'brainpoolP512r1': 'brainpoolP512r1',
"1.3.36.3.3.2.8.1.1.13": "brainpoolP512r1", '1.3.36.3.3.2.8.1.1.13': 'brainpoolP512r1',
"2b240303020801010d": "brainpoolP512r1", '2b240303020801010d': 'brainpoolP512r1',
"2B240303020801010D": "brainpoolP512r1" '2B240303020801010D': 'brainpoolP512r1'
}, },
/** A string to key specifier type /** A string to key specifier type

11
src/key/private_key.js
View File

@ -28,7 +28,6 @@ class PrivateKey extends PublicKey {
* Returns true if this is a private key * Returns true if this is a private key
* @returns {Boolean} * @returns {Boolean}
*/ */
// eslint-disable-next-line class-methods-use-this
isPrivate() { isPrivate() {
return true; return true;
} }
@ -123,7 +122,7 @@ class PrivateKey extends PublicKey {
*/ */
async validate(config = defaultConfig) { async validate(config = defaultConfig) {
if (!this.isPrivate()) { if (!this.isPrivate()) {
throw new Error("Cannot validate a public key"); throw new Error('Cannot validate a public key');
} }
let signingKeyPacket; let signingKeyPacket;
@ -147,7 +146,7 @@ class PrivateKey extends PublicKey {
const keys = this.getKeys(); const keys = this.getKeys();
const allDummies = keys.map(key => key.keyPacket.isDummy()).every(Boolean); const allDummies = keys.map(key => key.keyPacket.isDummy()).every(Boolean);
if (allDummies) { if (allDummies) {
throw new Error("Cannot validate an all-gnu-dummy key"); throw new Error('Cannot validate an all-gnu-dummy key');
} }
return Promise.all(keys.map(async key => key.keyPacket.validate())); return Promise.all(keys.map(async key => key.keyPacket.validate()));
@ -213,17 +212,17 @@ class PrivateKey extends PublicKey {
async addSubkey(options = {}) { async addSubkey(options = {}) {
const config = { ...defaultConfig, ...options.config }; const config = { ...defaultConfig, ...options.config };
if (options.passphrase) { if (options.passphrase) {
throw new Error("Subkey could not be encrypted here, please encrypt whole key"); throw new Error('Subkey could not be encrypted here, please encrypt whole key');
} }
if (options.rsaBits < config.minRSABits) { if (options.rsaBits < config.minRSABits) {
throw new Error(`rsaBits should be at least ${config.minRSABits}, got: ${options.rsaBits}`); throw new Error(`rsaBits should be at least ${config.minRSABits}, got: ${options.rsaBits}`);
} }
const secretKeyPacket = this.keyPacket; const secretKeyPacket = this.keyPacket;
if (secretKeyPacket.isDummy()) { if (secretKeyPacket.isDummy()) {
throw new Error("Cannot add subkey to gnu-dummy primary key"); throw new Error('Cannot add subkey to gnu-dummy primary key');
} }
if (!secretKeyPacket.isDecrypted()) { if (!secretKeyPacket.isDecrypted()) {
throw new Error("Key is not decrypted"); throw new Error('Key is not decrypted');
} }
const defaultOptions = secretKeyPacket.getAlgorithmInfo(); const defaultOptions = secretKeyPacket.getAlgorithmInfo();
defaultOptions.type = defaultOptions.curve ? 'ecc' : 'rsa'; // DSA keys default to RSA defaultOptions.type = defaultOptions.curve ? 'ecc' : 'rsa'; // DSA keys default to RSA

2
src/key/public_key.js
View File

@ -1,4 +1,3 @@
/* eslint-disable class-methods-use-this */
// This library is free software; you can redistribute it and/or // This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public // modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either // License as published by the Free Software Foundation; either
@ -44,7 +43,6 @@ class PublicKey extends Key {
* Returns true if this is a private key * Returns true if this is a private key
* @returns {false} * @returns {false}
*/ */
// eslint-disable-next-line class-methods-use-this
isPrivate() { isPrivate() {
return false; return false;
} }

30
src/openpgp.js
View File

@ -51,13 +51,13 @@ import util from './util';
* @async * @async
* @static * @static
*/ */
export async function generateKey({ userIDs = [], passphrase = "", type = "ecc", rsaBits = 4096, curve = "curve25519", keyExpirationTime = 0, date = new Date(), subkeys = [{}], format = 'armor', config }) { export async function generateKey({ userIDs = [], passphrase = '', type = 'ecc', rsaBits = 4096, curve = 'curve25519', keyExpirationTime = 0, date = new Date(), subkeys = [{}], format = 'armor', config }) {
config = { ...defaultConfig, ...config }; config = { ...defaultConfig, ...config };
userIDs = toArray(userIDs); userIDs = toArray(userIDs);
if (userIDs.length === 0) { if (userIDs.length === 0) {
throw new Error('UserIDs are required for key generation'); throw new Error('UserIDs are required for key generation');
} }
if (type === "rsa" && rsaBits < config.minRSABits) { if (type === 'rsa' && rsaBits < config.minRSABits) {
throw new Error(`rsaBits should be at least ${config.minRSABits}, got: ${rsaBits}`); throw new Error(`rsaBits should be at least ${config.minRSABits}, got: ${rsaBits}`);
} }
const options = { userIDs, passphrase, type, rsaBits, curve, keyExpirationTime, date, subkeys }; const options = { userIDs, passphrase, type, rsaBits, curve, keyExpirationTime, date, subkeys };
@ -90,7 +90,7 @@ export async function generateKey({ userIDs = [], passphrase = "", type = "ecc",
* @async * @async
* @static * @static
*/ */
export async function reformatKey({ privateKey, userIDs = [], passphrase = "", keyExpirationTime = 0, date, format = 'armor', config }) { export async function reformatKey({ privateKey, userIDs = [], passphrase = '', keyExpirationTime = 0, date, format = 'armor', config }) {
config = { ...defaultConfig, ...config }; config = { ...defaultConfig, ...config };
userIDs = toArray(userIDs); userIDs = toArray(userIDs);
if (userIDs.length === 0) { if (userIDs.length === 0) {
@ -161,7 +161,7 @@ export async function revokeKey({ key, revocationCertificate, reasonForRevocatio
export async function decryptKey({ privateKey, passphrase, config }) { export async function decryptKey({ privateKey, passphrase, config }) {
config = { ...defaultConfig, ...config }; config = { ...defaultConfig, ...config };
if (!privateKey.isPrivate()) { if (!privateKey.isPrivate()) {
throw new Error("Cannot decrypt a public key"); throw new Error('Cannot decrypt a public key');
} }
const clonedPrivateKey = privateKey.clone(true); const clonedPrivateKey = privateKey.clone(true);
const passphrases = util.isArray(passphrase) ? passphrase : [passphrase]; const passphrases = util.isArray(passphrase) ? passphrase : [passphrase];
@ -193,14 +193,14 @@ export async function decryptKey({ privateKey, passphrase, config }) {
export async function encryptKey({ privateKey, passphrase, config }) { export async function encryptKey({ privateKey, passphrase, config }) {
config = { ...defaultConfig, ...config }; config = { ...defaultConfig, ...config };
if (!privateKey.isPrivate()) { if (!privateKey.isPrivate()) {
throw new Error("Cannot encrypt a public key"); throw new Error('Cannot encrypt a public key');
} }
const clonedPrivateKey = privateKey.clone(true); const clonedPrivateKey = privateKey.clone(true);
const keys = clonedPrivateKey.getKeys(); const keys = clonedPrivateKey.getKeys();
const passphrases = util.isArray(passphrase) ? passphrase : new Array(keys.length).fill(passphrase); const passphrases = util.isArray(passphrase) ? passphrase : new Array(keys.length).fill(passphrase);
if (passphrases.length !== keys.length) { if (passphrases.length !== keys.length) {
throw new Error("Invalid number of passphrases given for key encryption"); throw new Error('Invalid number of passphrases given for key encryption');
} }
try { try {
@ -253,8 +253,8 @@ export async function encrypt({ message, encryptionKeys, signingKeys, passwords,
if (rest.detached) { if (rest.detached) {
throw new Error("The `detached` option has been removed from openpgp.encrypt, separately call openpgp.sign instead. Don't forget to remove the `privateKeys` option as well."); throw new Error("The `detached` option has been removed from openpgp.encrypt, separately call openpgp.sign instead. Don't forget to remove the `privateKeys` option as well.");
} }
if (rest.publicKeys) throw new Error("The `publicKeys` option has been removed from openpgp.encrypt, pass `encryptionKeys` instead"); if (rest.publicKeys) throw new Error('The `publicKeys` option has been removed from openpgp.encrypt, pass `encryptionKeys` instead');
if (rest.privateKeys) throw new Error("The `privateKeys` option has been removed from openpgp.encrypt, pass `signingKeys` instead"); if (rest.privateKeys) throw new Error('The `privateKeys` option has been removed from openpgp.encrypt, pass `signingKeys` instead');
if (!signingKeys) { if (!signingKeys) {
signingKeys = []; signingKeys = [];
@ -311,8 +311,8 @@ export async function encrypt({ message, encryptionKeys, signingKeys, passwords,
export async function decrypt({ message, decryptionKeys, passwords, sessionKeys, verificationKeys, expectSigned = false, format = 'utf8', signature = null, date = new Date(), config, ...rest }) { export async function decrypt({ message, decryptionKeys, passwords, sessionKeys, verificationKeys, expectSigned = false, format = 'utf8', signature = null, date = new Date(), config, ...rest }) {
config = { ...defaultConfig, ...config }; config = { ...defaultConfig, ...config };
checkMessage(message); verificationKeys = toArray(verificationKeys); decryptionKeys = toArray(decryptionKeys); passwords = toArray(passwords); sessionKeys = toArray(sessionKeys); checkMessage(message); verificationKeys = toArray(verificationKeys); decryptionKeys = toArray(decryptionKeys); passwords = toArray(passwords); sessionKeys = toArray(sessionKeys);
if (rest.privateKeys) throw new Error("The `privateKeys` option has been removed from openpgp.decrypt, pass `decryptionKeys` instead"); if (rest.privateKeys) throw new Error('The `privateKeys` option has been removed from openpgp.decrypt, pass `decryptionKeys` instead');
if (rest.publicKeys) throw new Error("The `publicKeys` option has been removed from openpgp.decrypt, pass `verificationKeys` instead"); if (rest.publicKeys) throw new Error('The `publicKeys` option has been removed from openpgp.decrypt, pass `verificationKeys` instead');
try { try {
const decrypted = await message.decrypt(decryptionKeys, passwords, sessionKeys, date, config); const decrypted = await message.decrypt(decryptionKeys, passwords, sessionKeys, date, config);
@ -373,7 +373,7 @@ export async function decrypt({ message, decryptionKeys, passwords, sessionKeys,
export async function sign({ message, signingKeys, armor = true, detached = false, signingKeyIDs = [], date = new Date(), signingUserIDs = [], config, ...rest }) { export async function sign({ message, signingKeys, armor = true, detached = false, signingKeyIDs = [], date = new Date(), signingUserIDs = [], config, ...rest }) {
config = { ...defaultConfig, ...config }; config = { ...defaultConfig, ...config };
checkCleartextOrMessage(message); checkCleartextOrMessage(message);
if (rest.privateKeys) throw new Error("The `privateKeys` option has been removed from openpgp.sign, pass `signingKeys` instead"); if (rest.privateKeys) throw new Error('The `privateKeys` option has been removed from openpgp.sign, pass `signingKeys` instead');
if (message instanceof CleartextMessage && !armor) throw new Error("Can't sign non-armored cleartext message"); if (message instanceof CleartextMessage && !armor) throw new Error("Can't sign non-armored cleartext message");
if (message instanceof CleartextMessage && detached) throw new Error("Can't detach-sign a cleartext message"); if (message instanceof CleartextMessage && detached) throw new Error("Can't detach-sign a cleartext message");
@ -433,7 +433,7 @@ export async function sign({ message, signingKeys, armor = true, detached = fals
export async function verify({ message, verificationKeys, expectSigned = false, format = 'utf8', signature = null, date = new Date(), config, ...rest }) { export async function verify({ message, verificationKeys, expectSigned = false, format = 'utf8', signature = null, date = new Date(), config, ...rest }) {
config = { ...defaultConfig, ...config }; config = { ...defaultConfig, ...config };
checkCleartextOrMessage(message); checkCleartextOrMessage(message);
if (rest.publicKeys) throw new Error("The `publicKeys` option has been removed from openpgp.verify, pass `verificationKeys` instead"); if (rest.publicKeys) throw new Error('The `publicKeys` option has been removed from openpgp.verify, pass `verificationKeys` instead');
if (message instanceof CleartextMessage && format === 'binary') throw new Error("Can't return cleartext message data as binary"); if (message instanceof CleartextMessage && format === 'binary') throw new Error("Can't return cleartext message data as binary");
if (message instanceof CleartextMessage && signature) throw new Error("Can't verify detached cleartext signature"); if (message instanceof CleartextMessage && signature) throw new Error("Can't verify detached cleartext signature");
@ -488,7 +488,7 @@ export async function verify({ message, verificationKeys, expectSigned = false,
export async function generateSessionKey({ encryptionKeys, date = new Date(), encryptionUserIDs = [], config, ...rest }) { export async function generateSessionKey({ encryptionKeys, date = new Date(), encryptionUserIDs = [], config, ...rest }) {
config = { ...defaultConfig, ...config }; config = { ...defaultConfig, ...config };
encryptionKeys = toArray(encryptionKeys); encryptionUserIDs = toArray(encryptionUserIDs); encryptionKeys = toArray(encryptionKeys); encryptionUserIDs = toArray(encryptionUserIDs);
if (rest.publicKeys) throw new Error("The `publicKeys` option has been removed from openpgp.generateSessionKey, pass `encryptionKeys` instead"); if (rest.publicKeys) throw new Error('The `publicKeys` option has been removed from openpgp.generateSessionKey, pass `encryptionKeys` instead');
try { try {
const sessionKeys = await Message.generateSessionKey(encryptionKeys, date, encryptionUserIDs, config); const sessionKeys = await Message.generateSessionKey(encryptionKeys, date, encryptionUserIDs, config);
@ -520,7 +520,7 @@ export async function generateSessionKey({ encryptionKeys, date = new Date(), en
export async function encryptSessionKey({ data, algorithm, aeadAlgorithm, encryptionKeys, passwords, armor = true, wildcard = false, encryptionKeyIDs = [], date = new Date(), encryptionUserIDs = [], config, ...rest }) { export async function encryptSessionKey({ data, algorithm, aeadAlgorithm, encryptionKeys, passwords, armor = true, wildcard = false, encryptionKeyIDs = [], date = new Date(), encryptionUserIDs = [], config, ...rest }) {
config = { ...defaultConfig, ...config }; config = { ...defaultConfig, ...config };
checkBinary(data); checkString(algorithm, 'algorithm'); encryptionKeys = toArray(encryptionKeys); passwords = toArray(passwords); encryptionKeyIDs = toArray(encryptionKeyIDs); encryptionUserIDs = toArray(encryptionUserIDs); checkBinary(data); checkString(algorithm, 'algorithm'); encryptionKeys = toArray(encryptionKeys); passwords = toArray(passwords); encryptionKeyIDs = toArray(encryptionKeyIDs); encryptionUserIDs = toArray(encryptionUserIDs);
if (rest.publicKeys) throw new Error("The `publicKeys` option has been removed from openpgp.encryptSessionKey, pass `encryptionKeys` instead"); if (rest.publicKeys) throw new Error('The `publicKeys` option has been removed from openpgp.encryptSessionKey, pass `encryptionKeys` instead');
try { try {
const message = await Message.encryptSessionKey(data, algorithm, aeadAlgorithm, encryptionKeys, passwords, wildcard, encryptionKeyIDs, date, encryptionUserIDs, config); const message = await Message.encryptSessionKey(data, algorithm, aeadAlgorithm, encryptionKeys, passwords, wildcard, encryptionKeyIDs, date, encryptionUserIDs, config);
@ -548,7 +548,7 @@ export async function encryptSessionKey({ data, algorithm, aeadAlgorithm, encryp
export async function decryptSessionKeys({ message, decryptionKeys, passwords, date = new Date(), config, ...rest }) { export async function decryptSessionKeys({ message, decryptionKeys, passwords, date = new Date(), config, ...rest }) {
config = { ...defaultConfig, ...config }; config = { ...defaultConfig, ...config };
checkMessage(message); decryptionKeys = toArray(decryptionKeys); passwords = toArray(passwords); checkMessage(message); decryptionKeys = toArray(decryptionKeys); passwords = toArray(passwords);
if (rest.privateKeys) throw new Error("The `privateKeys` option has been removed from openpgp.decryptSessionKeys, pass `decryptionKeys` instead"); if (rest.privateKeys) throw new Error('The `privateKeys` option has been removed from openpgp.decryptSessionKeys, pass `decryptionKeys` instead');
try { try {
const sessionKeys = await message.decryptSessionKeys(decryptionKeys, passwords, date, config); const sessionKeys = await message.decryptSessionKeys(decryptionKeys, passwords, date, config);

3
src/packet/marker.js
View File

@ -15,8 +15,6 @@
// License along with this library; if not, write to the Free Software // License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
/* eslint class-methods-use-this: ["error", { "exceptMethods": ["read"] }] */
import enums from '../enums'; import enums from '../enums';
/** /**
@ -55,7 +53,6 @@ class MarkerPacket {
return false; return false;
} }
// eslint-disable-next-line class-methods-use-this
write() { write() {
return new Uint8Array([0x50, 0x47, 0x50]); return new Uint8Array([0x50, 0x47, 0x50]);
} }

2
src/packet/packet.js
View File

@ -125,7 +125,7 @@ export async function readPackets(input, callback) {
const peekedBytes = await reader.peekBytes(2); const peekedBytes = await reader.peekBytes(2);
// some sanity checks // some sanity checks
if (!peekedBytes || peekedBytes.length < 2 || (peekedBytes[0] & 0x80) === 0) { if (!peekedBytes || peekedBytes.length < 2 || (peekedBytes[0] & 0x80) === 0) {
throw new Error("Error during parsing. This message / key probably does not conform to a valid OpenPGP format."); throw new Error('Error during parsing. This message / key probably does not conform to a valid OpenPGP format.');
} }
const headerByte = await reader.readByte(); const headerByte = await reader.readByte();
let tag = -1; let tag = -1;

2
src/packet/public_key.js
View File

@ -15,8 +15,6 @@
// License along with this library; if not, write to the Free Software // License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
/* eslint class-methods-use-this: ["error", { "exceptMethods": ["isDecrypted"] }] */
import KeyID from '../type/keyid'; import KeyID from '../type/keyid';
import defaultConfig from '../config'; import defaultConfig from '../config';
import crypto from '../crypto'; import crypto from '../crypto';

3
src/packet/trust.js
View File

@ -1,5 +1,3 @@
/* eslint class-methods-use-this: ["error", { "exceptMethods": ["read"] }] */
import enums from '../enums'; import enums from '../enums';
import { UnsupportedError } from './packet'; import { UnsupportedError } from './packet';
@ -31,7 +29,6 @@ class TrustPacket {
throw new UnsupportedError('Trust packets are not supported'); throw new UnsupportedError('Trust packets are not supported');
} }
// eslint-disable-next-line class-methods-use-this
write() { write() {
throw new UnsupportedError('Trust packets are not supported'); throw new UnsupportedError('Trust packets are not supported');
} }

16
src/type/s2k.js
View File

@ -88,22 +88,22 @@ class S2K {
break; break;
case 'gnu': case 'gnu':
if (util.uint8ArrayToString(bytes.subarray(i, i + 3)) === "GNU") { if (util.uint8ArrayToString(bytes.subarray(i, i + 3)) === 'GNU') {
i += 3; // GNU i += 3; // GNU
const gnuExtType = 1000 + bytes[i++]; const gnuExtType = 1000 + bytes[i++];
if (gnuExtType === 1001) { if (gnuExtType === 1001) {
this.type = 'gnu-dummy'; this.type = 'gnu-dummy';
// GnuPG extension mode 1001 -- don't write secret key at all // GnuPG extension mode 1001 -- don't write secret key at all
} else { } else {
throw new Error("Unknown s2k gnu protection mode."); throw new Error('Unknown s2k gnu protection mode.');
} }
} else { } else {
throw new Error("Unknown s2k type."); throw new Error('Unknown s2k type.');
} }
break; break;
default: default:
throw new Error("Unknown s2k type."); throw new Error('Unknown s2k type.');
} }
return i; return i;
@ -131,9 +131,9 @@ class S2K {
arr.push(new Uint8Array([this.c])); arr.push(new Uint8Array([this.c]));
break; break;
case 'gnu': case 'gnu':
throw new Error("GNU s2k type not supported."); throw new Error('GNU s2k type not supported.');
default: default:
throw new Error("Unknown s2k type."); throw new Error('Unknown s2k type.');
} }
return util.concatUint8Array(arr); return util.concatUint8Array(arr);
@ -176,9 +176,9 @@ class S2K {
break; break;
} }
case 'gnu': case 'gnu':
throw new Error("GNU s2k type not supported."); throw new Error('GNU s2k type not supported.');
default: default:
throw new Error("Unknown s2k type."); throw new Error('Unknown s2k type.');
} }
const result = await crypto.hash.digest(algorithm, toHash); const result = await crypto.hash.digest(algorithm, toHash);
arr.push(result); arr.push(result);

4
src/util.js
View File

@ -154,9 +154,9 @@ const util = {
while (c < e) { while (c < e) {
h = bytes[c++].toString(16); h = bytes[c++].toString(16);
while (h.length < 2) { while (h.length < 2) {
h = "0" + h; h = '0' + h;
} }
r.push("" + h); r.push('' + h);
} }
return r.join(''); return r.join('');
}, },

52
test/crypto/aes_kw.js
View File

@ -6,49 +6,49 @@ const expect = require('chai').expect;
module.exports = () => describe('AES Key Wrap and Unwrap', function () { module.exports = () => describe('AES Key Wrap and Unwrap', function () {
const test_vectors = [ const test_vectors = [
[ [
"128 bits of Key Data with a 128-bit KEK", '128 bits of Key Data with a 128-bit KEK',
"000102030405060708090A0B0C0D0E0F", '000102030405060708090A0B0C0D0E0F',
"00112233445566778899AABBCCDDEEFF", '00112233445566778899AABBCCDDEEFF',
"1FA68B0A8112B447 AEF34BD8FB5A7B82 9D3E862371D2CFE5" '1FA68B0A8112B447 AEF34BD8FB5A7B82 9D3E862371D2CFE5'
], ],
[ [
"128 bits of Key Data with a 192-bit KEK", '128 bits of Key Data with a 192-bit KEK',
"000102030405060708090A0B0C0D0E0F1011121314151617", '000102030405060708090A0B0C0D0E0F1011121314151617',
"00112233445566778899AABBCCDDEEFF", '00112233445566778899AABBCCDDEEFF',
"96778B25AE6CA435 F92B5B97C050AED2 468AB8A17AD84E5D" '96778B25AE6CA435 F92B5B97C050AED2 468AB8A17AD84E5D'
], ],
[ [
"128 bits of Key Data with a 256-bit KEK", '128 bits of Key Data with a 256-bit KEK',
"000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F", '000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F',
"00112233445566778899AABBCCDDEEFF", '00112233445566778899AABBCCDDEEFF',
"64E8C3F9CE0F5BA2 63E9777905818A2A 93C8191E7D6E8AE7" '64E8C3F9CE0F5BA2 63E9777905818A2A 93C8191E7D6E8AE7'
], ],
[ [
"192 bits of Key Data with a 192-bit KEK", '192 bits of Key Data with a 192-bit KEK',
"000102030405060708090A0B0C0D0E0F1011121314151617", '000102030405060708090A0B0C0D0E0F1011121314151617',
"00112233445566778899AABBCCDDEEFF0001020304050607", '00112233445566778899AABBCCDDEEFF0001020304050607',
"031D33264E15D332 68F24EC260743EDC E1C6C7DDEE725A93 6BA814915C6762D2" '031D33264E15D332 68F24EC260743EDC E1C6C7DDEE725A93 6BA814915C6762D2'
], ],
[ [
"192 bits of Key Data with a 256-bit KEK", '192 bits of Key Data with a 256-bit KEK',
"000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F", '000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F',
"00112233445566778899AABBCCDDEEFF0001020304050607", '00112233445566778899AABBCCDDEEFF0001020304050607',
"A8F9BC1612C68B3F F6E6F4FBE30E71E4 769C8B80A32CB895 8CD5D17D6B254DA1" 'A8F9BC1612C68B3F F6E6F4FBE30E71E4 769C8B80A32CB895 8CD5D17D6B254DA1'
], ],
[ [
"256 bits of Key Data with a 256-bit KEK", '256 bits of Key Data with a 256-bit KEK',
"000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F", '000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F',
"00112233445566778899AABBCCDDEEFF000102030405060708090A0B0C0D0E0F", '00112233445566778899AABBCCDDEEFF000102030405060708090A0B0C0D0E0F',
"28C9F404C4B810F4 CBCCB35CFB87F826 3F5786E2D80ED326 CBC7F0E71A99F43B FB988B9B7A02DD21" '28C9F404C4B810F4 CBCCB35CFB87F826 3F5786E2D80ED326 CBC7F0E71A99F43B FB988B9B7A02DD21'
] ]
]; ];
test_vectors.forEach(function(test) { test_vectors.forEach(function(test) {
it(test[0], function(done) { it(test[0], function(done) {
const kek = util.hexToUint8Array(test[1]); const kek = util.hexToUint8Array(test[1]);
const input = test[2].replace(/\s/g, ""); const input = test[2].replace(/\s/g, '');
const input_bin = util.uint8ArrayToString(util.hexToUint8Array(input)); const input_bin = util.uint8ArrayToString(util.hexToUint8Array(input));
const output = test[3].replace(/\s/g, ""); const output = test[3].replace(/\s/g, '');
const output_bin = util.uint8ArrayToString(util.hexToUint8Array(output)); const output_bin = util.uint8ArrayToString(util.hexToUint8Array(output));
expect(util.uint8ArrayToHex(aesKW.wrap(kek, input_bin)).toUpperCase()).to.equal(output); expect(util.uint8ArrayToHex(aesKW.wrap(kek, input_bin)).toUpperCase()).to.equal(output);
expect(util.uint8ArrayToHex(aesKW.unwrap(kek, output_bin)).toUpperCase()).to.equal(input); expect(util.uint8ArrayToHex(aesKW.unwrap(kek, output_bin)).toUpperCase()).to.equal(input);

12
test/crypto/crypto.js
View File

@ -207,7 +207,7 @@ module.exports = () => describe('API functional testing', function() {
const elGamalPublicParams = crypto.parsePublicKeyParams(algoElGamal, elGamalPublicKeyMaterial).publicParams; const elGamalPublicParams = crypto.parsePublicKeyParams(algoElGamal, elGamalPublicKeyMaterial).publicParams;
const elGamalPrivateParams = crypto.parsePrivateKeyParams(algoElGamal, elGamalPrivateKeyMaterial).privateParams; const elGamalPrivateParams = crypto.parsePrivateKeyParams(algoElGamal, elGamalPrivateKeyMaterial).privateParams;
const data = util.stringToUint8Array("foobar"); const data = util.stringToUint8Array('foobar');
describe('Sign and verify', function () { describe('Sign and verify', function () {
it('RSA', async function () { it('RSA', async function () {
@ -247,11 +247,11 @@ module.exports = () => describe('API functional testing', function() {
expect(text).to.equal(plaintext); expect(text).to.equal(plaintext);
})); }));
} }
it("Symmetric with OpenPGP CFB", async function () { it('Symmetric with OpenPGP CFB', async function () {
await testCFB("hello"); await testCFB('hello');
await testCFB("1234567"); await testCFB('1234567');
await testCFB("foobarfoobar1234567890"); await testCFB('foobarfoobar1234567890');
await testCFB("12345678901234567890123456789012345678901234567890"); await testCFB('12345678901234567890123456789012345678901234567890');
}); });
it('Asymmetric using RSA with eme_pkcs1 padding', async function () { it('Asymmetric using RSA with eme_pkcs1 padding', async function () {

104
test/crypto/eax.js
View File

@ -16,74 +16,74 @@ function testAESEAX() {
const vectors = [ const vectors = [
// From http://www.cs.ucdavis.edu/~rogaway/papers/eax.pdf ... // From http://www.cs.ucdavis.edu/~rogaway/papers/eax.pdf ...
{ {
msg: "", msg: '',
key: "233952DEE4D5ED5F9B9C6D6FF80FF478", key: '233952DEE4D5ED5F9B9C6D6FF80FF478',
nonce: "62EC67F9C3A4A407FCB2A8C49031A8B3", nonce: '62EC67F9C3A4A407FCB2A8C49031A8B3',
header: "6BFB914FD07EAE6B", header: '6BFB914FD07EAE6B',
ct: "E037830E8389F27B025A2D6527E79D01" ct: 'E037830E8389F27B025A2D6527E79D01'
}, },
{ {
msg: "F7FB", msg: 'F7FB',
key: "91945D3F4DCBEE0BF45EF52255F095A4", key: '91945D3F4DCBEE0BF45EF52255F095A4',
nonce: "BECAF043B0A23D843194BA972C66DEBD", nonce: 'BECAF043B0A23D843194BA972C66DEBD',
header: "FA3BFD4806EB53FA", header: 'FA3BFD4806EB53FA',
ct: "19DD5C4C9331049D0BDAB0277408F67967E5" ct: '19DD5C4C9331049D0BDAB0277408F67967E5'
}, },
{ {
msg: "1A47CB4933", msg: '1A47CB4933',
key: "01F74AD64077F2E704C0F60ADA3DD523", key: '01F74AD64077F2E704C0F60ADA3DD523',
nonce: "70C3DB4F0D26368400A10ED05D2BFF5E", nonce: '70C3DB4F0D26368400A10ED05D2BFF5E',
header: "234A3463C1264AC6", header: '234A3463C1264AC6',
ct: "D851D5BAE03A59F238A23E39199DC9266626C40F80" ct: 'D851D5BAE03A59F238A23E39199DC9266626C40F80'
}, },
{ {
msg: "481C9E39B1", msg: '481C9E39B1',
key: "D07CF6CBB7F313BDDE66B727AFD3C5E8", key: 'D07CF6CBB7F313BDDE66B727AFD3C5E8',
nonce: "8408DFFF3C1A2B1292DC199E46B7D617", nonce: '8408DFFF3C1A2B1292DC199E46B7D617',
header: "33CCE2EABFF5A79D", header: '33CCE2EABFF5A79D',
ct: "632A9D131AD4C168A4225D8E1FF755939974A7BEDE" ct: '632A9D131AD4C168A4225D8E1FF755939974A7BEDE'
}, },
{ {
msg: "40D0C07DA5E4", msg: '40D0C07DA5E4',
key: "35B6D0580005BBC12B0587124557D2C2", key: '35B6D0580005BBC12B0587124557D2C2',
nonce: "FDB6B06676EEDC5C61D74276E1F8E816", nonce: 'FDB6B06676EEDC5C61D74276E1F8E816',
header: "AEB96EAEBE2970E9", header: 'AEB96EAEBE2970E9',
ct: "071DFE16C675CB0677E536F73AFE6A14B74EE49844DD" ct: '071DFE16C675CB0677E536F73AFE6A14B74EE49844DD'
}, },
{ {
msg: "4DE3B35C3FC039245BD1FB7D", msg: '4DE3B35C3FC039245BD1FB7D',
key: "BD8E6E11475E60B268784C38C62FEB22", key: 'BD8E6E11475E60B268784C38C62FEB22',
nonce: "6EAC5C93072D8E8513F750935E46DA1B", nonce: '6EAC5C93072D8E8513F750935E46DA1B',
header: "D4482D1CA78DCE0F", header: 'D4482D1CA78DCE0F',
ct: "835BB4F15D743E350E728414ABB8644FD6CCB86947C5E10590210A4F" ct: '835BB4F15D743E350E728414ABB8644FD6CCB86947C5E10590210A4F'
}, },
{ {
msg: "8B0A79306C9CE7ED99DAE4F87F8DD61636", msg: '8B0A79306C9CE7ED99DAE4F87F8DD61636',
key: "7C77D6E813BED5AC98BAA417477A2E7D", key: '7C77D6E813BED5AC98BAA417477A2E7D',
nonce: "1A8C98DCD73D38393B2BF1569DEEFC19", nonce: '1A8C98DCD73D38393B2BF1569DEEFC19',
header: "65D2017990D62528", header: '65D2017990D62528',
ct: "02083E3979DA014812F59F11D52630DA30137327D10649B0AA6E1C181DB617D7F2" ct: '02083E3979DA014812F59F11D52630DA30137327D10649B0AA6E1C181DB617D7F2'
}, },
{ {
msg: "1BDA122BCE8A8DBAF1877D962B8592DD2D56", msg: '1BDA122BCE8A8DBAF1877D962B8592DD2D56',
key: "5FFF20CAFAB119CA2FC73549E20F5B0D", key: '5FFF20CAFAB119CA2FC73549E20F5B0D',
nonce: "DDE59B97D722156D4D9AFF2BC7559826", nonce: 'DDE59B97D722156D4D9AFF2BC7559826',
header: "54B9F04E6A09189A", header: '54B9F04E6A09189A',
ct: "2EC47B2C4954A489AFC7BA4897EDCDAE8CC33B60450599BD02C96382902AEF7F832A" ct: '2EC47B2C4954A489AFC7BA4897EDCDAE8CC33B60450599BD02C96382902AEF7F832A'
}, },
{ {
msg: "6CF36720872B8513F6EAB1A8A44438D5EF11", msg: '6CF36720872B8513F6EAB1A8A44438D5EF11',
key: "A4A4782BCFFD3EC5E7EF6D8C34A56123", key: 'A4A4782BCFFD3EC5E7EF6D8C34A56123',
nonce: "B781FCF2F75FA5A8DE97A9CA48E522EC", nonce: 'B781FCF2F75FA5A8DE97A9CA48E522EC',
header: "899A175897561D7E", header: '899A175897561D7E',
ct: "0DE18FD0FDD91E7AF19F1D8EE8733938B1E8E7F6D2231618102FDB7FE55FF1991700" ct: '0DE18FD0FDD91E7AF19F1D8EE8733938B1E8E7F6D2231618102FDB7FE55FF1991700'
}, },
{ {
msg: "CA40D7446E545FFAED3BD12A740A659FFBBB3CEAB7", msg: 'CA40D7446E545FFAED3BD12A740A659FFBBB3CEAB7',
key: "8395FCF1E95BEBD697BD010BC766AAC3", key: '8395FCF1E95BEBD697BD010BC766AAC3',
nonce: "22E7ADD93CFC6393C57EC0B3C17D6B44", nonce: '22E7ADD93CFC6393C57EC0B3C17D6B44',
header: "126735FCC320D25A", header: '126735FCC320D25A',
ct: "CB8920F87A6C75CFF39627B56E3ED197C552D295A7CFC46AFC253B4652B1AF3795B124AB6E" ct: 'CB8920F87A6C75CFF39627B56E3ED197C552D295A7CFC46AFC253B4652B1AF3795B124AB6E'
} }
]; ];
@ -133,8 +133,8 @@ module.exports = () => describe('Symmetric AES-EAX', function() {
const disableNative = () => { const disableNative = () => {
enableNative(); enableNative();
// stubbed functions return undefined // stubbed functions return undefined
getWebCryptoStub = sinonSandbox.stub(util, "getWebCrypto"); getWebCryptoStub = sinonSandbox.stub(util, 'getWebCrypto');
getNodeCryptoStub = sinonSandbox.stub(util, "getNodeCrypto"); getNodeCryptoStub = sinonSandbox.stub(util, 'getNodeCrypto');
}; };
const enableNative = () => { const enableNative = () => {
getWebCryptoStub && getWebCryptoStub.restore(); getWebCryptoStub && getWebCryptoStub.restore();

4
test/crypto/ecdh.js
View File

@ -206,8 +206,8 @@ module.exports = () => describe('ECDH key exchange @lightweight', function () {
const disableNative = () => { const disableNative = () => {
enableNative(); enableNative();
// stubbed functions return undefined // stubbed functions return undefined
getWebCryptoStub = sinonSandbox.stub(util, "getWebCrypto"); getWebCryptoStub = sinonSandbox.stub(util, 'getWebCrypto');
getNodeCryptoStub = sinonSandbox.stub(util, "getNodeCrypto"); getNodeCryptoStub = sinonSandbox.stub(util, 'getNodeCrypto');
}; };
const enableNative = () => { const enableNative = () => {
getWebCryptoStub && getWebCryptoStub.restore(); getWebCryptoStub && getWebCryptoStub.restore();

6
test/crypto/elliptic.js
View File

@ -115,8 +115,8 @@ module.exports = () => describe('Elliptic Curve Cryptography @lightweight', func
const disableNative = () => { const disableNative = () => {
enableNative(); enableNative();
// stubbed functions return undefined // stubbed functions return undefined
getWebCryptoStub = sinonSandbox.stub(util, "getWebCrypto"); getWebCryptoStub = sinonSandbox.stub(util, 'getWebCrypto');
getNodeCryptoStub = sinonSandbox.stub(util, "getNodeCrypto"); getNodeCryptoStub = sinonSandbox.stub(util, 'getNodeCrypto');
}; };
const enableNative = () => { const enableNative = () => {
getWebCryptoStub && getWebCryptoStub.restore(); getWebCryptoStub && getWebCryptoStub.restore();
@ -169,7 +169,7 @@ module.exports = () => describe('Elliptic Curve Cryptography @lightweight', func
'invalid oid', 8, [], [], [], [] 'invalid oid', 8, [], [], [], []
)).to.be.rejectedWith(Error, /Not valid curve/), )).to.be.rejectedWith(Error, /Not valid curve/),
expect(verify_signature( expect(verify_signature(
"\x00", 8, [], [], [], [] '\x00', 8, [], [], [], []
)).to.be.rejectedWith(Error, /Not valid curve/) )).to.be.rejectedWith(Error, /Not valid curve/)
]); ]);
}); });

10
test/crypto/gcm.js
View File

@ -25,8 +25,8 @@ module.exports = () => describe('Symmetric AES-GCM (experimental)', function() {
const disableNative = () => { const disableNative = () => {
enableNative(); enableNative();
// stubbed functions return undefined // stubbed functions return undefined
getWebCryptoStub = sinonSandbox.stub(util, "getWebCrypto"); getWebCryptoStub = sinonSandbox.stub(util, 'getWebCrypto');
getNodeCryptoStub = sinonSandbox.stub(util, "getNodeCrypto"); getNodeCryptoStub = sinonSandbox.stub(util, 'getNodeCrypto');
}; };
const enableNative = () => { const enableNative = () => {
getWebCryptoStub && getWebCryptoStub.restore(); getWebCryptoStub && getWebCryptoStub.restore();
@ -73,14 +73,14 @@ module.exports = () => describe('Symmetric AES-GCM (experimental)', function() {
} }
describe('Symmetric AES-GCM (native)', function() { describe('Symmetric AES-GCM (native)', function() {
testAESGCM("12345678901234567890123456789012345678901234567890", true, true); testAESGCM('12345678901234567890123456789012345678901234567890', true, true);
}); });
describe('Symmetric AES-GCM (asm.js fallback)', function() { describe('Symmetric AES-GCM (asm.js fallback)', function() {
testAESGCM("12345678901234567890123456789012345678901234567890", false, false); testAESGCM('12345678901234567890123456789012345678901234567890', false, false);
}); });
describe('Symmetric AES-GCM (native encrypt, asm.js decrypt)', function() { describe('Symmetric AES-GCM (native encrypt, asm.js decrypt)', function() {
testAESGCM("12345678901234567890123456789012345678901234567890", true, false); testAESGCM('12345678901234567890123456789012345678901234567890', true, false);
}); });
}); });

2
test/crypto/hash/ripemd.js
View File

@ -5,7 +5,7 @@ const chai = require('chai');
const { expect } = chai; const { expect } = chai;
module.exports = () => it("RIPE-MD 160 bits with test vectors from https://homes.esat.kuleuven.be/~bosselae/ripemd160.html", async function() { module.exports = () => it('RIPE-MD 160 bits with test vectors from https://homes.esat.kuleuven.be/~bosselae/ripemd160.html', async function() {
expect(util.uint8ArrayToHex(await rmdString(util.stringToUint8Array('')), 'RMDstring("") = 9c1185a5c5e9fc54612808977ee8f548b2258d31')).to.equal('9c1185a5c5e9fc54612808977ee8f548b2258d31'); expect(util.uint8ArrayToHex(await rmdString(util.stringToUint8Array('')), 'RMDstring("") = 9c1185a5c5e9fc54612808977ee8f548b2258d31')).to.equal('9c1185a5c5e9fc54612808977ee8f548b2258d31');
expect(util.uint8ArrayToHex(await rmdString(util.stringToUint8Array('a')), 'RMDstring("a") = 0bdc9d2d256b3ee9daae347be6f4dc835a467ffe')).to.equal('0bdc9d2d256b3ee9daae347be6f4dc835a467ffe'); expect(util.uint8ArrayToHex(await rmdString(util.stringToUint8Array('a')), 'RMDstring("a") = 0bdc9d2d256b3ee9daae347be6f4dc835a467ffe')).to.equal('0bdc9d2d256b3ee9daae347be6f4dc835a467ffe');
expect(util.uint8ArrayToHex(await rmdString(util.stringToUint8Array('abc')), 'RMDstring("abc") = 8eb208f7e05d987a9b044a8e98c6b087f15a0bfc')).to.equal('8eb208f7e05d987a9b044a8e98c6b087f15a0bfc'); expect(util.uint8ArrayToHex(await rmdString(util.stringToUint8Array('abc')), 'RMDstring("abc") = 8eb208f7e05d987a9b044a8e98c6b087f15a0bfc')).to.equal('8eb208f7e05d987a9b044a8e98c6b087f15a0bfc');

4
test/crypto/rsa.js
View File

@ -28,8 +28,8 @@ module.exports = () => describe('basic RSA cryptography', function () {
const disableNative = () => { const disableNative = () => {
enableNative(); enableNative();
// stubbed functions return undefined // stubbed functions return undefined
getWebCryptoStub = sinonSandbox.stub(util, "getWebCrypto"); getWebCryptoStub = sinonSandbox.stub(util, 'getWebCrypto');
getNodeCryptoStub = sinonSandbox.stub(util, "getNodeCrypto"); getNodeCryptoStub = sinonSandbox.stub(util, 'getNodeCrypto');
}; };
const enableNative = () => { const enableNative = () => {
getWebCryptoStub && getWebCryptoStub.restore(); getWebCryptoStub && getWebCryptoStub.restore();

2
test/general/armor.js
View File

@ -4,7 +4,7 @@ const chai = require('chai');
const { expect } = chai; const { expect } = chai;
module.exports = () => describe("ASCII armor", function() { module.exports = () => describe('ASCII armor', function() {
function getArmor(headers, signatureHeaders) { function getArmor(headers, signatureHeaders) {
return ['-----BEGIN PGP SIGNED MESSAGE-----'] return ['-----BEGIN PGP SIGNED MESSAGE-----']

4
test/general/brainpool.js
View File

@ -285,8 +285,8 @@ function omnibus() {
const testData = input.createSomeMessage(); const testData = input.createSomeMessage();
const testData2 = input.createSomeMessage(); const testData2 = input.createSomeMessage();
const { privateKey: hi, publicKey: pubHi } = await openpgp.generateKey({ userIDs: { name: "Hi", email: "hi@hel.lo" }, curve: "brainpoolP256r1", format: 'object' }); const { privateKey: hi, publicKey: pubHi } = await openpgp.generateKey({ userIDs: { name: 'Hi', email: 'hi@hel.lo' }, curve: 'brainpoolP256r1', format: 'object' });
const { privateKey: bye, publicKey: pubBye } = await openpgp.generateKey({ userIDs: { name: "Bye", email: "bye@good.bye" }, curve: "brainpoolP256r1", format: 'object' }); const { privateKey: bye, publicKey: pubBye } = await openpgp.generateKey({ userIDs: { name: 'Bye', email: 'bye@good.bye' }, curve: 'brainpoolP256r1', format: 'object' });
const cleartextMessage = await openpgp.sign({ message: await openpgp.createCleartextMessage({ text: testData }), signingKeys: hi }); const cleartextMessage = await openpgp.sign({ message: await openpgp.createCleartextMessage({ text: testData }), signingKeys: hi });
await openpgp.verify({ await openpgp.verify({

14
test/general/config.js
View File

@ -4,7 +4,7 @@ const openpgp = typeof window !== 'undefined' && window.openpgp ? window.openpgp
module.exports = () => describe('Custom configuration', function() { module.exports = () => describe('Custom configuration', function() {
it('openpgp.readMessage', async function() { it('openpgp.readMessage', async function() {
const armoredMessage = await openpgp.encrypt({ message: await openpgp.createMessage({ text:"hello world" }), passwords: 'password' }); const armoredMessage = await openpgp.encrypt({ message: await openpgp.createMessage({ text:'hello world' }), passwords: 'password' });
const message = await openpgp.readMessage({ armoredMessage }); const message = await openpgp.readMessage({ armoredMessage });
message.packets.findPacket(openpgp.SymEncryptedSessionKeyPacket.tag).version = 1; // unsupported SKESK version message.packets.findPacket(openpgp.SymEncryptedSessionKeyPacket.tag).version = 1; // unsupported SKESK version
@ -201,7 +201,7 @@ vAFM3jjrAQDgJPXsv8PqCrLGDuMa/2r6SgzYd03aw/xt1WM6hgUvhQD+J54Z
try { try {
const passwords = ['12345678']; const passwords = ['12345678'];
const message = await openpgp.createMessage({ text: "test" }); const message = await openpgp.createMessage({ text: 'test' });
const armored = await openpgp.encrypt({ message, passwords }); const armored = await openpgp.encrypt({ message, passwords });
const encrypted = await openpgp.readMessage({ armoredMessage: armored }); const encrypted = await openpgp.readMessage({ armoredMessage: armored });
@ -223,7 +223,7 @@ vAFM3jjrAQDgJPXsv8PqCrLGDuMa/2r6SgzYd03aw/xt1WM6hgUvhQD+J54Z
expect(encData2.constructor.tag).to.equal(openpgp.enums.packet.aeadEncryptedData); expect(encData2.constructor.tag).to.equal(openpgp.enums.packet.aeadEncryptedData);
const { packets: [compressed] } = await encrypted2.decrypt(null, passwords, null, encrypted2.fromStream, openpgp.config); const { packets: [compressed] } = await encrypted2.decrypt(null, passwords, null, encrypted2.fromStream, openpgp.config);
expect(compressed.constructor.tag).to.equal(openpgp.enums.packet.compressedData); expect(compressed.constructor.tag).to.equal(openpgp.enums.packet.compressedData);
expect(compressed.algorithm).to.equal("zip"); expect(compressed.algorithm).to.equal('zip');
const userIDs = { name: 'Test User', email: 'text2@example.com' }; const userIDs = { name: 'Test User', email: 'text2@example.com' };
const { privateKey: key } = await openpgp.generateKey({ userIDs, format: 'object' }); const { privateKey: key } = await openpgp.generateKey({ userIDs, format: 'object' });
@ -276,7 +276,7 @@ vAFM3jjrAQDgJPXsv8PqCrLGDuMa/2r6SgzYd03aw/xt1WM6hgUvhQD+J54Z
const userIDs = { name: 'Test User', email: 'text2@example.com' }; const userIDs = { name: 'Test User', email: 'text2@example.com' };
const { privateKey: key } = await openpgp.generateKey({ userIDs, format: 'object' }); const { privateKey: key } = await openpgp.generateKey({ userIDs, format: 'object' });
const message = await openpgp.createMessage({ text: "test" }); const message = await openpgp.createMessage({ text: 'test' });
const opt = { const opt = {
message, message,
signingKeys: key, signingKeys: key,
@ -286,7 +286,7 @@ vAFM3jjrAQDgJPXsv8PqCrLGDuMa/2r6SgzYd03aw/xt1WM6hgUvhQD+J54Z
opt.detached = true; opt.detached = true;
await expect(openpgp.sign(opt)).to.be.rejectedWith(/Insecure hash algorithm/); await expect(openpgp.sign(opt)).to.be.rejectedWith(/Insecure hash algorithm/);
const clearText = await openpgp.createCleartextMessage({ text: "test" }); const clearText = await openpgp.createCleartextMessage({ text: 'test' });
const opt2 = { const opt2 = {
message: clearText, message: clearText,
signingKeys: key, signingKeys: key,
@ -305,7 +305,7 @@ vAFM3jjrAQDgJPXsv8PqCrLGDuMa/2r6SgzYd03aw/xt1WM6hgUvhQD+J54Z
const config = { rejectMessageHashAlgorithms: new Set([openpgp.enums.hash.sha256, openpgp.enums.hash.sha512]) }; const config = { rejectMessageHashAlgorithms: new Set([openpgp.enums.hash.sha256, openpgp.enums.hash.sha512]) };
const message = await openpgp.createMessage({ text: "test" }); const message = await openpgp.createMessage({ text: 'test' });
const signed = await openpgp.sign({ message, signingKeys: key }); const signed = await openpgp.sign({ message, signingKeys: key });
const opt = { const opt = {
message: await openpgp.readMessage({ armoredMessage: signed }), message: await openpgp.readMessage({ armoredMessage: signed }),
@ -324,7 +324,7 @@ vAFM3jjrAQDgJPXsv8PqCrLGDuMa/2r6SgzYd03aw/xt1WM6hgUvhQD+J54Z
const { signatures: [sig2] } = await openpgp.verify(opt2); const { signatures: [sig2] } = await openpgp.verify(opt2);
await expect(sig2.error).to.match(/Insecure message hash algorithm/); await expect(sig2.error).to.match(/Insecure message hash algorithm/);
const cleartext = await openpgp.createCleartextMessage({ text: "test" }); const cleartext = await openpgp.createCleartextMessage({ text: 'test' });
const signedCleartext = await openpgp.sign({ message: cleartext, signingKeys: key }); const signedCleartext = await openpgp.sign({ message: cleartext, signingKeys: key });
const opt3 = { const opt3 = {
message: await openpgp.readCleartextMessage({ cleartextMessage: signedCleartext }), message: await openpgp.readCleartextMessage({ cleartextMessage: signedCleartext }),

10
test/general/ecc_nist.js
View File

@ -13,8 +13,8 @@ module.exports = () => describe('Elliptic Curve Cryptography for NIST P-256,P-38
const testData = input.createSomeMessage(); const testData = input.createSomeMessage();
const testData2 = input.createSomeMessage(); const testData2 = input.createSomeMessage();
const { privateKey: hi, publicKey: pubHi } = await openpgp.generateKey({ userIDs: { name: "Hi", email: "hi@hel.lo" }, curve: "p256", format: 'object' }); const { privateKey: hi, publicKey: pubHi } = await openpgp.generateKey({ userIDs: { name: 'Hi', email: 'hi@hel.lo' }, curve: 'p256', format: 'object' });
const { privateKey: bye, publicKey: pubBye } = await openpgp.generateKey({ userIDs: { name: "Bye", email: "bye@good.bye" }, curve: "p256", format: 'object' }); const { privateKey: bye, publicKey: pubBye } = await openpgp.generateKey({ userIDs: { name: 'Bye', email: 'bye@good.bye' }, curve: 'p256', format: 'object' });
const cleartextMessage = await openpgp.sign({ message: await openpgp.createCleartextMessage({ text: testData }), signingKeys: hi }); const cleartextMessage = await openpgp.sign({ message: await openpgp.createCleartextMessage({ text: testData }), signingKeys: hi });
await openpgp.verify({ await openpgp.verify({
@ -50,7 +50,7 @@ module.exports = () => describe('Elliptic Curve Cryptography for NIST P-256,P-38
it('Sign message', async function () { it('Sign message', async function () {
const testData = input.createSomeMessage(); const testData = input.createSomeMessage();
const options = { userIDs: { name: "Hi", email: "hi@hel.lo" }, curve: "p256", format: 'object' }; const options = { userIDs: { name: 'Hi', email: 'hi@hel.lo' }, curve: 'p256', format: 'object' };
const { privateKey, publicKey } = await openpgp.generateKey(options); const { privateKey, publicKey } = await openpgp.generateKey(options);
const signature = await openpgp.sign({ message: await openpgp.createCleartextMessage({ text: testData }), signingKeys: privateKey }); const signature = await openpgp.sign({ message: await openpgp.createCleartextMessage({ text: testData }), signingKeys: privateKey });
const msg = await openpgp.readCleartextMessage({ cleartextMessage: signature }); const msg = await openpgp.readCleartextMessage({ cleartextMessage: signature });
@ -60,9 +60,9 @@ module.exports = () => describe('Elliptic Curve Cryptography for NIST P-256,P-38
it('Encrypt and sign message', async function () { it('Encrypt and sign message', async function () {
const testData = input.createSomeMessage(); const testData = input.createSomeMessage();
let options = { userIDs: { name: "Hi", email: "hi@hel.lo" }, curve: "p256", format: 'object' }; let options = { userIDs: { name: 'Hi', email: 'hi@hel.lo' }, curve: 'p256', format: 'object' };
const firstKey = await openpgp.generateKey(options); const firstKey = await openpgp.generateKey(options);
options = { userIDs: { name: "Bye", email: "bye@good.bye" }, curve: "p256", format: 'object' }; options = { userIDs: { name: 'Bye', email: 'bye@good.bye' }, curve: 'p256', format: 'object' };
const secondKey = await openpgp.generateKey(options); const secondKey = await openpgp.generateKey(options);
const encrypted = await openpgp.encrypt({ const encrypted = await openpgp.encrypt({
message: await openpgp.createMessage({ text: testData }), message: await openpgp.createMessage({ text: testData }),

6
test/general/ecc_secp256k1.js
View File

@ -224,9 +224,9 @@ module.exports = () => describe('Elliptic Curve Cryptography for secp256k1 curve
}); });
it('Generate key', function () { it('Generate key', function () {
const options = { const options = {
userIDs: { name: "Hamlet (secp256k1)", email: "hamlet@example.net" }, userIDs: { name: 'Hamlet (secp256k1)', email: 'hamlet@example.net' },
curve: "secp256k1", curve: 'secp256k1',
passphrase: "ophelia", passphrase: 'ophelia',
format: 'object' format: 'object'
}; };
return openpgp.generateKey(options).then(function ({ privateKey, publicKey }) { return openpgp.generateKey(options).then(function ({ privateKey, publicKey }) {

22
test/general/key.js
View File

@ -2558,7 +2558,7 @@ function versionSpecificTests() {
it('Reformat and encrypt key with no subkey', async function() { it('Reformat and encrypt key with no subkey', async function() {
const userID = { name: 'test', email: 'a@b.com' }; const userID = { name: 'test', email: 'a@b.com' };
const key = await openpgp.readKey({ armoredKey: key_without_subkey }); const key = await openpgp.readKey({ armoredKey: key_without_subkey });
const opt = { privateKey: key, userIDs: [userID], passphrase: "test", format: 'object' }; const opt = { privateKey: key, userIDs: [userID], passphrase: 'test', format: 'object' };
return openpgp.reformatKey(opt).then(function({ privateKey: newKey }) { return openpgp.reformatKey(opt).then(function({ privateKey: newKey }) {
expect(newKey.users.length).to.equal(1); expect(newKey.users.length).to.equal(1);
expect(newKey.users[0].userID.userID).to.equal('test <a@b.com>'); expect(newKey.users[0].userID.userID).to.equal('test <a@b.com>');
@ -2939,27 +2939,27 @@ module.exports = () => describe('Key', function() {
await expect(key.validate()).to.not.be.rejected; await expect(key.validate()).to.not.be.rejected;
}); });
it("validate() - throw if all-gnu-dummy key", async function() { it('validate() - throw if all-gnu-dummy key', async function() {
const key = await openpgp.readKey({ armoredKey: gnuDummyKey }); const key = await openpgp.readKey({ armoredKey: gnuDummyKey });
await expect(key.validate()).to.be.rejectedWith('Cannot validate an all-gnu-dummy key'); await expect(key.validate()).to.be.rejectedWith('Cannot validate an all-gnu-dummy key');
}); });
it("validate() - gnu-dummy primary key with signing subkey", async function() { it('validate() - gnu-dummy primary key with signing subkey', async function() {
const key = await openpgp.readKey({ armoredKey: gnuDummyKeySigningSubkey }); const key = await openpgp.readKey({ armoredKey: gnuDummyKeySigningSubkey });
await expect(key.validate()).to.not.be.rejected; await expect(key.validate()).to.not.be.rejected;
}); });
it("validate() - gnu-dummy primary key with encryption subkey", async function() { it('validate() - gnu-dummy primary key with encryption subkey', async function() {
const key = await openpgp.readKey({ armoredKey: dsaGnuDummyKeyWithElGamalSubkey }); const key = await openpgp.readKey({ armoredKey: dsaGnuDummyKeyWithElGamalSubkey });
await expect(key.validate()).to.not.be.rejected; await expect(key.validate()).to.not.be.rejected;
}); });
it("validate() - curve ed25519 (eddsa) cannot be used for ecdsa", async function() { it('validate() - curve ed25519 (eddsa) cannot be used for ecdsa', async function() {
const key = await openpgp.readKey({ armoredKey: eddsaKeyAsEcdsa }); const key = await openpgp.readKey({ armoredKey: eddsaKeyAsEcdsa });
await expect(key.validate()).to.be.rejectedWith('Key is invalid'); await expect(key.validate()).to.be.rejectedWith('Key is invalid');
}); });
it("isDecrypted() - should reflect whether all (sub)keys are encrypted", async function() { it('isDecrypted() - should reflect whether all (sub)keys are encrypted', async function() {
const passphrase = '12345678'; const passphrase = '12345678';
const { privateKey: key } = await openpgp.generateKey({ userIDs: {}, curve: 'ed25519', passphrase, format: 'object' }); const { privateKey: key } = await openpgp.generateKey({ userIDs: {}, curve: 'ed25519', passphrase, format: 'object' });
expect(key.isDecrypted()).to.be.false; expect(key.isDecrypted()).to.be.false;
@ -2967,14 +2967,14 @@ module.exports = () => describe('Key', function() {
expect(key.isDecrypted()).to.be.true; expect(key.isDecrypted()).to.be.true;
}); });
it("isDecrypted() - gnu-dummy primary key", async function() { it('isDecrypted() - gnu-dummy primary key', async function() {
const key = await openpgp.readKey({ armoredKey: gnuDummyKeySigningSubkey }); const key = await openpgp.readKey({ armoredKey: gnuDummyKeySigningSubkey });
expect(key.isDecrypted()).to.be.true; expect(key.isDecrypted()).to.be.true;
const encryptedKey = await openpgp.encryptKey({ privateKey: key, passphrase: '12345678' }); const encryptedKey = await openpgp.encryptKey({ privateKey: key, passphrase: '12345678' });
expect(encryptedKey.isDecrypted()).to.be.false; expect(encryptedKey.isDecrypted()).to.be.false;
}); });
it("isDecrypted() - all-gnu-dummy key", async function() { it('isDecrypted() - all-gnu-dummy key', async function() {
const key = await openpgp.readKey({ armoredKey: gnuDummyKey }); const key = await openpgp.readKey({ armoredKey: gnuDummyKey });
expect(key.isDecrypted()).to.be.false; expect(key.isDecrypted()).to.be.false;
}); });
@ -3606,7 +3606,7 @@ VYGdb3eNlV8CfoEC
const opt = { type: 'rsa', rsaBits, userIDs: [userID], format: 'object', subkeys: [] }; const opt = { type: 'rsa', rsaBits, userIDs: [userID], format: 'object', subkeys: [] };
const { privateKey: key } = await openpgp.generateKey(opt); const { privateKey: key } = await openpgp.generateKey(opt);
expect(key.subkeys).to.have.length(0); expect(key.subkeys).to.have.length(0);
key.getAlgorithmInfo().algorithm = "rsaSign"; key.getAlgorithmInfo().algorithm = 'rsaSign';
const newKey = await key.addSubkey(); const newKey = await key.addSubkey();
expect(newKey.subkeys[0].getAlgorithmInfo().algorithm).to.equal('rsaEncryptSign'); expect(newKey.subkeys[0].getAlgorithmInfo().algorithm).to.equal('rsaEncryptSign');
}); });
@ -3854,13 +3854,13 @@ VYGdb3eNlV8CfoEC
}); });
it('Subkey.verify returns the latest valid signature', async function () { it('Subkey.verify returns the latest valid signature', async function () {
const { privateKey: encryptionKey } = await openpgp.generateKey({ userIDs: { name: "purple" }, format: 'object' }); const { privateKey: encryptionKey } = await openpgp.generateKey({ userIDs: { name: 'purple' }, format: 'object' });
const encryptionKeySignature = await encryptionKey.getSubkeys()[0].verify(); const encryptionKeySignature = await encryptionKey.getSubkeys()[0].verify();
expect(encryptionKeySignature instanceof openpgp.SignaturePacket).to.be.true; expect(encryptionKeySignature instanceof openpgp.SignaturePacket).to.be.true;
expect(encryptionKeySignature.keyFlags[0] & openpgp.enums.keyFlags.encryptCommunication).to.be.equals(openpgp.enums.keyFlags.encryptCommunication); expect(encryptionKeySignature.keyFlags[0] & openpgp.enums.keyFlags.encryptCommunication).to.be.equals(openpgp.enums.keyFlags.encryptCommunication);
expect(encryptionKeySignature.keyFlags[0] & openpgp.enums.keyFlags.encryptStorage).to.be.equals(openpgp.enums.keyFlags.encryptStorage); expect(encryptionKeySignature.keyFlags[0] & openpgp.enums.keyFlags.encryptStorage).to.be.equals(openpgp.enums.keyFlags.encryptStorage);
const { privateKey: signingKey } = await openpgp.generateKey({ userIDs: { name: "purple" }, format: 'object', subkeys: [{ sign: true }] }); const { privateKey: signingKey } = await openpgp.generateKey({ userIDs: { name: 'purple' }, format: 'object', subkeys: [{ sign: true }] });
const signingKeySignature = await signingKey.getSubkeys()[0].verify(); const signingKeySignature = await signingKey.getSubkeys()[0].verify();
expect(signingKeySignature instanceof openpgp.SignaturePacket).to.be.true; expect(signingKeySignature instanceof openpgp.SignaturePacket).to.be.true;
expect(signingKeySignature.keyFlags[0] & openpgp.enums.keyFlags.signData).to.be.equals(openpgp.enums.keyFlags.signData); expect(signingKeySignature.keyFlags[0] & openpgp.enums.keyFlags.signData).to.be.equals(openpgp.enums.keyFlags.signData);

24
test/general/openpgp.js
View File

@ -2272,7 +2272,7 @@ aOU=
try { try {
openpgp.config.rejectPublicKeyAlgorithms = new Set(); openpgp.config.rejectPublicKeyAlgorithms = new Set();
const plaintext = "  \t┍ͤ޵၂༫዇◧˘˻ᙑ᎚⏴ំந⛑nٓኵΉⅶ⋋ŵ⋲΂ͽᣏ₅ᄶɼ┋⌔û᬴Ƚᔡᧅ≃ṱἆ⃷݂૿ӌ᰹෇ٹჵ⛇໶⛌  \t\n한국어/조선말"; const plaintext = '  \t┍ͤ޵၂༫዇◧˘˻ᙑ᎚⏴ំந⛑nٓኵΉⅶ⋋ŵ⋲΂ͽᣏ₅ᄶɼ┋⌔û᬴Ƚᔡᧅ≃ṱἆ⃷݂૿ӌ᰹෇ٹჵ⛇໶⛌  \t\n한국어/조선말';
const privKeyDE = await openpgp.decryptKey({ const privKeyDE = await openpgp.decryptKey({
privateKey: await openpgp.readKey({ armoredKey: priv_key_de }), privateKey: await openpgp.readKey({ armoredKey: priv_key_de }),
@ -2500,7 +2500,7 @@ aOU=
badSumEncrypted = data.replace(/\n=[a-zA-Z0-9/+]{4}/, '\n=bbbb'); badSumEncrypted = data.replace(/\n=[a-zA-Z0-9/+]{4}/, '\n=bbbb');
} }
if (badSumEncrypted === data) { if (badSumEncrypted === data) {
throw new Error("Was not able to successfully modify checksum"); throw new Error('Was not able to successfully modify checksum');
} }
const badBodyEncrypted = data.replace(/\n=([a-zA-Z0-9/+]{4})/, 'aaa\n=$1'); const badBodyEncrypted = data.replace(/\n=([a-zA-Z0-9/+]{4})/, 'aaa\n=$1');
await stream.loadStreamsPonyfill(); await stream.loadStreamsPonyfill();
@ -2602,7 +2602,7 @@ aOU=
}); });
}); });
describe("3DES decrypt", function() { describe('3DES decrypt', function() {
const pgp_msg = [ const pgp_msg = [
'-----BEGIN PGP MESSAGE-----', '-----BEGIN PGP MESSAGE-----',
'Version: GnuPG/MacGPG2 v2.0.19 (Darwin)', 'Version: GnuPG/MacGPG2 v2.0.19 (Darwin)',
@ -3599,14 +3599,14 @@ bsZgJWVlAa5eil6J9ePX2xbo1vVAkLQdzE9+1jL+l7PRIZuVBQ==
describe('Specific encryption/signing key testing', async function () { describe('Specific encryption/signing key testing', async function () {
const encryptionKeyIDs = [ const encryptionKeyIDs = [
keyIDType.fromID("87EAE0977B2185EA"), keyIDType.fromID('87EAE0977B2185EA'),
keyIDType.fromID("F94F9B34AF93FA14"), keyIDType.fromID('F94F9B34AF93FA14'),
keyIDType.fromID("08F7D4C7C59545C0") keyIDType.fromID('08F7D4C7C59545C0')
]; ];
const signingKeyIDs = [ const signingKeyIDs = [
keyIDType.fromID("663277AF60400638"), keyIDType.fromID('663277AF60400638'),
keyIDType.fromID("BBE14491E6EE6366"), keyIDType.fromID('BBE14491E6EE6366'),
keyIDType.fromID("3E0F20F1A71D6DFD") keyIDType.fromID('3E0F20F1A71D6DFD')
]; ];
const getPrimaryKey = async () => openpgp.readKey({ const getPrimaryKey = async () => openpgp.readKey({
armoredKey: multipleEncryptionAndSigningSubkeys armoredKey: multipleEncryptionAndSigningSubkeys
@ -3619,7 +3619,7 @@ bsZgJWVlAa5eil6J9ePX2xbo1vVAkLQdzE9+1jL+l7PRIZuVBQ==
for (let i = 0; i < encryptionKeyIDs.length; i++) { for (let i = 0; i < encryptionKeyIDs.length; i++) {
m = await openpgp.readMessage({ m = await openpgp.readMessage({
armoredMessage: await openpgp.encrypt({ armoredMessage: await openpgp.encrypt({
message: await openpgp.createMessage({ text: "Hello World\n" }), message: await openpgp.createMessage({ text: 'Hello World\n' }),
encryptionKeys: primaryKey, encryptionKeys: primaryKey,
encryptionKeyIDs: [encryptionKeyIDs[i]] encryptionKeyIDs: [encryptionKeyIDs[i]]
}) })
@ -3637,7 +3637,7 @@ bsZgJWVlAa5eil6J9ePX2xbo1vVAkLQdzE9+1jL+l7PRIZuVBQ==
for (let i = 0; i < signingKeyIDs.length; i++) { for (let i = 0; i < signingKeyIDs.length; i++) {
s = await openpgp.readSignature({ s = await openpgp.readSignature({
armoredSignature: await openpgp.sign({ armoredSignature: await openpgp.sign({
message: await openpgp.createMessage({ text: "Hello World\n" }), message: await openpgp.createMessage({ text: 'Hello World\n' }),
signingKeys: primaryKey, signingKeys: primaryKey,
signingKeyIDs: [signingKeyIDs[i]], signingKeyIDs: [signingKeyIDs[i]],
detached: true detached: true
@ -3651,7 +3651,7 @@ bsZgJWVlAa5eil6J9ePX2xbo1vVAkLQdzE9+1jL+l7PRIZuVBQ==
it('Encrypt and sign with specific encryption/signing key ids', async function () { it('Encrypt and sign with specific encryption/signing key ids', async function () {
const primaryKey = await getPrimaryKey(); const primaryKey = await getPrimaryKey();
const plaintextMessage = await openpgp.createMessage({ text: "Hello World\n" }); const plaintextMessage = await openpgp.createMessage({ text: 'Hello World\n' });
const checkEncryptedPackets = (encryptionKeyIDs, pKESKList) => { const checkEncryptedPackets = (encryptionKeyIDs, pKESKList) => {
pKESKList.forEach(({ publicKeyID }, i) => { pKESKList.forEach(({ publicKeyID }, i) => {

26
test/general/packet.js
View File

@ -29,7 +29,7 @@ function stringify(array) {
return result.join(''); return result.join('');
} }
module.exports = () => describe("Packet", function() { module.exports = () => describe('Packet', function() {
const allAllowedPackets = util.constructAllowedPackets([...Object.values(openpgp).filter(packetClass => !!packetClass.tag)]); const allAllowedPackets = util.constructAllowedPackets([...Object.values(openpgp).filter(packetClass => !!packetClass.tag)]);
const armored_key = const armored_key =
@ -531,10 +531,10 @@ module.exports = () => describe("Packet", function() {
openpgp.config.aeadChunkSizeByte = 14; openpgp.config.aeadChunkSizeByte = 14;
openpgp.config.s2kIterationCountByte = 0x90; openpgp.config.s2kIterationCountByte = 0x90;
const salt = util.hexToUint8Array(`cd5a9f70fbe0bc65`); const salt = util.hexToUint8Array('cd5a9f70fbe0bc65');
const sessionKey = util.hexToUint8Array(`86 f1 ef b8 69 52 32 9f 24 ac d3 bf d0 e5 34 6d`.replace(/\s+/g, '')); const sessionKey = util.hexToUint8Array('86 f1 ef b8 69 52 32 9f 24 ac d3 bf d0 e5 34 6d'.replace(/\s+/g, ''));
const sessionIV = util.hexToUint8Array(`bc 66 9e 34 e5 00 dc ae dc 5b 32 aa 2d ab 02 35`.replace(/\s+/g, '')); const sessionIV = util.hexToUint8Array('bc 66 9e 34 e5 00 dc ae dc 5b 32 aa 2d ab 02 35'.replace(/\s+/g, ''));
const dataIV = util.hexToUint8Array(`b7 32 37 9f 73 c4 92 8d e2 5f ac fe 65 17 ec 10`.replace(/\s+/g, '')); const dataIV = util.hexToUint8Array('b7 32 37 9f 73 c4 92 8d e2 5f ac fe 65 17 ec 10'.replace(/\s+/g, ''));
const randomBytesStub = stub(nodeCrypto, 'randomBytes'); const randomBytesStub = stub(nodeCrypto, 'randomBytes');
randomBytesStub.onCall(0).returns(salt); randomBytesStub.onCall(0).returns(salt);
@ -608,10 +608,10 @@ module.exports = () => describe("Packet", function() {
openpgp.config.aeadChunkSizeByte = 14; openpgp.config.aeadChunkSizeByte = 14;
openpgp.config.s2kIterationCountByte = 0x90; openpgp.config.s2kIterationCountByte = 0x90;
const salt = util.hexToUint8Array(`9f0b7da3e5ea6477`); const salt = util.hexToUint8Array('9f0b7da3e5ea6477');
const sessionKey = util.hexToUint8Array(`d1 f0 1b a3 0e 13 0a a7 d2 58 2c 16 e0 50 ae 44`.replace(/\s+/g, '')); const sessionKey = util.hexToUint8Array('d1 f0 1b a3 0e 13 0a a7 d2 58 2c 16 e0 50 ae 44'.replace(/\s+/g, ''));
const sessionIV = util.hexToUint8Array(`99 e3 26 e5 40 0a 90 93 6c ef b4 e8 eb a0 8c`.replace(/\s+/g, '')); const sessionIV = util.hexToUint8Array('99 e3 26 e5 40 0a 90 93 6c ef b4 e8 eb a0 8c'.replace(/\s+/g, ''));
const dataIV = util.hexToUint8Array(`5e d2 bc 1e 47 0a be 8f 1d 64 4c 7a 6c 8a 56`.replace(/\s+/g, '')); const dataIV = util.hexToUint8Array('5e d2 bc 1e 47 0a be 8f 1d 64 4c 7a 6c 8a 56'.replace(/\s+/g, ''));
const randomBytesStub = stub(nodeCrypto, 'randomBytes'); const randomBytesStub = stub(nodeCrypto, 'randomBytes');
randomBytesStub.onCall(0).returns(salt); randomBytesStub.onCall(0).returns(salt);
@ -840,7 +840,7 @@ V+HOQJQxXJkVRYa3QrFUehiMzTeqqMdgC6ZqJy7+
const secretKeyPacket = new openpgp.SecretKeyPacket(); const secretKeyPacket = new openpgp.SecretKeyPacket();
secretKeyPacket.privateParams = privateParams; secretKeyPacket.privateParams = privateParams;
secretKeyPacket.publicParams = publicParams; secretKeyPacket.publicParams = publicParams;
secretKeyPacket.algorithm = "rsaSign"; secretKeyPacket.algorithm = 'rsaSign';
secretKeyPacket.isEncrypted = false; secretKeyPacket.isEncrypted = false;
await secretKeyPacket.encrypt('hello', { ...openpgp.config, aeadProtect: true }); await secretKeyPacket.encrypt('hello', { ...openpgp.config, aeadProtect: true });
expect(secretKeyPacket.s2kUsage).to.equal(253); expect(secretKeyPacket.s2kUsage).to.equal(253);
@ -864,7 +864,7 @@ V+HOQJQxXJkVRYa3QrFUehiMzTeqqMdgC6ZqJy7+
packet.privateParams = { key: new Uint8Array([1, 2, 3]) }; packet.privateParams = { key: new Uint8Array([1, 2, 3]) };
packet.publicParams = { pubKey: new Uint8Array([4, 5, 6]) }; packet.publicParams = { pubKey: new Uint8Array([4, 5, 6]) };
packet.algorithm = "rsaSign"; packet.algorithm = 'rsaSign';
packet.isEncrypted = false; packet.isEncrypted = false;
packet.s2kUsage = 0; packet.s2kUsage = 0;
@ -896,7 +896,7 @@ V+HOQJQxXJkVRYa3QrFUehiMzTeqqMdgC6ZqJy7+
const secretKeyPacket = new openpgp.SecretKeyPacket(); const secretKeyPacket = new openpgp.SecretKeyPacket();
secretKeyPacket.privateParams = privateParams; secretKeyPacket.privateParams = privateParams;
secretKeyPacket.publicParams = publicParams; secretKeyPacket.publicParams = publicParams;
secretKeyPacket.algorithm = "rsaSign"; secretKeyPacket.algorithm = 'rsaSign';
secretKeyPacket.isEncrypted = false; secretKeyPacket.isEncrypted = false;
await secretKeyPacket.encrypt('hello', { ...openpgp.config, aeadProtect: false }); await secretKeyPacket.encrypt('hello', { ...openpgp.config, aeadProtect: false });
expect(secretKeyPacket.s2kUsage).to.equal(254); expect(secretKeyPacket.s2kUsage).to.equal(254);
@ -917,7 +917,7 @@ V+HOQJQxXJkVRYa3QrFUehiMzTeqqMdgC6ZqJy7+
key.publicParams = publicParams; key.publicParams = publicParams;
key.privateParams = privateParams; key.privateParams = privateParams;
key.algorithm = "rsaSign"; key.algorithm = 'rsaSign';
await key.computeFingerprintAndKeyID(); await key.computeFingerprintAndKeyID();
const signed = new openpgp.PacketList(); const signed = new openpgp.PacketList();

12
test/general/signature.js
View File

@ -11,7 +11,7 @@ chai.use(require('chai-as-promised'));
const expect = chai.expect; const expect = chai.expect;
module.exports = () => describe("Signature", function() { module.exports = () => describe('Signature', function() {
const priv_key_arm1 = const priv_key_arm1 =
['-----BEGIN PGP PRIVATE KEY BLOCK-----', ['-----BEGIN PGP PRIVATE KEY BLOCK-----',
'Version: GnuPG v1.4.11 (GNU/Linux)', 'Version: GnuPG v1.4.11 (GNU/Linux)',
@ -39,7 +39,7 @@ module.exports = () => describe("Signature", function() {
'AgAJBQJREZ6zAhsMAAoJEBEnlAPLFp74QbMAn3V4857xwnO9/+vzIVnL93W3k0/8', 'AgAJBQJREZ6zAhsMAAoJEBEnlAPLFp74QbMAn3V4857xwnO9/+vzIVnL93W3k0/8',
'AKC8omYPPomN1E/UJFfXdLDIMi5LoA==', 'AKC8omYPPomN1E/UJFfXdLDIMi5LoA==',
'=LSrW', '=LSrW',
'-----END PGP PRIVATE KEY BLOCK-----'].join("\n"); '-----END PGP PRIVATE KEY BLOCK-----'].join('\n');
const pub_key_arm1 = const pub_key_arm1 =
['-----BEGIN PGP PUBLIC KEY BLOCK-----', ['-----BEGIN PGP PUBLIC KEY BLOCK-----',
@ -58,7 +58,7 @@ module.exports = () => describe("Signature", function() {
'HgECF4AACgkQikDlZK/UvLSspgCfcNaOpTg1W2ucR1JwBbBGvaERfuMAnRgt3/rs', 'HgECF4AACgkQikDlZK/UvLSspgCfcNaOpTg1W2ucR1JwBbBGvaERfuMAnRgt3/rs',
'EplqEakMckCtikEnpxYe', 'EplqEakMckCtikEnpxYe',
'=b2Ln', '=b2Ln',
'-----END PGP PUBLIC KEY BLOCK-----'].join("\n"); '-----END PGP PUBLIC KEY BLOCK-----'].join('\n');
const msg_arm1 = const msg_arm1 =
['-----BEGIN PGP MESSAGE-----', ['-----BEGIN PGP MESSAGE-----',
@ -75,7 +75,7 @@ module.exports = () => describe("Signature", function() {
'0Dqnp0yfefrkjQ0nuvubgB6Rv89mHpnvuJfFJRInpg4lrHwLvRwdpN2HDozFHcKK', '0Dqnp0yfefrkjQ0nuvubgB6Rv89mHpnvuJfFJRInpg4lrHwLvRwdpN2HDozFHcKK',
'aOU=', 'aOU=',
'=4iGt', '=4iGt',
'-----END PGP MESSAGE-----'].join("\n"); '-----END PGP MESSAGE-----'].join('\n');
const priv_key_arm2 = const priv_key_arm2 =
['-----BEGIN PGP PRIVATE KEY BLOCK-----', ['-----BEGIN PGP PRIVATE KEY BLOCK-----',
@ -693,13 +693,13 @@ hUhMKMuiM3pRwdIyDOItkUWQmjEEw7/XmhgInkXsCw==
-----END PGP SIGNATURE----- -----END PGP SIGNATURE-----
`; `;
it("Retrieve the issuer Key ID of a signature", async function () { it('Retrieve the issuer Key ID of a signature', async function () {
const publicKey = await openpgp.readKey({ armoredKey: pub_key_arm2 }); const publicKey = await openpgp.readKey({ armoredKey: pub_key_arm2 });
const privateKey = await openpgp.decryptKey({ const privateKey = await openpgp.decryptKey({
privateKey: await openpgp.readKey({ armoredKey: priv_key_arm2 }), privateKey: await openpgp.readKey({ armoredKey: priv_key_arm2 }),
passphrase: 'hello world' passphrase: 'hello world'
}); });
const message = await openpgp.createMessage({ text: "test" }); const message = await openpgp.createMessage({ text: 'test' });
const armoredSignature = await openpgp.sign({ const armoredSignature = await openpgp.sign({
message, message,
signingKeys: privateKey, signingKeys: privateKey,

2
test/general/util.js
View File

@ -141,7 +141,7 @@ module.exports = () => describe('Util unit tests', function() {
}); });
}); });
describe("Misc.", function() { describe('Misc.', function() {
it('util.readNumber should not overflow until full range of uint32', function () { it('util.readNumber should not overflow until full range of uint32', function () {
const ints = [2 ** 20, 2 ** 25, 2 ** 30, 2 ** 32 - 1]; const ints = [2 ** 20, 2 ** 25, 2 ** 30, 2 ** 32 - 1];
for (let i = 0; i < ints.length; i++) { for (let i = 0; i < ints.length; i++) {

8
test/general/x25519.js
View File

@ -381,8 +381,8 @@ module.exports = () => (openpgp.config.ci ? describe.skip : describe)('X25519 Cr
function omnibus() { function omnibus() {
it('Omnibus Ed25519/Curve25519 Test', function() { it('Omnibus Ed25519/Curve25519 Test', function() {
const options = { const options = {
userIDs: { name: "Hi", email: "hi@hel.lo" }, userIDs: { name: 'Hi', email: 'hi@hel.lo' },
curve: "ed25519", curve: 'ed25519',
format: 'object' format: 'object'
}; };
return openpgp.generateKey(options).then(async function({ privateKey, publicKey }) { return openpgp.generateKey(options).then(async function({ privateKey, publicKey }) {
@ -409,8 +409,8 @@ function omnibus() {
await user.verifyCertificate(certificate, [hi.toPublic()], undefined, openpgp.config); await user.verifyCertificate(certificate, [hi.toPublic()], undefined, openpgp.config);
const options = { const options = {
userIDs: { name: "Bye", email: "bye@good.bye" }, userIDs: { name: 'Bye', email: 'bye@good.bye' },
curve: "curve25519", curve: 'curve25519',
format: 'object' format: 'object'
}; };

2
test/security/message_signature_bypass.js
View File

@ -74,7 +74,7 @@ async function getOtherPubKey() {
/** /**
* The "standalone" signature signed by the victim. * The "standalone" signature signed by the victim.
*/ */
const STANDALONE_PKT = util.hexToUint8Array(`04020108001005025bab730a091055208b2d18ace3ce000059da0800b823eceba1bae016afa584bc67ef931dde167fe683bea58761dac31abaaf223afa4cd41fe609b06f7809f2e01ae8792e08591419e591d652d7580af3b7cdfa27e63dd4838fc7ec2aa485757d6c1c6c33bf305cb8fb7eaa1b47ac00825b08a20606a320e988733294957e03012064b61c74a3d41bfebddd4fdd739ab9e220ae48d32a9edf8ff5aec1e13807fc76cd84b9bba914926a14e6f5aacb0c584fa306b4d11280ff107e6aeee9f68c419c7084dc5504990aa7e31d3e042fa745fdb9ae8207fbc15fc440b5df148252e9c65cccaf3a5d6d6919a5c12912ef41761afde4561ca70696bba37452b32584684fa2d50e4f138e101f13dab6125aa5680bd9658c`); const STANDALONE_PKT = util.hexToUint8Array('04020108001005025bab730a091055208b2d18ace3ce000059da0800b823eceba1bae016afa584bc67ef931dde167fe683bea58761dac31abaaf223afa4cd41fe609b06f7809f2e01ae8792e08591419e591d652d7580af3b7cdfa27e63dd4838fc7ec2aa485757d6c1c6c33bf305cb8fb7eaa1b47ac00825b08a20606a320e988733294957e03012064b61c74a3d41bfebddd4fdd739ab9e220ae48d32a9edf8ff5aec1e13807fc76cd84b9bba914926a14e6f5aacb0c584fa306b4d11280ff107e6aeee9f68c419c7084dc5504990aa7e31d3e042fa745fdb9ae8207fbc15fc440b5df148252e9c65cccaf3a5d6d6919a5c12912ef41761afde4561ca70696bba37452b32584684fa2d50e4f138e101f13dab6125aa5680bd9658c');
async function fakeSignature() { async function fakeSignature() {
// read the template and modify the text to // read the template and modify the text to
// invalidate the signature. // invalidate the signature.