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

Don't unnecessarily return objects in top-level functions

Browse Source 
openpgp.encrypt, sign, encryptSessionKey, encryptKey and decryptKey now
return their result directly without wrapping it in a "result" object.

Also, remove the `detached` and `returnSessionKey` options of
openpgp.encrypt.
This commit is contained in:
Daniel Huigens 2020-02-18 15:02:56 +01:00
parent be7b174df4
commit ef7c38860b
16 changed files with 375 additions and 534 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
README.md
View File

@ -162,12 +162,12 @@ Encryption will use the algorithm specified in config.encryption_cipher (default
```js
(async () => {
const { message } = await openpgp.encrypt({
const encrypted = await openpgp.encrypt({
message: openpgp.message.fromBinary(new Uint8Array([0x01, 0x01, 0x01])), // input as Message object
passwords: ['secret stuff'], // multiple passwords possible
armor: false // don't ASCII armor (for Uint8Array output)
});
const encrypted = message.packets.write(); // get raw encrypted packets as Uint8Array
console.log(encrypted); // Uint8Array
const { data: decrypted } = await openpgp.decrypt({
message: await openpgp.message.read(encrypted), // parse encrypted bytes
@ -200,7 +200,7 @@ const openpgp = require('openpgp'); // use as CommonJS, AMD, ES6 module or via w
const { keys: [privateKey] } = await openpgp.key.readArmored(privateKeyArmored);
await privateKey.decrypt(passphrase);
const { data: encrypted } = await openpgp.encrypt({
const encrypted = await openpgp.encrypt({
message: openpgp.message.fromText('Hello, World!'), // input as Message object
publicKeys: (await openpgp.key.readArmored(publicKeyArmored)).keys, // for encryption
privateKeys: [privateKey] // for signing (optional)
@ -240,7 +240,7 @@ Encrypt with multiple public keys:
return (await openpgp.key.readArmored(key)).keys[0];
}));
const { data: encrypted } = await openpgp.encrypt({
const encrypted = await openpgp.encrypt({
message: openpgp.message.fromText(message), // input as Message object
publicKeys, // for encryption
privateKeys: [privateKey] // for signing (optional)
@ -343,14 +343,15 @@ its [Reader class](https://openpgpjs.org/web-stream-tools/Reader.html).
publicKeys: (await openpgp.key.readArmored(publicKeyArmored)).keys, // for encryption
privateKeys: [privateKey] // for signing (optional)
});
const ciphertext = encrypted.data; // ReadableStream containing '-----BEGIN PGP MESSAGE ... END PGP MESSAGE-----'
console.log(encrypted); // ReadableStream containing '-----BEGIN PGP MESSAGE ... END PGP MESSAGE-----'
const decrypted = await openpgp.decrypt({
message: await openpgp.message.readArmored(ciphertext), // parse armored message
message: await openpgp.message.readArmored(encrypted), // parse armored message
publicKeys: (await openpgp.key.readArmored(publicKeyArmored)).keys, // for verification (optional)
privateKeys: [privateKey] // for decryption
});
const plaintext = await openpgp.stream.readToEnd(decrypted.data); // 'Hello, World!'
const plaintext = await openpgp.stream.readToEnd(decrypted.data);
console.log(plaintext); // 'Hello, World!'
})();
```
@ -454,7 +455,7 @@ Using the private key:
const { keys: [privateKey] } = await openpgp.key.readArmored(privateKeyArmored);
await privateKey.decrypt(passphrase);
const { data: cleartext } = await openpgp.sign({
const cleartext = await openpgp.sign({
message: openpgp.cleartext.fromText('Hello, World!'), // CleartextMessage or Message object
privateKeys: [privateKey] // for signing
});
@ -531,7 +532,7 @@ Using the private key:
const { keys: [privateKey] } = await openpgp.key.readArmored(privateKeyArmored);
await privateKey.decrypt(passphrase);
const { data: signatureArmored } = await openpgp.sign({
const signatureArmored = await openpgp.sign({
message: openpgp.message.fromBinary(readableStream), // or .fromText(readableStream: ReadableStream<String>)
privateKeys: [privateKey] // for signing
});

9
src/message.js
View File

@ -337,14 +337,7 @@ Message.prototype.encrypt = async function(keys, passwords, sessionKey, wildcard
msg.packets.push(symEncryptedPacket);
symEncryptedPacket.packets = new packet.List(); // remove packets after encryption
return {
message: msg,
sessionKey: {
data: sessionKey,
algorithm: symAlgo,
aeadAlgorithm: aeadAlgo
}
};
return msg;
};
/**

87
src/openpgp.js
View File

@ -253,9 +253,7 @@ export function decryptKey({ privateKey, passphrase }) {
return Promise.resolve().then(async function() {
await privateKey.decrypt(passphrase);
return {
key: privateKey
};
return privateKey;
}).catch(onError.bind(null, 'Error decrypting private key'));
}
@ -274,9 +272,7 @@ export function encryptKey({ privateKey, passphrase }) {
return Promise.resolve().then(async function() {
await privateKey.encrypt(passphrase);
return {
key: privateKey
};
return privateKey;
}).catch(onError.bind(null, 'Error decrypting private key'));
}
@ -299,53 +295,35 @@ export function encryptKey({ privateKey, passphrase }) {
* @param {module:enums.compression} compression (optional) which compression algorithm to compress the message with, defaults to what is specified in config
* @param {Boolean} armor (optional) whether the return values should be ascii armored (true, the default) or binary (false)
* @param {'web'|'ponyfill'|'node'|false} streaming (optional) whether to return data as a stream. Defaults to the type of stream `message` was created from, if any.
* @param {Boolean} detached (optional) if the signature should be detached (if true, signature will be added to returned object)
* @param {Signature} signature (optional) a detached signature to add to the encrypted message
* @param {Boolean} returnSessionKey (optional) if the unencrypted session key should be added to returned object
* @param {Boolean} wildcard (optional) use a key ID of 0 instead of the public key IDs
* @param {Date} date (optional) override the creation date of the message signature
* @param {Array} fromUserIds (optional) array of user IDs to sign with, one per key in `privateKeys`, e.g. [{ name:'Steve Sender', email:'steve@openpgp.org' }]
* @param {Array} toUserIds (optional) array of user IDs to encrypt for, one per key in `publicKeys`, e.g. [{ name:'Robert Receiver', email:'robert@openpgp.org' }]
* @returns {Promise<Object>} Object containing encrypted (and optionally signed) message in the form:
*
* {
* data: String|ReadableStream<String>|NodeStream, (if `armor` was true, the default)
* data: Uint8Array|ReadableStream<Uint8Array>|NodeStream, (if `armor` was false)
* signature: String|ReadableStream<String>|NodeStream, (if `detached` was true and `armor` was true)
* signature: Uint8Array|ReadableStream<Uint8Array>|NodeStream (if `detached` was true and `armor` was false)
* sessionKey: { data, algorithm, aeadAlgorithm } (if `returnSessionKey` was true)
* }
* @returns {Promise<String|ReadableStream<String>|NodeStream<String>|Uint8Array|ReadableStream<Uint8Array>|NodeStream<Uint8Array>>} (String if `armor` was true, the default; Uint8Array if `armor` was false)
* @async
* @static
*/
export function encrypt({ message, publicKeys, privateKeys, passwords, sessionKey, compression = config.compression, armor = true, streaming = message && message.fromStream, detached = false, signature = null, returnSessionKey = false, wildcard = false, date = new Date(), fromUserIds = [], toUserIds = [] }) {
export function encrypt({ message, publicKeys, privateKeys, passwords, sessionKey, compression = config.compression, armor = true, streaming = message && message.fromStream, detached = false, signature = null, wildcard = false, date = new Date(), fromUserIds = [], toUserIds = [] }) {
checkMessage(message); publicKeys = toArray(publicKeys); privateKeys = toArray(privateKeys); passwords = toArray(passwords); fromUserIds = toArray(fromUserIds); toUserIds = toArray(toUserIds);
if (detached) {
throw new Error("detached option has been removed from openpgp.encrypt. Separately call openpgp.sign instead. Don't forget to remove privateKeys option as well.");
}
if (!nativeAEAD() && asyncProxy) { // use web worker if web crypto apis are not supported
return asyncProxy.delegate('encrypt', { message, publicKeys, privateKeys, passwords, sessionKey, compression, armor, streaming, detached, signature, returnSessionKey, wildcard, date, fromUserIds, toUserIds });
return asyncProxy.delegate('encrypt', { message, publicKeys, privateKeys, passwords, sessionKey, compression, armor, streaming, detached, signature, wildcard, date, fromUserIds, toUserIds });
}
const result = {};
return Promise.resolve().then(async function() {
if (!privateKeys) {
privateKeys = [];
}
if (privateKeys.length || signature) { // sign the message only if private keys or signature is specified
if (detached) {
const detachedSignature = await message.signDetached(privateKeys, signature, date, fromUserIds, message.fromStream);
result.signature = armor ? detachedSignature.armor() : detachedSignature.write();
} else {
message = await message.sign(privateKeys, signature, date, fromUserIds, message.fromStream);
}
message = await message.sign(privateKeys, signature, date, fromUserIds, message.fromStream);
}
message = message.compress(compression);
return message.encrypt(publicKeys, passwords, sessionKey, wildcard, date, toUserIds, streaming);
}).then(async encrypted => {
result.data = armor ? encrypted.message.armor() : encrypted.message.write();
if (returnSessionKey) {
result.sessionKey = encrypted.sessionKey;
}
return convertStreams(result, streaming, armor ? 'utf8' : 'binary', ['signature', 'data']);
message = await message.encrypt(publicKeys, passwords, sessionKey, wildcard, date, toUserIds, streaming);
const data = armor ? message.armor() : message.write();
return convertStream(data, streaming, armor ? 'utf8' : 'binary');
}).catch(onError.bind(null, 'Error encrypting message'));
}
@ -410,7 +388,7 @@ export function decrypt({ message, privateKeys, passwords, sessionKeys, publicKe
/**
* Signs a cleartext message.
* Signs a message.
* @param {CleartextMessage|Message} message (cleartext) message to be signed
* @param {Key|Array<Key>} privateKeys array of keys or single key with decrypted secret key data to sign cleartext
* @param {Boolean} armor (optional) whether the return values should be ascii armored (true, the default) or binary (false)
@ -418,19 +396,7 @@ export function decrypt({ message, privateKeys, passwords, sessionKeys, publicKe
* @param {Boolean} detached (optional) if the return value should contain a detached signature
* @param {Date} date (optional) override the creation date of the signature
* @param {Array} fromUserIds (optional) array of user IDs to sign with, one per key in `privateKeys`, e.g. [{ name:'Steve Sender', email:'steve@openpgp.org' }]
* @returns {Promise<Object>} Object containing signed message in the form:
*
* {
* data: String|ReadableStream<String>|NodeStream, (if `armor` was true, the default)
* data: Uint8Array|ReadableStream<Uint8Array>|NodeStream (if `armor` was false)
* }
*
* Or, if `detached` was true:
*
* {
* signature: String|ReadableStream<String>|NodeStream, (if `armor` was true, the default)
* signature: Uint8Array|ReadableStream<Uint8Array>|NodeStream (if `armor` was false)
* }
* @returns {Promise<String|ReadableStream<String>|NodeStream<String>|Uint8Array|ReadableStream<Uint8Array>|NodeStream<Uint8Array>>} (String if `armor` was true, the default; Uint8Array if `armor` was false)
* @async
* @static
*/
@ -445,22 +411,23 @@ export function sign({ message, privateKeys, armor = true, streaming = message &
});
}
const result = {};
return Promise.resolve().then(async function() {
let signature;
if (detached) {
const signature = await message.signDetached(privateKeys, undefined, date, fromUserIds, message.fromStream);
result.signature = armor ? signature.armor() : signature.write();
result.signature = stream.transformPair(message.packets.write(), async (readable, writable) => {
signature = await message.signDetached(privateKeys, undefined, date, fromUserIds, message.fromStream);
} else {
signature = await message.sign(privateKeys, undefined, date, fromUserIds, message.fromStream);
}
signature = armor ? signature.armor() : signature.write();
if (detached) {
signature = stream.transformPair(message.packets.write(), async (readable, writable) => {
await Promise.all([
stream.pipe(result.signature, writable),
stream.pipe(signature, writable),
stream.readToEnd(readable).catch(() => {})
]);
});
} else {
message = await message.sign(privateKeys, undefined, date, fromUserIds, message.fromStream);
result.data = armor ? message.armor() : message.write();
}
return convertStreams(result, streaming, armor ? 'utf8' : 'binary', ['signature', 'data']);
return convertStream(signature, streaming, armor ? 'utf8' : 'binary');
}).catch(onError.bind(null, 'Error signing message'));
}
@ -553,7 +520,7 @@ export function generateSessionKey({ publicKeys, date = new Date(), toUserIds =
* @param {Boolean} wildcard (optional) use a key ID of 0 instead of the public key IDs
* @param {Date} date (optional) override the date
* @param {Array} toUserIds (optional) array of user IDs to encrypt for, one per key in `publicKeys`, e.g. [{ name:'Phil Zimmermann', email:'phil@openpgp.org' }]
* @returns {Promise<Message>} the encrypted session key packets contained in a message object
* @returns {Promise<String|Uint8Array>} (String if `armor` was true, the default; Uint8Array if `armor` was false)
* @async
* @static
*/
@ -567,9 +534,7 @@ export function encryptSessionKey({ data, algorithm, aeadAlgorithm, publicKeys,
return Promise.resolve().then(async function() {
const message = await messageLib.encryptSessionKey(data, algorithm, aeadAlgorithm, publicKeys, passwords, wildcard, date, toUserIds);
const result = {};
result.data = armor ? message.armor() : message.write();
return result;
return armor ? message.armor() : message.write();
}).catch(onError.bind(null, 'Error encrypting session key'));
}

55
src/util.js
View File

@ -114,36 +114,35 @@ export default {
* @returns {Object}
*/
restoreStreams: function(obj, streaming) {
if (Object.prototype.toString.call(obj) === '[object MessagePort]') {
return new (streaming === 'web' ? global.ReadableStream : stream.ReadableStream)({
pull(controller) {
return new Promise(resolve => {
obj.onmessage = evt => {
const { done, value, error } = evt.data;
if (error) {
controller.error(new Error(error));
} else if (!done) {
controller.enqueue(value);
} else {
controller.close();
}
resolve();
};
obj.postMessage({ action: 'read' });
});
},
cancel() {
return new Promise(resolve => {
obj.onmessage = resolve;
obj.postMessage({ action: 'cancel' });
});
}
}, { highWaterMark: 0 });
}
if (Object.prototype.isPrototypeOf(obj) && !Uint8Array.prototype.isPrototypeOf(obj)) {
Object.entries(obj).forEach(([key, value]) => { // recursively search all children
if (Object.prototype.toString.call(value) === '[object MessagePort]') {
obj[key] = new (streaming === 'web' ? global.ReadableStream : stream.ReadableStream)({
pull(controller) {
return new Promise(resolve => {
value.onmessage = evt => {
const { done, value, error } = evt.data;
if (error) {
controller.error(new Error(error));
} else if (!done) {
controller.enqueue(value);
} else {
controller.close();
}
resolve();
};
value.postMessage({ action: 'read' });
});
},
cancel() {
return new Promise(resolve => {
value.onmessage = resolve;
value.postMessage({ action: 'cancel' });
});
}
}, { highWaterMark: 0 });
return;
}
util.restoreStreams(value, streaming);
obj[key] = util.restoreStreams(value, streaming);
});
}
return obj;

4
src/worker/async_proxy.js
View File

@ -178,8 +178,10 @@ AsyncProxy.prototype.delegate = function(method, options) {
}
return new Promise((resolve, reject) => {
const data = { id, event: method, options: packet.clone.clonePackets(options) };
const transferables = util.getTransferables(data, config.zero_copy);
// clone packets (for web worker structured cloning algorithm)
this.workers[workerId].postMessage({ id:id, event:method, options:packet.clone.clonePackets(options) }, util.getTransferables(options, config.zero_copy));
this.workers[workerId].postMessage(data, transferables);
this.workers[workerId].requests++;
// remember to handle parsing cloned packets from worker

10
test/general/brainpool.js
View File

@ -216,7 +216,7 @@ EJ4QcD/oQ6x1M/8X/iKQCtxZP8RnlrbH7ExkNON5s5g=
const romeoPrivate = await load_priv_key('romeo');
const signed = await openpgp.sign({privateKeys: [romeoPrivate], message: openpgp.cleartext.fromText(data.romeo.message)});
const romeoPublic = await load_pub_key('romeo');
const msg = await openpgp.cleartext.readArmored(signed.data);
const msg = await openpgp.cleartext.readArmored(signed);
const result = await openpgp.verify({publicKeys: [romeoPublic], message: msg});
expect(result).to.exist;
@ -266,7 +266,7 @@ EJ4QcD/oQ6x1M/8X/iKQCtxZP8RnlrbH7ExkNON5s5g=
const julietPublic = await load_pub_key('juliet');
const encrypted = await openpgp.encrypt({publicKeys: [julietPublic], privateKeys: [romeoPrivate], message: openpgp.message.fromText(data.romeo.message)});
const message = await openpgp.message.readArmored(encrypted.data);
const message = await openpgp.message.readArmored(encrypted);
const romeoPublic = await load_pub_key('romeo');
const julietPrivate = await load_priv_key('juliet');
const result = await openpgp.decrypt({privateKeys: julietPrivate, publicKeys: [romeoPublic], message: message});
@ -297,7 +297,7 @@ function omnibus() {
openpgp.sign(
{ message: openpgp.cleartext.fromText(testData), privateKeys: hi }
).then(async signed => {
const msg = await openpgp.cleartext.readArmored(signed.data);
const msg = await openpgp.cleartext.readArmored(signed);
// Verifying signed message
return Promise.all([
openpgp.verify(
@ -308,7 +308,7 @@ function omnibus() {
{
message: openpgp.cleartext.fromText(testData),
publicKeys: pubHi,
signature: await openpgp.signature.readArmored(signed.data)
signature: await openpgp.signature.readArmored(signed)
}
).then(output => expect(output.signatures[0].valid).to.be.true)
]);
@ -321,7 +321,7 @@ function omnibus() {
privateKeys: [hi]
}
).then(async encrypted => {
const msg = await openpgp.message.readArmored(encrypted.data);
const msg = await openpgp.message.readArmored(encrypted);
// Decrypting and verifying
return openpgp.decrypt(
{

4
test/general/decompression.js
View File

@ -49,8 +49,8 @@ describe('Decrypt and decompress message tests', function () {
passwords: password,
message
};
return openpgp.decrypt(options).then(function (encrypted) {
expect(encrypted.data).to.equal(test.output + '\n');
return openpgp.decrypt(options).then(function (decrypted) {
expect(decrypted.data).to.equal(test.output + '\n');
});
});
}

10
test/general/ecc_nist.js
View File

@ -29,7 +29,7 @@ describe('Elliptic Curve Cryptography for NIST P-256,P-384,P-521 curves @lightwe
openpgp.sign(
{ message: openpgp.cleartext.fromText(testData), privateKeys: hi }
).then(async signed => {
const msg = await openpgp.cleartext.readArmored(signed.data);
const msg = await openpgp.cleartext.readArmored(signed);
// Verifying signed message
return Promise.all([
openpgp.verify(
@ -39,7 +39,7 @@ describe('Elliptic Curve Cryptography for NIST P-256,P-384,P-521 curves @lightwe
openpgp.verify(
{ message: openpgp.cleartext.fromText(testData),
publicKeys: pubHi,
signature: await openpgp.signature.readArmored(signed.data) }
signature: await openpgp.signature.readArmored(signed) }
).then(output => expect(output.signatures[0].valid).to.be.true)
]);
}),
@ -49,7 +49,7 @@ describe('Elliptic Curve Cryptography for NIST P-256,P-384,P-521 curves @lightwe
publicKeys: [pubBye],
privateKeys: [hi] }
).then(async encrypted => {
const msg = await openpgp.message.readArmored(encrypted.data);
const msg = await openpgp.message.readArmored(encrypted);
// Decrypting and verifying
return openpgp.decrypt(
{ message: msg,
@ -73,7 +73,7 @@ describe('Elliptic Curve Cryptography for NIST P-256,P-384,P-521 curves @lightwe
let options = { userIds: {name: "Hi", email: "hi@hel.lo"}, curve: "p256" };
const firstKey = await openpgp.generateKey(options);
const signature = await openpgp.sign({ message: openpgp.cleartext.fromText(testData), privateKeys: firstKey.key });
const msg = await openpgp.cleartext.readArmored(signature.data);
const msg = await openpgp.cleartext.readArmored(signature);
const result = await openpgp.verify({ message: msg, publicKeys: firstKey.key.toPublic()});
expect(result.signatures[0].valid).to.be.true;
});
@ -89,7 +89,7 @@ describe('Elliptic Curve Cryptography for NIST P-256,P-384,P-521 curves @lightwe
publicKeys: [secondKey.key.toPublic()],
privateKeys: [firstKey.key] }
);
const msg = await openpgp.message.readArmored(encrypted.data);
const msg = await openpgp.message.readArmored(encrypted);
const result = await openpgp.decrypt(
{ message: msg,
privateKeys: secondKey.key,

4
test/general/ecc_secp256k1.js
View File

@ -191,7 +191,7 @@ describe('Elliptic Curve Cryptography for secp256k1 curve @lightweight', functio
const romeoPrivate = await load_priv_key('romeo');
const signed = await openpgp.sign({privateKeys: [romeoPrivate], message: openpgp.cleartext.fromText(data.romeo.message)});
const romeoPublic = await load_pub_key('romeo');
const msg = await openpgp.cleartext.readArmored(signed.data);
const msg = await openpgp.cleartext.readArmored(signed);
const result = await openpgp.verify({publicKeys: [romeoPublic], message: msg});
expect(result).to.exist;
@ -215,7 +215,7 @@ describe('Elliptic Curve Cryptography for secp256k1 curve @lightweight', functio
const julietPublic = await load_pub_key('juliet');
const encrypted = await openpgp.encrypt({publicKeys: [julietPublic], privateKeys: [romeoPrivate], message: openpgp.message.fromText(data.romeo.message)});
const message = await openpgp.message.readArmored(encrypted.data);
const message = await openpgp.message.readArmored(encrypted);
const romeoPublic = await load_pub_key('romeo');
const julietPrivate = await load_priv_key('juliet');
const result = await openpgp.decrypt({privateKeys: julietPrivate, publicKeys: [romeoPublic], message: message});

47
test/general/key.js
View File

@ -2055,7 +2055,7 @@ function versionSpecificTests() {
key = newKey.key;
return openpgp.message.fromText('hello').encrypt([key]);
}).then(function(msg) {
return msg.message.decrypt([key]);
return msg.decrypt([key]);
}).catch(function(err) {
expect(err.message).to.equal('Private key is not decrypted.');
});
@ -2419,7 +2419,7 @@ function versionSpecificTests() {
expect(newKey.isDecrypted()).to.be.true;
return openpgp.sign({message: openpgp.cleartext.fromText('hello'), privateKeys: newKey, armor: true}).then(async function(signed) {
return openpgp.verify(
{message: await openpgp.cleartext.readArmored(signed.data), publicKeys: newKey.toPublic()}
{message: await openpgp.cleartext.readArmored(signed), publicKeys: newKey.toPublic()}
).then(async function(verified) {
expect(verified.signatures[0].valid).to.be.true;
const newSigningKey = await newKey.getSigningKey();
@ -2464,7 +2464,7 @@ function versionSpecificTests() {
return openpgp.reformatKey(opt).then(function(newKey) {
newKey = newKey.key;
return openpgp.encrypt({message: openpgp.message.fromText('hello'), publicKeys: newKey.toPublic(), privateKeys: newKey, armor: true}).then(async function(encrypted) {
return openpgp.decrypt({message: await openpgp.message.readArmored(encrypted.data), privateKeys: newKey, publicKeys: newKey.toPublic()}).then(function(decrypted) {
return openpgp.decrypt({message: await openpgp.message.readArmored(encrypted), privateKeys: newKey, publicKeys: newKey.toPublic()}).then(function(decrypted) {
expect(decrypted.data).to.equal('hello');
expect(decrypted.signatures[0].valid).to.be.true;
});
@ -3190,17 +3190,17 @@ VYGdb3eNlV8CfoEC
await expect(key.getPrimaryUser()).to.be.rejectedWith('Could not find valid self-signature in key 3ce893915c44212f');
});
it('Encrypt - latest created user', async function() {
it('Generate session key - latest created user', async function() {
let publicKey = (await openpgp.key.readArmored(multi_uid_key)).keys[0];
const privateKey = (await openpgp.key.readArmored(priv_key_rsa)).keys[0];
await privateKey.decrypt('hello world');
// Set second user to prefer aes128. We should select this user by default, since it was created later.
publicKey.users[1].selfCertifications[0].preferredSymmetricAlgorithms = [openpgp.enums.symmetric.aes128];
const encrypted = await openpgp.encrypt({message: openpgp.message.fromText('hello'), publicKeys: publicKey, privateKeys: privateKey, armor: false, returnSessionKey: true});
expect(encrypted.sessionKey.algorithm).to.equal('aes128');
const sessionKey = await openpgp.generateSessionKey({publicKeys: publicKey});
expect(sessionKey.algorithm).to.equal('aes128');
});
it('Encrypt - primary user', async function() {
it('Generate session key - primary user', async function() {
let publicKey = (await openpgp.key.readArmored(multi_uid_key)).keys[0];
const privateKey = (await openpgp.key.readArmored(priv_key_rsa)).keys[0];
await privateKey.decrypt('hello world');
@ -3208,11 +3208,11 @@ VYGdb3eNlV8CfoEC
publicKey.users[0].selfCertifications[0].isPrimaryUserID = true;
// Set first user to prefer aes128.
publicKey.users[0].selfCertifications[0].preferredSymmetricAlgorithms = [openpgp.enums.symmetric.aes128];
const encrypted = await openpgp.encrypt({message: openpgp.message.fromText('hello'), publicKeys: publicKey, privateKeys: privateKey, armor: false, returnSessionKey: true});
expect(encrypted.sessionKey.algorithm).to.equal('aes128');
const sessionKey = await openpgp.generateSessionKey({publicKeys: publicKey});
expect(sessionKey.algorithm).to.equal('aes128');
});
it('Encrypt - specific user', async function() {
it('Generate session key - specific user', async function() {
let publicKey = (await openpgp.key.readArmored(multi_uid_key)).keys[0];
const privateKey = (await openpgp.key.readArmored(priv_key_rsa)).keys[0];
await privateKey.decrypt('hello world');
@ -3220,8 +3220,9 @@ VYGdb3eNlV8CfoEC
publicKey.users[0].selfCertifications[0].isPrimaryUserID = true;
// Set second user to prefer aes128. We will select this user.
publicKey.users[1].selfCertifications[0].preferredSymmetricAlgorithms = [openpgp.enums.symmetric.aes128];
const encrypted = await openpgp.encrypt({message: openpgp.message.fromText('hello'), publicKeys: publicKey, privateKeys: privateKey, toUserIds: {name: 'Test User', email: 'b@c.com'}, armor: false, returnSessionKey: true});
expect(encrypted.sessionKey.algorithm).to.equal('aes128');
const sessionKey = await openpgp.generateSessionKey({publicKeys: publicKey, toUserIds: {name: 'Test User', email: 'b@c.com'}});
expect(sessionKey.algorithm).to.equal('aes128');
await openpgp.encrypt({message: openpgp.message.fromText('hello'), publicKeys: publicKey, privateKeys: privateKey, toUserIds: {name: 'Test User', email: 'b@c.com'}, armor: false});
await expect(openpgp.encrypt({message: openpgp.message.fromText('hello'), publicKeys: publicKey, privateKeys: privateKey, toUserIds: {name: 'Test User', email: 'c@c.com'}, armor: false})).to.be.rejectedWith('Could not find user that matches that user ID');
});
@ -3239,12 +3240,12 @@ VYGdb3eNlV8CfoEC
// Set second user to prefer aes128. We will select this user.
privateKey.users[1].selfCertifications[0].preferredHashAlgorithms = [openpgp.enums.hash.sha512];
const signed = await openpgp.sign({message: openpgp.message.fromText('hello'), privateKeys: privateKey, fromUserIds: {name: 'Test McTestington', email: 'test@example.com'}, armor: false});
const signature = await openpgp.message.read(signed.data);
const signature = await openpgp.message.read(signed);
expect(signature.packets[0].hashAlgorithm).to.equal(openpgp.enums.hash.sha512);
const encrypted = await openpgp.encrypt({message: openpgp.message.fromText('hello'), publicKeys: publicKey, privateKeys: privateKey, fromUserIds: {name: 'Test McTestington', email: 'test@example.com'}, detached: true, armor: false});
const signature2 = await openpgp.message.read(encrypted.signature);
expect(signature2.packets[0].hashAlgorithm).to.equal(openpgp.enums.hash.sha512);
await expect(openpgp.encrypt({message: openpgp.message.fromText('hello'), publicKeys: publicKey, privateKeys: privateKey, fromUserIds: {name: 'Not Test McTestington', email: 'test@example.com'}, detached: true, armor: false})).to.be.rejectedWith('Could not find user that matches that user ID');
const encrypted = await openpgp.encrypt({message: openpgp.message.fromText('hello'), passwords: 'test', privateKeys: privateKey, fromUserIds: {name: 'Test McTestington', email: 'test@example.com'}, armor: false});
const { signatures } = await openpgp.decrypt({message: await openpgp.message.read(encrypted), passwords: 'test'});
expect(signatures[0].signature.packets[0].hashAlgorithm).to.equal(openpgp.enums.hash.sha512);
await expect(openpgp.encrypt({message: openpgp.message.fromText('hello'), publicKeys: publicKey, privateKeys: privateKey, fromUserIds: {name: 'Not Test McTestington', email: 'test@example.com'}, armor: false})).to.be.rejectedWith('Could not find user that matches that user ID');
});
it('Find a valid subkey binding signature among many invalid ones', async function() {
@ -3436,7 +3437,7 @@ describe('addSubkey functionality testing', function(){
await subKey.verify(newPrivateKey.primaryKey);
expect(await newPrivateKey.getSigningKey()).to.be.equal(subKey);
const signed = await openpgp.sign({message: openpgp.message.fromText('the data to signed'), privateKeys: newPrivateKey, armor:false});
const message = await openpgp.message.read(signed.data);
const message = await openpgp.message.read(signed);
const { signatures } = await openpgp.verify({message, publicKeys: [newPrivateKey.toPublic()]});
expect(signatures).to.exist;
expect(signatures.length).to.be.equal(1);
@ -3458,8 +3459,8 @@ describe('addSubkey functionality testing', function(){
await subKey.verify(newPrivateKey.primaryKey);
expect(await newPrivateKey.getEncryptionKey()).to.be.equal(subKey);
const encrypted = await openpgp.encrypt({message: openpgp.message.fromText(vData), publicKeys: publicKey, armor:false});
expect(encrypted.data).to.be.exist;
const message = await openpgp.message.read(encrypted.data);
expect(encrypted).to.be.exist;
const message = await openpgp.message.read(encrypted);
const pkSessionKeys = message.packets.filterByTag(openpgp.enums.packet.publicKeyEncryptedSessionKey);
expect(pkSessionKeys).to.exist;
expect(pkSessionKeys.length).to.be.equal(1);
@ -3482,7 +3483,7 @@ describe('addSubkey functionality testing', function(){
await subKey.verify(newPrivateKey.primaryKey);
expect(await newPrivateKey.getSigningKey()).to.be.equal(subKey);
const signed = await openpgp.sign({message: openpgp.message.fromText('the data to signed'), privateKeys: newPrivateKey, armor:false});
const message = await openpgp.message.read(signed.data);
const message = await openpgp.message.read(signed);
const { signatures } = await openpgp.verify({message, publicKeys: [newPrivateKey.toPublic()]});
expect(signatures).to.exist;
expect(signatures.length).to.be.equal(1);
@ -3502,8 +3503,8 @@ describe('addSubkey functionality testing', function(){
const vData = 'the data to encrypted!';
expect(await newPrivateKey.getEncryptionKey()).to.be.equal(subKey);
const encrypted = await openpgp.encrypt({message: openpgp.message.fromText(vData), publicKeys: publicKey, armor:false});
expect(encrypted.data).to.be.exist;
const message = await openpgp.message.read(encrypted.data);
expect(encrypted).to.be.exist;
const message = await openpgp.message.read(encrypted);
const pkSessionKeys = message.packets.filterByTag(openpgp.enums.packet.publicKeyEncryptedSessionKey);
expect(pkSessionKeys).to.exist;
expect(pkSessionKeys.length).to.be.equal(1);

503
test/general/openpgp.js
View File

@ -806,9 +806,9 @@ describe('OpenPGP.js public api tests', function() {
await openpgp.initWorker({ path:'../dist/openpgp.worker.js' });
}
return openpgp.encrypt({ publicKeys:publicKey.keys, message:openpgp.message.fromText(plaintext) }).then(function(encrypted) {
expect(encrypted.data).to.exist;
expect(encrypted.data).not.to.match(/^Version:/);
expect(encrypted.data).to.match(/Comment: different/);
expect(encrypted).to.exist;
expect(encrypted).not.to.match(/^Version:/);
expect(encrypted).to.match(/Comment: different/);
});
});
@ -829,12 +829,12 @@ describe('OpenPGP.js public api tests', function() {
publicKeys: publicKey.keys,
data: plaintext
}).then(function (encrypted) {
expect(encrypted.data).to.exist;
expect(encrypted.data).not.to.match(/^Version:/);
expect(encrypted.data).to.match(/Comment: different/);
expect(encrypted).to.exist;
expect(encrypted).not.to.match(/^Version:/);
expect(encrypted).to.match(/Comment: different/);
return openpgp.decrypt({
privateKeys: privateKey.keys[0],
message: openpgp.message.readArmored(encrypted.data)
message: openpgp.message.readArmored(encrypted)
});
}).then(function (decrypted) {
expect(decrypted.data).to.equal(plaintext);
@ -860,8 +860,8 @@ describe('OpenPGP.js public api tests', function() {
privateKey: privateKey.keys[0],
passphrase: passphrase
}).then(function(unlocked){
expect(unlocked.key.getKeyId().toHex()).to.equal(privateKey.keys[0].getKeyId().toHex());
expect(unlocked.key.isDecrypted()).to.be.true;
expect(unlocked.getKeyId().toHex()).to.equal(privateKey.keys[0].getKeyId().toHex());
expect(unlocked.isDecrypted()).to.be.true;
});
});
@ -970,7 +970,7 @@ describe('OpenPGP.js public api tests', function() {
publicKeys: publicKey.keys,
armor: false
}).then(async function(encrypted) {
const message = await openpgp.message.read(encrypted.data);
const message = await openpgp.message.read(encrypted);
return openpgp.decryptSessionKeys({
message,
privateKeys: privateKey.keys[0]
@ -987,7 +987,7 @@ describe('OpenPGP.js public api tests', function() {
passwords: password1,
armor: false
}).then(async function(encrypted) {
const message = await openpgp.message.read(encrypted.data);
const message = await openpgp.message.read(encrypted);
return openpgp.decryptSessionKeys({
message,
passwords: password1
@ -1016,119 +1016,86 @@ describe('OpenPGP.js public api tests', function() {
});
});
it('roundtrip workflow: encrypt, decryptSessionKeys, decrypt with pgp key pair', function () {
let msgAsciiArmored;
return openpgp.encrypt({
it('roundtrip workflow: encrypt, decryptSessionKeys, decrypt with pgp key pair', async function () {
const encrypted = await openpgp.encrypt({
message: openpgp.message.fromText(plaintext),
publicKeys: publicKey.keys
}).then(async function (encrypted) {
msgAsciiArmored = encrypted.data;
return openpgp.decryptSessionKeys({
message: await openpgp.message.readArmored(msgAsciiArmored),
privateKeys: privateKey.keys[0]
});
}).then(async function (decryptedSessionKeys) {
const message = await openpgp.message.readArmored(msgAsciiArmored);
return openpgp.decrypt({
sessionKeys: decryptedSessionKeys[0],
message
});
}).then(function (decrypted) {
expect(decrypted.data).to.equal(plaintext);
});
const decryptedSessionKeys = await openpgp.decryptSessionKeys({
message: await openpgp.message.readArmored(encrypted),
privateKeys: privateKey.keys[0]
});
const decrypted = await openpgp.decrypt({
message: await openpgp.message.readArmored(encrypted),
sessionKeys: decryptedSessionKeys[0]
});
expect(decrypted.data).to.equal(plaintext);
});
it('roundtrip workflow: encrypt, decryptSessionKeys, decrypt with pgp key pair -- trailing spaces', function () {
it('roundtrip workflow: encrypt, decryptSessionKeys, decrypt with pgp key pair -- trailing spaces', async function () {
const plaintext = 'space: \nspace and tab: \t\nno trailing space\n \ntab:\t\ntab and space:\t ';
let msgAsciiArmored;
return openpgp.encrypt({
const encrypted = await openpgp.encrypt({
message: openpgp.message.fromText(plaintext),
publicKeys: publicKey.keys
}).then(async function (encrypted) {
msgAsciiArmored = encrypted.data;
return openpgp.decryptSessionKeys({
message: await openpgp.message.readArmored(msgAsciiArmored),
privateKeys: privateKey.keys[0]
});
}).then(async function (decryptedSessionKeys) {
const message = await openpgp.message.readArmored(msgAsciiArmored);
return openpgp.decrypt({
sessionKeys: decryptedSessionKeys[0],
message
});
}).then(function (decrypted) {
expect(decrypted.data).to.equal(plaintext);
});
const decryptedSessionKeys = await openpgp.decryptSessionKeys({
message: await openpgp.message.readArmored(encrypted),
privateKeys: privateKey.keys[0]
});
const decrypted = await openpgp.decrypt({
message: await openpgp.message.readArmored(encrypted),
sessionKeys: decryptedSessionKeys[0]
});
expect(decrypted.data).to.equal(plaintext);
});
it('roundtrip workflow: encrypt, decryptSessionKeys, decrypt with password', function () {
let msgAsciiArmored;
return openpgp.encrypt({
it('roundtrip workflow: encrypt, decryptSessionKeys, decrypt with password', async function () {
const encrypted = await openpgp.encrypt({
message: openpgp.message.fromText(plaintext),
passwords: password1
}).then(async function (encrypted) {
msgAsciiArmored = encrypted.data;
return openpgp.decryptSessionKeys({
message: await openpgp.message.readArmored(msgAsciiArmored),
passwords: password1
});
}).then(async function (decryptedSessionKeys) {
return openpgp.decrypt({
sessionKeys: decryptedSessionKeys[0],
message: await openpgp.message.readArmored(msgAsciiArmored)
});
}).then(function (decrypted) {
expect(decrypted.data).to.equal(plaintext);
});
const decryptedSessionKeys = await openpgp.decryptSessionKeys({
message: await openpgp.message.readArmored(encrypted),
passwords: password1
});
const decrypted = await openpgp.decrypt({
message: await openpgp.message.readArmored(encrypted),
sessionKeys: decryptedSessionKeys[0]
});
expect(decrypted.data).to.equal(plaintext);
});
it('roundtrip workflow: encrypt with multiple passwords, decryptSessionKeys, decrypt with multiple passwords', function () {
let msgAsciiArmored;
return openpgp.encrypt({
it('roundtrip workflow: encrypt with multiple passwords, decryptSessionKeys, decrypt with multiple passwords', async function () {
const encrypted = await openpgp.encrypt({
message: openpgp.message.fromText(plaintext),
passwords: [password1, password2]
}).then(async function (encrypted) {
msgAsciiArmored = encrypted.data;
return openpgp.decryptSessionKeys({
message: await openpgp.message.readArmored(msgAsciiArmored),
passwords: [password1, password2]
});
}).then(async function (decryptedSessionKeys) {
return openpgp.decrypt({
sessionKeys: decryptedSessionKeys,
message: await openpgp.message.readArmored(msgAsciiArmored)
});
}).then(function (decrypted) {
expect(decrypted.data).to.equal(plaintext);
});
const decryptedSessionKeys = await openpgp.decryptSessionKeys({
message: await openpgp.message.readArmored(encrypted),
passwords: [password1, password2]
});
const decrypted = await openpgp.decrypt({
message: await openpgp.message.readArmored(encrypted),
sessionKeys: decryptedSessionKeys[0]
});
expect(decrypted.data).to.equal(plaintext);
});
it('roundtrip workflow: encrypt twice with one password, decryptSessionKeys, only one session key', function () {
let msgAsciiArmored;
return openpgp.encrypt({
it('roundtrip workflow: encrypt twice with one password, decryptSessionKeys, only one session key', async function () {
const encrypted = await openpgp.encrypt({
message: openpgp.message.fromText(plaintext),
passwords: [password1, password1]
}).then(async function (encrypted) {
msgAsciiArmored = encrypted.data;
return openpgp.decryptSessionKeys({
message: await openpgp.message.readArmored(msgAsciiArmored),
passwords: password1
});
}).then(async function (decryptedSessionKeys) {
expect(decryptedSessionKeys.length).to.equal(1);
return openpgp.decrypt({
sessionKeys: decryptedSessionKeys,
message: await openpgp.message.readArmored(msgAsciiArmored)
});
}).then(function (decrypted) {
expect(decrypted.data).to.equal(plaintext);
});
const decryptedSessionKeys = await openpgp.decryptSessionKeys({
message: await openpgp.message.readArmored(encrypted),
passwords: password1
});
expect(decryptedSessionKeys.length).to.equal(1);
const decrypted = await openpgp.decrypt({
message: await openpgp.message.readArmored(encrypted),
sessionKeys: decryptedSessionKeys[0]
});
expect(decrypted.data).to.equal(plaintext);
});
});
@ -1163,8 +1130,8 @@ describe('OpenPGP.js public api tests', function() {
privateKeys: privateKey.keys
};
return openpgp.encrypt(encOpt).then(async function (encrypted) {
expect(encrypted.data).to.match(/^-----BEGIN PGP MESSAGE/);
decOpt.message = await openpgp.message.readArmored(encrypted.data);
expect(encrypted).to.match(/^-----BEGIN PGP MESSAGE/);
decOpt.message = await openpgp.message.readArmored(encrypted);
return openpgp.decrypt(decOpt);
}).then(function (decrypted) {
expect(decrypted.data).to.equal(plaintext);
@ -1185,8 +1152,8 @@ describe('OpenPGP.js public api tests', function() {
privateKeys: [privKeyDE, privateKey.keys[0]]
};
return openpgp.encrypt(encOpt).then(async function (encrypted) {
expect(encrypted.data).to.match(/^-----BEGIN PGP MESSAGE/);
decOpt.message = await openpgp.message.readArmored(encrypted.data);
expect(encrypted).to.match(/^-----BEGIN PGP MESSAGE/);
decOpt.message = await openpgp.message.readArmored(encrypted);
return openpgp.decrypt(decOpt);
}).then(function (decrypted) {
expect(decrypted.data).to.equal(plaintext);
@ -1205,8 +1172,8 @@ describe('OpenPGP.js public api tests', function() {
privateKeys: privateKey.keys
};
return openpgp.encrypt(encOpt).then(async function (encrypted) {
expect(encrypted.data).to.match(/^-----BEGIN PGP MESSAGE/);
decOpt.message = await openpgp.message.readArmored(encrypted.data);
expect(encrypted).to.match(/^-----BEGIN PGP MESSAGE/);
decOpt.message = await openpgp.message.readArmored(encrypted);
return openpgp.decrypt(decOpt);
}).then(function (decrypted) {
expect(decrypted.data).to.equal(plaintext);
@ -1228,8 +1195,8 @@ describe('OpenPGP.js public api tests', function() {
privateKeys: [privKeyDE, privateKey.keys[0]]
};
return openpgp.encrypt(encOpt).then(async function (encrypted) {
expect(encrypted.data).to.match(/^-----BEGIN PGP MESSAGE/);
decOpt.message = await openpgp.message.readArmored(encrypted.data);
expect(encrypted).to.match(/^-----BEGIN PGP MESSAGE/);
decOpt.message = await openpgp.message.readArmored(encrypted);
return openpgp.decrypt(decOpt);
}).then(function (decrypted) {
expect(decrypted.data).to.equal(plaintext);
@ -1238,25 +1205,22 @@ describe('OpenPGP.js public api tests', function() {
});
});
it('should encrypt then decrypt using returned session key', function () {
const encOpt = {
message: openpgp.message.fromText(plaintext),
publicKeys: publicKey.keys,
returnSessionKey: true
};
return openpgp.encrypt(encOpt).then(async function (encrypted) {
expect(encrypted.data).to.match(/^-----BEGIN PGP MESSAGE/);
const decOpt = {
sessionKeys: encrypted.sessionKey,
message: await openpgp.message.readArmored(encrypted.data)
};
return openpgp.decrypt(decOpt);
}).then(function (decrypted) {
expect(decrypted.data).to.equal(plaintext);
expect(decrypted.signatures).to.exist;
expect(decrypted.signatures.length).to.equal(0);
it('should encrypt then decrypt using returned session key', async function () {
const sessionKey = await openpgp.generateSessionKey({
publicKeys: publicKey.keys
});
const encrypted = await openpgp.encrypt({
message: openpgp.message.fromText(plaintext),
sessionKey
});
expect(encrypted).to.match(/^-----BEGIN PGP MESSAGE/);
const decrypted = await openpgp.decrypt({
message: await openpgp.message.readArmored(encrypted),
sessionKeys: sessionKey
});
expect(decrypted.data).to.equal(plaintext);
expect(decrypted.signatures).to.exist;
expect(decrypted.signatures.length).to.equal(0);
});
it('should encrypt using custom session key and decrypt using session key', async function () {
@ -1273,8 +1237,8 @@ describe('OpenPGP.js public api tests', function() {
sessionKeys: sessionKey
};
return openpgp.encrypt(encOpt).then(async function (encrypted) {
expect(encrypted.data).to.match(/^-----BEGIN PGP MESSAGE/);
decOpt.message = await openpgp.message.readArmored(encrypted.data);
expect(encrypted).to.match(/^-----BEGIN PGP MESSAGE/);
decOpt.message = await openpgp.message.readArmored(encrypted);
expect(!!decOpt.message.packets.findPacket(openpgp.enums.packet.symEncryptedAEADProtected)).to.equal(false);
return openpgp.decrypt(decOpt);
}).then(function (decrypted) {
@ -1296,8 +1260,8 @@ describe('OpenPGP.js public api tests', function() {
privateKeys: privateKey.keys[0]
};
return openpgp.encrypt(encOpt).then(async function (encrypted) {
expect(encrypted.data).to.match(/^-----BEGIN PGP MESSAGE/);
decOpt.message = await openpgp.message.readArmored(encrypted.data);
expect(encrypted).to.match(/^-----BEGIN PGP MESSAGE/);
decOpt.message = await openpgp.message.readArmored(encrypted);
expect(!!decOpt.message.packets.findPacket(openpgp.enums.packet.symEncryptedAEADProtected)).to.equal(false);
return openpgp.decrypt(decOpt);
}).then(function (decrypted) {
@ -1316,7 +1280,7 @@ describe('OpenPGP.js public api tests', function() {
publicKeys: publicKey.keys
};
return openpgp.encrypt(encOpt).then(async function (encrypted) {
decOpt.message = await openpgp.message.readArmored(encrypted.data);
decOpt.message = await openpgp.message.readArmored(encrypted);
expect(!!decOpt.message.packets.findPacket(openpgp.enums.packet.symEncryptedAEADProtected)).to.equal(openpgp.config.aead_protect);
return openpgp.decrypt(decOpt);
}).then(async function (decrypted) {
@ -1339,7 +1303,7 @@ describe('OpenPGP.js public api tests', function() {
publicKeys: publicKeyNoAEAD.keys
};
return openpgp.encrypt(encOpt).then(async function (encrypted) {
decOpt.message = await openpgp.message.readArmored(encrypted.data);
decOpt.message = await openpgp.message.readArmored(encrypted);
expect(!!decOpt.message.packets.findPacket(openpgp.enums.packet.symEncryptedAEADProtected)).to.equal(false);
return openpgp.decrypt(decOpt);
}).then(async function (decrypted) {
@ -1372,7 +1336,7 @@ describe('OpenPGP.js public api tests', function() {
publicKeys: newPublicKey.keys
};
return openpgp.encrypt(encOpt).then(async function (encrypted) {
decOpt.message = await openpgp.message.readArmored(encrypted.data);
decOpt.message = await openpgp.message.readArmored(encrypted);
expect(!!decOpt.message.packets.findPacket(openpgp.enums.packet.symEncryptedAEADProtected)).to.equal(openpgp.config.aead_protect);
return openpgp.decrypt(decOpt);
}).then(async function (decrypted) {
@ -1385,40 +1349,36 @@ describe('OpenPGP.js public api tests', function() {
});
});
it('should encrypt/sign and decrypt/verify with generated key and detached signatures', function () {
const genOpt = {
it('should encrypt/sign and decrypt/verify with generated key and detached signatures', async function () {
const newKey = await openpgp.generateKey({
userIds: [{ name: 'Test User', email: 'text@example.com' }],
numBits: 512
};
if (openpgp.util.getWebCryptoAll()) { genOpt.numBits = 2048; } // webkit webcrypto accepts minimum 2048 bit keys
return openpgp.generateKey(genOpt).then(async function(newKey) {
const newPublicKey = await openpgp.key.readArmored(newKey.publicKeyArmored);
const newPrivateKey = await openpgp.key.readArmored(newKey.privateKeyArmored);
const encOpt = {
message: openpgp.message.fromText(plaintext),
publicKeys: newPublicKey.keys,
privateKeys: newPrivateKey.keys,
detached: true
};
const decOpt = {
privateKeys: newPrivateKey.keys[0],
publicKeys: newPublicKey.keys
};
return openpgp.encrypt(encOpt).then(async function (encrypted) {
decOpt.message = await openpgp.message.readArmored(encrypted.data);
decOpt.signature = await openpgp.signature.readArmored(encrypted.signature);
expect(!!decOpt.message.packets.findPacket(openpgp.enums.packet.symEncryptedAEADProtected)).to.equal(openpgp.config.aead_protect);
return openpgp.decrypt(decOpt);
}).then(async function (decrypted) {
expect(decrypted.data).to.equal(plaintext);
expect(decrypted.signatures[0].valid).to.be.true;
const signingKey = await newPrivateKey.keys[0].getSigningKey();
expect(decrypted.signatures[0].keyid.toHex()).to.equal(signingKey.getKeyId().toHex());
expect(decrypted.signatures[0].signature.packets.length).to.equal(1);
});
numBits: openpgp.util.getWebCryptoAll() ? 2048 : 512 // webkit webcrypto accepts minimum 2048 bit keys
});
const newPublicKey = await openpgp.key.readArmored(newKey.publicKeyArmored);
const newPrivateKey = await openpgp.key.readArmored(newKey.privateKeyArmored);
const encrypted = await openpgp.encrypt({
message: openpgp.message.fromText(plaintext),
publicKeys: newPublicKey.keys
});
const signed = await openpgp.sign({
message: openpgp.message.fromText(plaintext),
privateKeys: newPrivateKey.keys,
detached: true
});
const message = await openpgp.message.readArmored(encrypted);
expect(!!message.packets.findPacket(openpgp.enums.packet.symEncryptedAEADProtected)).to.equal(openpgp.config.aead_protect);
const decrypted = await openpgp.decrypt({
message,
signature: await openpgp.signature.readArmored(signed),
privateKeys: newPrivateKey.keys[0],
publicKeys: newPublicKey.keys
});
expect(decrypted.data).to.equal(plaintext);
expect(decrypted.signatures[0].valid).to.be.true;
const signingKey = await newPrivateKey.keys[0].getSigningKey();
expect(decrypted.signatures[0].keyid.toHex()).to.equal(signingKey.getKeyId().toHex());
expect(decrypted.signatures[0].signature.packets.length).to.equal(1);
});
it('should encrypt/sign and decrypt/verify with null string input', function () {
@ -1432,7 +1392,7 @@ describe('OpenPGP.js public api tests', function() {
publicKeys: publicKey.keys
};
return openpgp.encrypt(encOpt).then(async function (encrypted) {
decOpt.message = await openpgp.message.readArmored(encrypted.data);
decOpt.message = await openpgp.message.readArmored(encrypted);
return openpgp.decrypt(decOpt);
}).then(async function (decrypted) {
expect(decrypted.data).to.equal('');
@ -1443,65 +1403,30 @@ describe('OpenPGP.js public api tests', function() {
});
});
it('should encrypt/sign and decrypt/verify with detached signatures', function () {
const encOpt = {
it('should encrypt/sign and decrypt/verify with detached signatures', async function () {
const encrypted = await openpgp.encrypt({
message: openpgp.message.fromText(plaintext),
publicKeys: publicKey.keys
});
const signed = await openpgp.sign({
message: openpgp.message.fromText(plaintext),
publicKeys: publicKey.keys,
privateKeys: privateKey.keys,
detached: true
};
const decOpt = {
});
const decrypted = await openpgp.decrypt({
message: await openpgp.message.readArmored(encrypted),
signature: await openpgp.signature.readArmored(signed),
privateKeys: privateKey.keys[0],
publicKeys: publicKey.keys
};
return openpgp.encrypt(encOpt).then(async function (encrypted) {
decOpt.message = await openpgp.message.readArmored(encrypted.data);
decOpt.signature = await openpgp.signature.readArmored(encrypted.signature);
return openpgp.decrypt(decOpt);
}).then(async function (decrypted) {
expect(decrypted.data).to.equal(plaintext);
expect(decrypted.signatures[0].valid).to.be.true;
const signingKey = await privateKey.keys[0].getSigningKey();
expect(decrypted.signatures[0].keyid.toHex()).to.equal(signingKey.getKeyId().toHex());
expect(decrypted.signatures[0].signature.packets.length).to.equal(1);
});
expect(decrypted.data).to.equal(plaintext);
expect(decrypted.signatures[0].valid).to.be.true;
const signingKey = await privateKey.keys[0].getSigningKey();
expect(decrypted.signatures[0].keyid.toHex()).to.equal(signingKey.getKeyId().toHex());
expect(decrypted.signatures[0].signature.packets.length).to.equal(1);
});
it('should encrypt and decrypt/verify with detached signature input and detached flag set for encryption', function () {
const signOpt = {
message: openpgp.message.fromText(plaintext),
privateKeys: privateKey.keys[0],
detached: true
};
const encOpt = {
message: openpgp.message.fromText(plaintext),
publicKeys: publicKey.keys,
detached: true
};
const decOpt = {
privateKeys: privateKey.keys[0],
publicKeys: publicKey.keys[0]
};
return openpgp.sign(signOpt).then(async function (signed) {
encOpt.signature = await openpgp.signature.readArmored(signed.signature);
return openpgp.encrypt(encOpt);
}).then(async function (encrypted) {
decOpt.message = await openpgp.message.readArmored(encrypted.data);
decOpt.signature = await openpgp.signature.readArmored(encrypted.signature);
return openpgp.decrypt(decOpt);
}).then(async function (decrypted) {
expect(decrypted.data).to.equal(plaintext);
expect(decrypted.signatures[0].valid).to.be.true;
const signingKey = await privateKey.keys[0].getSigningKey();
expect(decrypted.signatures[0].keyid.toHex()).to.equal(signingKey.getKeyId().toHex());
expect(decrypted.signatures[0].signature.packets.length).to.equal(1);
});
});
it('should encrypt and decrypt/verify with detached signature as input and detached flag not set for encryption', async function () {
it('should encrypt and decrypt/verify with detached signature as input for encryption', async function () {
const plaintext = "  \t┍ͤ޵၂༫዇◧˘˻ᙑ᎚⏴ំந⛑nٓኵΉⅶ⋋ŵ⋲΂ͽᣏ₅ᄶɼ┋⌔û᬴Ƚᔡᧅ≃ṱἆ⃷݂૿ӌ᰹෇ٹჵ⛇໶⛌  \t\n한국어/조선말";
const privKeyDE = (await openpgp.key.readArmored(priv_key_de)).keys[0];
@ -1527,10 +1452,10 @@ describe('OpenPGP.js public api tests', function() {
};
return openpgp.sign(signOpt).then(async function (signed) {
encOpt.signature = await openpgp.signature.readArmored(signed.signature);
encOpt.signature = await openpgp.signature.readArmored(signed);
return openpgp.encrypt(encOpt);
}).then(async function (encrypted) {
decOpt.message = await openpgp.message.readArmored(encrypted.data);
decOpt.message = await openpgp.message.readArmored(encrypted);
return openpgp.decrypt(decOpt);
}).then(async function (decrypted) {
let signingKey;
@ -1546,41 +1471,7 @@ describe('OpenPGP.js public api tests', function() {
});
});
it('should fail to encrypt and decrypt/verify with detached signature input and detached flag set for encryption with wrong public key', async function () {
const signOpt = {
message: openpgp.message.fromText(plaintext),
privateKeys: privateKey.keys,
detached: true
};
const encOpt = {
message: openpgp.message.fromText(plaintext),
publicKeys: publicKey.keys,
detached: true
};
const decOpt = {
privateKeys: privateKey.keys[0],
publicKeys: (await openpgp.key.readArmored(wrong_pubkey)).keys
};
return openpgp.sign(signOpt).then(async function (signed) {
encOpt.signature = await openpgp.signature.readArmored(signed.signature);
return openpgp.encrypt(encOpt);
}).then(async function (encrypted) {
decOpt.message = await openpgp.message.readArmored(encrypted.data);
decOpt.signature = await openpgp.signature.readArmored(encrypted.signature);
return openpgp.decrypt(decOpt);
}).then(async function (decrypted) {
expect(decrypted.data).to.equal(plaintext);
expect(decrypted.signatures[0].valid).to.be.null;
const signingKey = await privateKey.keys[0].getSigningKey();
expect(decrypted.signatures[0].keyid.toHex()).to.equal(signingKey.getKeyId().toHex());
expect(decrypted.signatures[0].signature.packets.length).to.equal(1);
});
});
it('should fail to encrypt and decrypt/verify with detached signature as input and detached flag not set for encryption with wrong public key', async function () {
it('should fail to encrypt and decrypt/verify with detached signature as input for encryption with wrong public key', async function () {
const signOpt = {
message: openpgp.message.fromText(plaintext),
privateKeys: privateKey.keys,
@ -1598,10 +1489,10 @@ describe('OpenPGP.js public api tests', function() {
};
return openpgp.sign(signOpt).then(async function (signed) {
encOpt.signature = await openpgp.signature.readArmored(signed.signature);
encOpt.signature = await openpgp.signature.readArmored(signed);
return openpgp.encrypt(encOpt);
}).then(async function (encrypted) {
decOpt.message = await openpgp.message.readArmored(encrypted.data);
decOpt.message = await openpgp.message.readArmored(encrypted);
return openpgp.decrypt(decOpt);
}).then(async function (decrypted) {
expect(decrypted.data).to.equal(plaintext);
@ -1623,7 +1514,7 @@ describe('OpenPGP.js public api tests', function() {
publicKeys: (await openpgp.key.readArmored(wrong_pubkey)).keys
};
return openpgp.encrypt(encOpt).then(async function (encrypted) {
decOpt.message = await openpgp.message.readArmored(encrypted.data);
decOpt.message = await openpgp.message.readArmored(encrypted);
return openpgp.decrypt(decOpt);
}).then(async function (decrypted) {
expect(decrypted.data).to.equal(plaintext);
@ -1645,7 +1536,7 @@ describe('OpenPGP.js public api tests', function() {
publicKeys: (await openpgp.key.readArmored(wrong_pubkey)).keys
};
return openpgp.encrypt(encOpt).then(async function (encrypted) {
decOpt.message = await openpgp.message.readArmored(encrypted.data);
decOpt.message = await openpgp.message.readArmored(encrypted);
return openpgp.decrypt(decOpt);
}).then(async function (decrypted) {
expect(decrypted.data).to.equal('');
@ -1666,7 +1557,7 @@ describe('OpenPGP.js public api tests', function() {
privateKeys: privateKey.keys[0]
};
return openpgp.encrypt(encOpt).then(async function (encrypted) {
decOpt.message = await openpgp.message.readArmored(encrypted.data);
decOpt.message = await openpgp.message.readArmored(encrypted);
return openpgp.decrypt(decOpt);
}).then(async function (decrypted) {
expect(decrypted.data).to.equal(plaintext);
@ -1678,27 +1569,26 @@ describe('OpenPGP.js public api tests', function() {
});
it('should fail to verify decrypted data with wrong public pgp key with detached signatures', async function () {
const encOpt = {
const encrypted = await openpgp.encrypt({
message: openpgp.message.fromText(plaintext),
publicKeys: publicKey.keys
});
const signed = await openpgp.sign({
message: openpgp.message.fromText(plaintext),
publicKeys: publicKey.keys,
privateKeys: privateKey.keys,
detached: true
};
const decOpt = {
});
const decrypted = await openpgp.decrypt({
message: await openpgp.message.readArmored(encrypted),
signature: await openpgp.signature.readArmored(signed),
privateKeys: privateKey.keys[0],
publicKeys: (await openpgp.key.readArmored(wrong_pubkey)).keys
};
return openpgp.encrypt(encOpt).then(async function (encrypted) {
decOpt.message = await openpgp.message.readArmored(encrypted.data);
decOpt.signature = await openpgp.signature.readArmored(encrypted.signature);
return openpgp.decrypt(decOpt);
}).then(async function (decrypted) {
expect(decrypted.data).to.equal(plaintext);
expect(decrypted.signatures[0].valid).to.be.null;
const signingKey = await privateKey.keys[0].getSigningKey();
expect(decrypted.signatures[0].keyid.toHex()).to.equal(signingKey.getKeyId().toHex());
expect(decrypted.signatures[0].signature.packets.length).to.equal(1);
});
expect(decrypted.data).to.equal(plaintext);
expect(decrypted.signatures[0].valid).to.be.null;
const signingKey = await privateKey.keys[0].getSigningKey();
expect(decrypted.signatures[0].keyid.toHex()).to.equal(signingKey.getKeyId().toHex());
expect(decrypted.signatures[0].signature.packets.length).to.equal(1);
});
it('should encrypt and decrypt/verify both signatures when signed with two private keys', async function () {
@ -1719,7 +1609,7 @@ describe('OpenPGP.js public api tests', function() {
};
return openpgp.encrypt(encOpt).then(async function (encrypted) {
decOpt.message = await openpgp.message.readArmored(encrypted.data);
decOpt.message = await openpgp.message.readArmored(encrypted);
return openpgp.decrypt(decOpt);
}).then(async function (decrypted) {
let signingKey;
@ -1738,7 +1628,7 @@ describe('OpenPGP.js public api tests', function() {
it('should fail to decrypt modified message', async function() {
const { privateKeyArmored } = await openpgp.generateKey({ curve: 'curve25519', userIds: [{ email: 'test@email.com' }] });
const { keys: [key] } = await openpgp.key.readArmored(privateKeyArmored);
const { data } = await openpgp.encrypt({ message: openpgp.message.fromBinary(new Uint8Array(500)), publicKeys: [key.toPublic()] });
const data = await openpgp.encrypt({ message: openpgp.message.fromBinary(new Uint8Array(500)), publicKeys: [key.toPublic()] });
let badSumEncrypted = data.replace(/\n=[a-zA-Z0-9/+]{4}/, '\n=aaaa');
if (badSumEncrypted === data) { // checksum was already =aaaa
badSumEncrypted = data.replace(/\n=[a-zA-Z0-9/+]{4}/, '\n=bbbb');
@ -1810,7 +1700,7 @@ describe('OpenPGP.js public api tests', function() {
return openpgp.decrypt({
privateKeys: privKeyDE,
publicKeys: pubKeyDE,
message: await openpgp.message.readArmored(encrypted.data)
message: await openpgp.message.readArmored(encrypted)
});
}).then(async function (decrypted) {
expect(decrypted.data).to.exist;
@ -1898,7 +1788,7 @@ describe('OpenPGP.js public api tests', function() {
passwords: password1
};
return openpgp.encrypt(encOpt).then(async function (encrypted) {
decOpt.message = await openpgp.message.readArmored(encrypted.data);
decOpt.message = await openpgp.message.readArmored(encrypted);
return openpgp.decrypt(decOpt);
}).then(function (decrypted) {
expect(decrypted.data).to.equal(plaintext);
@ -1915,7 +1805,7 @@ describe('OpenPGP.js public api tests', function() {
passwords: password2
};
return openpgp.encrypt(encOpt).then(async function (encrypted) {
decOpt.message = await openpgp.message.readArmored(encrypted.data);
decOpt.message = await openpgp.message.readArmored(encrypted);
return openpgp.decrypt(decOpt);
}).then(function (decrypted) {
expect(decrypted.data).to.equal(plaintext);
@ -1933,7 +1823,7 @@ describe('OpenPGP.js public api tests', function() {
passwords: password1
};
return openpgp.encrypt(encOpt).then(async function (encrypted) {
decOpt.message = await openpgp.message.read(encrypted.data);
decOpt.message = await openpgp.message.read(encrypted);
return openpgp.decrypt(decOpt);
}).then(function (decrypted) {
expect(decrypted.data).to.equal(plaintext);
@ -1953,7 +1843,7 @@ describe('OpenPGP.js public api tests', function() {
format: 'binary'
};
return openpgp.encrypt(encOpt).then(async function (encrypted) {
decOpt.message = await openpgp.message.read(encrypted.data);
decOpt.message = await openpgp.message.read(encrypted);
openpgp.config.zero_copy = false;
if (openpgp.getWorker()) {
openpgp.getWorker().workers.forEach(worker => {
@ -1986,7 +1876,7 @@ describe('OpenPGP.js public api tests', function() {
passwords: password1
};
return openpgp.encrypt(encOpt).then(async function (encrypted) {
decOpt.message = await openpgp.message.readArmored(encrypted.data);
decOpt.message = await openpgp.message.readArmored(encrypted);
return openpgp.decrypt(decOpt);
}).then(function (decrypted) {
expect(decrypted.data).to.equal(plaintext);
@ -2015,10 +1905,9 @@ describe('OpenPGP.js public api tests', function() {
message: openpgp.message.fromBinary(data),
passwords: ['test']
}));
expect(openpgp.util.isStream(encrypted.data)).to.equal(useNativeStream ? 'web' : 'ponyfill');
expect(openpgp.util.isStream(encrypted)).to.equal(useNativeStream ? 'web' : 'ponyfill');
const msgAsciiArmored = encrypted.data;
const message = await openpgp.message.readArmored(msgAsciiArmored);
const message = await openpgp.message.readArmored(encrypted);
const decrypted = await openpgp.decrypt({
passwords: ['test'],
message,
@ -2064,8 +1953,8 @@ describe('OpenPGP.js public api tests', function() {
publicKeys: publicKey.keys
};
return openpgp.sign(signOpt).then(async function (signed) {
expect(signed.data).to.match(/-----BEGIN PGP SIGNED MESSAGE-----/);
verifyOpt.message = await openpgp.cleartext.readArmored(signed.data);
expect(signed).to.match(/-----BEGIN PGP SIGNED MESSAGE-----/);
verifyOpt.message = await openpgp.cleartext.readArmored(signed);
return openpgp.verify(verifyOpt);
}).then(async function (verified) {
expect(verified.data).to.equal(plaintext.replace(/[ \t]+$/mg, ''));
@ -2089,8 +1978,8 @@ describe('OpenPGP.js public api tests', function() {
publicKeys: [publicKey.keys[0], privKeyDE.toPublic()]
};
return openpgp.sign(signOpt).then(async function (signed) {
expect(signed.data).to.match(/-----BEGIN PGP SIGNED MESSAGE-----/);
verifyOpt.message = await openpgp.cleartext.readArmored(signed.data);
expect(signed).to.match(/-----BEGIN PGP SIGNED MESSAGE-----/);
verifyOpt.message = await openpgp.cleartext.readArmored(signed);
return openpgp.verify(verifyOpt);
}).then(async function (verified) {
let signingKey;
@ -2118,7 +2007,7 @@ describe('OpenPGP.js public api tests', function() {
publicKeys: publicKey.keys
};
return openpgp.sign(signOpt).then(async function (signed) {
verifyOpt.signature = await openpgp.signature.readArmored(signed.signature);
verifyOpt.signature = await openpgp.signature.readArmored(signed);
return openpgp.verify(verifyOpt);
}).then(async function (verified) {
expect(verified.data).to.equal(plaintext);
@ -2139,7 +2028,7 @@ describe('OpenPGP.js public api tests', function() {
publicKeys: (await openpgp.key.readArmored(wrong_pubkey)).keys
};
return openpgp.sign(signOpt).then(async function (signed) {
verifyOpt.message = await openpgp.cleartext.readArmored(signed.data);
verifyOpt.message = await openpgp.cleartext.readArmored(signed);
return openpgp.verify(verifyOpt);
}).then(async function (verified) {
expect(verified.data).to.equal(plaintext.replace(/[ \t]+$/mg, ''));
@ -2162,7 +2051,7 @@ describe('OpenPGP.js public api tests', function() {
publicKeys: (await openpgp.key.readArmored(wrong_pubkey)).keys
};
return openpgp.sign(signOpt).then(async function (signed) {
verifyOpt.signature = await openpgp.signature.readArmored(signed.signature);
verifyOpt.signature = await openpgp.signature.readArmored(signed);
return openpgp.verify(verifyOpt);
}).then(async function (verified) {
expect(verified.data).to.equal(plaintext);
@ -2184,7 +2073,7 @@ describe('OpenPGP.js public api tests', function() {
publicKeys: publicKey.keys
};
return openpgp.sign(signOpt).then(async function (signed) {
verifyOpt.message = await openpgp.message.read(signed.data);
verifyOpt.message = await openpgp.message.read(signed);
return openpgp.verify(verifyOpt);
}).then(async function (verified) {
expect(verified.data).to.equal(plaintext);
@ -2209,7 +2098,7 @@ describe('OpenPGP.js public api tests', function() {
publicKeys: publicKey.keys
};
return openpgp.sign(signOpt).then(async function (signed) {
verifyOpt.signature = await openpgp.signature.read(signed.signature);
verifyOpt.signature = await openpgp.signature.read(signed);
return openpgp.verify(verifyOpt);
}).then(async function (verified) {
expect(verified.data).to.equal(plaintext);
@ -2238,7 +2127,7 @@ describe('OpenPGP.js public api tests', function() {
date: past
};
return openpgp.sign(signOpt).then(async function (signed) {
verifyOpt.signature = await openpgp.signature.read(signed.signature);
verifyOpt.signature = await openpgp.signature.read(signed);
return openpgp.verify(verifyOpt).then(async function (verified) {
expect(+verified.signatures[0].signature.packets[0].created).to.equal(+past);
expect(verified.data).to.equal(plaintext);
@ -2277,7 +2166,7 @@ describe('OpenPGP.js public api tests', function() {
};
return openpgp.sign(signOpt).then(async function (signed) {
verifyOpt.message = openpgp.message.fromBinary(data);
verifyOpt.signature = await openpgp.signature.read(signed.signature);
verifyOpt.signature = await openpgp.signature.read(signed);
return openpgp.verify(verifyOpt);
}).then(async function (verified) {
expect(+verified.signatures[0].signature.packets[0].created).to.equal(+future);
@ -2301,7 +2190,7 @@ describe('OpenPGP.js public api tests', function() {
format: 'binary'
};
return openpgp.sign(signOpt).then(async function (signed) {
const message = await openpgp.message.read(signed.data);
const message = await openpgp.message.read(signed);
message.packets.concat(await openpgp.stream.readToEnd(message.packets.stream, _ => _));
const packets = new openpgp.packet.List();
packets.push(message.packets.findPacket(openpgp.enums.packet.signature));
@ -2332,8 +2221,8 @@ describe('OpenPGP.js public api tests', function() {
};
const useNativeStream = (() => { try { new global.ReadableStream(); return true; } catch (e) { return false; } })();
return openpgp.sign(signOpt).then(async function (signed) {
expect(openpgp.util.isStream(signed.data)).to.equal(useNativeStream ? 'web' : 'ponyfill');
const message = await openpgp.message.read(signed.data);
expect(openpgp.util.isStream(signed)).to.equal(useNativeStream ? 'web' : 'ponyfill');
const message = await openpgp.message.read(signed);
message.packets.concat(await openpgp.stream.readToEnd(message.packets.stream, _ => _));
const packets = new openpgp.packet.List();
packets.push(message.packets.findPacket(openpgp.enums.packet.signature));
@ -2360,7 +2249,7 @@ describe('OpenPGP.js public api tests', function() {
};
return openpgp.encrypt(encryptOpt).then(async function (encrypted) {
const message = await openpgp.message.read(encrypted.data);
const message = await openpgp.message.read(encrypted);
return message.decrypt(privateKey_2038_2045.keys);
}).then(async function (packets) {
const literals = packets.packets.filterByTag(openpgp.enums.packet.literal);
@ -2381,7 +2270,7 @@ describe('OpenPGP.js public api tests', function() {
};
return openpgp.encrypt(encryptOpt).then(async function (encrypted) {
const message = await openpgp.message.read(encrypted.data);
const message = await openpgp.message.read(encrypted);
return message.decrypt(privateKey_2000_2008.keys);
}).then(async function (packets) {
const literals = packets.packets.filterByTag(openpgp.enums.packet.literal);
@ -2402,7 +2291,7 @@ describe('OpenPGP.js public api tests', function() {
};
return openpgp.encrypt(encryptOpt).then(async function (encrypted) {
const message = await openpgp.message.read(encrypted.data);
const message = await openpgp.message.read(encrypted);
return message.decrypt(encryptOpt.privateKeys);
}).then(async function (packets) {
const literals = packets.packets.filterByTag(openpgp.enums.packet.literal);
@ -2430,7 +2319,7 @@ describe('OpenPGP.js public api tests', function() {
};
return openpgp.encrypt(encryptOpt).then(async function (encrypted) {
const message = await openpgp.message.read(encrypted.data);
const message = await openpgp.message.read(encrypted);
return message.decrypt(encryptOpt.privateKeys);
}).then(async function (packets) {
const literals = packets.packets.filterByTag(openpgp.enums.packet.literal);
@ -2459,7 +2348,7 @@ describe('OpenPGP.js public api tests', function() {
};
return openpgp.encrypt(encryptOpt).then(async function (encrypted) {
const message = await openpgp.message.read(encrypted.data);
const message = await openpgp.message.read(encrypted);
return message.decrypt(encryptOpt.privateKeys);
}).then(async function (packets) {
const literals = packets.packets.filterByTag(openpgp.enums.packet.literal);
@ -2518,7 +2407,7 @@ describe('OpenPGP.js public api tests', function() {
});
privKeyDE.subKeys[0] = await privKeyDE.subKeys[0].revoke(privKeyDE.primaryKey);
const decOpt = {
message: await openpgp.message.readArmored(encrypted.data),
message: await openpgp.message.readArmored(encrypted),
privateKeys: privKeyDE
};
const decrypted = await openpgp.decrypt(decOpt);
@ -2537,7 +2426,7 @@ describe('OpenPGP.js public api tests', function() {
publicKeys: pubKeyDE
});
const decOpt = {
message: await openpgp.message.readArmored(encrypted.data),
message: await openpgp.message.readArmored(encrypted),
privateKeys: privKeyDE
};
// binding signature is invalid
@ -2675,7 +2564,7 @@ amnR6g==
});
const decrypted = await openpgp.decrypt({
passwords: 'test',
message: await openpgp.message.readArmored(encrypted.data),
message: await openpgp.message.readArmored(encrypted),
format: 'binary'
});
expect(openpgp.util.decode_utf8(decrypted.data)).to.equal('"BEGIN:VCALENDAR\r\nVERSION:2.0\r\nBEGIN:VEVENT\r\nUID:123\r\nDTSTART:20191211T121212Z\r\nDTEND:20191212T121212Z\r\nEND:VEVENT\r\nEND:VCALENDAR"');

20
test/general/signature.js
View File

@ -893,7 +893,7 @@ hUhMKMuiM3pRwdIyDOItkUWQmjEEw7/XmhgInkXsCw==
const priv_key_gnupg_ext = (await openpgp.key.readArmored(flowcrypt_stripped_key)).keys[0];
await priv_key_gnupg_ext.decrypt('FlowCrypt');
const sig = await openpgp.sign({ message: openpgp.message.fromText('test'), privateKeys: [priv_key_gnupg_ext], date: new Date('2018-12-17T03:24:00') });
expect(sig.data).to.match(/-----END PGP MESSAGE-----\r\n$/);
expect(sig).to.match(/-----END PGP MESSAGE-----\r\n$/);
});
it('Supports non-human-readable notations', async function() {
@ -1361,7 +1361,7 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
return openpgp.sign({ privateKeys:[privKey], message: openpgp.cleartext.fromText(plaintext) }).then(async function(signed) {
const csMsg = await openpgp.cleartext.readArmored(signed.data);
const csMsg = await openpgp.cleartext.readArmored(signed);
return openpgp.verify({ publicKeys:[pubKey], message:csMsg });
}).then(function(cleartextSig) {
@ -1381,7 +1381,7 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
return openpgp.sign({ privateKeys:[privKey], message: openpgp.cleartext.fromText(plaintext) }).then(async function(signed) {
const csMsg = await openpgp.cleartext.readArmored(signed.data);
const csMsg = await openpgp.cleartext.readArmored(signed);
return openpgp.verify({ publicKeys:[pubKey], message:csMsg });
}).then(function(cleartextSig) {
@ -1401,7 +1401,7 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
return openpgp.sign({ privateKeys:[privKey], message: openpgp.cleartext.fromText(plaintext) }).then(async function(signed) {
const csMsg = await openpgp.cleartext.readArmored(signed.data);
const csMsg = await openpgp.cleartext.readArmored(signed);
return openpgp.verify({ publicKeys:[pubKey], message:csMsg });
}).then(function(cleartextSig) {
@ -1421,7 +1421,7 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
return openpgp.sign({ privateKeys:[privKey], message: openpgp.message.fromBinary(plaintext) }).then(async function(signed) {
const csMsg = await openpgp.message.readArmored(signed.data);
const csMsg = await openpgp.message.readArmored(signed);
return openpgp.verify({ publicKeys:[pubKey], message:csMsg, format: 'binary' });
}).then(async function(cleartextSig) {
@ -1441,7 +1441,7 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
return openpgp.sign({ privateKeys:[privKey], message: openpgp.message.fromBinary(plaintext), armor:false }).then(async function(signed) {
const csMsg = await openpgp.message.read(signed.data);
const csMsg = await openpgp.message.read(signed);
return openpgp.verify({ publicKeys:[pubKey], message:csMsg, format: 'binary' });
}).then(function(cleartextSig) {
@ -1459,7 +1459,7 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
const privKey = (await openpgp.key.readArmored(priv_key_arm2)).keys[0];
await privKey.decrypt('hello world');
return openpgp.sign({ privateKeys:[privKey], message: openpgp.message.fromText(plaintext), detached: true}).then(async function(signed) {
const signature = await openpgp.signature.readArmored(signed.signature);
const signature = await openpgp.signature.readArmored(signed);
return openpgp.verify({ publicKeys:[pubKey], message: openpgp.message.fromBinary(openpgp.util.encode_utf8(plaintext)), signature: signature });
}).then(function(cleartextSig) {
expect(cleartextSig).to.exist;
@ -1476,7 +1476,7 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
const privKey = (await openpgp.key.readArmored(priv_key_arm2)).keys[0];
await privKey.decrypt('hello world');
return openpgp.sign({ privateKeys:[privKey], message:openpgp.message.fromBinary(plaintextArray), detached: true}).then(async function(signed) {
const signature = await openpgp.signature.readArmored(signed.signature);
const signature = await openpgp.signature.readArmored(signed);
return openpgp.verify({ publicKeys:[pubKey], message: openpgp.message.fromText(plaintext), signature: signature });
}).then(function(cleartextSig) {
expect(cleartextSig).to.exist;
@ -1492,9 +1492,9 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
const privKey = (await openpgp.key.readArmored(priv_key_arm2)).keys[0];
await Promise.all([privKey.primaryKey.decrypt('hello world'), privKey.subKeys[0].keyPacket.decrypt('hello world')]);
return openpgp.sign({ privateKeys:[privKey], message: openpgp.message.fromText(plaintext), detached: true}).then(async function(signed) {
const signature = await openpgp.signature.readArmored(signed.signature);
const signature = await openpgp.signature.readArmored(signed);
return openpgp.encrypt({ message: openpgp.message.fromBinary(openpgp.util.encode_utf8(plaintext)), publicKeys: [pubKey], signature })
}).then(async ({ data }) => {
}).then(async data => {
const csMsg = await openpgp.message.readArmored(data);
return openpgp.decrypt({ message: csMsg, privateKeys: [ privKey ], publicKeys: [ pubKey ] });
}).then(function(cleartextSig) {

123
test/general/streaming.js
View File

@ -179,7 +179,7 @@ function tests() {
message: openpgp.message.fromBinary(data),
passwords: ['test'],
});
const msgAsciiArmored = await openpgp.stream.readToEnd(encrypted.data);
const msgAsciiArmored = await openpgp.stream.readToEnd(encrypted);
const message = await openpgp.message.readArmored(msgAsciiArmored);
const decrypted = await openpgp.decrypt({
passwords: ['test'],
@ -193,11 +193,11 @@ function tests() {
message: openpgp.message.fromBinary(data),
passwords: ['test'],
});
const reader = openpgp.stream.getReader(encrypted.data);
const reader = openpgp.stream.getReader(encrypted);
expect(await reader.peekBytes(1024)).to.match(/^-----BEGIN PGP MESSAGE-----\r\n/);
dataArrived();
reader.releaseLock();
const msgAsciiArmored = await openpgp.stream.readToEnd(encrypted.data);
const msgAsciiArmored = await openpgp.stream.readToEnd(encrypted);
const message = await openpgp.message.readArmored(msgAsciiArmored);
const decrypted = await openpgp.decrypt({
passwords: ['test'],
@ -212,11 +212,11 @@ function tests() {
message: openpgp.message.fromBinary(data),
passwords: ['test'],
});
const reader = openpgp.stream.getReader(encrypted.data);
const reader = openpgp.stream.getReader(encrypted);
expect(await reader.readBytes(1024)).to.match(/^-----BEGIN PGP MESSAGE-----\r\n/);
dataArrived();
reader.releaseLock();
await openpgp.stream.cancel(encrypted.data);
await openpgp.stream.cancel(encrypted);
expect(canceled).to.be.true;
});
@ -225,11 +225,11 @@ function tests() {
message: openpgp.message.fromBinary(data),
privateKeys: privKey
});
const reader = openpgp.stream.getReader(signed.data);
const reader = openpgp.stream.getReader(signed);
expect(await reader.readBytes(1024)).to.match(/^-----BEGIN PGP MESSAGE-----\r\n/);
dataArrived();
reader.releaseLock();
await openpgp.stream.cancel(signed.data);
await openpgp.stream.cancel(signed);
expect(canceled).to.be.true;
});
@ -239,9 +239,9 @@ function tests() {
passwords: ['test'],
armor: false
});
expect(util.isStream(encrypted.data)).to.equal(expectedType);
expect(util.isStream(encrypted)).to.equal(expectedType);
const message = await openpgp.message.read(encrypted.data);
const message = await openpgp.message.read(encrypted);
setTimeout(dataArrived, 3000); // Do not wait until data arrived, but wait a bit to check that it doesn't arrive early.
const decrypted = await openpgp.decrypt({
passwords: ['test'],
@ -264,9 +264,9 @@ function tests() {
passwords: ['test'],
armor: false
});
expect(util.isStream(encrypted.data)).to.equal(expectedType);
expect(util.isStream(encrypted)).to.equal(expectedType);
const message = await openpgp.message.read(encrypted.data);
const message = await openpgp.message.read(encrypted);
const decrypted = await openpgp.decrypt({
passwords: ['test'],
message,
@ -294,9 +294,9 @@ function tests() {
privateKeys: privKey,
armor: false
});
expect(util.isStream(encrypted.data)).to.equal(expectedType);
expect(util.isStream(encrypted)).to.equal(expectedType);
const message = await openpgp.message.read(encrypted.data);
const message = await openpgp.message.read(encrypted);
const decrypted = await openpgp.decrypt({
publicKeys: pubKey,
privateKeys: privKey,
@ -326,9 +326,9 @@ function tests() {
privateKeys: priv,
armor: false
});
expect(util.isStream(encrypted.data)).to.equal(expectedType);
expect(util.isStream(encrypted)).to.equal(expectedType);
const message = await openpgp.message.read(encrypted.data);
const message = await openpgp.message.read(encrypted);
const decrypted = await openpgp.decrypt({
publicKeys: pub,
privateKeys: priv,
@ -358,9 +358,9 @@ function tests() {
privateKeys: priv,
armor: false
});
expect(util.isStream(encrypted.data)).to.equal(expectedType);
expect(util.isStream(encrypted)).to.equal(expectedType);
const message = await openpgp.message.read(encrypted.data);
const message = await openpgp.message.read(encrypted);
const decrypted = await openpgp.decrypt({
publicKeys: pub,
privateKeys: priv,
@ -385,10 +385,9 @@ function tests() {
message: openpgp.message.fromBinary(data),
passwords: ['test']
});
expect(util.isStream(encrypted.data)).to.equal(expectedType);
expect(util.isStream(encrypted)).to.equal(expectedType);
const msgAsciiArmored = encrypted.data;
const message = await openpgp.message.readArmored(openpgp.stream.transform(msgAsciiArmored, value => {
const message = await openpgp.message.readArmored(openpgp.stream.transform(encrypted, value => {
value += '';
if (value === '=' || value.length === 6) return; // Remove checksum
const newlineIndex = value.indexOf('\r\n', 500);
@ -421,10 +420,9 @@ function tests() {
publicKeys: pubKey,
privateKeys: privKey
});
expect(util.isStream(encrypted.data)).to.equal(expectedType);
expect(util.isStream(encrypted)).to.equal(expectedType);
const msgAsciiArmored = encrypted.data;
const message = await openpgp.message.readArmored(openpgp.stream.transform(msgAsciiArmored, value => {
const message = await openpgp.message.readArmored(openpgp.stream.transform(encrypted, value => {
value += '';
const newlineIndex = value.indexOf('\r\n', 500);
if (value.length > 1000) return value.slice(0, newlineIndex - 1) + (value[newlineIndex - 1] === 'a' ? 'b' : 'a') + value.slice(newlineIndex);
@ -457,10 +455,9 @@ function tests() {
publicKeys: pubKey,
privateKeys: privKey
});
expect(util.isStream(encrypted.data)).to.equal(expectedType);
expect(util.isStream(encrypted)).to.equal(expectedType);
const msgAsciiArmored = encrypted.data;
const message = await openpgp.message.readArmored(openpgp.stream.transform(msgAsciiArmored, value => {
const message = await openpgp.message.readArmored(openpgp.stream.transform(encrypted, value => {
value += '';
const newlineIndex = value.indexOf('\r\n', 500);
if (value.length > 1000) return value.slice(0, newlineIndex - 1) + (value[newlineIndex - 1] === 'a' ? 'b' : 'a') + value.slice(newlineIndex);
@ -489,10 +486,9 @@ function tests() {
message: openpgp.message.fromBinary(data),
privateKeys: privKey
});
expect(util.isStream(signed.data)).to.equal(expectedType);
expect(util.isStream(signed)).to.equal(expectedType);
const msgAsciiArmored = signed.data;
const message = await openpgp.message.readArmored(openpgp.stream.transform(msgAsciiArmored, value => {
const message = await openpgp.message.readArmored(openpgp.stream.transform(signed, value => {
value += '';
const newlineIndex = value.indexOf('\r\n', 500);
if (value.length > 1000) return value.slice(0, newlineIndex - 1) + (value[newlineIndex - 1] === 'a' ? 'b' : 'a') + value.slice(newlineIndex);
@ -524,9 +520,9 @@ function tests() {
passwords: ['test'],
armor: false
});
expect(util.isStream(encrypted.data)).to.equal(expectedType);
expect(util.isStream(encrypted)).to.equal(expectedType);
const message = await openpgp.message.read(encrypted.data);
const message = await openpgp.message.read(encrypted);
const decrypted = await openpgp.decrypt({
passwords: ['test'],
message,
@ -568,10 +564,9 @@ function tests() {
streaming: expectedType,
passwords: ['test']
});
expect(util.isStream(encrypted.data)).to.equal(expectedType);
expect(util.isStream(encrypted)).to.equal(expectedType);
const msgAsciiArmored = encrypted.data;
const message = await openpgp.message.readArmored(msgAsciiArmored);
const message = await openpgp.message.readArmored(encrypted);
const decrypted = await openpgp.decrypt({
passwords: ['test'],
message
@ -623,8 +618,7 @@ function tests() {
passwords: ['test'],
});
const msgAsciiArmored = encrypted.data;
const message = await openpgp.message.readArmored(msgAsciiArmored);
const message = await openpgp.message.readArmored(encrypted);
const decrypted = await openpgp.decrypt({
passwords: ['test'],
message,
@ -648,10 +642,9 @@ function tests() {
message: openpgp.message.fromBinary(data),
privateKeys: privKey
});
expect(util.isStream(signed.data)).to.equal(expectedType);
expect(util.isStream(signed)).to.equal(expectedType);
const msgAsciiArmored = signed.data;
const message = await openpgp.message.readArmored(msgAsciiArmored);
const message = await openpgp.message.readArmored(signed);
const verified = await openpgp.verify({
publicKeys: pubKey,
message,
@ -673,9 +666,9 @@ function tests() {
message: openpgp.message.fromBinary(data),
passwords: ['test']
});
expect(util.isStream(encrypted.data)).to.equal(expectedType);
expect(util.isStream(encrypted)).to.equal(expectedType);
const reader = openpgp.stream.getReader(encrypted.data);
const reader = openpgp.stream.getReader(encrypted);
expect(await reader.readBytes(1024)).to.match(/^-----BEGIN PGP MESSAGE-----\r\n/);
dataArrived();
await new Promise(resolve => setTimeout(resolve, 3000));
@ -687,9 +680,9 @@ function tests() {
message: openpgp.message.fromBinary(data),
privateKeys: privKey
});
expect(util.isStream(signed.data)).to.equal(expectedType);
expect(util.isStream(signed)).to.equal(expectedType);
const reader = openpgp.stream.getReader(signed.data);
const reader = openpgp.stream.getReader(signed);
expect(await reader.readBytes(1024)).to.match(/^-----BEGIN PGP MESSAGE-----\r\n/);
dataArrived();
await new Promise(resolve => setTimeout(resolve, 3000));
@ -708,9 +701,8 @@ function tests() {
message: openpgp.message.fromBinary(data),
passwords: ['test']
});
expect(util.isStream(encrypted.data)).to.equal(expectedType);
const msgAsciiArmored = encrypted.data;
const message = await openpgp.message.readArmored(msgAsciiArmored);
expect(util.isStream(encrypted)).to.equal(expectedType);
const message = await openpgp.message.readArmored(encrypted);
const decrypted = await openpgp.decrypt({
passwords: ['test'],
message,
@ -734,9 +726,8 @@ function tests() {
message: openpgp.message.fromBinary(data),
privateKeys: privKey
});
expect(util.isStream(signed.data)).to.equal(expectedType);
const msgAsciiArmored = signed.data;
const message = await openpgp.message.readArmored(msgAsciiArmored);
expect(util.isStream(signed)).to.equal(expectedType);
const message = await openpgp.message.readArmored(signed);
const verified = await openpgp.verify({
publicKeys: pubKey,
message,
@ -765,8 +756,8 @@ function tests() {
detached: true,
streaming: expectedType
});
expect(util.isStream(signed.signature)).to.equal(expectedType);
const sigArmored = await openpgp.stream.readToEnd(signed.signature);
expect(util.isStream(signed)).to.equal(expectedType);
const sigArmored = await openpgp.stream.readToEnd(signed);
const signature = await openpgp.message.readArmored(sigArmored);
const verified = await openpgp.verify({
signature,
@ -794,8 +785,8 @@ function tests() {
streaming: false,
armor: false
});
expect(util.isStream(signed.signature)).to.be.false;
const signature = await openpgp.message.read(signed.signature);
expect(util.isStream(signed)).to.be.false;
const signature = await openpgp.message.read(signed);
const verified = await openpgp.verify({
signature,
publicKeys: pubKey,
@ -824,8 +815,8 @@ function tests() {
detached: true,
streaming: expectedType
});
expect(util.isStream(signed.signature)).to.equal(expectedType);
const sigArmored = await openpgp.stream.readToEnd(signed.signature);
expect(util.isStream(signed)).to.equal(expectedType);
const sigArmored = await openpgp.stream.readToEnd(signed);
const signature = await openpgp.message.readArmored(sigArmored);
const verified = await openpgp.verify({
signature,
@ -855,8 +846,8 @@ function tests() {
detached: true,
streaming: expectedType
});
expect(util.isStream(signed.signature)).to.equal(expectedType);
const sigArmored = await openpgp.stream.readToEnd(signed.signature);
expect(util.isStream(signed)).to.equal(expectedType);
const sigArmored = await openpgp.stream.readToEnd(signed);
const signature = await openpgp.message.readArmored(sigArmored);
const verified = await openpgp.verify({
signature,
@ -874,8 +865,8 @@ function tests() {
privateKeys: privKey,
detached: true
});
expect(util.isStream(signed.signature)).to.equal(expectedType);
const reader = openpgp.stream.getReader(signed.signature);
expect(util.isStream(signed)).to.equal(expectedType);
const reader = openpgp.stream.getReader(signed);
expect((await reader.readBytes(31)).toString('utf8')).to.equal('-----BEGIN PGP SIGNATURE-----\r\n');
dataArrived();
await new Promise(resolve => setTimeout(resolve, 3000));
@ -888,12 +879,12 @@ function tests() {
privateKeys: privKey,
detached: true
});
expect(util.isStream(signed.signature)).to.equal(expectedType);
const reader = openpgp.stream.getReader(signed.signature);
expect(util.isStream(signed)).to.equal(expectedType);
const reader = openpgp.stream.getReader(signed);
expect((await reader.readBytes(31)).toString('utf8')).to.equal('-----BEGIN PGP SIGNATURE-----\r\n');
dataArrived();
reader.releaseLock();
await openpgp.stream.cancel(signed.signature, new Error('canceled by test'));
await openpgp.stream.cancel(signed, new Error('canceled by test'));
expect(canceled).to.be.true;
});
}
@ -960,9 +951,9 @@ describe('Streaming', function() {
message: openpgp.message.fromText(data),
passwords: ['test']
});
expect(util.isStream(encrypted.data)).to.equal('node');
expect(util.isStream(encrypted)).to.equal('node');
const message = await openpgp.message.readArmored(encrypted.data);
const message = await openpgp.message.readArmored(encrypted);
const decrypted = await openpgp.decrypt({
passwords: ['test'],
message
@ -980,9 +971,9 @@ describe('Streaming', function() {
passwords: ['test'],
armor: false
});
expect(util.isStream(encrypted.data)).to.equal('node');
expect(util.isStream(encrypted)).to.equal('node');
const message = await openpgp.message.read(encrypted.data);
const message = await openpgp.message.read(encrypted);
const decrypted = await openpgp.decrypt({
passwords: ['test'],
message,

10
test/general/x25519.js
View File

@ -176,7 +176,7 @@ const input = require('./testInputs');
const priv = await load_priv_key(name);
const signed = await openpgp.sign({ privateKeys: [priv], message: openpgp.cleartext.fromText(randomData)});
const pub = await load_pub_key(name);
const msg = await openpgp.cleartext.readArmored(signed.data);
const msg = await openpgp.cleartext.readArmored(signed);
const result = await openpgp.verify({ publicKeys: [pub], message: msg});
expect(result).to.exist;
@ -203,7 +203,7 @@ const input = require('./testInputs');
const randomData = input.createSomeMessage();
const encrypted = await openpgp.encrypt({ publicKeys: [nightPublic], privateKeys: [lightPrivate], message: openpgp.message.fromText(randomData) });
const message = await openpgp.message.readArmored(encrypted.data);
const message = await openpgp.message.readArmored(encrypted);
const lightPublic = await load_pub_key('light');
const nightPrivate = await load_priv_key('night');
const result = await openpgp.decrypt({ privateKeys: nightPrivate, publicKeys: [lightPublic], message: message });
@ -495,7 +495,7 @@ function omnibus() {
openpgp.sign(
{ message: openpgp.cleartext.fromText('Hi, this is me, Hi!'), privateKeys: hi }
).then(async signed => {
const msg = await openpgp.cleartext.readArmored(signed.data);
const msg = await openpgp.cleartext.readArmored(signed);
// Verifying signed message
return Promise.all([
openpgp.verify(
@ -506,7 +506,7 @@ function omnibus() {
{
message: openpgp.message.fromText('Hi, this is me, Hi!'),
publicKeys: hi.toPublic(),
signature: await openpgp.signature.readArmored(signed.data)
signature: await openpgp.signature.readArmored(signed)
}
).then(output => expect(output.signatures[0].valid).to.be.true)
]);
@ -519,7 +519,7 @@ function omnibus() {
privateKeys: [hi]
}
).then(async encrypted => {
const msg = await openpgp.message.readArmored(encrypted.data);
const msg = await openpgp.message.readArmored(encrypted);
// Decrypting and verifying
return openpgp.decrypt(
{

2
test/security/subkey_trust.js
View File

@ -65,7 +65,7 @@ async function testSubkeyTrust() {
let fakeKey = new key.Key(newList);
fakeKey = (await key.readArmored(await fakeKey.toPublic().armor())).keys[0];
const verifyAttackerIsBatman = await openpgp.verify({
message: (await cleartext.readArmored(signed.data)),
message: (await cleartext.readArmored(signed)),
publicKeys: fakeKey,
streaming: false
});

2
test/worker/worker_example.js
View File

@ -45,7 +45,7 @@ onmessage = async function({ data: { action, message }, ports: [port] }) {
const { keys: publicKeys } = await openpgp.key.readArmored(publicKeyArmored);
const { keys: privateKeys } = await openpgp.key.readArmored(privateKeyArmored);
await privateKeys[0].decrypt('test');
const { data } = await openpgp.encrypt({
const data = await openpgp.encrypt({
message: openpgp.message.fromText(message),
publicKeys,
privateKeys