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

Consolidate read* functions (#1236)

Browse Source 
Make all `read*` functions accept an options object, so that we can add config
options to them later (for #1166). This is necessary so that we can remove the
global `openpgp.config`, which doesn't work that well when importing
individual functions.

Furthermore, merge `readMessage` and `readArmoredMessage` into one function,
et cetera.
This commit is contained in:
Daniel Huigens 2021-02-17 20:36:33 +01:00 committed by GitHub
parent 9ae0aae7a2
commit e1307b88d0
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
31 changed files with 789 additions and 751 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

143
README.md
View File

@ -147,17 +147,21 @@ Encryption will use the algorithm specified in config.encryptionCipher (defaults
```js
(async () => {
const message = openpgp.Message.fromBinary(new Uint8Array([0x01, 0x01, 0x01]));
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)
message, // input as Message object
passwords: ['secret stuff'], // multiple passwords possible
armor: false // don't ASCII armor (for Uint8Array output)
});
console.log(encrypted); // Uint8Array
const encryptedMessage = await openpgp.readMessage({
binaryMessage: encrypted // parse encrypted bytes
});
const { data: decrypted } = await openpgp.decrypt({
message: await openpgp.readMessage(encrypted), // parse encrypted bytes
passwords: ['secret stuff'], // decrypt with password
format: 'binary' // output as Uint8Array
message: encryptedMessage,
passwords: ['secret stuff'], // decrypt with password
format: 'binary' // output as Uint8Array
});
console.log(decrypted); // Uint8Array([0x01, 0x01, 0x01])
})();
@ -180,19 +184,25 @@ const openpgp = require('openpgp'); // use as CommonJS, AMD, ES6 module or via w
-----END PGP PRIVATE KEY BLOCK-----`; // encrypted private key
const passphrase = `yourPassphrase`; // what the private key is encrypted with
const privateKey = await openpgp.readArmoredKey(privateKeyArmored);
const publicKey = await openpgp.readKey({ armoredKey: publicKeyArmored });
const privateKey = await openpgp.readKey({ armoredKey: privateKeyArmored });
await privateKey.decrypt(passphrase);
const encrypted = await openpgp.encrypt({
message: openpgp.Message.fromText('Hello, World!'), // input as Message object
publicKeys: await openpgp.readArmoredKey(publicKeyArmored), // for encryption
privateKeys: privateKey // for signing (optional)
message: openpgp.Message.fromText('Hello, World!'), // input as Message object
publicKeys: publicKey, // for encryption
privateKeys: privateKey // for signing (optional)
});
console.log(encrypted); // '-----BEGIN PGP MESSAGE ... END PGP MESSAGE-----'
const message = await openpgp.readMessage({
armoredMessage: encrypted // parse armored message
});
const { data: decrypted } = await openpgp.decrypt({
message: await openpgp.readArmoredMessage(encrypted), // parse armored message
publicKeys: await openpgp.readArmoredKey(publicKeyArmored), // for verification (optional)
privateKeys: privateKey // for decryption
message,
publicKeys: publicKey, // for verification (optional)
privateKeys: privateKey // for decryption
});
console.log(decrypted); // 'Hello, World!'
})();
@ -216,15 +226,16 @@ Encrypt with multiple public keys:
const passphrase = `yourPassphrase`; // what the private key is encrypted with
const message = 'Hello, World!';
const privateKey = await openpgp.readArmoredKey(privateKeyArmored);
const publicKeys = await Promise.all(publicKeysArmored.map(armoredKey => openpgp.readKey({ armoredKey })));
const privateKey = await openpgp.readKey({ armoredKey: privateKeyArmored });
await privateKey.decrypt(passphrase)
const publicKeys = await Promise.all(publicKeysArmored.map(openpgp.readArmoredKey));
const message = openpgp.Message.fromText(message);
const encrypted = await openpgp.encrypt({
message: openpgp.Message.fromText(message), // input as Message object
publicKeys, // for encryption
privateKeys: [privateKey] // for signing (optional)
message:, // input as Message object
publicKeys, // for encryption
privateKeys: privateKey // for signing (optional)
});
console.log(encrypted); // '-----BEGIN PGP MESSAGE ... END PGP MESSAGE-----'
})();
@ -238,10 +249,11 @@ Either set the `compression` parameter in the options object when calling `encry
```js
(async () => {
const message = openpgp.Message.fromBinary(new Uint8Array([0x01, 0x02, 0x03])); // or .fromText('string')
const encrypted = await openpgp.encrypt({
message: openpgp.Message.fromBinary(new Uint8Array([0x01, 0x02, 0x03])), // or .fromText('string')
passwords: ['secret stuff'], // multiple passwords possible
compression: openpgp.enums.compression.zip // compress the data with zip
message,
passwords: ['secret stuff'], // multiple passwords possible
compression: openpgp.enums.compression.zip // compress the data with zip
});
})();
```
@ -268,12 +280,13 @@ Where the value can be any of:
}
});
const { message } = await openpgp.encrypt({
message: openpgp.Message.fromBinary(readableStream), // input as Message object
passwords: ['secret stuff'], // multiple passwords possible
armor: false // don't ASCII armor (for Uint8Array output)
const message = openpgp.Message.fromBinary(readableStream);
const encrypted = await openpgp.encrypt({
message, // 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 ReadableStream<Uint8Array>
console.log(encrypted); // raw encrypted packets as ReadableStream<Uint8Array>
// Either pipe the above stream somewhere, pass it to another function,
// or read it manually as follows:
@ -309,7 +322,9 @@ its [Reader class](https://openpgpjs.org/web-stream-tools/Reader.html).
-----END PGP PRIVATE KEY BLOCK-----`; // Encrypted private key
const passphrase = `yourPassphrase`; // Password that private key is encrypted with
const privateKey = await openpgp.readArmoredKey(privateKeyArmored);
const publicKey = await openpgp.readKey({ armoredKey: publicKeyArmored });
const privateKey = await openpgp.readKey({ armoredKey: privateKeyArmored });
await privateKey.decrypt(passphrase);
const readableStream = new openpgp.stream.ReadableStream({
@ -320,16 +335,19 @@ its [Reader class](https://openpgpjs.org/web-stream-tools/Reader.html).
});
const encrypted = await openpgp.encrypt({
message: openpgp.Message.fromText(readableStream), // input as Message object
publicKeys: await openpgp.readArmoredKey(publicKeyArmored), // for encryption
privateKeys: privateKey // for signing (optional)
message: openpgp.Message.fromText(readableStream), // input as Message object
publicKeys: publicKey, // for encryption
privateKeys: privateKey // for signing (optional)
});
console.log(encrypted); // ReadableStream containing '-----BEGIN PGP MESSAGE ... END PGP MESSAGE-----'
const message = await openpgp.readMessage({
armoredMessage: encrypted // parse armored message
});
const decrypted = await openpgp.decrypt({
message: await openpgp.readArmoredMessage(encrypted), // parse armored message
publicKeys: await openpgp.readArmoredKey(publicKeyArmored), // for verification (optional)
privateKeys: privateKey // for decryption
message,
publicKeys: publicKey, // for verification (optional)
privateKeys: privateKey // for decryption
});
const plaintext = await openpgp.stream.readToEnd(decrypted.data);
console.log(plaintext); // 'Hello, World!'
@ -378,7 +396,7 @@ Using a revocation certificate:
```js
(async () => {
const { publicKeyArmored: revokedKeyArmored } = await openpgp.revokeKey({
key: await openpgp.readArmoredKey(publicKeyArmored),
key: await openpgp.readKey({ armoredKey: publicKeyArmored }),
revocationCertificate
});
console.log(revokedKeyArmored); // '-----BEGIN PGP PUBLIC KEY BLOCK ... '
@ -389,7 +407,7 @@ Using the private key:
```js
(async () => {
const { publicKeyArmored, publicKey } = await openpgp.revokeKey({
key: await openpgp.readArmoredKey(privateKeyArmored)
key: await openpgp.readKey({ armoredKey: privateKeyArmored })
});
})();
```
@ -403,7 +421,7 @@ Using the private key:
let publicKeyArmored = await hkp.lookup({
query: 'alice@example.com'
});
let publicKey = await openpgp.readArmoredKey(publicKeyArmored);
let publicKey = await openpgp.readKey({ armoredKey: publicKeyArmored });
})();
```
@ -433,18 +451,24 @@ Using the private key:
-----END PGP PRIVATE KEY BLOCK-----`; // encrypted private key
const passphrase = `yourPassphrase`; // what the private key is encrypted with
const privateKey = await openpgp.readArmoredKey(privateKeyArmored);
const publicKey = await openpgp.readKey({ armoredKey: publicKeyArmored });
const privateKey = await openpgp.readKey({ armoredKey: privateKeyArmored });
await privateKey.decrypt(passphrase);
const cleartext = await openpgp.sign({
message: openpgp.CleartextMessage.fromText('Hello, World!'), // CleartextMessage or Message object
privateKeys: privateKey // for signing
const unsignedMessage = openpgp.CleartextMessage.fromText('Hello, World!');
const cleartextMessage = await openpgp.sign({
message: unsignedMessage, // CleartextMessage or Message object
privateKeys: privateKey // for signing
});
console.log(cleartext); // '-----BEGIN PGP SIGNED MESSAGE ... END PGP SIGNATURE-----'
console.log(cleartextMessage); // '-----BEGIN PGP SIGNED MESSAGE ... END PGP SIGNATURE-----'
const signedMessage = await openpgp.readCleartextMessage({
cleartextMessage // parse armored message
});
const verified = await openpgp.verify({
message: await openpgp.readArmoredCleartextMessage(cleartext), // parse armored message
publicKeys: await openpgp.readArmoredKey(publicKeyArmored) // for verification
message: signedMessage,
publicKeys: publicKey // for verification
});
const { valid } = verified.signatures[0];
if (valid) {
@ -467,20 +491,26 @@ Using the private key:
-----END PGP PRIVATE KEY BLOCK-----`; // encrypted private key
const passphrase = `yourPassphrase`; // what the private key is encrypted with
const privateKey = await openpgp.readArmoredKey(privateKeyArmored);
const publicKey = await openpgp.readKey({ armoredKey: publicKeyArmored });
const privateKey = await openpgp.readKey({ armoredKey: privateKeyArmored });
await privateKey.decrypt(passphrase);
const { signature: detachedSignature } = await openpgp.sign({
message: openpgp.CleartextMessage.fromText('Hello, World!'), // CleartextMessage or Message object
privateKeys: privateKey, // for signing
const cleartextMessage = openpgp.CleartextMessage.fromText('Hello, World!');
const detachedSignature = await openpgp.sign({
message: cleartextMessage, // CleartextMessage or Message object
privateKeys: privateKey, // for signing
detached: true
});
console.log(detachedSignature);
const signature = await openpgp.readSignature({
armoredSignature: detachedSignature // parse detached signature
});
const verified = await openpgp.verify({
message: openpgp.CleartextMessage.fromText('Hello, World!'), // CleartextMessage or Message object
signature: await openpgp.readArmoredSignature(detachedSignature), // parse detached signature
publicKeys: await openpgp.readArmoredKey(publicKeyArmored) // for verification
message: cleartextMessage, // CleartextMessage or Message object
signature,
publicKeys: publicKey // for verification
});
const { valid } = verified.signatures[0];
if (valid) {
@ -510,18 +540,19 @@ Using the private key:
-----END PGP PRIVATE KEY BLOCK-----`; // encrypted private key
const passphrase = `yourPassphrase`; // what the private key is encrypted with
const privateKey = await openpgp.readArmoredKey(privateKeyArmored);
const privateKey = await openpgp.readKey({ armoredKey: privateKeyArmored });
await privateKey.decrypt(passphrase);
const message = openpgp.Message.fromBinary(readableStream); // or .fromText(readableStream: ReadableStream<String>)
const signatureArmored = await openpgp.sign({
message: openpgp.Message.fromBinary(readableStream), // or .fromText(readableStream: ReadableStream<String>)
privateKeys: privateKey // for signing
message,
privateKeys: privateKey // for signing
});
console.log(signatureArmored); // ReadableStream containing '-----BEGIN PGP MESSAGE ... END PGP MESSAGE-----'
const verified = await openpgp.verify({
message: await openpgp.readArmoredMessage(signatureArmored), // parse armored signature
publicKeys: await openpgp.readArmoredKey(publicKeyArmored) // for verification
message: await openpgp.readMessage({ armoredMessage: signatureArmored }), // parse armored signature
publicKeys: await openpgp.readKey({ armoredKey: publicKeyArmored }) // for verification
});
await openpgp.stream.readToEnd(verified.data);

18
openpgp.d.ts vendored
View File

@ -9,10 +9,10 @@
/* ############## v5 KEY #################### */
export function readArmoredKey(armoredText: string): Promise<Key>;
export function readKey(data: Uint8Array): Promise<Key>;
export function readArmoredKeys(armoredText: string): Promise<Key[]>;
export function readKeys(data: Uint8Array): Promise<Key[]>;
export function readKey(options: { armoredKey: string }): Promise<Key>;
export function readKey(options: { binaryKey: Uint8Array }): Promise<Key>;
export function readKeys(options: { armoredKeys: string }): Promise<Key[]>;
export function readKeys(options: { binaryKeys: Uint8Array }): Promise<Key[]>;
export function generateKey(options: KeyOptions): Promise<KeyPair>;
export function generateSessionKey(options: { publicKeys: Key[], date?: Date, toUserIds?: UserID[] }): Promise<SessionKey>;
export function decryptKey(options: { privateKey: Key; passphrase?: string | string[]; }): Promise<Key>;
@ -85,8 +85,8 @@ type AlgorithmInfo = {
/* ############## v5 SIG #################### */
export function readArmoredSignature(armoredText: string): Promise<Signature>;
export function readSignature(input: Uint8Array): Promise<Signature>;
export function readSignature(options: { armoredSignature: string }): Promise<Signature>;
export function readSignature(options: { binarySignature: Uint8Array }): Promise<Signature>;
export class Signature {
public packets: PacketList<SignaturePacket>;
@ -102,7 +102,7 @@ interface VerificationResult {
/* ############## v5 CLEARTEXT #################### */
export function readArmoredCleartextMessage(armoredText: string): Promise<CleartextMessage>;
export function readCleartextMessage(options: { cleartextMessage: string }): Promise<CleartextMessage>;
/** Class that represents an OpenPGP cleartext signed message.
*/
@ -135,8 +135,8 @@ export class CleartextMessage {
/* ############## v5 MSG #################### */
export function readArmoredMessage<T extends MaybeStream<string>>(armoredText: T): Promise<Message<T>>;
export function readMessage<T extends MaybeStream<Uint8Array>>(input: T): Promise<Message<T>>;
export function readMessage<T extends MaybeStream<string>>(options: { armoredMessage: T }): Promise<Message<T>>;
export function readMessage<T extends MaybeStream<Uint8Array>>(options: { binaryMessage: T }): Promise<Message<T>>;
export function encrypt<T extends 'web' | 'node' | false>(options: EncryptOptions & { streaming: T, armor: false }): Promise<
T extends 'web' ? WebStream<Uint8Array> :

11
src/cleartext.js
View File

@ -157,14 +157,17 @@ export class CleartextMessage {
/**
* reads an OpenPGP cleartext signed message and returns a CleartextMessage object
* @param {String | ReadableStream<String>} armoredText text to be parsed
* Reads an OpenPGP cleartext signed message and returns a CleartextMessage object
* @param {String | ReadableStream<String>} cleartextMessage text to be parsed
* @returns {module:cleartext.CleartextMessage} new cleartext message object
* @async
* @static
*/
export async function readArmoredCleartextMessage(armoredText) {
const input = await unarmor(armoredText);
export async function readCleartextMessage({ cleartextMessage }) {
if (!cleartextMessage) {
throw new Error('readCleartextMessage: must pass options object containing `cleartextMessage`');
}
const input = await unarmor(cleartextMessage);
if (input.type !== enums.armor.signed) {
throw new Error('No cleartext signed message.');
}

15
src/index.js
View File

@ -15,32 +15,25 @@ export {
* @see module:key
* @name module:openpgp.key
*/
export {
readKey, readArmoredKey,
readKeys, readArmoredKeys,
Key
} from './key';
export { Key, readKey, readKeys } from './key';
/**
* @see module:signature
* @name module:openpgp.signature
*/
export * from './signature';
export { Signature, readSignature } from './signature';
/**
* @see module:message
* @name module:openpgp.message
*/
export {
readMessage, readArmoredMessage,
Message
} from './message';
export { Message, readMessage } from './message';
/**
* @see module:cleartext
* @name module:openpgp.cleartext
*/
export * from './cleartext';
export { CleartextMessage, readCleartextMessage } from './cleartext';
/**
* @see module:packet

74
src/key/factory.js
View File

@ -252,44 +252,55 @@ async function wrapKeyObject(secretKeyPacket, secretSubkeyPackets, options) {
}
/**
* Reads an unarmored OpenPGP key and returns a key object
* @param {Uint8Array} data to be parsed
* @returns {Promise<module:key.Key>} key object
* Reads an (optionally armored) OpenPGP key and returns a key object
* @param {String} armoredKey armored key to be parsed
* @param {Uint8Array} binaryKey binary key to be parsed
* @returns {Promise<Key>} key object
* @async
* @static
*/
export async function readKey(data) {
export async function readKey({ armoredKey, binaryKey }) {
if (!armoredKey && !binaryKey) {
throw new Error('readKey: must pass options object containing `armoredKey` or `binaryKey`');
}
let input;
if (armoredKey) {
const { type, data } = await unarmor(armoredKey);
if (!(type === enums.armor.publicKey || type === enums.armor.privateKey)) {
throw new Error('Armored text not of type key');
}
input = data;
} else {
input = binaryKey;
}
const packetlist = new PacketList();
await packetlist.read(data, helper.allowedKeyPackets);
await packetlist.read(input, helper.allowedKeyPackets);
return new Key(packetlist);
}
/**
* Reads an OpenPGP armored key and returns a key object
* @param {String | ReadableStream<String>} armoredKey text to be parsed
* @returns {Promise<module:key.Key>} key object
* Reads an (optionally armored) OpenPGP key block and returns a list of key objects
* @param {String | ReadableStream<String>} armoredKeys armored keys to be parsed
* @param {Uint8Array | ReadableStream<Uint8Array>} binaryKeys binary keys to be parsed
* @returns {Promise<Array<Key>>} key objects
* @async
* @static
*/
export async function readArmoredKey(armoredKey) {
const input = await unarmor(armoredKey);
if (!(input.type === enums.armor.publicKey || input.type === enums.armor.privateKey)) {
throw new Error('Armored text not of type key');
export async function readKeys({ armoredKeys, binaryKeys }) {
let input = armoredKeys || binaryKeys;
if (!input) {
throw new Error('readKeys: must pass options object containing `armoredKeys` or `binaryKeys`');
}
if (armoredKeys) {
const { type, data } = await unarmor(armoredKeys);
if (type !== enums.armor.publicKey && type !== enums.armor.privateKey) {
throw new Error('Armored text not of type key');
}
input = data;
}
return readKey(input.data);
}
/**
* Reads an unarmored OpenPGP key block and returns a list of key objects
* @param {Uint8Array} data to be parsed
* @returns {Promise<Array<module:key.Key>>} key object
* @async
* @static
*/
export async function readKeys(data) {
const keys = [];
const packetlist = new PacketList();
await packetlist.read(data, helper.allowedKeyPackets);
await packetlist.read(input, helper.allowedKeyPackets);
const keyIndex = packetlist.indexOfTag(enums.packet.publicKey, enums.packet.secretKey);
if (keyIndex.length === 0) {
throw new Error('No key packet found');
@ -301,18 +312,3 @@ export async function readKeys(data) {
}
return keys;
}
/**
* Reads an OpenPGP armored key block and returns a list of key objects
* @param {String | ReadableStream<String>} armoredKey text to be parsed
* @returns {Promise<Array<module:key.Key>>} key objects
* @async
* @static
*/
export async function readArmoredKeys(armoredKey) {
const input = await unarmor(armoredKey);
if (!(input.type === enums.armor.publicKey || input.type === enums.armor.privateKey)) {
throw new Error('Armored text not of type key');
}
return readKeys(input.data);
}

8
src/key/index.js
View File

@ -4,8 +4,8 @@
*/
import {
readKey, readArmoredKey,
readKeys, readArmoredKeys,
readKey,
readKeys,
generate,
reformat
} from './factory';
@ -20,8 +20,8 @@ import {
import Key from './key.js';
export {
readKey, readArmoredKey,
readKeys, readArmoredKeys,
readKey,
readKeys,
generate,
reformat,
getPreferredAlgo,

4
src/keyring/keyring.js
View File

@ -22,7 +22,7 @@
* @module keyring/keyring
*/
import { readArmoredKeys } from '../key';
import { readKeys } from '../key';
import LocalStore from './localstore';
/**
@ -80,7 +80,7 @@ class KeyArray {
* @async
*/
async importKey(armored) {
const imported = await readArmoredKeys(armored);
const imported = await readKeys({ armoredKeys: armored });
for (let i = 0; i < imported.length; i++) {
const key = imported[i];
// check if key already in key array

4
src/keyring/localstore.js
View File

@ -25,7 +25,7 @@
import stream from 'web-stream-tools';
import config from '../config';
import { readArmoredKey } from '../key';
import { readKey } from '../key';
/**
* The class that deals with storage of the keyring.
@ -97,7 +97,7 @@ async function loadKeys(storage, itemname) {
if (armoredKeys !== null && armoredKeys.length !== 0) {
let key;
for (let i = 0; i < armoredKeys.length; i++) {
key = await readArmoredKey(armoredKeys[i]);
key = await readKey({ armoredKey: armoredKeys[i] });
keys.push(key);
}
}

41
src/message.js
View File

@ -809,36 +809,29 @@ export async function createVerificationObjects(signatureList, literalDataList,
}
/**
* reads an OpenPGP armored message and returns a message object
* @param {String | ReadableStream<String>} armoredText text to be parsed
* @returns {Promise<module:message.Message>} new message object
* Reads an (optionally armored) OpenPGP message and returns a Message object
* @param {String | ReadableStream<String>} armoredMessage armored message to be parsed
* @param {Uint8Array | ReadableStream<Uint8Array>} binaryMessage binary to be parsed
* @returns {Promise<Message>} new message object
* @async
* @static
*/
export async function readArmoredMessage(armoredText) {
//TODO how do we want to handle bad text? Exception throwing
//TODO don't accept non-message armored texts
const streamType = util.isStream(armoredText);
if (streamType === 'node') {
armoredText = stream.nodeToWeb(armoredText);
export async function readMessage({ armoredMessage, binaryMessage }) {
let input = armoredMessage || binaryMessage;
if (!input) {
throw new Error('readMessage: must pass options object containing `armoredMessage` or `binaryMessage`');
}
const input = await unarmor(armoredText);
return readMessage(input.data, streamType);
}
/**
* reads an OpenPGP message as byte array and returns a message object
* @param {Uint8Array | ReadableStream<Uint8Array>} input binary message
* @param {Boolean} fromStream whether the message was created from a Stream
* @returns {Promise<module:message.Message>} new message object
* @async
* @static
*/
export async function readMessage(input, fromStream = util.isStream(input)) {
const streamType = util.isStream(input);
if (streamType === 'node') {
input = stream.nodeToWeb(input);
}
if (armoredMessage) {
const { type, data } = await unarmor(input);
if (type !== enums.armor.message) {
throw new Error('Armored text not of type message');
}
input = data;
}
const packetlist = new PacketList();
await packetlist.read(input, {
LiteralDataPacket,
@ -850,8 +843,8 @@ export async function readMessage(input, fromStream = util.isStream(input)) {
SymEncryptedSessionKeyPacket,
OnePassSignaturePacket,
SignaturePacket
}, fromStream);
}, streamType);
const message = new Message(packetlist);
message.fromStream = fromStream;
message.fromStream = streamType;
return message;
}

30
src/signature.js
View File

@ -55,25 +55,25 @@ export class Signature {
}
/**
* reads an OpenPGP armored signature and returns a signature object
* @param {String | ReadableStream<String>} armoredText text to be parsed
* reads an (optionally armored) OpenPGP signature and returns a signature object
* @param {String | ReadableStream<String>} armoredSignature armored signature to be parsed
* @param {Uint8Array | ReadableStream<Uint8Array>} binarySignature binary signature to be parsed
* @returns {Signature} new signature object
* @async
* @static
*/
export async function readArmoredSignature(armoredText) {
const input = await unarmor(armoredText);
return readSignature(input.data);
}
/**
* reads an OpenPGP signature as byte array and returns a signature object
* @param {Uint8Array | ReadableStream<Uint8Array>} input binary signature
* @returns {Signature} new signature object
* @async
* @static
*/
export async function readSignature(input) {
export async function readSignature({ armoredSignature, binarySignature }) {
let input = armoredSignature || binarySignature;
if (!input) {
throw new Error('readSignature: must pass options object containing `armoredSignature` or `binarySignature`');
}
if (armoredSignature) {
const { type, data } = await unarmor(input);
if (type !== enums.armor.signature) {
throw new Error('Armored text not of type signature');
}
input = data;
}
const packetlist = new PacketList();
await packetlist.read(input, { SignaturePacket });
return new Signature(packetlist);

2
src/wkd.js
View File

@ -78,7 +78,7 @@ class WKD {
if (options.rawBytes) {
return rawBytes;
}
return readKeys(rawBytes);
return readKeys({ binaryKeys: rawBytes });
}
}

34
test/crypto/ecdh.js
View File

@ -152,9 +152,9 @@ module.exports = () => describe('ECDH key exchange @lightweight', function () {
privateKey.subKeys[0].keyPacket.publicParams.Q = Q2;
privateKey.subKeys[0].keyPacket.privateParams.d = d2;
privateKey.subKeys[0].keyPacket.fingerprint = fingerprint1;
const message = await openpgp.encrypt({ publicKeys: [publicKey], message: openpgp.Message.fromText('test') });
const armoredMessage = await openpgp.encrypt({ publicKeys: [publicKey], message: openpgp.Message.fromText('test') });
await expect(
openpgp.decrypt({ privateKeys: [privateKey], message: await openpgp.readArmoredMessage(message) })
openpgp.decrypt({ privateKeys: [privateKey], message: await openpgp.readMessage({ armoredMessage }) })
).to.be.rejectedWith('Error decrypting message: Key Data Integrity failed');
});
it('Invalid fingerprint', async function () {
@ -165,9 +165,9 @@ module.exports = () => describe('ECDH key exchange @lightweight', function () {
privateKey.subKeys[0].keyPacket.publicParams.Q = Q2;
privateKey.subKeys[0].keyPacket.privateParams.d = d2;
privateKey.subKeys[0].keyPacket.fingerprint = fingerprint2;
const message = await openpgp.encrypt({ publicKeys: [publicKey], message: openpgp.Message.fromText('test') });
const armoredMessage = await openpgp.encrypt({ publicKeys: [publicKey], message: openpgp.Message.fromText('test') });
await expect(
openpgp.decrypt({ privateKeys: [privateKey], message: await openpgp.readArmoredMessage(message) })
openpgp.decrypt({ privateKeys: [privateKey], message: await openpgp.readMessage({ armoredMessage }) })
).to.be.rejectedWith('Error decrypting message: Session key decryption failed');
});
it('Different keys', async function () {
@ -178,9 +178,9 @@ module.exports = () => describe('ECDH key exchange @lightweight', function () {
privateKey.subKeys[0].keyPacket.publicParams.Q = Q1;
privateKey.subKeys[0].keyPacket.privateParams.d = d1;
privateKey.subKeys[0].keyPacket.fingerprint = fingerprint1;
const message = await openpgp.encrypt({ publicKeys: [publicKey], message: openpgp.Message.fromText('test') });
const armoredMessage = await openpgp.encrypt({ publicKeys: [publicKey], message: openpgp.Message.fromText('test') });
await expect(
openpgp.decrypt({ privateKeys: [privateKey], message: await openpgp.readArmoredMessage(message) })
openpgp.decrypt({ privateKeys: [privateKey], message: await openpgp.readMessage({ armoredMessage }) })
).to.be.rejectedWith('Error decrypting message: Key Data Integrity failed');
});
it('Successful exchange curve25519', async function () {
@ -191,9 +191,9 @@ module.exports = () => describe('ECDH key exchange @lightweight', function () {
privateKey.subKeys[0].keyPacket.publicParams.Q = Q1;
privateKey.subKeys[0].keyPacket.privateParams.d = d1;
privateKey.subKeys[0].keyPacket.fingerprint = fingerprint1;
const message = await openpgp.encrypt({ publicKeys: [publicKey], message: openpgp.Message.fromText('test') });
const armoredMessage = await openpgp.encrypt({ publicKeys: [publicKey], message: openpgp.Message.fromText('test') });
expect((
await openpgp.decrypt({ privateKeys: [privateKey], message: await openpgp.readArmoredMessage(message) })
await openpgp.decrypt({ privateKeys: [privateKey], message: await openpgp.readMessage({ armoredMessage }) })
).data).to.equal('test');
});
it('Successful exchange NIST P256', async function () {
@ -204,9 +204,9 @@ module.exports = () => describe('ECDH key exchange @lightweight', function () {
privateKey.subKeys[0].keyPacket.publicParams.Q = key_data.p256.pub;
privateKey.subKeys[0].keyPacket.privateParams.d = key_data.p256.priv;
privateKey.subKeys[0].keyPacket.fingerprint = fingerprint1;
const message = await openpgp.encrypt({ publicKeys: [publicKey], message: openpgp.Message.fromText('test') });
const armoredMessage = await openpgp.encrypt({ publicKeys: [publicKey], message: openpgp.Message.fromText('test') });
expect((
await openpgp.decrypt({ privateKeys: [privateKey], message: await openpgp.readArmoredMessage(message) })
await openpgp.decrypt({ privateKeys: [privateKey], message: await openpgp.readMessage({ armoredMessage }) })
).data).to.equal('test');
});
it('Successful exchange NIST P384', async function () {
@ -217,9 +217,9 @@ module.exports = () => describe('ECDH key exchange @lightweight', function () {
privateKey.subKeys[0].keyPacket.publicParams.Q = key_data.p384.pub;
privateKey.subKeys[0].keyPacket.privateParams.d = key_data.p384.priv;
privateKey.subKeys[0].keyPacket.fingerprint = fingerprint1;
const message = await openpgp.encrypt({ publicKeys: [publicKey], message: openpgp.Message.fromText('test') });
const armoredMessage = await openpgp.encrypt({ publicKeys: [publicKey], message: openpgp.Message.fromText('test') });
expect((
await openpgp.decrypt({ privateKeys: [privateKey], message: await openpgp.readArmoredMessage(message) })
await openpgp.decrypt({ privateKeys: [privateKey], message: await openpgp.readMessage({ armoredMessage }) })
).data).to.equal('test');
});
it('Successful exchange NIST P521', async function () {
@ -230,9 +230,9 @@ module.exports = () => describe('ECDH key exchange @lightweight', function () {
privateKey.subKeys[0].keyPacket.publicParams.Q = key_data.p521.pub;
privateKey.subKeys[0].keyPacket.privateParams.d = key_data.p521.priv;
privateKey.subKeys[0].keyPacket.fingerprint = fingerprint1;
const message = await openpgp.encrypt({ publicKeys: [publicKey], message: openpgp.Message.fromText('test') });
const armoredMessage = await openpgp.encrypt({ publicKeys: [publicKey], message: openpgp.Message.fromText('test') });
expect((
await openpgp.decrypt({ privateKeys: [privateKey], message: await openpgp.readArmoredMessage(message) })
await openpgp.decrypt({ privateKeys: [privateKey], message: await openpgp.readMessage({ armoredMessage }) })
).data).to.equal('test');
});
@ -246,15 +246,15 @@ module.exports = () => describe('ECDH key exchange @lightweight', function () {
privateKey.subKeys[0].keyPacket.publicParams.Q = key_data[name].pub;
privateKey.subKeys[0].keyPacket.privateParams.d = key_data[name].priv;
privateKey.subKeys[0].keyPacket.fingerprint = fingerprint1;
const message = await openpgp.encrypt({ publicKeys: [publicKey], message: openpgp.Message.fromText('test') });
const armoredMessage = await openpgp.encrypt({ publicKeys: [publicKey], message: openpgp.Message.fromText('test') });
expect((
await openpgp.decrypt({ privateKeys: [privateKey], message: await openpgp.readArmoredMessage(message) })
await openpgp.decrypt({ privateKeys: [privateKey], message: await openpgp.readMessage({ armoredMessage }) })
).data).to.equal('test');
const useNative = openpgp.config.useNative;
openpgp.config.useNative = !useNative;
try {
expect((
await openpgp.decrypt({ privateKeys: [privateKey], message: await openpgp.readArmoredMessage(message) })
await openpgp.decrypt({ privateKeys: [privateKey], message: await openpgp.readMessage({ armoredMessage }) })
).data).to.equal('test');
} finally {
openpgp.config.useNative = useNative;

4
test/crypto/validate.js
View File

@ -269,7 +269,7 @@ module.exports = () => {
describe('DSA parameter validation', function() {
let dsaKey;
before(async () => {
dsaKey = await openpgp.readArmoredKey(armoredDSAKey);
dsaKey = await openpgp.readKey({ armoredKey: armoredDSAKey });
});
it('DSA params should be valid', async function() {
@ -306,7 +306,7 @@ module.exports = () => {
describe('ElGamal parameter validation', function() {
let egKey;
before(async () => {
egKey = (await openpgp.readArmoredKey(armoredElGamalKey)).subKeys[0];
egKey = (await openpgp.readKey({ armoredKey: armoredElGamalKey })).subKeys[0];
});
it('params should be valid', async function() {

62
test/general/armor.js
View File

@ -28,55 +28,55 @@ module.exports = () => describe("ASCII armor", function() {
it('Parse cleartext signed message', async function () {
let msg = getArmor(['Hash: SHA1']);
msg = await openpgp.readArmoredCleartextMessage(msg);
msg = await openpgp.readCleartextMessage({ cleartextMessage: msg });
expect(msg).to.be.an.instanceof(openpgp.CleartextMessage);
});
it('Exception if mismatch in armor header and signature', async function () {
let msg = getArmor(['Hash: SHA256']);
msg = openpgp.readArmoredCleartextMessage(msg);
msg = openpgp.readCleartextMessage({ cleartextMessage: msg });
await expect(msg).to.be.rejectedWith(Error, /Hash algorithm mismatch in armor header and signature/);
});
it('Exception if no header and non-MD5 signature', async function () {
let msg = getArmor(null);
msg = openpgp.readArmoredCleartextMessage(msg);
msg = openpgp.readCleartextMessage({ cleartextMessage: msg });
await expect(msg).to.be.rejectedWith(Error, /If no "Hash" header in cleartext signed message, then only MD5 signatures allowed/);
});
it('Exception if unknown hash algorithm', async function () {
let msg = getArmor(['Hash: LAV750']);
msg = openpgp.readArmoredCleartextMessage(msg);
msg = openpgp.readCleartextMessage({ cleartextMessage: msg });
await expect(msg).to.be.rejectedWith(Error, /Unknown hash algorithm in armor header/);
});
it('Multiple hash values', async function () {
let msg = getArmor(['Hash: SHA1, SHA256']);
msg = await openpgp.readArmoredCleartextMessage(msg);
msg = await openpgp.readCleartextMessage({ cleartextMessage: msg });
expect(msg).to.be.an.instanceof(openpgp.CleartextMessage);
});
it('Multiple hash header lines', async function () {
let msg = getArmor(['Hash: SHA1', 'Hash: SHA256']);
msg = await openpgp.readArmoredCleartextMessage(msg);
msg = await openpgp.readCleartextMessage({ cleartextMessage: msg });
expect(msg).to.be.an.instanceof(openpgp.CleartextMessage);
});
it('Non-hash header line throws exception', async function () {
let msg = getArmor(['Hash: SHA1', 'Comment: could be anything']);
msg = openpgp.readArmoredCleartextMessage(msg);
msg = openpgp.readCleartextMessage({ cleartextMessage: msg });
await expect(msg).to.be.rejectedWith(Error, /Only "Hash" header allowed in cleartext signed message/);
});
it('Multiple wrong hash values', async function () {
let msg = getArmor(['Hash: SHA512, SHA256']);
msg = openpgp.readArmoredCleartextMessage(msg);
msg = openpgp.readCleartextMessage({ cleartextMessage: msg });
await expect(msg).to.be.rejectedWith(Error, /Hash algorithm mismatch in armor header and signature/);
});
it('Multiple wrong hash values', async function () {
let msg = getArmor(['Hash: SHA512, SHA256']);
msg = openpgp.readArmoredCleartextMessage(msg);
msg = openpgp.readCleartextMessage({ cleartextMessage: msg });
await expect(msg).to.be.rejectedWith(Error, /Hash algorithm mismatch in armor header and signature/);
});
@ -97,33 +97,33 @@ module.exports = () => describe("ASCII armor", function() {
'-----END PGP SIGNATURE-----'
].join('\n');
msg = await openpgp.readArmoredCleartextMessage(msg);
msg = await openpgp.readCleartextMessage({ cleartextMessage: msg });
expect(msg).to.be.an.instanceof(openpgp.CleartextMessage);
});
it('Exception if improperly formatted armor header - plaintext section', async function () {
let msg = getArmor(['Hash:SHA256']);
msg = openpgp.readArmoredCleartextMessage(msg);
msg = openpgp.readCleartextMessage({ cleartextMessage: msg });
await expect(msg).to.be.rejectedWith(Error, /Improperly formatted armor header/);
msg = getArmor(['Ha sh: SHA256']);
msg = openpgp.readArmoredCleartextMessage(msg);
msg = openpgp.readCleartextMessage({ cleartextMessage: msg });
await expect(msg).to.be.rejectedWith(Error, /Only "Hash" header allowed in cleartext signed message/);
msg = getArmor(['Hash SHA256']);
msg = openpgp.readArmoredCleartextMessage(msg);
msg = openpgp.readCleartextMessage({ cleartextMessage: msg });
await expect(msg).to.be.rejectedWith(Error, /Improperly formatted armor header/);
});
it('Exception if improperly formatted armor header - signature section', async function () {
await Promise.all(['Space : trailing', 'Space :switched', ': empty', 'none', 'Space:missing'].map(async function (invalidHeader) {
await expect(openpgp.readArmoredCleartextMessage(getArmor(['Hash: SHA1'], [invalidHeader]))).to.be.rejectedWith(Error, /Improperly formatted armor header/);
await expect(openpgp.readCleartextMessage({ cleartextMessage: getArmor(['Hash: SHA1'], [invalidHeader]) })).to.be.rejectedWith(Error, /Improperly formatted armor header/);
}));
});
it('Ignore unknown armor header - signature section', async function () {
const validHeaders = ['Version: BCPG C# v1.7.4114.6375', 'Independent Reserve Pty. Ltd. 2017: 1.0.0.0'];
expect(await openpgp.readArmoredCleartextMessage(getArmor(['Hash: SHA1'], validHeaders))).to.be.an.instanceof(openpgp.CleartextMessage);
expect(await openpgp.readCleartextMessage({ cleartextMessage: getArmor(['Hash: SHA1'], validHeaders) })).to.be.an.instanceof(openpgp.CleartextMessage);
await Promise.all(['A: Hello', 'Ab: 1.2.3', 'Abcd: #!/yah', 'Acd 123 5.6.$.8: Hello', '_: Hello', '*: Hello', '* & ## ?? ()(): Hello', '( ): Weird'].map(async function (validHeader) {
expect(await openpgp.readArmoredCleartextMessage(getArmor(['Hash: SHA1'], [validHeader]))).to.be.an.instanceof(openpgp.CleartextMessage);
expect(await openpgp.readCleartextMessage({ cleartextMessage: getArmor(['Hash: SHA1'], [validHeader]) })).to.be.an.instanceof(openpgp.CleartextMessage);
}));
});
@ -143,7 +143,7 @@ module.exports = () => describe("ASCII armor", function() {
'-----END PGP SIGNNATURE-----'
].join('\n');
msg = openpgp.readArmoredCleartextMessage(msg);
msg = openpgp.readCleartextMessage({ cleartextMessage: msg });
await expect(msg).to.be.rejectedWith(Error, /Unknown ASCII armor type/);
});
@ -170,11 +170,11 @@ module.exports = () => describe("ASCII armor", function() {
].join('\n');
// try with default config
await expect(openpgp.readArmoredKey(privKey)).to.be.rejectedWith(/Ascii armor integrity check on message failed/);
await expect(openpgp.readKey({ armoredKey: privKey })).to.be.rejectedWith(/Ascii armor integrity check on message failed/);
// try opposite config
openpgp.config.checksumRequired = !openpgp.config.checksumRequired;
await expect(openpgp.readArmoredKey(privKey)).to.be.rejectedWith(/Ascii armor integrity check on message failed/);
await expect(openpgp.readKey({ armoredKey: privKey })).to.be.rejectedWith(/Ascii armor integrity check on message failed/);
// back to default
openpgp.config.checksumRequired = !openpgp.config.checksumRequired;
@ -202,11 +202,11 @@ module.exports = () => describe("ASCII armor", function() {
'-----END PGP PRIVATE KEY BLOCK-----'].join('\n');
// try with default config
await openpgp.readArmoredKey(privKey);
await openpgp.readKey({ armoredKey: privKey });
// try opposite config
openpgp.config.checksumRequired = !openpgp.config.checksumRequired;
await openpgp.readArmoredKey(privKey);
await openpgp.readKey({ armoredKey: privKey });
// back to default
openpgp.config.checksumRequired = !openpgp.config.checksumRequired;
@ -234,17 +234,17 @@ module.exports = () => describe("ASCII armor", function() {
// try with default config
if (openpgp.config.checksumRequired) {
await expect(openpgp.readArmoredKey(privKeyNoCheckSum)).to.be.rejectedWith(/Ascii armor integrity check on message failed/);
await expect(openpgp.readKey({ armoredKey: privKeyNoCheckSum })).to.be.rejectedWith(/Ascii armor integrity check on message failed/);
} else {
await openpgp.readArmoredKey(privKeyNoCheckSum);
await openpgp.readKey({ armoredKey: privKeyNoCheckSum });
}
// try opposite config
openpgp.config.checksumRequired = !openpgp.config.checksumRequired;
if (openpgp.config.checksumRequired) {
await expect(openpgp.readArmoredKey(privKeyNoCheckSum)).to.be.rejectedWith(/Ascii armor integrity check on message failed/);
await expect(openpgp.readKey({ armoredKey: privKeyNoCheckSum })).to.be.rejectedWith(/Ascii armor integrity check on message failed/);
} else {
await openpgp.readArmoredKey(privKeyNoCheckSum);
await openpgp.readKey({ armoredKey: privKeyNoCheckSum });
}
// back to default
@ -274,17 +274,17 @@ module.exports = () => describe("ASCII armor", function() {
// try with default config
if (openpgp.config.checksumRequired) {
await expect(openpgp.readArmoredKey(privKeyNoCheckSumWithTrailingNewline)).to.be.rejectedWith(/Ascii armor integrity check on message failed/);
await expect(openpgp.readKey({ armoredKey: privKeyNoCheckSumWithTrailingNewline })).to.be.rejectedWith(/Ascii armor integrity check on message failed/);
} else {
await openpgp.readArmoredKey(privKeyNoCheckSumWithTrailingNewline);
await openpgp.readKey({ armoredKey: privKeyNoCheckSumWithTrailingNewline });
}
// try opposite config
openpgp.config.checksumRequired = !openpgp.config.checksumRequired;
if (openpgp.config.checksumRequired) {
await expect(openpgp.readArmoredKey(privKeyNoCheckSumWithTrailingNewline)).to.be.rejectedWith(/Ascii armor integrity check on message failed/);
await expect(openpgp.readKey({ armoredKey: privKeyNoCheckSumWithTrailingNewline })).to.be.rejectedWith(/Ascii armor integrity check on message failed/);
} else {
await openpgp.readArmoredKey(privKeyNoCheckSumWithTrailingNewline);
await openpgp.readKey({ armoredKey: privKeyNoCheckSumWithTrailingNewline });
}
// back to default
@ -314,13 +314,13 @@ module.exports = () => describe("ASCII armor", function() {
''
].join('\t \r\n');
const result = await openpgp.readArmoredKey(privKey);
const result = await openpgp.readKey({ armoredKey: privKey });
expect(result).to.be.an.instanceof(openpgp.Key);
});
it('Do not filter blank lines after header', async function () {
let msg = getArmor(['Hash: SHA1', '']);
msg = await openpgp.readArmoredCleartextMessage(msg);
msg = await openpgp.readCleartextMessage({ cleartextMessage: msg });
expect(msg.text).to.equal('\r\nsign this');
});

32
test/general/brainpool.js
View File

@ -173,7 +173,7 @@ EJ4QcD/oQ6x1M/8X/iKQCtxZP8RnlrbH7ExkNON5s5g=
if (data[name].pub_key) {
return data[name].pub_key;
}
const pub = await openpgp.readArmoredKey(data[name].pub);
const pub = await openpgp.readKey({ armoredKey: data[name].pub });
expect(pub.getKeyId().toHex()).to.equal(data[name].id);
data[name].pub_key = pub;
return pub;
@ -182,7 +182,7 @@ EJ4QcD/oQ6x1M/8X/iKQCtxZP8RnlrbH7ExkNON5s5g=
if (data[name].priv_key) {
return data[name].priv_key;
}
const pk = await openpgp.readArmoredKey(data[name].priv);
const pk = await openpgp.readKey({ armoredKey: data[name].priv });
expect(pk).to.exist;
expect(pk.getKeyId().toHex()).to.equal(data[name].id);
await pk.decrypt(data[name].pass);
@ -200,7 +200,7 @@ EJ4QcD/oQ6x1M/8X/iKQCtxZP8RnlrbH7ExkNON5s5g=
});
it('Verify clear signed message', async function () {
const pub = await load_pub_key('juliet');
const msg = await openpgp.readArmoredCleartextMessage(data.juliet.message_signed);
const msg = await openpgp.readCleartextMessage({ cleartextMessage: data.juliet.message_signed });
return openpgp.verify({ publicKeys: [pub], message: msg }).then(function(result) {
expect(result).to.exist;
expect(result.data).to.equal(data.juliet.message);
@ -212,7 +212,7 @@ EJ4QcD/oQ6x1M/8X/iKQCtxZP8RnlrbH7ExkNON5s5g=
const romeoPrivate = await load_priv_key('romeo');
const signed = await openpgp.sign({ privateKeys: [romeoPrivate], message: openpgp.CleartextMessage.fromText(data.romeo.message) });
const romeoPublic = await load_pub_key('romeo');
const msg = await openpgp.readArmoredCleartextMessage(signed);
const msg = await openpgp.readCleartextMessage({ cleartextMessage: signed });
const result = await openpgp.verify({ publicKeys: [romeoPublic], message: msg });
expect(result).to.exist;
@ -223,7 +223,7 @@ EJ4QcD/oQ6x1M/8X/iKQCtxZP8RnlrbH7ExkNON5s5g=
it('Decrypt and verify message', async function () {
const juliet = await load_pub_key('juliet');
const romeo = await load_priv_key('romeo');
const msg = await openpgp.readArmoredMessage(data.romeo.message_encrypted);
const msg = await openpgp.readMessage({ armoredMessage: data.romeo.message_encrypted });
const result = await openpgp.decrypt({ privateKeys: romeo, publicKeys: [juliet], message: msg });
expect(result).to.exist;
@ -234,7 +234,7 @@ EJ4QcD/oQ6x1M/8X/iKQCtxZP8RnlrbH7ExkNON5s5g=
it('Decrypt and verify message with leading zero in hash', async function () {
const juliet = await load_priv_key('juliet');
const romeo = await load_pub_key('romeo');
const msg = await openpgp.readArmoredMessage(data.romeo.message_encrypted_with_leading_zero_in_hash);
const msg = await openpgp.readMessage({ armoredMessage: data.romeo.message_encrypted_with_leading_zero_in_hash });
const result = await openpgp.decrypt({ privateKeys: juliet, publicKeys: [romeo], message: msg });
expect(result).to.exist;
@ -248,7 +248,7 @@ EJ4QcD/oQ6x1M/8X/iKQCtxZP8RnlrbH7ExkNON5s5g=
openpgp.config.useNative = false;
const juliet = await load_priv_key('juliet');
const romeo = await load_pub_key('romeo');
const msg = await openpgp.readArmoredMessage(data.romeo.message_encrypted_with_leading_zero_in_hash_signed_by_elliptic_with_old_implementation);
const msg = await openpgp.readMessage({ armoredMessage: data.romeo.message_encrypted_with_leading_zero_in_hash_signed_by_elliptic_with_old_implementation });
const result = await openpgp.decrypt({ privateKeys: juliet, publicKeys: [romeo], message: msg });
openpgp.config.useNative = useNative;
expect(result).to.exist;
@ -262,7 +262,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.readArmoredMessage(encrypted);
const message = await openpgp.readMessage({ armoredMessage: 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,20 +297,18 @@ function omnibus() {
openpgp.sign(
{ message: openpgp.CleartextMessage.fromText(testData), privateKeys: hi }
).then(async signed => {
const msg = await openpgp.readArmoredCleartextMessage(signed);
const msg = await openpgp.readCleartextMessage({ cleartextMessage: signed });
// Verifying signed message
return Promise.all([
openpgp.verify(
{ message: msg, publicKeys: pubHi }
).then(output => expect(output.signatures[0].valid).to.be.true),
// Verifying detached signature
openpgp.verify(
{
message: openpgp.CleartextMessage.fromText(testData),
publicKeys: pubHi,
signature: await openpgp.readArmoredSignature(signed)
}
).then(output => expect(output.signatures[0].valid).to.be.true)
openpgp.verify({
message: openpgp.CleartextMessage.fromText(testData),
publicKeys: pubHi,
signature: msg.signature
}).then(output => expect(output.signatures[0].valid).to.be.true)
]);
}),
// Encrypting and signing
@ -321,7 +319,7 @@ function omnibus() {
privateKeys: [hi]
}
).then(async encrypted => {
const msg = await openpgp.readArmoredMessage(encrypted);
const msg = await openpgp.readMessage({ armoredMessage: encrypted });
// Decrypting and verifying
return openpgp.decrypt(
{

2
test/general/decompression.js
View File

@ -44,7 +44,7 @@ module.exports = () => describe('Decrypt and decompress message tests', function
function runTest(key, test) {
it(`Decrypts message compressed with ${key}`, async function () {
const message = await openpgp.readArmoredMessage(test.input);
const message = await openpgp.readMessage({ armoredMessage: test.input });
const options = {
passwords: password,
message

18
test/general/ecc_nist.js
View File

@ -27,18 +27,18 @@ module.exports = () => describe('Elliptic Curve Cryptography for NIST P-256,P-38
openpgp.sign(
{ message: openpgp.CleartextMessage.fromText(testData), privateKeys: hi }
).then(async signed => {
const msg = await openpgp.readArmoredCleartextMessage(signed);
const msg = await openpgp.readCleartextMessage({ cleartextMessage: signed });
// Verifying signed message
return Promise.all([
openpgp.verify(
{ message: msg, publicKeys: pubHi }
).then(output => expect(output.signatures[0].valid).to.be.true),
// Verifying detached signature
openpgp.verify(
{ message: openpgp.CleartextMessage.fromText(testData),
publicKeys: pubHi,
signature: await openpgp.readArmoredSignature(signed) }
).then(output => expect(output.signatures[0].valid).to.be.true)
openpgp.verify({
message: openpgp.CleartextMessage.fromText(testData),
publicKeys: pubHi,
signature: msg.signature
}).then(output => expect(output.signatures[0].valid).to.be.true)
]);
}),
// Encrypting and signing
@ -47,7 +47,7 @@ module.exports = () => describe('Elliptic Curve Cryptography for NIST P-256,P-38
publicKeys: [pubBye],
privateKeys: [hi] }
).then(async encrypted => {
const msg = await openpgp.readArmoredMessage(encrypted);
const msg = await openpgp.readMessage({ armoredMessage: encrypted });
// Decrypting and verifying
return openpgp.decrypt(
{ message: msg,
@ -71,7 +71,7 @@ module.exports = () => describe('Elliptic Curve Cryptography for NIST P-256,P-38
const options = { userIds: { name: "Hi", email: "hi@hel.lo" }, curve: "p256" };
const firstKey = await openpgp.generateKey(options);
const signature = await openpgp.sign({ message: openpgp.CleartextMessage.fromText(testData), privateKeys: firstKey.key });
const msg = await openpgp.readArmoredCleartextMessage(signature);
const msg = await openpgp.readCleartextMessage({ cleartextMessage: signature });
const result = await openpgp.verify({ message: msg, publicKeys: firstKey.key.toPublic() });
expect(result.signatures[0].valid).to.be.true;
});
@ -87,7 +87,7 @@ module.exports = () => describe('Elliptic Curve Cryptography for NIST P-256,P-38
publicKeys: [secondKey.key.toPublic()],
privateKeys: [firstKey.key] }
);
const msg = await openpgp.readArmoredMessage(encrypted);
const msg = await openpgp.readMessage({ armoredMessage: encrypted });
const result = await openpgp.decrypt(
{ message: msg,
privateKeys: secondKey.key,

12
test/general/ecc_secp256k1.js
View File

@ -140,7 +140,7 @@ module.exports = () => describe('Elliptic Curve Cryptography for secp256k1 curve
if (data[name].pub_key) {
return data[name].pub_key;
}
const pub = await openpgp.readArmoredKey(data[name].pub);
const pub = await openpgp.readKey({ armoredKey: data[name].pub });
expect(pub).to.exist;
expect(pub.getKeyId().toHex()).to.equal(data[name].id);
data[name].pub_key = pub;
@ -150,7 +150,7 @@ module.exports = () => describe('Elliptic Curve Cryptography for secp256k1 curve
if (data[name].priv_key) {
return data[name].priv_key;
}
const pk = await openpgp.readArmoredKey(data[name].priv);
const pk = await openpgp.readKey({ armoredKey: data[name].priv });
expect(pk).to.exist;
expect(pk.getKeyId().toHex()).to.equal(data[name].id);
await pk.decrypt(data[name].pass);
@ -174,7 +174,7 @@ module.exports = () => describe('Elliptic Curve Cryptography for secp256k1 curve
});
it('Verify clear signed message', async function () {
const pub = await load_pub_key('juliet');
const msg = await openpgp.readArmoredCleartextMessage(data.juliet.message_signed);
const msg = await openpgp.readCleartextMessage({ cleartextMessage: data.juliet.message_signed });
return openpgp.verify({ publicKeys: [pub], message: msg }).then(function(result) {
expect(result).to.exist;
expect(result.data).to.equal(data.juliet.message);
@ -186,7 +186,7 @@ module.exports = () => describe('Elliptic Curve Cryptography for secp256k1 curve
const romeoPrivate = await load_priv_key('romeo');
const signed = await openpgp.sign({ privateKeys: [romeoPrivate], message: openpgp.CleartextMessage.fromText(data.romeo.message) });
const romeoPublic = await load_pub_key('romeo');
const msg = await openpgp.readArmoredCleartextMessage(signed);
const msg = await openpgp.readCleartextMessage({ cleartextMessage: signed });
const result = await openpgp.verify({ publicKeys: [romeoPublic], message: msg });
expect(result).to.exist;
@ -197,7 +197,7 @@ module.exports = () => describe('Elliptic Curve Cryptography for secp256k1 curve
it('Decrypt and verify message', async function () {
const juliet = await load_pub_key('juliet');
const romeo = await load_priv_key('romeo');
const msg = await openpgp.readArmoredMessage(data.juliet.message_encrypted);
const msg = await openpgp.readMessage({ armoredMessage: data.juliet.message_encrypted });
const result = await openpgp.decrypt({ privateKeys: romeo, publicKeys: [juliet], message: msg });
expect(result).to.exist;
@ -210,7 +210,7 @@ module.exports = () => describe('Elliptic Curve Cryptography for secp256k1 curve
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.readArmoredMessage(encrypted);
const message = await openpgp.readMessage({ armoredMessage: 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 });

287
test/general/key.js
View File

@ -2107,7 +2107,7 @@ function versionSpecificTests() {
const opt = { userIds: { name: 'test', email: 'a@b.com' }, passphrase: 'hello' };
return openpgp.generateKey(opt).then(async function(key) {
testPref(key.key);
testPref(await openpgp.readArmoredKey(key.publicKeyArmored));
testPref(await openpgp.readKey({ armoredKey: key.publicKeyArmored }));
});
});
@ -2153,7 +2153,7 @@ function versionSpecificTests() {
try {
const key = await openpgp.generateKey(opt);
testPref(key.key);
testPref(await openpgp.readArmoredKey(key.publicKeyArmored));
testPref(await openpgp.readKey({ armoredKey: key.publicKeyArmored }));
} finally {
openpgp.config.encryptionCipher = encryptionCipherVal;
openpgp.config.preferHashAlgorithm = preferHashAlgorithmVal;
@ -2325,7 +2325,7 @@ function versionSpecificTests() {
const userId = { name: 'test', email: 'a@b.com' };
const opt = { userIds: [userId], passphrase: '123', subkeys:[{}, { sign: true }] };
return openpgp.generateKey(opt).then(async function({ privateKeyArmored }) {
const key = await openpgp.readArmoredKey(privateKeyArmored);
const key = await openpgp.readKey({ armoredKey: privateKeyArmored });
expect(key.users.length).to.equal(1);
expect(key.users[0].userId.userid).to.equal('test <a@b.com>');
expect(key.users[0].selfCertifications[0].isPrimaryUserID).to.be.true;
@ -2344,7 +2344,7 @@ function versionSpecificTests() {
await key.decrypt('123');
return openpgp.reformatKey({ privateKey: key, userIds: [userId] });
}).then(async function({ privateKeyArmored }) {
const key = await openpgp.readArmoredKey(privateKeyArmored);
const key = await openpgp.readKey({ armoredKey: privateKeyArmored });
expect(key.users.length).to.equal(1);
expect(key.users[0].userId.userid).to.equal('test <a@b.com>');
expect(key.users[0].selfCertifications[0].isPrimaryUserID).to.be.true;
@ -2417,8 +2417,8 @@ function versionSpecificTests() {
});
it('Sign and verify key - primary user', async function() {
let publicKey = await openpgp.readArmoredKey(pub_sig_test);
const privateKey = await openpgp.readArmoredKey(priv_key_rsa);
let publicKey = await openpgp.readKey({ armoredKey: pub_sig_test });
const privateKey = await openpgp.readKey({ armoredKey: priv_key_rsa });
await privateKey.decrypt('hello world');
publicKey = await publicKey.signPrimaryUser([privateKey]);
const signatures = await publicKey.verifyPrimaryUser([privateKey]);
@ -2432,9 +2432,9 @@ function versionSpecificTests() {
});
it('Sign key and verify with wrong key - primary user', async function() {
let publicKey = await openpgp.readArmoredKey(pub_sig_test);
const privateKey = await openpgp.readArmoredKey(priv_key_rsa);
const wrongKey = await openpgp.readArmoredKey(wrong_key);
let publicKey = await openpgp.readKey({ armoredKey: pub_sig_test });
const privateKey = await openpgp.readKey({ armoredKey: priv_key_rsa });
const wrongKey = await openpgp.readKey({ armoredKey: wrong_key });
await privateKey.decrypt('hello world');
publicKey = await publicKey.signPrimaryUser([privateKey]);
const signatures = await publicKey.verifyPrimaryUser([wrongKey]);
@ -2448,8 +2448,8 @@ function versionSpecificTests() {
});
it('Sign and verify key - all users', async function() {
let publicKey = await openpgp.readArmoredKey(multi_uid_key);
const privateKey = await openpgp.readArmoredKey(priv_key_rsa);
let publicKey = await openpgp.readKey({ armoredKey: multi_uid_key });
const privateKey = await openpgp.readKey({ armoredKey: priv_key_rsa });
await privateKey.decrypt('hello world');
publicKey = await publicKey.signAllUsers([privateKey]);
const signatures = await publicKey.verifyAllUsers([privateKey]);
@ -2471,9 +2471,9 @@ function versionSpecificTests() {
});
it('Sign key and verify with wrong key - all users', async function() {
let publicKey = await openpgp.readArmoredKey(multi_uid_key);
const privateKey = await openpgp.readArmoredKey(priv_key_rsa);
const wrongKey = await openpgp.readArmoredKey(wrong_key);
let publicKey = await openpgp.readKey({ armoredKey: multi_uid_key });
const privateKey = await openpgp.readKey({ armoredKey: priv_key_rsa });
const wrongKey = await openpgp.readKey({ armoredKey: wrong_key });
await privateKey.decrypt('hello world');
publicKey = await publicKey.signAllUsers([privateKey]);
const signatures = await publicKey.verifyAllUsers([wrongKey]);
@ -2516,7 +2516,7 @@ function versionSpecificTests() {
it('Reformat key with no subkey with passphrase', async function() {
const userId = { name: 'test', email: 'a@b.com' };
const key = await openpgp.readArmoredKey(key_without_subkey);
const key = await openpgp.readKey({ armoredKey: key_without_subkey });
const opt = { privateKey: key, userIds: [userId], passphrase: "test" };
return openpgp.reformatKey(opt).then(function(newKey) {
newKey = newKey.key;
@ -2550,7 +2550,7 @@ function versionSpecificTests() {
it('Reformat key with no subkey without passphrase', async function() {
const userId = { name: 'test', email: 'a@b.com' };
const key = await openpgp.readArmoredKey(key_without_subkey);
const key = await openpgp.readKey({ armoredKey: key_without_subkey });
const opt = { privateKey: key, userIds: [userId] };
return openpgp.reformatKey(opt).then(function(newKey) {
newKey = newKey.key;
@ -2559,7 +2559,7 @@ function versionSpecificTests() {
expect(newKey.isDecrypted()).to.be.true;
return openpgp.sign({ message: openpgp.CleartextMessage.fromText('hello'), privateKeys: newKey, armor: true }).then(async function(signed) {
return openpgp.verify(
{ message: await openpgp.readArmoredCleartextMessage(signed), publicKeys: newKey.toPublic() }
{ message: await openpgp.readCleartextMessage({ cleartextMessage: signed }), publicKeys: newKey.toPublic() }
).then(async function(verified) {
expect(verified.signatures[0].valid).to.be.true;
const newSigningKey = await newKey.getSigningKey();
@ -2602,7 +2602,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.readArmoredMessage(encrypted), privateKeys: newKey, publicKeys: newKey.toPublic() }).then(function(decrypted) {
return openpgp.decrypt({ message: await openpgp.readMessage({ armoredMessage: encrypted }), privateKeys: newKey, publicKeys: newKey.toPublic() }).then(function(decrypted) {
expect(decrypted.data).to.equal('hello');
expect(decrypted.signatures[0].valid).to.be.true;
});
@ -2653,7 +2653,7 @@ function versionSpecificTests() {
// uid emma.goldman@example.net
// ssb cv25519 2019-03-20 [E]
// E4557C2B02FFBF4B04F87401EC336AF7133D0F85BE7FD09BAEFD9CAEB8C93965
const key = await openpgp.readArmoredKey(v5_sample_key);
const key = await openpgp.readKey({ armoredKey: v5_sample_key });
expect(key.primaryKey.getFingerprint()).to.equal('19347bc9872464025f99df3ec2e0000ed9884892e1f7b3ea4c94009159569b54');
expect(key.subKeys[0].getFingerprint()).to.equal('e4557c2b02ffbf4b04f87401ec336af7133d0f85be7fd09baefd9caeb8c93965');
await key.verifyPrimaryKey();
@ -2690,14 +2690,14 @@ module.exports = () => describe('Key', function() {
});
it('Parsing armored text with RSA key and ECC subkey', async function() {
const pubKeys = await openpgp.readArmoredKeys(rsa_ecc_pub);
const pubKeys = await openpgp.readKeys({ armoredKeys: rsa_ecc_pub });
expect(pubKeys).to.exist;
expect(pubKeys).to.have.length(1);
expect(pubKeys[0].getKeyId().toHex()).to.equal('b8e4105cc9dedc77');
});
it('Parsing armored text with two keys', async function() {
const pubKeys = await openpgp.readArmoredKeys(twoKeys);
const pubKeys = await openpgp.readKeys({ armoredKeys: twoKeys });
expect(pubKeys).to.exist;
expect(pubKeys).to.have.length(2);
expect(pubKeys[0].getKeyId().toHex()).to.equal('4a63613a4d6e4094');
@ -2705,12 +2705,12 @@ module.exports = () => describe('Key', function() {
});
it('Parsing armored key with an authorized revocation key in a User ID self-signature', async function() {
const pubKey = await openpgp.readArmoredKey(key_with_authorized_revocation_key);
const pubKey = await openpgp.readKey({ armoredKey: key_with_authorized_revocation_key });
await expect(pubKey.getPrimaryUser()).to.be.rejectedWith('This key is intended to be revoked with an authorized key, which OpenPGP.js does not support.');
});
it('Parsing armored key with an authorized revocation key in a direct-key signature', async function() {
const pubKey = await openpgp.readArmoredKey(key_with_authorized_revocation_key_in_separate_sig);
const pubKey = await openpgp.readKey({ armoredKey: key_with_authorized_revocation_key_in_separate_sig });
const primaryUser = await pubKey.getPrimaryUser();
expect(primaryUser).to.exist;
});
@ -2731,7 +2731,7 @@ module.exports = () => describe('Key', function() {
});
it('Testing key ID and fingerprint for V4 keys', async function() {
const pubKeysV4 = await openpgp.readArmoredKeys(twoKeys);
const pubKeysV4 = await openpgp.readKeys({ armoredKeys: twoKeys });
expect(pubKeysV4).to.exist;
expect(pubKeysV4).to.have.length(2);
@ -2743,14 +2743,14 @@ module.exports = () => describe('Key', function() {
});
it('Create new key ID with fromId()', async function() {
const [pubKeyV4] = await openpgp.readArmoredKeys(twoKeys);
const [pubKeyV4] = await openpgp.readKeys({ armoredKeys: twoKeys });
const keyId = pubKeyV4.getKeyId();
const newKeyId = keyId.constructor.fromId(keyId.toHex());
expect(newKeyId.toHex()).to.equal(keyId.toHex());
});
it('Testing key method getSubkeys', async function() {
const pubKey = await openpgp.readArmoredKey(pub_sig_test);
const pubKey = await openpgp.readKey({ armoredKey: pub_sig_test });
expect(pubKey).to.exist;
const packetlist = new openpgp.PacketList();
@ -2765,12 +2765,12 @@ module.exports = () => describe('Key', function() {
});
it('Verify status of revoked primary key', async function() {
const pubKey = await openpgp.readArmoredKey(pub_revoked_subkeys);
const pubKey = await openpgp.readKey({ armoredKey: pub_revoked_subkeys });
await expect(pubKey.verifyPrimaryKey()).to.be.rejectedWith('Primary key is revoked');
});
it('Verify status of revoked subkey', async function() {
const pubKey = await openpgp.readArmoredKey(pub_sig_test);
const pubKey = await openpgp.readKey({ armoredKey: pub_sig_test });
expect(pubKey).to.exist;
expect(pubKey.subKeys).to.exist;
expect(pubKey.subKeys).to.have.length(2);
@ -2781,13 +2781,13 @@ module.exports = () => describe('Key', function() {
});
it('Verify status of key with non-self revocation signature', async function() {
const pubKey = await openpgp.readArmoredKey(key_with_revoked_third_party_cert);
const pubKey = await openpgp.readKey({ armoredKey: key_with_revoked_third_party_cert });
const [selfCertification] = await pubKey.verifyPrimaryUser();
const publicSigningKey = await pubKey.getSigningKey();
expect(selfCertification.keyid.toHex()).to.equal(publicSigningKey.getKeyId().toHex());
expect(selfCertification.valid).to.be.true;
const certifyingKey = await openpgp.readArmoredKey(certifying_key);
const certifyingKey = await openpgp.readKey({ armoredKey: certifying_key });
const certifyingSigningKey = await certifyingKey.getSigningKey();
const signatures = await pubKey.verifyPrimaryUser([certifyingKey]);
expect(signatures.length).to.equal(2);
@ -2801,7 +2801,7 @@ module.exports = () => describe('Key', function() {
});
it('Verify certificate of key with future creation date', async function() {
const pubKey = await openpgp.readArmoredKey(key_created_2030);
const pubKey = await openpgp.readKey({ armoredKey: key_created_2030 });
const user = pubKey.users[0];
await user.verifyCertificate(pubKey.primaryKey, user.selfCertifications[0], [pubKey], pubKey.primaryKey.created);
const verifyAllResult = await user.verifyAllCertifications(pubKey.primaryKey, [pubKey], pubKey.primaryKey.created);
@ -2810,7 +2810,7 @@ module.exports = () => describe('Key', function() {
});
it('Evaluate key flags to find valid encryption key packet', async function() {
const pubKey = await openpgp.readArmoredKey(pub_sig_test);
const pubKey = await openpgp.readKey({ armoredKey: pub_sig_test });
// remove subkeys
pubKey.subKeys = [];
// primary key has only key flags for signing
@ -2818,7 +2818,7 @@ module.exports = () => describe('Key', function() {
});
it('should pad an ECDSA P-521 key with shorter secret key', async function() {
const key = await openpgp.readArmoredKey(shortP521Key);
const key = await openpgp.readKey({ armoredKey: shortP521Key });
// secret key should be padded
expect(key.keyPacket.privateParams.d.length === 66);
// sanity check
@ -2827,17 +2827,17 @@ module.exports = () => describe('Key', function() {
it('should not decrypt using a sign-only RSA key, unless explicitly configured', async function () {
const allowSigningKeyDecryption = openpgp.config.allowInsecureDecryptionWithSigningKeys;
const key = await openpgp.readArmoredKey(rsaSignOnly);
const key = await openpgp.readKey({ armoredKey: rsaSignOnly });
try {
openpgp.config.allowInsecureDecryptionWithSigningKeys = false;
await expect(openpgp.decrypt({
message: await openpgp.readArmoredMessage(encryptedRsaSignOnly),
message: await openpgp.readMessage({ armoredMessage: encryptedRsaSignOnly }),
privateKeys: key
})).to.be.rejectedWith(/Session key decryption failed/);
openpgp.config.allowInsecureDecryptionWithSigningKeys = true;
await expect(openpgp.decrypt({
message: await openpgp.readArmoredMessage(encryptedRsaSignOnly),
message: await openpgp.readMessage({ armoredMessage: encryptedRsaSignOnly }),
privateKeys: key
})).to.be.fulfilled;
} finally {
@ -2846,7 +2846,7 @@ module.exports = () => describe('Key', function() {
});
it('Method getExpirationTime V4 Key', async function() {
const [, pubKey] = await openpgp.readArmoredKeys(twoKeys);
const [, pubKey] = await openpgp.readKeys({ armoredKeys: twoKeys });
expect(pubKey).to.exist;
expect(pubKey).to.be.an.instanceof(openpgp.Key);
const expirationTime = await pubKey.getExpirationTime();
@ -2854,7 +2854,7 @@ module.exports = () => describe('Key', function() {
});
it('Method getExpirationTime expired V4 Key', async function() {
const pubKey = await openpgp.readArmoredKey(expiredKey);
const pubKey = await openpgp.readKey({ armoredKey: expiredKey });
expect(pubKey).to.exist;
expect(pubKey).to.be.an.instanceof(openpgp.Key);
const expirationTime = await pubKey.getExpirationTime();
@ -2862,7 +2862,7 @@ module.exports = () => describe('Key', function() {
});
it('Method getExpirationTime V4 SubKey', async function() {
const [, pubKey] = await openpgp.readArmoredKeys(twoKeys);
const [, pubKey] = await openpgp.readKeys({ armoredKeys: twoKeys });
expect(pubKey).to.exist;
expect(pubKey).to.be.an.instanceof(openpgp.Key);
const expirationTime = await pubKey.subKeys[0].getExpirationTime(pubKey.primaryKey);
@ -2870,7 +2870,7 @@ module.exports = () => describe('Key', function() {
});
it('Method getExpirationTime V4 Key with capabilities', async function() {
const pubKey = await openpgp.readArmoredKey(priv_key_2000_2008);
const pubKey = await openpgp.readKey({ armoredKey: priv_key_2000_2008 });
expect(pubKey).to.exist;
expect(pubKey).to.be.an.instanceof(openpgp.Key);
pubKey.users[0].selfCertifications[0].keyFlags = [1];
@ -2881,7 +2881,7 @@ module.exports = () => describe('Key', function() {
});
it('Method getExpirationTime V4 Key with capabilities - capable primary key', async function() {
const pubKey = await openpgp.readArmoredKey(priv_key_2000_2008);
const pubKey = await openpgp.readKey({ armoredKey: priv_key_2000_2008 });
expect(pubKey).to.exist;
expect(pubKey).to.be.an.instanceof(openpgp.Key);
const expirationTime = await pubKey.getExpirationTime();
@ -2891,12 +2891,12 @@ module.exports = () => describe('Key', function() {
});
it("decrypt() - throw if key parameters don't correspond", async function() {
const key = await openpgp.readArmoredKey(mismatchingKeyParams);
const key = await openpgp.readKey({ armoredKey: mismatchingKeyParams });
await expect(key.decrypt('userpass')).to.be.rejectedWith('Key is invalid');
});
it("decrypt(keyId) - throw if key parameters don't correspond", async function() {
const key = await openpgp.readArmoredKey(mismatchingKeyParams);
const key = await openpgp.readKey({ armoredKey: mismatchingKeyParams });
const subKeyId = key.subKeys[0].getKeyId();
await expect(key.decrypt('userpass', subKeyId)).to.be.rejectedWith('Key is invalid');
});
@ -2907,22 +2907,22 @@ module.exports = () => describe('Key', function() {
});
it("validate() - throw if all-gnu-dummy key", async function() {
const key = await openpgp.readArmoredKey(gnuDummyKey);
const key = await openpgp.readKey({ armoredKey: gnuDummyKey });
await expect(key.validate()).to.be.rejectedWith('Cannot validate an all-gnu-dummy key');
});
it("validate() - gnu-dummy primary key with signing subkey", async function() {
const key = await openpgp.readArmoredKey(gnuDummyKeySigningSubkey);
const key = await openpgp.readKey({ armoredKey: gnuDummyKeySigningSubkey });
await expect(key.validate()).to.not.be.rejected;
});
it("validate() - gnu-dummy primary key with encryption subkey", async function() {
const key = await openpgp.readArmoredKey(dsaGnuDummyKeyWithElGamalSubkey);
const key = await openpgp.readKey({ armoredKey: dsaGnuDummyKeyWithElGamalSubkey });
await expect(key.validate()).to.not.be.rejected;
});
it("validate() - curve ed25519 (eddsa) cannot be used for ecdsa", async function() {
const key = await openpgp.readArmoredKey(eddsaKeyAsEcdsa);
const key = await openpgp.readKey({ armoredKey: eddsaKeyAsEcdsa });
await expect(key.validate()).to.be.rejectedWith('Key is invalid');
});
@ -2935,21 +2935,21 @@ module.exports = () => describe('Key', function() {
});
it("isDecrypted() - gnu-dummy primary key", async function() {
const key = await openpgp.readArmoredKey(gnuDummyKeySigningSubkey);
const key = await openpgp.readKey({ armoredKey: gnuDummyKeySigningSubkey });
expect(key.isDecrypted()).to.be.true;
await key.encrypt('12345678');
expect(key.isDecrypted()).to.be.false;
});
it("isDecrypted() - all-gnu-dummy key", async function() {
const key = await openpgp.readArmoredKey(gnuDummyKey);
const key = await openpgp.readKey({ armoredKey: gnuDummyKey });
expect(key.isDecrypted()).to.be.false;
});
it('makeDummy() - the converted key can be parsed', async function() {
const { key } = await openpgp.generateKey({ userIds: { name: 'dummy', email: 'dummy@alice.com' } });
key.primaryKey.makeDummy();
const parsedKeys = await openpgp.readArmoredKey(key.armor());
const parsedKeys = await openpgp.readKey({ armoredKey: key.armor() });
expect(parsedKeys).to.not.be.empty;
});
@ -2965,7 +2965,7 @@ module.exports = () => describe('Key', function() {
});
it('makeDummy() - the converted key is valid but can no longer sign', async function() {
const key = await openpgp.readArmoredKey(priv_key_rsa);
const key = await openpgp.readKey({ armoredKey: priv_key_rsa });
await key.decrypt('hello world');
expect(key.primaryKey.isDummy()).to.be.false;
key.primaryKey.makeDummy();
@ -2975,7 +2975,7 @@ module.exports = () => describe('Key', function() {
});
it('makeDummy() - subkeys of the converted key can still sign', async function() {
const key = await openpgp.readArmoredKey(priv_key_rsa);
const key = await openpgp.readKey({ armoredKey: priv_key_rsa });
await key.decrypt('hello world');
expect(key.primaryKey.isDummy()).to.be.false;
key.primaryKey.makeDummy();
@ -2984,7 +2984,7 @@ module.exports = () => describe('Key', function() {
});
it('makeDummy() - should work for encrypted keys', async function() {
const key = await openpgp.readArmoredKey(priv_key_rsa);
const key = await openpgp.readKey({ armoredKey: priv_key_rsa });
expect(key.primaryKey.isDummy()).to.be.false;
expect(key.primaryKey.makeDummy()).to.not.throw;
expect(key.primaryKey.isDummy()).to.be.true;
@ -2998,19 +2998,18 @@ module.exports = () => describe('Key', function() {
expect(key.primaryKey.isEncrypted === null);
expect(key.primaryKey.isDecrypted()).to.be.false;
// confirm that the converted key can be parsed
const parsedKeys = (await openpgp.readArmoredKey(key.armor())).keys;
expect(parsedKeys).to.be.undefined;
await openpgp.readKey({ armoredKey: key.armor() });
});
it('clearPrivateParams() - check that private key can no longer be used', async function() {
const key = await openpgp.readArmoredKey(priv_key_rsa);
const key = await openpgp.readKey({ armoredKey: priv_key_rsa });
await key.decrypt('hello world');
await key.clearPrivateParams();
await expect(key.validate()).to.be.rejectedWith('Key is not decrypted');
});
it('clearPrivateParams() - detect that private key parameters were removed', async function() {
const key = await openpgp.readArmoredKey(priv_key_rsa);
const key = await openpgp.readKey({ armoredKey: priv_key_rsa });
await key.decrypt('hello world');
const signingKeyPacket = key.subKeys[0].keyPacket;
const privateParams = signingKeyPacket.privateParams;
@ -3023,7 +3022,7 @@ module.exports = () => describe('Key', function() {
});
it('clearPrivateParams() - detect that private key parameters were zeroed out', async function() {
const key = await openpgp.readArmoredKey(priv_key_rsa);
const key = await openpgp.readKey({ armoredKey: priv_key_rsa });
await key.decrypt('hello world');
const signingKeyPacket = key.subKeys[0].keyPacket;
const privateParams = {};
@ -3039,15 +3038,15 @@ module.exports = () => describe('Key', function() {
});
it('update() - throw error if fingerprints not equal', async function() {
const keys = await openpgp.readArmoredKeys(twoKeys);
const keys = await openpgp.readKeys({ armoredKeys: twoKeys });
await expect(keys[0].update.bind(
keys[0], keys[1]
)()).to.be.rejectedWith('Key update method: fingerprints of keys not equal');
});
it('update() - merge revocation signatures', async function() {
const source = await openpgp.readArmoredKey(pub_revoked_subkeys);
const dest = await openpgp.readArmoredKey(pub_revoked_subkeys);
const source = await openpgp.readKey({ armoredKey: pub_revoked_subkeys });
const dest = await openpgp.readKey({ armoredKey: pub_revoked_subkeys });
expect(source.revocationSignatures).to.exist;
dest.revocationSignatures = [];
return dest.update(source).then(() => {
@ -3056,8 +3055,8 @@ module.exports = () => describe('Key', function() {
});
it('update() - merge user', async function() {
const source = await openpgp.readArmoredKey(pub_sig_test);
const dest = await openpgp.readArmoredKey(pub_sig_test);
const source = await openpgp.readKey({ armoredKey: pub_sig_test });
const dest = await openpgp.readKey({ armoredKey: pub_sig_test });
expect(source.users[1]).to.exist;
dest.users.pop();
return dest.update(source).then(() => {
@ -3067,8 +3066,8 @@ module.exports = () => describe('Key', function() {
});
it('update() - merge user - other and certification revocation signatures', async function() {
const source = await openpgp.readArmoredKey(pub_sig_test);
const dest = await openpgp.readArmoredKey(pub_sig_test);
const source = await openpgp.readKey({ armoredKey: pub_sig_test });
const dest = await openpgp.readKey({ armoredKey: pub_sig_test });
expect(source.users[1].otherCertifications).to.exist;
expect(source.users[1].revocationSignatures).to.exist;
dest.users[1].otherCertifications = [];
@ -3082,8 +3081,8 @@ module.exports = () => describe('Key', function() {
});
it('update() - merge subkey', async function() {
const source = await openpgp.readArmoredKey(pub_sig_test);
const dest = await openpgp.readArmoredKey(pub_sig_test);
const source = await openpgp.readKey({ armoredKey: pub_sig_test });
const dest = await openpgp.readKey({ armoredKey: pub_sig_test });
expect(source.subKeys[1]).to.exist;
dest.subKeys.pop();
return dest.update(source).then(() => {
@ -3095,8 +3094,8 @@ module.exports = () => describe('Key', function() {
});
it('update() - merge subkey - revocation signature', async function() {
const source = await openpgp.readArmoredKey(pub_sig_test);
const dest = await openpgp.readArmoredKey(pub_sig_test);
const source = await openpgp.readKey({ armoredKey: pub_sig_test });
const dest = await openpgp.readKey({ armoredKey: pub_sig_test });
expect(source.subKeys[0].revocationSignatures).to.exist;
dest.subKeys[0].revocationSignatures = [];
return dest.update(source).then(() => {
@ -3106,8 +3105,8 @@ module.exports = () => describe('Key', function() {
});
it('update() - merge private key into public key', async function() {
const source = await openpgp.readArmoredKey(priv_key_rsa);
const [dest] = await openpgp.readArmoredKeys(twoKeys);
const source = await openpgp.readKey({ armoredKey: priv_key_rsa });
const [dest] = await openpgp.readKeys({ armoredKeys: twoKeys });
expect(dest.isPublic()).to.be.true;
return dest.update(source).then(() => {
expect(dest.isPrivate()).to.be.true;
@ -3126,8 +3125,8 @@ module.exports = () => describe('Key', function() {
});
it('update() - merge private key into public key - no subkeys', async function() {
const source = await openpgp.readArmoredKey(priv_key_rsa);
const [dest] = await openpgp.readArmoredKeys(twoKeys);
const source = await openpgp.readKey({ armoredKey: priv_key_rsa });
const [dest] = await openpgp.readKeys({ armoredKeys: twoKeys });
source.subKeys = [];
dest.subKeys = [];
expect(dest.isPublic()).to.be.true;
@ -3149,8 +3148,8 @@ module.exports = () => describe('Key', function() {
});
it('update() - merge private key into public key - mismatch throws error', async function() {
const source = await openpgp.readArmoredKey(priv_key_rsa);
const [dest] = await openpgp.readArmoredKeys(twoKeys);
const source = await openpgp.readKey({ armoredKey: priv_key_rsa });
const [dest] = await openpgp.readKeys({ armoredKeys: twoKeys });
source.subKeys = [];
expect(dest.subKeys).to.exist;
expect(dest.isPublic()).to.be.true;
@ -3159,8 +3158,8 @@ module.exports = () => describe('Key', function() {
});
it('update() - merge subkey binding signatures', async function() {
const source = await openpgp.readArmoredKey(pgp_desktop_pub);
const dest = await openpgp.readArmoredKey(pgp_desktop_priv);
const source = await openpgp.readKey({ armoredKey: pgp_desktop_pub });
const dest = await openpgp.readKey({ armoredKey: pgp_desktop_priv });
expect(source.subKeys[0].bindingSignatures[0]).to.exist;
await source.subKeys[0].verify(source.primaryKey);
expect(dest.subKeys[0].bindingSignatures[0]).to.not.exist;
@ -3170,8 +3169,8 @@ module.exports = () => describe('Key', function() {
});
it('update() - merge multiple subkey binding signatures', async function() {
const source = await openpgp.readArmoredKey(multipleBindingSignatures);
const dest = await openpgp.readArmoredKey(multipleBindingSignatures);
const source = await openpgp.readKey({ armoredKey: multipleBindingSignatures });
const dest = await openpgp.readKey({ armoredKey: multipleBindingSignatures });
// remove last subkey binding signature of destination subkey
dest.subKeys[0].bindingSignatures.length = 1;
expect((await source.subKeys[0].getExpirationTime(source.primaryKey)).toISOString()).to.equal('2015-10-18T07:41:30.000Z');
@ -3184,7 +3183,7 @@ module.exports = () => describe('Key', function() {
});
it('revoke() - primary key', async function() {
const privKey = await openpgp.readArmoredKey(priv_key_arm2);
const privKey = await openpgp.readKey({ armoredKey: priv_key_arm2 });
await privKey.decrypt('hello world');
await privKey.revoke({
@ -3202,8 +3201,8 @@ module.exports = () => describe('Key', function() {
});
it('revoke() - subkey', async function() {
const pubKey = await openpgp.readArmoredKey(pub_key_arm2);
const privKey = await openpgp.readArmoredKey(priv_key_arm2);
const pubKey = await openpgp.readKey({ armoredKey: pub_key_arm2 });
const privKey = await openpgp.readKey({ armoredKey: priv_key_arm2 });
await privKey.decrypt('hello world');
const subKey = pubKey.subKeys[0];
@ -3221,15 +3220,15 @@ module.exports = () => describe('Key', function() {
});
it('applyRevocationCertificate() should produce the same revoked key as GnuPG', async function() {
const pubKey = await openpgp.readArmoredKey(pub_key_arm4);
const pubKey = await openpgp.readKey({ armoredKey: pub_key_arm4 });
return pubKey.applyRevocationCertificate(revocation_certificate_arm4).then(async revKey => {
expect(revKey.armor()).to.equal((await openpgp.readArmoredKey(revoked_key_arm4)).armor());
expect(revKey.armor()).to.equal((await openpgp.readKey({ armoredKey: revoked_key_arm4 })).armor());
});
});
it('getRevocationCertificate() should produce the same revocation certificate as GnuPG', async function() {
const revKey = await openpgp.readArmoredKey(revoked_key_arm4);
const revKey = await openpgp.readKey({ armoredKey: revoked_key_arm4 });
const revocationCertificate = await revKey.getRevocationCertificate();
const input = await openpgp.unarmor(revocation_certificate_arm4);
@ -3241,7 +3240,7 @@ module.exports = () => describe('Key', function() {
});
it('getRevocationCertificate() should have an appropriate comment', async function() {
const revKey = await openpgp.readArmoredKey(revoked_key_arm4);
const revKey = await openpgp.readKey({ armoredKey: revoked_key_arm4 });
const revocationCertificate = await revKey.getRevocationCertificate();
expect(revocationCertificate).to.match(/Comment: This is a revocation certificate/);
@ -3249,13 +3248,13 @@ module.exports = () => describe('Key', function() {
});
it("getPreferredAlgo('symmetric') - one key - AES256", async function() {
const [key1] = await openpgp.readArmoredKeys(twoKeys);
const [key1] = await openpgp.readKeys({ armoredKeys: twoKeys });
const prefAlgo = await key.getPreferredAlgo('symmetric', [key1]);
expect(prefAlgo).to.equal(openpgp.enums.symmetric.aes256);
});
it("getPreferredAlgo('symmetric') - two key - AES192", async function() {
const keys = await openpgp.readArmoredKeys(twoKeys);
const keys = await openpgp.readKeys({ armoredKeys: twoKeys });
const key1 = keys[0];
const key2 = keys[1];
const primaryUser = await key2.getPrimaryUser();
@ -3265,7 +3264,7 @@ module.exports = () => describe('Key', function() {
});
it("getPreferredAlgo('symmetric') - two key - one without pref", async function() {
const keys = await openpgp.readArmoredKeys(twoKeys);
const keys = await openpgp.readKeys({ armoredKeys: twoKeys });
const key1 = keys[0];
const key2 = keys[1];
const primaryUser = await key2.getPrimaryUser();
@ -3275,7 +3274,7 @@ module.exports = () => describe('Key', function() {
});
it("getPreferredAlgo('aead') - one key - OCB", async function() {
const [key1] = await openpgp.readArmoredKeys(twoKeys);
const [key1] = await openpgp.readKeys({ armoredKeys: twoKeys });
const primaryUser = await key1.getPrimaryUser();
primaryUser.selfCertification.features = [7]; // Monkey-patch AEAD feature flag
primaryUser.selfCertification.preferredAeadAlgorithms = [2,1];
@ -3286,7 +3285,7 @@ module.exports = () => describe('Key', function() {
});
it("getPreferredAlgo('aead') - two key - one without pref", async function() {
const keys = await openpgp.readArmoredKeys(twoKeys);
const keys = await openpgp.readKeys({ armoredKeys: twoKeys });
const key1 = keys[0];
const key2 = keys[1];
const primaryUser = await key1.getPrimaryUser();
@ -3301,7 +3300,7 @@ module.exports = () => describe('Key', function() {
});
it("getPreferredAlgo('aead') - two key - one with no support", async function() {
const keys = await openpgp.readArmoredKeys(twoKeys);
const keys = await openpgp.readKeys({ armoredKeys: twoKeys });
const key1 = keys[0];
const key2 = keys[1];
const primaryUser = await key1.getPrimaryUser();
@ -3314,13 +3313,13 @@ module.exports = () => describe('Key', function() {
});
it('User attribute packet read & write', async function() {
const key = await openpgp.readArmoredKey(user_attr_key);
const key2 = await openpgp.readArmoredKey(key.armor());
const key = await openpgp.readKey({ armoredKey: user_attr_key });
const key2 = await openpgp.readKey({ armoredKey: key.armor() });
expect(key.users[1].userAttribute).eql(key2.users[1].userAttribute);
});
it('getPrimaryUser()', async function() {
const key = await openpgp.readArmoredKey(pub_sig_test);
const key = await openpgp.readKey({ armoredKey: pub_sig_test });
const primUser = await key.getPrimaryUser();
expect(primUser).to.exist;
expect(primUser.user.userId.userid).to.equal('Signature Test <signature@test.com>');
@ -3343,13 +3342,13 @@ Vz/bMCJoAShgybW1r6kRWejybzIjFSLnx/YA/iLZeo5UNdlXRJco+15RbFiNSAbw
VYGdb3eNlV8CfoEC
=FYbP
-----END PGP PRIVATE KEY BLOCK-----`;
const key = await openpgp.readArmoredKey(keyWithoutUserID);
const key = await openpgp.readKey({ armoredKey: keyWithoutUserID });
await expect(key.getPrimaryUser()).to.be.rejectedWith('Could not find valid self-signature in key 3ce893915c44212f');
});
it('Generate session key - latest created user', async function() {
const publicKey = await openpgp.readArmoredKey(multi_uid_key);
const privateKey = await openpgp.readArmoredKey(priv_key_rsa);
const publicKey = await openpgp.readKey({ armoredKey: multi_uid_key });
const privateKey = await openpgp.readKey({ armoredKey: priv_key_rsa });
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];
@ -3358,8 +3357,8 @@ VYGdb3eNlV8CfoEC
});
it('Generate session key - primary user', async function() {
const publicKey = await openpgp.readArmoredKey(multi_uid_key);
const privateKey = await openpgp.readArmoredKey(priv_key_rsa);
const publicKey = await openpgp.readKey({ armoredKey: multi_uid_key });
const privateKey = await openpgp.readKey({ armoredKey: priv_key_rsa });
await privateKey.decrypt('hello world');
// Set first user to primary. We should select this user by default.
publicKey.users[0].selfCertifications[0].isPrimaryUserID = true;
@ -3370,8 +3369,8 @@ VYGdb3eNlV8CfoEC
});
it('Generate session key - specific user', async function() {
const publicKey = await openpgp.readArmoredKey(multi_uid_key);
const privateKey = await openpgp.readArmoredKey(priv_key_rsa);
const publicKey = await openpgp.readKey({ armoredKey: multi_uid_key });
const privateKey = await openpgp.readKey({ armoredKey: priv_key_rsa });
await privateKey.decrypt('hello world');
// Set first user to primary. We won't select this user, this is to test that.
publicKey.users[0].selfCertifications[0].isPrimaryUserID = true;
@ -3384,18 +3383,18 @@ VYGdb3eNlV8CfoEC
});
it('Fails to encrypt to User ID-less key', async function() {
const publicKey = await openpgp.readArmoredKey(uidlessKey);
const publicKey = await openpgp.readKey({ armoredKey: uidlessKey });
expect(publicKey.users.length).to.equal(0);
const privateKey = await openpgp.readArmoredKey(uidlessKey);
const privateKey = await openpgp.readKey({ armoredKey: uidlessKey });
await privateKey.decrypt('correct horse battery staple');
await expect(openpgp.encrypt({ message: openpgp.Message.fromText('hello'), publicKeys: publicKey, privateKeys: privateKey, armor: false })).to.be.rejectedWith('Could not find primary user');
});
it('Sign - specific user', async function() {
const publicKey = await openpgp.readArmoredKey(multi_uid_key);
const privateKey = await openpgp.readArmoredKey(priv_key_rsa);
const publicKey = await openpgp.readKey({ armoredKey: multi_uid_key });
const privateKey = await openpgp.readKey({ armoredKey: priv_key_rsa });
await privateKey.decrypt('hello world');
const privateKeyClone = await openpgp.readArmoredKey(priv_key_rsa);
const privateKeyClone = await openpgp.readKey({ armoredKey: priv_key_rsa });
// Duplicate user
privateKey.users.push(privateKeyClone.users[0]);
// Set first user to primary. We won't select this user, this is to test that.
@ -3405,46 +3404,46 @@ 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.readMessage(signed);
const signature = await openpgp.readMessage({ binaryMessage: signed });
expect(signature.packets[0].hashAlgorithm).to.equal(openpgp.enums.hash.sha512);
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.readMessage(encrypted), passwords: 'test' });
const { signatures } = await openpgp.decrypt({ message: await openpgp.readMessage({ binaryMessage: 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() {
const key = await openpgp.readArmoredKey(valid_binding_sig_among_many_expired_sigs_pub);
const key = await openpgp.readKey({ armoredKey: valid_binding_sig_among_many_expired_sigs_pub });
expect(await key.getEncryptionKey()).to.not.be.null;
});
it('Selects the most recent subkey binding signature', async function() {
const key = await openpgp.readArmoredKey(multipleBindingSignatures);
const key = await openpgp.readKey({ armoredKey: multipleBindingSignatures });
expect((await key.subKeys[0].getExpirationTime(key.primaryKey)).toISOString()).to.equal('2015-10-18T07:41:30.000Z');
});
it('Selects the most recent non-expired subkey binding signature', async function() {
const key = await openpgp.readArmoredKey(multipleBindingSignatures);
const key = await openpgp.readKey({ armoredKey: multipleBindingSignatures });
key.subKeys[0].bindingSignatures[1].signatureNeverExpires = false;
key.subKeys[0].bindingSignatures[1].signatureExpirationTime = 0;
expect((await key.subKeys[0].getExpirationTime(key.primaryKey)).toISOString()).to.equal('2018-09-07T06:03:37.000Z');
});
it('Selects the most recent valid subkey binding signature', async function() {
const key = await openpgp.readArmoredKey(multipleBindingSignatures);
const key = await openpgp.readKey({ armoredKey: multipleBindingSignatures });
key.subKeys[0].bindingSignatures[1].signatureData[0]++;
expect((await key.subKeys[0].getExpirationTime(key.primaryKey)).toISOString()).to.equal('2018-09-07T06:03:37.000Z');
});
it('Handles a key with no valid subkey binding signatures gracefully', async function() {
const key = await openpgp.readArmoredKey(multipleBindingSignatures);
const key = await openpgp.readKey({ armoredKey: multipleBindingSignatures });
key.subKeys[0].bindingSignatures[0].signatureData[0]++;
key.subKeys[0].bindingSignatures[1].signatureData[0]++;
expect(await key.subKeys[0].getExpirationTime(key.primaryKey)).to.be.null;
});
it('Reject encryption with revoked primary user', async function() {
const key = await openpgp.readArmoredKey(pub_revoked_subkeys);
const key = await openpgp.readKey({ armoredKey: pub_revoked_subkeys });
return openpgp.encrypt({ publicKeys: [key], message: openpgp.Message.fromText('random data') }).then(() => {
throw new Error('encryptSessionKey should not encrypt with revoked public key');
}).catch(function(error) {
@ -3453,7 +3452,7 @@ VYGdb3eNlV8CfoEC
});
it('Reject encryption with revoked subkey', async function() {
const key = await openpgp.readArmoredKey(pub_revoked_subkeys);
const key = await openpgp.readKey({ armoredKey: pub_revoked_subkeys });
key.revocationSignatures = [];
key.users[0].revocationSignatures = [];
return openpgp.encrypt({ publicKeys: [key], message: openpgp.Message.fromText('random data'), date: new Date(1386842743000) }).then(() => {
@ -3464,7 +3463,7 @@ VYGdb3eNlV8CfoEC
});
it('Reject encryption with key revoked with appended revocation cert', async function() {
const key = await openpgp.readArmoredKey(pub_revoked_with_cert);
const key = await openpgp.readKey({ armoredKey: pub_revoked_with_cert });
return openpgp.encrypt({ publicKeys: [key], message: openpgp.Message.fromText('random data') }).then(() => {
throw new Error('encryptSessionKey should not encrypt with revoked public key');
}).catch(function(error) {
@ -3473,8 +3472,8 @@ VYGdb3eNlV8CfoEC
});
it('Merge key with another key with non-ID user attributes', async function() {
const key = await openpgp.readArmoredKey(mergeKey1);
const updateKey = await openpgp.readArmoredKey(mergeKey2);
const key = await openpgp.readKey({ armoredKey: mergeKey1 });
const updateKey = await openpgp.readKey({ armoredKey: mergeKey2 });
expect(key).to.exist;
expect(updateKey).to.exist;
expect(key.users).to.have.length(1);
@ -3489,7 +3488,7 @@ VYGdb3eNlV8CfoEC
it("Should throw when trying to encrypt a key that's already encrypted", async function() {
await expect((async function() {
const { privateKeyArmored } = await openpgp.generateKey({ userIds: [{ email: 'hello@user.com' }], passphrase: 'pass' });
const k = await openpgp.readArmoredKey(privateKeyArmored);
const k = await openpgp.readKey({ armoredKey: privateKeyArmored });
await k.decrypt('pass');
await k.encrypt('pass');
await k.encrypt('pass');
@ -3509,12 +3508,12 @@ VYGdb3eNlV8CfoEC
});
it('create and add a new rsa subkey to stored rsa key', async function() {
const privateKey = await openpgp.readArmoredKey(priv_key_rsa);
const privateKey = await openpgp.readKey({ armoredKey: priv_key_rsa });
await privateKey.decrypt('hello world');
const total = privateKey.subKeys.length;
let newPrivateKey = await privateKey.addSubkey(rsaOpt);
const armoredKey = newPrivateKey.armor();
newPrivateKey = await openpgp.readArmoredKey(armoredKey);
newPrivateKey = await openpgp.readKey({ armoredKey: armoredKey });
const subKey = newPrivateKey.subKeys[total];
expect(subKey).to.exist;
expect(newPrivateKey.subKeys.length).to.be.equal(total + 1);
@ -3547,7 +3546,7 @@ VYGdb3eNlV8CfoEC
});
it('Add a new default subkey to a dsa key', async function() {
const key = await openpgp.readArmoredKey(dsaPrivateKey);
const key = await openpgp.readKey({ armoredKey: dsaPrivateKey });
const total = key.subKeys.length;
const newKey = await key.addSubkey();
expect(newKey.subKeys[total].getAlgorithmInfo().algorithm).to.equal('rsaEncryptSign');
@ -3555,21 +3554,21 @@ VYGdb3eNlV8CfoEC
});
it('should throw when trying to encrypt a subkey separately from key', async function() {
const privateKey = await openpgp.readArmoredKey(priv_key_rsa);
const privateKey = await openpgp.readKey({ armoredKey: priv_key_rsa });
await privateKey.decrypt('hello world');
const opt = { rsaBits: rsaBits, passphrase: 'subkey passphrase' };
await expect(privateKey.addSubkey(opt)).to.be.rejectedWith('Subkey could not be encrypted here, please encrypt whole key');
});
it('encrypt and decrypt key with added subkey', async function() {
const privateKey = await openpgp.readArmoredKey(priv_key_rsa);
const privateKey = await openpgp.readKey({ armoredKey: priv_key_rsa });
await privateKey.decrypt('hello world');
const total = privateKey.subKeys.length;
let newPrivateKey = await privateKey.addSubkey(rsaOpt);
newPrivateKey = await openpgp.readArmoredKey(newPrivateKey.armor());
newPrivateKey = await openpgp.readKey({ armoredKey: newPrivateKey.armor() });
await newPrivateKey.encrypt('12345678');
const armoredKey = newPrivateKey.armor();
const importedPrivateKey = await openpgp.readArmoredKey(armoredKey);
const importedPrivateKey = await openpgp.readKey({ armoredKey: armoredKey });
await importedPrivateKey.decrypt('12345678');
const subKey = importedPrivateKey.subKeys[total];
expect(subKey).to.exist;
@ -3587,7 +3586,7 @@ VYGdb3eNlV8CfoEC
const subKey1 = newPrivateKey.subKeys[total];
await newPrivateKey.encrypt('12345678');
const armoredKey = newPrivateKey.armor();
newPrivateKey = await openpgp.readArmoredKey(armoredKey);
newPrivateKey = await openpgp.readKey({ armoredKey: armoredKey });
await newPrivateKey.decrypt('12345678');
const subKey = newPrivateKey.subKeys[total];
expect(subKey.isDecrypted()).to.be.true;
@ -3607,7 +3606,7 @@ VYGdb3eNlV8CfoEC
const privateKey = (await openpgp.generateKey(opt)).key;
const total = privateKey.subKeys.length;
let newPrivateKey = await privateKey.addSubkey({ curve: 'p256', sign: true });
newPrivateKey = await openpgp.readArmoredKey(newPrivateKey.armor());
newPrivateKey = await openpgp.readKey({ armoredKey: newPrivateKey.armor() });
const subKey = newPrivateKey.subKeys[total];
expect(subKey).to.exist;
expect(newPrivateKey.subKeys.length).to.be.equal(total + 1);
@ -3620,13 +3619,13 @@ VYGdb3eNlV8CfoEC
});
it('create and add a new ecc subkey to a rsa key', async function() {
const privateKey = await openpgp.readArmoredKey(priv_key_rsa);
const privateKey = await openpgp.readKey({ armoredKey: priv_key_rsa });
await privateKey.decrypt('hello world');
const total = privateKey.subKeys.length;
const opt2 = { type: 'ecc', curve: 'curve25519' };
let newPrivateKey = await privateKey.addSubkey(opt2);
const armoredKey = newPrivateKey.armor();
newPrivateKey = await openpgp.readArmoredKey(armoredKey);
newPrivateKey = await openpgp.readKey({ armoredKey: armoredKey });
expect(newPrivateKey.subKeys.length).to.be.equal(total + 1);
const subKey = newPrivateKey.subKeys[total];
expect(subKey).to.exist;
@ -3642,7 +3641,7 @@ VYGdb3eNlV8CfoEC
const total = privateKey.subKeys.length;
let newPrivateKey = await privateKey.addSubkey({ type: 'rsa' });
const armoredKey = newPrivateKey.armor();
newPrivateKey = await openpgp.readArmoredKey(armoredKey);
newPrivateKey = await openpgp.readKey({ armoredKey: armoredKey });
const subKey = newPrivateKey.subKeys[total];
expect(subKey).to.exist;
expect(newPrivateKey.subKeys.length).to.be.equal(total + 1);
@ -3652,10 +3651,10 @@ VYGdb3eNlV8CfoEC
});
it('create and add a new rsa subkey to a dsa key', async function() {
const privateKey = await openpgp.readArmoredKey(dsaPrivateKey);
const privateKey = await openpgp.readKey({ armoredKey: dsaPrivateKey });
const total = privateKey.subKeys.length;
let newPrivateKey = await privateKey.addSubkey({ type: 'rsa', rsaBits: 2048 });
newPrivateKey = await openpgp.readArmoredKey(newPrivateKey.armor());
newPrivateKey = await openpgp.readKey({ armoredKey: newPrivateKey.armor() });
expect(newPrivateKey.subKeys.length).to.be.equal(total + 1);
const subKey = newPrivateKey.subKeys[total];
expect(subKey).to.exist;
@ -3672,7 +3671,7 @@ VYGdb3eNlV8CfoEC
const opt2 = { sign: true };
let newPrivateKey = await privateKey.addSubkey(opt2);
const armoredKey = newPrivateKey.armor();
newPrivateKey = await openpgp.readArmoredKey(armoredKey);
newPrivateKey = await openpgp.readKey({ armoredKey: armoredKey });
const subKey = newPrivateKey.subKeys[total];
const subkeyOid = subKey.keyPacket.publicParams.oid;
const pkOid = newPrivateKey.primaryKey.publicParams.oid;
@ -3681,7 +3680,7 @@ VYGdb3eNlV8CfoEC
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.readMessage(signed);
const message = await openpgp.readMessage({ binaryMessage: signed });
const { signatures } = await openpgp.verify({ message, publicKeys: [newPrivateKey.toPublic()] });
expect(signatures).to.exist;
expect(signatures.length).to.be.equal(1);
@ -3697,14 +3696,14 @@ VYGdb3eNlV8CfoEC
const total = privateKey.subKeys.length;
let newPrivateKey = await privateKey.addSubkey();
const armoredKey = newPrivateKey.armor();
newPrivateKey = await openpgp.readArmoredKey(armoredKey);
newPrivateKey = await openpgp.readKey({ armoredKey: armoredKey });
const subKey = newPrivateKey.subKeys[total];
const publicKey = newPrivateKey.toPublic();
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).to.be.exist;
const message = await openpgp.readMessage(encrypted);
const message = await openpgp.readMessage({ binaryMessage: encrypted });
const pkSessionKeys = message.packets.filterByTag(openpgp.enums.packet.publicKeyEncryptedSessionKey);
expect(pkSessionKeys).to.exist;
expect(pkSessionKeys.length).to.be.equal(1);
@ -3715,19 +3714,19 @@ VYGdb3eNlV8CfoEC
});
it('sign/verify data with the new subkey correctly using rsa', async function() {
const privateKey = await openpgp.readArmoredKey(priv_key_rsa);
const privateKey = await openpgp.readKey({ armoredKey: priv_key_rsa });
await privateKey.decrypt('hello world');
const total = privateKey.subKeys.length;
const opt2 = { sign: true, rsaBits: rsaBits };
let newPrivateKey = await privateKey.addSubkey(opt2);
const armoredKey = newPrivateKey.armor();
newPrivateKey = await openpgp.readArmoredKey(armoredKey);
newPrivateKey = await openpgp.readKey({ armoredKey: armoredKey });
const subKey = newPrivateKey.subKeys[total];
expect(subKey.getAlgorithmInfo().algorithm).to.be.equal('rsaEncryptSign');
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.readMessage(signed);
const message = await openpgp.readMessage({ binaryMessage: signed });
const { signatures } = await openpgp.verify({ message, publicKeys: [newPrivateKey.toPublic()] });
expect(signatures).to.exist;
expect(signatures.length).to.be.equal(1);
@ -3736,19 +3735,19 @@ VYGdb3eNlV8CfoEC
});
it('encrypt/decrypt data with the new subkey correctly using rsa', async function() {
const privateKey = await openpgp.readArmoredKey(priv_key_rsa);
const privateKey = await openpgp.readKey({ armoredKey: priv_key_rsa });
await privateKey.decrypt('hello world');
const total = privateKey.subKeys.length;
let newPrivateKey = await privateKey.addSubkey(rsaOpt);
const armoredKey = newPrivateKey.armor();
newPrivateKey = await openpgp.readArmoredKey(armoredKey);
newPrivateKey = await openpgp.readKey({ armoredKey: armoredKey });
const subKey = newPrivateKey.subKeys[total];
const publicKey = newPrivateKey.toPublic();
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).to.be.exist;
const message = await openpgp.readMessage(encrypted);
const message = await openpgp.readMessage({ binaryMessage: encrypted });
const pkSessionKeys = message.packets.filterByTag(openpgp.enums.packet.publicKeyEncryptedSessionKey);
expect(pkSessionKeys).to.exist;
expect(pkSessionKeys.length).to.be.equal(1);

4
test/general/keyring.js
View File

@ -273,14 +273,14 @@ module.exports = () => describe("Keyring", async function() {
const localstore2 = new openpgp.Keyring.localstore('my-custom-prefix-');
const localstore3 = new openpgp.Keyring.localstore();
await localstore3.storePublic([]);
const key = await openpgp.readArmoredKey(pubkey);
const key = await openpgp.readKey({ armoredKey: pubkey });
await localstore1.storePublic([key]);
expect((await localstore2.loadPublic())[0].getKeyId().equals(key.getKeyId())).to.be.true;
expect(await localstore3.loadPublic()).to.have.length(0);
});
it('emptying keyring and storing removes keys', async function() {
const key = await openpgp.readArmoredKey(pubkey);
const key = await openpgp.readKey({ armoredKey: pubkey });
const localstore = new openpgp.Keyring.localstore('remove-prefix-');

304
test/general/openpgp.js
View File

@ -853,16 +853,16 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
let privateKeyMismatchingParams;
beforeEach(async function() {
publicKey = await openpgp.readArmoredKey(pub_key);
publicKeyNoAEAD = await openpgp.readArmoredKey(pub_key);
privateKey = await openpgp.readArmoredKey(priv_key);
privateKey_2000_2008 = await openpgp.readArmoredKey(priv_key_2000_2008);
publicKey = await openpgp.readKey({ armoredKey: pub_key });
publicKeyNoAEAD = await openpgp.readKey({ armoredKey: pub_key });
privateKey = await openpgp.readKey({ armoredKey: priv_key });
privateKey_2000_2008 = await openpgp.readKey({ armoredKey: priv_key_2000_2008 });
publicKey_2000_2008 = privateKey_2000_2008.toPublic();
privateKey_2038_2045 = await openpgp.readArmoredKey(priv_key_2038_2045);
privateKey_2038_2045 = await openpgp.readKey({ armoredKey: priv_key_2038_2045 });
publicKey_2038_2045 = privateKey_2038_2045.toPublic();
privateKey_1337 = await openpgp.readArmoredKey(priv_key_expires_1337);
privateKey_1337 = await openpgp.readKey({ armoredKey: priv_key_expires_1337 });
publicKey_1337 = privateKey_1337.toPublic();
privateKeyMismatchingParams = await openpgp.readArmoredKey(mismatchingKeyParams);
privateKeyMismatchingParams = await openpgp.readKey({ armoredKey: mismatchingKeyParams });
useNativeVal = openpgp.config.useNative;
aeadProtectVal = openpgp.config.aeadProtect;
@ -915,7 +915,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
describe('decryptKey', function() {
it('should work for correct passphrase', async function() {
const originalKey = await openpgp.readArmoredKey(privateKey.armor());
const originalKey = await openpgp.readKey({ armoredKey: privateKey.armor() });
return openpgp.decryptKey({
privateKey: privateKey,
passphrase: passphrase
@ -933,7 +933,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
});
it('should fail for incorrect passphrase', async function() {
const originalKey = await openpgp.readArmoredKey(privateKey.armor());
const originalKey = await openpgp.readKey({ armoredKey: privateKey.armor() });
return openpgp.decryptKey({
privateKey: privateKey,
passphrase: 'incorrect'
@ -949,7 +949,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
});
it('should fail for corrupted key', async function() {
const originalKey = await openpgp.readArmoredKey(privateKeyMismatchingParams.armor());
const originalKey = await openpgp.readKey({ armoredKey: privateKeyMismatchingParams.armor() });
return openpgp.decryptKey({
privateKey: privateKeyMismatchingParams,
passphrase: 'userpass'
@ -968,8 +968,8 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
it('should not change original key', async function() {
const { privateKeyArmored } = await openpgp.generateKey({ userIds: [{ name: 'test', email: 'test@test.com' }] });
// read both keys from armored data to make sure all fields are exactly the same
const key = await openpgp.readArmoredKey(privateKeyArmored);
const originalKey = await openpgp.readArmoredKey(privateKeyArmored);
const key = await openpgp.readKey({ armoredKey: privateKeyArmored });
const originalKey = await openpgp.readKey({ armoredKey: privateKeyArmored });
return openpgp.encryptKey({
privateKey: key,
passphrase: passphrase
@ -1020,7 +1020,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
});
it('should encrypt gnu-dummy key', async function() {
const key = await openpgp.readArmoredKey(gnuDummyKeySigningSubkey);
const key = await openpgp.readKey({ armoredKey: gnuDummyKeySigningSubkey });
const locked = await openpgp.encryptKey({
privateKey: key,
passphrase: passphrase
@ -1047,7 +1047,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
privateKeys: privateKey
};
const encrypted = await openpgp.encrypt(encOpt);
decOpt.message = await openpgp.readArmoredMessage(encrypted);
decOpt.message = await openpgp.readMessage({ armoredMessage: encrypted });
await expect(openpgp.decrypt(decOpt)).to.be.rejectedWith('Error decrypting message: Private key is not decrypted.');
});
@ -1118,7 +1118,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
publicKeys: publicKey,
armor: false
}).then(async function(encrypted) {
const message = await openpgp.readMessage(encrypted);
const message = await openpgp.readMessage({ binaryMessage: encrypted });
return openpgp.decryptSessionKeys({
message,
privateKeys: privateKey
@ -1135,7 +1135,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
passwords: password1,
armor: false
}).then(async function(encrypted) {
const message = await openpgp.readMessage(encrypted);
const message = await openpgp.readMessage({ binaryMessage: encrypted });
return openpgp.decryptSessionKeys({
message,
passwords: password1
@ -1152,8 +1152,8 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
publicKeys: publicKey,
armor: false
}).then(async function(encrypted) {
const message = await openpgp.readMessage(encrypted);
const invalidPrivateKey = await openpgp.readArmoredKey(priv_key);
const message = await openpgp.readMessage({ binaryMessage: encrypted });
const invalidPrivateKey = await openpgp.readKey({ armoredKey: priv_key });
invalidPrivateKey.subKeys[0].bindingSignatures = [];
return openpgp.decryptSessionKeys({
message,
@ -1172,11 +1172,11 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
publicKeys: publicKey
});
const decryptedSessionKeys = await openpgp.decryptSessionKeys({
message: await openpgp.readArmoredMessage(encrypted),
message: await openpgp.readMessage({ armoredMessage: encrypted }),
privateKeys: privateKey
});
const decrypted = await openpgp.decrypt({
message: await openpgp.readArmoredMessage(encrypted),
message: await openpgp.readMessage({ armoredMessage: encrypted }),
sessionKeys: decryptedSessionKeys[0]
});
expect(decrypted.data).to.equal(plaintext);
@ -1189,11 +1189,11 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
publicKeys: publicKey
});
const decryptedSessionKeys = await openpgp.decryptSessionKeys({
message: await openpgp.readArmoredMessage(encrypted),
message: await openpgp.readMessage({ armoredMessage: encrypted }),
privateKeys: privateKey
});
const decrypted = await openpgp.decrypt({
message: await openpgp.readArmoredMessage(encrypted),
message: await openpgp.readMessage({ armoredMessage: encrypted }),
sessionKeys: decryptedSessionKeys[0]
});
expect(decrypted.data).to.equal(plaintext);
@ -1205,11 +1205,11 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
passwords: password1
});
const decryptedSessionKeys = await openpgp.decryptSessionKeys({
message: await openpgp.readArmoredMessage(encrypted),
message: await openpgp.readMessage({ armoredMessage: encrypted }),
passwords: password1
});
const decrypted = await openpgp.decrypt({
message: await openpgp.readArmoredMessage(encrypted),
message: await openpgp.readMessage({ armoredMessage: encrypted }),
sessionKeys: decryptedSessionKeys[0]
});
expect(decrypted.data).to.equal(plaintext);
@ -1221,11 +1221,11 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
passwords: [password1, password2]
});
const decryptedSessionKeys = await openpgp.decryptSessionKeys({
message: await openpgp.readArmoredMessage(encrypted),
message: await openpgp.readMessage({ armoredMessage: encrypted }),
passwords: [password1, password2]
});
const decrypted = await openpgp.decrypt({
message: await openpgp.readArmoredMessage(encrypted),
message: await openpgp.readMessage({ armoredMessage: encrypted }),
sessionKeys: decryptedSessionKeys[0]
});
expect(decrypted.data).to.equal(plaintext);
@ -1237,12 +1237,12 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
passwords: [password1, password1]
});
const decryptedSessionKeys = await openpgp.decryptSessionKeys({
message: await openpgp.readArmoredMessage(encrypted),
message: await openpgp.readMessage({ armoredMessage: encrypted }),
passwords: password1
});
expect(decryptedSessionKeys.length).to.equal(1);
const decrypted = await openpgp.decrypt({
message: await openpgp.readArmoredMessage(encrypted),
message: await openpgp.readMessage({ armoredMessage: encrypted }),
sessionKeys: decryptedSessionKeys[0]
});
expect(decrypted.data).to.equal(plaintext);
@ -1281,7 +1281,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
};
return openpgp.encrypt(encOpt).then(async function (encrypted) {
expect(encrypted).to.match(/^-----BEGIN PGP MESSAGE/);
decOpt.message = await openpgp.readArmoredMessage(encrypted);
decOpt.message = await openpgp.readMessage({ armoredMessage: encrypted });
return openpgp.decrypt(decOpt);
}).then(function (decrypted) {
expect(decrypted.data).to.equal(plaintext);
@ -1291,7 +1291,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
});
it('should encrypt then decrypt with multiple private keys', async function () {
const privKeyDE = await openpgp.readArmoredKey(priv_key_de);
const privKeyDE = await openpgp.readKey({ armoredKey: priv_key_de });
await privKeyDE.decrypt(passphrase);
const encOpt = {
@ -1303,7 +1303,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
};
return openpgp.encrypt(encOpt).then(async function (encrypted) {
expect(encrypted).to.match(/^-----BEGIN PGP MESSAGE/);
decOpt.message = await openpgp.readArmoredMessage(encrypted);
decOpt.message = await openpgp.readMessage({ armoredMessage: encrypted });
return openpgp.decrypt(decOpt);
}).then(function (decrypted) {
expect(decrypted.data).to.equal(plaintext);
@ -1323,7 +1323,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
};
return openpgp.encrypt(encOpt).then(async function (encrypted) {
expect(encrypted).to.match(/^-----BEGIN PGP MESSAGE/);
decOpt.message = await openpgp.readArmoredMessage(encrypted);
decOpt.message = await openpgp.readMessage({ armoredMessage: encrypted });
return openpgp.decrypt(decOpt);
}).then(function (decrypted) {
expect(decrypted.data).to.equal(plaintext);
@ -1333,7 +1333,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
});
it('should encrypt then decrypt with wildcard with multiple private keys', async function () {
const privKeyDE = await openpgp.readArmoredKey(priv_key_de);
const privKeyDE = await openpgp.readKey({ armoredKey: priv_key_de });
await privKeyDE.decrypt(passphrase);
const encOpt = {
@ -1346,7 +1346,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
};
return openpgp.encrypt(encOpt).then(async function (encrypted) {
expect(encrypted).to.match(/^-----BEGIN PGP MESSAGE/);
decOpt.message = await openpgp.readArmoredMessage(encrypted);
decOpt.message = await openpgp.readMessage({ armoredMessage: encrypted });
return openpgp.decrypt(decOpt);
}).then(function (decrypted) {
expect(decrypted.data).to.equal(plaintext);
@ -1365,7 +1365,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
});
expect(encrypted).to.match(/^-----BEGIN PGP MESSAGE/);
const decrypted = await openpgp.decrypt({
message: await openpgp.readArmoredMessage(encrypted),
message: await openpgp.readMessage({ armoredMessage: encrypted }),
sessionKeys: sessionKey
});
expect(decrypted.data).to.equal(plaintext);
@ -1388,7 +1388,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
};
return openpgp.encrypt(encOpt).then(async function (encrypted) {
expect(encrypted).to.match(/^-----BEGIN PGP MESSAGE/);
decOpt.message = await openpgp.readArmoredMessage(encrypted);
decOpt.message = await openpgp.readMessage({ armoredMessage: encrypted });
expect(!!decOpt.message.packets.findPacket(openpgp.enums.packet.AEADEncryptedData)).to.equal(false);
return openpgp.decrypt(decOpt);
}).then(function (decrypted) {
@ -1411,7 +1411,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
};
return openpgp.encrypt(encOpt).then(async function (encrypted) {
expect(encrypted).to.match(/^-----BEGIN PGP MESSAGE/);
decOpt.message = await openpgp.readArmoredMessage(encrypted);
decOpt.message = await openpgp.readMessage({ armoredMessage: encrypted });
expect(!!decOpt.message.packets.findPacket(openpgp.enums.packet.AEADEncryptedData)).to.equal(false);
return openpgp.decrypt(decOpt);
}).then(function (decrypted) {
@ -1430,7 +1430,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
publicKeys: publicKey
};
return openpgp.encrypt(encOpt).then(async function (encrypted) {
decOpt.message = await openpgp.readArmoredMessage(encrypted);
decOpt.message = await openpgp.readMessage({ armoredMessage: encrypted });
expect(!!decOpt.message.packets.findPacket(openpgp.enums.packet.AEADEncryptedData)).to.equal(openpgp.config.aeadProtect);
return openpgp.decrypt(decOpt);
}).then(async function (decrypted) {
@ -1453,7 +1453,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
publicKeys: publicKeyNoAEAD
};
return openpgp.encrypt(encOpt).then(async function (encrypted) {
decOpt.message = await openpgp.readArmoredMessage(encrypted);
decOpt.message = await openpgp.readMessage({ armoredMessage: encrypted });
expect(!!decOpt.message.packets.findPacket(openpgp.enums.packet.AEADEncryptedData)).to.equal(false);
return openpgp.decrypt(decOpt);
}).then(async function (decrypted) {
@ -1471,8 +1471,8 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
};
return openpgp.generateKey(genOpt).then(async function(newKey) {
const newPublicKey = await openpgp.readArmoredKey(newKey.publicKeyArmored);
const newPrivateKey = await openpgp.readArmoredKey(newKey.privateKeyArmored);
const newPublicKey = await openpgp.readKey({ armoredKey: newKey.publicKeyArmored });
const newPrivateKey = await openpgp.readKey({ armoredKey: newKey.privateKeyArmored });
const encOpt = {
message: openpgp.Message.fromText(plaintext),
@ -1484,7 +1484,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
publicKeys: newPublicKey
};
return openpgp.encrypt(encOpt).then(async function (encrypted) {
decOpt.message = await openpgp.readArmoredMessage(encrypted);
decOpt.message = await openpgp.readMessage({ armoredMessage: encrypted });
expect(!!decOpt.message.packets.findPacket(openpgp.enums.packet.AEADEncryptedData)).to.equal(openpgp.config.aeadProtect);
return openpgp.decrypt(decOpt);
}).then(async function (decrypted) {
@ -1501,8 +1501,8 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
const newKey = await openpgp.generateKey({
userIds: [{ name: 'Test User', email: 'text@example.com' }]
});
const newPublicKey = await openpgp.readArmoredKey(newKey.publicKeyArmored);
const newPrivateKey = await openpgp.readArmoredKey(newKey.privateKeyArmored);
const newPublicKey = await openpgp.readKey({ armoredKey: newKey.publicKeyArmored });
const newPrivateKey = await openpgp.readKey({ armoredKey: newKey.privateKeyArmored });
const encrypted = await openpgp.encrypt({
message: openpgp.Message.fromText(plaintext),
@ -1513,11 +1513,11 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
privateKeys: newPrivateKey,
detached: true
});
const message = await openpgp.readArmoredMessage(encrypted);
const message = await openpgp.readMessage({ armoredMessage: encrypted });
expect(!!message.packets.findPacket(openpgp.enums.packet.AEADEncryptedData)).to.equal(openpgp.config.aeadProtect);
const decrypted = await openpgp.decrypt({
message,
signature: await openpgp.readArmoredSignature(signed),
signature: await openpgp.readSignature({ armoredSignature: signed }),
privateKeys: newPrivateKey,
publicKeys: newPublicKey
});
@ -1539,7 +1539,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
publicKeys: publicKey
};
return openpgp.encrypt(encOpt).then(async function (encrypted) {
decOpt.message = await openpgp.readArmoredMessage(encrypted);
decOpt.message = await openpgp.readMessage({ armoredMessage: encrypted });
return openpgp.decrypt(decOpt);
}).then(async function (decrypted) {
expect(decrypted.data).to.equal('');
@ -1561,8 +1561,8 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
detached: true
});
const decrypted = await openpgp.decrypt({
message: await openpgp.readArmoredMessage(encrypted),
signature: await openpgp.readArmoredSignature(signed),
message: await openpgp.readMessage({ armoredMessage: encrypted }),
signature: await openpgp.readSignature({ armoredSignature: signed }),
privateKeys: privateKey,
publicKeys: publicKey
});
@ -1576,10 +1576,10 @@ module.exports = () => describe('OpenPGP.js public api tests', 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.readArmoredKey(priv_key_de);
const privKeyDE = await openpgp.readKey({ armoredKey: priv_key_de });
await privKeyDE.decrypt(passphrase);
const pubKeyDE = await openpgp.readArmoredKey(pub_key_de);
const pubKeyDE = await openpgp.readKey({ armoredKey: pub_key_de });
const signOpt = {
message: openpgp.Message.fromText(plaintext),
@ -1598,11 +1598,11 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
publicKeys: [publicKey, pubKeyDE]
};
return openpgp.sign(signOpt).then(async function (signed) {
encOpt.signature = await openpgp.readArmoredSignature(signed);
return openpgp.sign(signOpt).then(async function (armoredSignature) {
encOpt.signature = await openpgp.readSignature({ armoredSignature });
return openpgp.encrypt(encOpt);
}).then(async function (encrypted) {
decOpt.message = await openpgp.readArmoredMessage(encrypted);
}).then(async function (armoredMessage) {
decOpt.message = await openpgp.readMessage({ armoredMessage });
return openpgp.decrypt(decOpt);
}).then(async function (decrypted) {
let signingKey;
@ -1632,14 +1632,14 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
const decOpt = {
privateKeys: privateKey,
publicKeys: await openpgp.readArmoredKey(wrong_pubkey)
publicKeys: await openpgp.readKey({ armoredKey: wrong_pubkey })
};
return openpgp.sign(signOpt).then(async function (signed) {
encOpt.signature = await openpgp.readArmoredSignature(signed);
return openpgp.sign(signOpt).then(async function (armoredSignature) {
encOpt.signature = await openpgp.readSignature({ armoredSignature });
return openpgp.encrypt(encOpt);
}).then(async function (encrypted) {
decOpt.message = await openpgp.readArmoredMessage(encrypted);
}).then(async function (armoredMessage) {
decOpt.message = await openpgp.readMessage({ armoredMessage });
return openpgp.decrypt(decOpt);
}).then(async function (decrypted) {
expect(decrypted.data).to.equal(plaintext);
@ -1658,10 +1658,10 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
};
const decOpt = {
privateKeys: privateKey,
publicKeys: await openpgp.readArmoredKey(wrong_pubkey)
publicKeys: await openpgp.readKey({ armoredKey: wrong_pubkey })
};
return openpgp.encrypt(encOpt).then(async function (encrypted) {
decOpt.message = await openpgp.readArmoredMessage(encrypted);
decOpt.message = await openpgp.readMessage({ armoredMessage: encrypted });
return openpgp.decrypt(decOpt);
}).then(async function (decrypted) {
expect(decrypted.data).to.equal(plaintext);
@ -1680,10 +1680,10 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
};
const decOpt = {
privateKeys: privateKey,
publicKeys: await openpgp.readArmoredKey(wrong_pubkey)
publicKeys: await openpgp.readKey({ armoredKey: wrong_pubkey })
};
return openpgp.encrypt(encOpt).then(async function (encrypted) {
decOpt.message = await openpgp.readArmoredMessage(encrypted);
decOpt.message = await openpgp.readMessage({ armoredMessage: encrypted });
return openpgp.decrypt(decOpt);
}).then(async function (decrypted) {
expect(decrypted.data).to.equal('');
@ -1704,7 +1704,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
privateKeys: privateKey
};
return openpgp.encrypt(encOpt).then(async function (encrypted) {
decOpt.message = await openpgp.readArmoredMessage(encrypted);
decOpt.message = await openpgp.readMessage({ armoredMessage: encrypted });
return openpgp.decrypt(decOpt);
}).then(async function (decrypted) {
expect(decrypted.data).to.equal(plaintext);
@ -1726,10 +1726,10 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
detached: true
});
const decrypted = await openpgp.decrypt({
message: await openpgp.readArmoredMessage(encrypted),
signature: await openpgp.readArmoredSignature(signed),
message: await openpgp.readMessage({ armoredMessage: encrypted }),
signature: await openpgp.readSignature({ armoredSignature: signed }),
privateKeys: privateKey,
publicKeys: await openpgp.readArmoredKey(wrong_pubkey)
publicKeys: await openpgp.readKey({ armoredKey: wrong_pubkey })
});
expect(decrypted.data).to.equal(plaintext);
expect(decrypted.signatures[0].valid).to.be.null;
@ -1739,10 +1739,10 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
});
it('should encrypt and decrypt/verify both signatures when signed with two private keys', async function () {
const privKeyDE = await openpgp.readArmoredKey(priv_key_de);
const privKeyDE = await openpgp.readKey({ armoredKey: priv_key_de });
await privKeyDE.decrypt(passphrase);
const pubKeyDE = await openpgp.readArmoredKey(pub_key_de);
const pubKeyDE = await openpgp.readKey({ armoredKey: pub_key_de });
const encOpt = {
message: openpgp.Message.fromText(plaintext),
@ -1756,7 +1756,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
};
return openpgp.encrypt(encOpt).then(async function (encrypted) {
decOpt.message = await openpgp.readArmoredMessage(encrypted);
decOpt.message = await openpgp.readMessage({ armoredMessage: encrypted });
return openpgp.decrypt(decOpt);
}).then(async function (decrypted) {
let signingKey;
@ -1774,7 +1774,7 @@ module.exports = () => 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 key = await openpgp.readArmoredKey(privateKeyArmored);
const key = await openpgp.readKey({ armoredKey: privateKeyArmored });
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
@ -1806,7 +1806,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
].map(async (encrypted, j) => {
let stepReached = 0;
try {
const message = await openpgp.readArmoredMessage(encrypted);
const message = await openpgp.readMessage({ armoredMessage: encrypted });
stepReached = 1;
const { data: decrypted } = await openpgp.decrypt({ message: message, privateKeys: [key] });
stepReached = 2;
@ -1831,7 +1831,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
const message = await openpgp.encrypt({ message: openpgp.Message.fromText('test'), publicKeys: key, privateKeys: key, armor: false });
const encrypted = util.concat([message, new Uint8Array([11])]);
await expect(
openpgp.decrypt({ message: await openpgp.readMessage(encrypted), privateKeys: key, publicKeys: key })
openpgp.decrypt({ message: await openpgp.readMessage({ binaryMessage: encrypted }), privateKeys: key, publicKeys: key })
).to.be.rejectedWith('Error during parsing. This message / key probably does not conform to a valid OpenPGP format.');
});
});
@ -1839,8 +1839,8 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
describe('ELG / DSA encrypt, decrypt, sign, verify', function() {
it('round trip test', async function () {
const pubKeyDE = await openpgp.readArmoredKey(pub_key_de);
const privKeyDE = await openpgp.readArmoredKey(priv_key_de);
const pubKeyDE = await openpgp.readKey({ armoredKey: pub_key_de });
const privKeyDE = await openpgp.readKey({ armoredKey: priv_key_de });
await privKeyDE.decrypt(passphrase);
pubKeyDE.users[0].selfCertifications[0].features = [7]; // Monkey-patch AEAD feature flag
return openpgp.encrypt({
@ -1851,7 +1851,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
return openpgp.decrypt({
privateKeys: privKeyDE,
publicKeys: pubKeyDE,
message: await openpgp.readArmoredMessage(encrypted)
message: await openpgp.readMessage({ armoredMessage: encrypted })
});
}).then(async function (decrypted) {
expect(decrypted.data).to.exist;
@ -1919,9 +1919,9 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
].join('\n');
it('Decrypt message', async function() {
const privKey = await openpgp.readArmoredKey(priv_key);
const privKey = await openpgp.readKey({ armoredKey: priv_key });
await privKey.decrypt('1234');
const message = await openpgp.readArmoredMessage(pgp_msg);
const message = await openpgp.readMessage({ armoredMessage: pgp_msg });
return openpgp.decrypt({ privateKeys:privKey, message:message }).then(function(decrypted) {
expect(decrypted.data).to.equal('hello 3des\n');
@ -1941,7 +1941,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
passwords: password1
};
return openpgp.encrypt(encOpt).then(async function (encrypted) {
decOpt.message = await openpgp.readArmoredMessage(encrypted);
decOpt.message = await openpgp.readMessage({ armoredMessage: encrypted });
return openpgp.decrypt(decOpt);
}).then(function (decrypted) {
expect(decrypted.data).to.equal(plaintext);
@ -1958,7 +1958,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
passwords: password2
};
return openpgp.encrypt(encOpt).then(async function (encrypted) {
decOpt.message = await openpgp.readArmoredMessage(encrypted);
decOpt.message = await openpgp.readMessage({ armoredMessage: encrypted });
return openpgp.decrypt(decOpt);
}).then(function (decrypted) {
expect(decrypted.data).to.equal(plaintext);
@ -1976,7 +1976,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
passwords: password1
};
return openpgp.encrypt(encOpt).then(async function (encrypted) {
decOpt.message = await openpgp.readMessage(encrypted);
decOpt.message = await openpgp.readMessage({ binaryMessage: encrypted });
return openpgp.decrypt(decOpt);
}).then(function (decrypted) {
expect(decrypted.data).to.equal(plaintext);
@ -1995,7 +1995,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
format: 'binary'
};
return openpgp.encrypt(encOpt).then(async function (encrypted) {
decOpt.message = await openpgp.readMessage(encrypted);
decOpt.message = await openpgp.readMessage({ binaryMessage: encrypted });
return openpgp.decrypt(decOpt);
}).then(function (decrypted) {
expect(decrypted.data).to.deep.equal(new Uint8Array([0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01]));
@ -2015,7 +2015,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
passwords: password1
};
return openpgp.encrypt(encOpt).then(async function (encrypted) {
decOpt.message = await openpgp.readArmoredMessage(encrypted);
decOpt.message = await openpgp.readMessage({ armoredMessage: encrypted });
return openpgp.decrypt(decOpt);
}).then(function (decrypted) {
expect(decrypted.data).to.equal(plaintext);
@ -2046,7 +2046,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
}));
expect(openpgp.stream.isStream(encrypted)).to.equal(useNativeStream ? 'web' : 'ponyfill');
const message = await openpgp.readArmoredMessage(encrypted);
const message = await openpgp.readMessage({ armoredMessage: encrypted });
const decrypted = await openpgp.decrypt({
passwords: ['test'],
message,
@ -2093,7 +2093,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
};
return openpgp.sign(signOpt).then(async function (signed) {
expect(signed).to.match(/-----BEGIN PGP SIGNED MESSAGE-----/);
verifyOpt.message = await openpgp.readArmoredCleartextMessage(signed);
verifyOpt.message = await openpgp.readCleartextMessage({ cleartextMessage: signed });
return openpgp.verify(verifyOpt);
}).then(async function (verified) {
expect(verified.data).to.equal(plaintext.replace(/[ \t]+$/mg, ''));
@ -2105,7 +2105,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
});
it('should sign and verify cleartext message with multiple private keys', async function () {
const privKeyDE = await openpgp.readArmoredKey(priv_key_de);
const privKeyDE = await openpgp.readKey({ armoredKey: priv_key_de });
await privKeyDE.decrypt(passphrase);
const message = openpgp.CleartextMessage.fromText(plaintext);
@ -2118,7 +2118,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
};
return openpgp.sign(signOpt).then(async function (signed) {
expect(signed).to.match(/-----BEGIN PGP SIGNED MESSAGE-----/);
verifyOpt.message = await openpgp.readArmoredCleartextMessage(signed);
verifyOpt.message = await openpgp.readCleartextMessage({ cleartextMessage: signed });
return openpgp.verify(verifyOpt);
}).then(async function (verified) {
let signingKey;
@ -2145,8 +2145,8 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
message,
publicKeys: publicKey
};
return openpgp.sign(signOpt).then(async function (signed) {
verifyOpt.signature = await openpgp.readArmoredSignature(signed);
return openpgp.sign(signOpt).then(async function (armoredSignature) {
verifyOpt.signature = await openpgp.readSignature({ armoredSignature });
return openpgp.verify(verifyOpt);
}).then(async function (verified) {
expect(verified.data).to.equal(plaintext);
@ -2164,10 +2164,10 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
privateKeys: privateKey
};
const verifyOpt = {
publicKeys: await openpgp.readArmoredKey(wrong_pubkey)
publicKeys: await openpgp.readKey({ armoredKey: wrong_pubkey })
};
return openpgp.sign(signOpt).then(async function (signed) {
verifyOpt.message = await openpgp.readArmoredCleartextMessage(signed);
verifyOpt.message = await openpgp.readCleartextMessage({ cleartextMessage: signed });
return openpgp.verify(verifyOpt);
}).then(async function (verified) {
expect(verified.data).to.equal(plaintext.replace(/[ \t]+$/mg, ''));
@ -2187,10 +2187,10 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
};
const verifyOpt = {
message,
publicKeys: await openpgp.readArmoredKey(wrong_pubkey)
publicKeys: await openpgp.readKey({ armoredKey: wrong_pubkey })
};
return openpgp.sign(signOpt).then(async function (signed) {
verifyOpt.signature = await openpgp.readArmoredSignature(signed);
return openpgp.sign(signOpt).then(async function (armoredSignature) {
verifyOpt.signature = await openpgp.readSignature({ armoredSignature });
return openpgp.verify(verifyOpt);
}).then(async function (verified) {
expect(verified.data).to.equal(plaintext);
@ -2212,7 +2212,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
publicKeys: publicKey
};
return openpgp.sign(signOpt).then(async function (signed) {
verifyOpt.message = await openpgp.readMessage(signed);
verifyOpt.message = await openpgp.readMessage({ binaryMessage: signed });
return openpgp.verify(verifyOpt);
}).then(async function (verified) {
expect(verified.data).to.equal(plaintext);
@ -2237,7 +2237,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
publicKeys: publicKey
};
return openpgp.sign(signOpt).then(async function (signed) {
verifyOpt.signature = await openpgp.readSignature(signed);
verifyOpt.signature = await openpgp.readSignature({ binarySignature: signed });
return openpgp.verify(verifyOpt);
}).then(async function (verified) {
expect(verified.data).to.equal(plaintext);
@ -2266,7 +2266,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
date: past
};
return openpgp.sign(signOpt).then(async function (signed) {
verifyOpt.signature = await openpgp.readSignature(signed);
verifyOpt.signature = await openpgp.readSignature({ binarySignature: 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);
@ -2305,7 +2305,7 @@ module.exports = () => 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.readSignature(signed);
verifyOpt.signature = await openpgp.readSignature({ binarySignature: signed });
return openpgp.verify(verifyOpt);
}).then(async function (verified) {
expect(+verified.signatures[0].signature.packets[0].created).to.equal(+future);
@ -2329,7 +2329,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
format: 'binary'
};
return openpgp.sign(signOpt).then(async function (signed) {
const message = await openpgp.readMessage(signed);
const message = await openpgp.readMessage({ binaryMessage: signed });
message.packets.concat(await openpgp.stream.readToEnd(message.packets.stream, _ => _));
const packets = new openpgp.PacketList();
packets.push(message.packets.findPacket(openpgp.enums.packet.signature));
@ -2361,7 +2361,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
const useNativeStream = (() => { try { new global.ReadableStream(); return true; } catch (e) { return false; } })(); // eslint-disable-line no-new
return openpgp.sign(signOpt).then(async function (signed) {
expect(openpgp.stream.isStream(signed)).to.equal(useNativeStream ? 'web' : 'ponyfill');
const message = await openpgp.readMessage(signed);
const message = await openpgp.readMessage({ binaryMessage: signed });
message.packets.concat(await openpgp.stream.readToEnd(message.packets.stream, _ => _));
const packets = new openpgp.PacketList();
packets.push(message.packets.findPacket(openpgp.enums.packet.signature));
@ -2388,7 +2388,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
};
return openpgp.encrypt(encryptOpt).then(async function (encrypted) {
const message = await openpgp.readMessage(encrypted);
const message = await openpgp.readMessage({ binaryMessage: encrypted });
return message.decrypt([privateKey_2038_2045]);
}).then(async function (packets) {
const literals = packets.packets.filterByTag(openpgp.enums.packet.literalData);
@ -2409,7 +2409,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
};
return openpgp.encrypt(encryptOpt).then(async function (encrypted) {
const message = await openpgp.readMessage(encrypted);
const message = await openpgp.readMessage({ binaryMessage: encrypted });
return message.decrypt([privateKey_2000_2008]);
}).then(async function (packets) {
const literals = packets.packets.filterByTag(openpgp.enums.packet.literalData);
@ -2430,7 +2430,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
};
return openpgp.encrypt(encryptOpt).then(async function (encrypted) {
const message = await openpgp.readMessage(encrypted);
const message = await openpgp.readMessage({ binaryMessage: encrypted });
return message.decrypt([privateKey_2000_2008]);
}).then(async function (message) {
const literals = message.packets.filterByTag(openpgp.enums.packet.literalData);
@ -2458,7 +2458,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
};
return openpgp.encrypt(encryptOpt).then(async function (encrypted) {
const message = await openpgp.readMessage(encrypted);
const message = await openpgp.readMessage({ binaryMessage: encrypted });
return message.decrypt([privateKey_2038_2045]);
}).then(async function (message) {
const literals = message.packets.filterByTag(openpgp.enums.packet.literalData);
@ -2487,7 +2487,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
};
return openpgp.encrypt(encryptOpt).then(async function (encrypted) {
const message = await openpgp.readMessage(encrypted);
const message = await openpgp.readMessage({ binaryMessage: encrypted });
return message.decrypt([privateKey_2038_2045]);
}).then(async function (message) {
const literals = message.packets.filterByTag(openpgp.enums.packet.literalData);
@ -2520,8 +2520,8 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
});
it('should fail to encrypt with revoked subkey', async function() {
const pubKeyDE = await openpgp.readArmoredKey(pub_key_de);
const privKeyDE = await openpgp.readArmoredKey(priv_key_de);
const pubKeyDE = await openpgp.readKey({ armoredKey: pub_key_de });
const privKeyDE = await openpgp.readKey({ armoredKey: priv_key_de });
await privKeyDE.decrypt(passphrase);
return privKeyDE.subKeys[0].revoke(privKeyDE.primaryKey).then(function(revSubKey) {
pubKeyDE.subKeys[0] = revSubKey;
@ -2537,8 +2537,8 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
});
it('should decrypt with revoked subkey', async function() {
const pubKeyDE = await openpgp.readArmoredKey(pub_key_de);
const privKeyDE = await openpgp.readArmoredKey(priv_key_de);
const pubKeyDE = await openpgp.readKey({ armoredKey: pub_key_de });
const privKeyDE = await openpgp.readKey({ armoredKey: priv_key_de });
await privKeyDE.decrypt(passphrase);
const encrypted = await openpgp.encrypt({
message: openpgp.Message.fromText(plaintext),
@ -2546,7 +2546,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
});
privKeyDE.subKeys[0] = await privKeyDE.subKeys[0].revoke(privKeyDE.primaryKey);
const decOpt = {
message: await openpgp.readArmoredMessage(encrypted),
message: await openpgp.readMessage({ armoredMessage: encrypted }),
privateKeys: privKeyDE
};
const decrypted = await openpgp.decrypt(decOpt);
@ -2554,8 +2554,8 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
});
it('should not decrypt with corrupted subkey', async function() {
const pubKeyDE = await openpgp.readArmoredKey(pub_key_de);
const privKeyDE = await openpgp.readArmoredKey(priv_key_de);
const pubKeyDE = await openpgp.readKey({ armoredKey: pub_key_de });
const privKeyDE = await openpgp.readKey({ armoredKey: priv_key_de });
// corrupt the public key params
privKeyDE.subKeys[0].keyPacket.publicParams.p[0]++;
// validation will not check the decryption subkey and will succeed
@ -2565,7 +2565,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
publicKeys: pubKeyDE
});
const decOpt = {
message: await openpgp.readArmoredMessage(encrypted),
message: await openpgp.readMessage({ armoredMessage: encrypted }),
privateKeys: privKeyDE
};
// binding signature is invalid
@ -2573,7 +2573,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
});
it('RSA decryption with PKCS1 padding of wrong length should fail', async function() {
const key = await openpgp.readArmoredKey(rsaPrivateKeyPKCS1);
const key = await openpgp.readKey({ armoredKey: rsaPrivateKeyPKCS1 });
// the paddings of these messages are prefixed by 0x02 and 0x000002 instead of 0x0002
// the code should discriminate between these cases by checking the length of the padded plaintext
const padding02 = `-----BEGIN PGP MESSAGE-----
@ -2606,13 +2606,13 @@ J9I8AcH94nE77JUtCm7s1kOlo0EIshZsAqJwGveDGdAuabfViVwVxG4I24M6
-----END PGP MESSAGE-----`;
const decOpt02 = {
message: await openpgp.readArmoredMessage(padding02),
message: await openpgp.readMessage({ armoredMessage: padding02 }),
privateKeys: key
};
await expect(openpgp.decrypt(decOpt02)).to.be.rejectedWith(/Decryption error/);
const decOpt000002 = {
message: await openpgp.readArmoredMessage(padding000002),
message: await openpgp.readMessage({ armoredMessage: padding000002 }),
privateKeys: key
};
await expect(openpgp.decrypt(decOpt000002)).to.be.rejectedWith(/Decryption error/);
@ -2620,7 +2620,7 @@ J9I8AcH94nE77JUtCm7s1kOlo0EIshZsAqJwGveDGdAuabfViVwVxG4I24M6
it('should decrypt with two passwords message which GPG fails on', async function() {
const decOpt = {
message: await openpgp.readArmoredMessage(twoPasswordGPGFail),
message: await openpgp.readMessage({ armoredMessage: twoPasswordGPGFail }),
passwords: password2
};
return openpgp.decrypt(decOpt).then(function(decrypted) {
@ -2631,23 +2631,23 @@ J9I8AcH94nE77JUtCm7s1kOlo0EIshZsAqJwGveDGdAuabfViVwVxG4I24M6
it('should decrypt with three passwords', async function() {
const messageBinary = util.hexToUint8Array('c32e04090308125231fe38b0255f60a7f319fc4959c147c7af33817ceb4cf159a00f2efa17b7921961f6ead025c77588d2430166fe9395cd58e9b69a67a30470e2d31bf0bbbb31c7eca31fb9015dddf70c6957036b093d104cbf0b26e218113e69c4fa89dda97a61d0cba364efa77d5144c5b9b701');
const message = await openpgp.readMessage(messageBinary);
const message = await openpgp.readMessage({ binaryMessage: messageBinary });
const passwords = ['Test', 'Pinata', 'a'];
const decrypted = await openpgp.decrypt({ message, passwords });
expect(decrypted.data).to.equal('Hello world');
});
it('should decrypt broken ECC message from old OpenPGP.js', async function() {
const key = await openpgp.readArmoredKey(ecdh_dec_key);
const message = await openpgp.readArmoredMessage(ecdh_msg_bad);
const key = await openpgp.readKey({ armoredKey: ecdh_dec_key });
const message = await openpgp.readMessage({ armoredMessage: ecdh_msg_bad });
await key.decrypt('12345');
const decrypted = await openpgp.decrypt({ message, privateKeys: [key] });
expect(decrypted.data).to.equal('\n');
});
it('should decrypt broken ECC message from old go crypto', async function() {
const key = await openpgp.readArmoredKey(ecdh_dec_key_2);
const message = await openpgp.readArmoredMessage(ecdh_msg_bad_2);
const key = await openpgp.readKey({ armoredKey: ecdh_dec_key_2 });
const message = await openpgp.readMessage({ armoredMessage: ecdh_msg_bad_2 });
await key.decrypt('12345');
const decrypted = await openpgp.decrypt({ message, privateKeys: [key] });
expect(decrypted.data).to.equal('Tesssst<br><br><br>Sent from ProtonMail mobile<br><br><br>');
@ -2656,7 +2656,8 @@ J9I8AcH94nE77JUtCm7s1kOlo0EIshZsAqJwGveDGdAuabfViVwVxG4I24M6
it('should decrypt Blowfish message', async function() {
const { data } = await openpgp.decrypt({
passwords: 'test',
message: await openpgp.readArmoredMessage(`-----BEGIN PGP MESSAGE-----
message: await openpgp.readMessage({
armoredMessage: `-----BEGIN PGP MESSAGE-----
Version: OpenPGP.js v4.9.0
Comment: https://openpgpjs.org
@ -2664,7 +2665,8 @@ wx4EBAMI7Di70u7hoDfgBUJQ2+1ig6ym3KMjRS9kAovSPAGRQLIPv2DgkINL
3DUgMNqtQCA23xWhq7Ly6o9H1lRfoAo7V5UElVCqGEX7cgyZjI97alY6Je3o
amnR6g==
=rPIK
-----END PGP MESSAGE-----`)
-----END PGP MESSAGE-----`
})
});
expect(data).to.equal('Hello World!');
});
@ -2677,7 +2679,7 @@ amnR6g==
});
const decrypted = await openpgp.decrypt({
passwords: 'test',
message: await openpgp.readArmoredMessage(encrypted),
message: await openpgp.readMessage({ armoredMessage: encrypted }),
format: 'binary'
});
expect(util.decodeUtf8(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"');
@ -2691,7 +2693,7 @@ amnR6g==
const plaintext = 'short message';
const key = (await openpgp.generateKey({ curve, userIds: { name: 'Alice', email: 'info@alice.com' } })).key;
const signed = await openpgp.sign({ privateKeys:[key], message: openpgp.CleartextMessage.fromText(plaintext) });
const verified = await openpgp.verify({ publicKeys:[key], message: await openpgp.readArmoredCleartextMessage(signed) });
const verified = await openpgp.verify({ publicKeys:[key], message: await openpgp.readCleartextMessage({ cleartextMessage: signed }) });
expect(verified.signatures[0].valid).to.be.true;
});
});
@ -2723,20 +2725,22 @@ amnR6g==
keyIdType.fromId("BBE14491E6EE6366"),
keyIdType.fromId("3E0F20F1A71D6DFD")
];
const getPrimaryKey = async () => openpgp.readArmoredKey(
multipleEncryptionAndSigningSubkeys
);
const getPrimaryKey = async () => openpgp.readKey({
armoredKey: multipleEncryptionAndSigningSubkeys
});
it('Encrypt message with a specific encryption key id', async function () {
const primaryKey = await getPrimaryKey();
let m;
let p;
for (let i = 0; i < encryptionKeyIds.length; i++) {
m = await openpgp.readArmoredMessage(await openpgp.encrypt({
message: openpgp.Message.fromText("Hello World\n"),
publicKeys: primaryKey,
encryptionKeyIds: [encryptionKeyIds[i]]
}));
m = await openpgp.readMessage({
armoredMessage: await openpgp.encrypt({
message: openpgp.Message.fromText("Hello World\n"),
publicKeys: primaryKey,
encryptionKeyIds: [encryptionKeyIds[i]]
})
});
p = m.packets.filterByTag(openpgp.enums.packet.publicKeyEncryptedSessionKey);
expect(p.length).equals(1);
expect(p[0].publicKeyId.equals(encryptionKeyIds[i])).to.be.true;
@ -2748,12 +2752,14 @@ amnR6g==
let s;
let p;
for (let i = 0; i < signingKeyIds.length; i++) {
s = await openpgp.readArmoredSignature(await openpgp.sign({
message: openpgp.Message.fromText("Hello World\n"),
privateKeys: primaryKey,
signingKeyIds: [signingKeyIds[i]],
detached: true
}));
s = await openpgp.readSignature({
armoredSignature: await openpgp.sign({
message: openpgp.Message.fromText("Hello World\n"),
privateKeys: primaryKey,
signingKeyIds: [signingKeyIds[i]],
detached: true
})
});
p = s.packets.filterByTag(openpgp.enums.packet.signature);
expect(p.length).equals(1);
expect(p[0].issuerKeyId.equals(signingKeyIds[i])).to.be.true;
@ -2777,13 +2783,15 @@ amnR6g==
const kIds = [encryptionKeyIds[1], encryptionKeyIds[0], encryptionKeyIds[2]];
const sIds = [signingKeyIds[2], signingKeyIds[1], signingKeyIds[0]];
const message = await openpgp.readArmoredMessage(await openpgp.encrypt({
message: plaintextMessage,
privateKeys: [primaryKey, primaryKey, primaryKey],
publicKeys: [primaryKey, primaryKey, primaryKey],
encryptionKeyIds: kIds,
signingKeyIds: sIds
}));
const message = await openpgp.readMessage({
armoredMessage: await openpgp.encrypt({
message: plaintextMessage,
privateKeys: [primaryKey, primaryKey, primaryKey],
publicKeys: [primaryKey, primaryKey, primaryKey],
encryptionKeyIds: kIds,
signingKeyIds: sIds
})
});
const pKESKList = message.packets.filterByTag(openpgp.enums.packet.publicKeyEncryptedSessionKey);
expect(pKESKList.length).equals(3);
checkEncryptedPackets(kIds, pKESKList);

6
test/general/packet.js
View File

@ -764,7 +764,7 @@ module.exports = () => describe("Packet", function() {
});
it('Reading signersUserId from armored signature', async function() {
const armored_sig =
const armoredSignature =
`-----BEGIN PGP SIGNATURE-----
iQFKBAEBCgA0FiEEdOyNPagqedqiXfEMa6Ve2Dq64bsFAlszXwQWHHRlc3Qtd2tk
@ -777,7 +777,7 @@ kePFjAnu9cpynKXu3usf8+FuBw2zLsg1Id1n7ttxoAte416KjBN9lFBt8mcu
=wEIR
-----END PGP SIGNATURE-----`;
const signature = await openpgp.readArmoredSignature(armored_sig);
const signature = await openpgp.readSignature({ armoredSignature });
expect(signature.packets[0].signersUserId).to.equal('test-wkd@metacode.biz');
});
@ -816,7 +816,7 @@ V+HOQJQxXJkVRYa3QrFUehiMzTeqqMdgC6ZqJy7+
=et/d
-----END PGP PUBLIC KEY BLOCK-----`;
const key = await openpgp.readArmoredKey(pubkey);
const key = await openpgp.readKey({ armoredKey: pubkey });
const { notations, rawNotations } = key.users[0].selfCertifications[0];

218
test/general/signature.js
View File

@ -850,9 +850,9 @@ hUhMKMuiM3pRwdIyDOItkUWQmjEEw7/XmhgInkXsCw==
const { rejectMessageHashAlgorithms } = openpgp.config;
Object.assign(openpgp.config, { rejectMessageHashAlgorithms: new Set([openpgp.enums.hash.md5, openpgp.enums.hash.ripemd]) });
try {
const priv_key = await openpgp.readArmoredKey(priv_key_arm1);
const pub_key = await openpgp.readArmoredKey(pub_key_arm1);
const msg = await openpgp.readArmoredMessage(msg_arm1);
const priv_key = await openpgp.readKey({ armoredKey: priv_key_arm1 });
const pub_key = await openpgp.readKey({ armoredKey: pub_key_arm1 });
const msg = await openpgp.readMessage({ armoredMessage: msg_arm1 });
await priv_key.decrypt("abcd");
const decrypted = await openpgp.decrypt({ privateKeys: priv_key, publicKeys:[pub_key], message:msg });
expect(decrypted.data).to.exist;
@ -869,10 +869,10 @@ hUhMKMuiM3pRwdIyDOItkUWQmjEEw7/XmhgInkXsCw==
try {
// exercises the GnuPG s2k type 1001 extension:
// the secrets on the primary key have been stripped.
const priv_key_gnupg_ext = await openpgp.readArmoredKey(priv_key_arm1_stripped);
const priv_key_gnupg_ext_2 = await openpgp.readArmoredKey(priv_key_arm1_stripped);
const pub_key = await openpgp.readArmoredKey(pub_key_arm1);
const message = await openpgp.readArmoredMessage(msg_arm1);
const priv_key_gnupg_ext = await openpgp.readKey({ armoredKey: priv_key_arm1_stripped });
const priv_key_gnupg_ext_2 = await openpgp.readKey({ armoredKey: priv_key_arm1_stripped });
const pub_key = await openpgp.readKey({ armoredKey: pub_key_arm1 });
const message = await openpgp.readMessage({ armoredMessage: msg_arm1 });
const primaryKey_packet = priv_key_gnupg_ext.primaryKey.write();
expect(priv_key_gnupg_ext.isDecrypted()).to.be.false;
await priv_key_gnupg_ext.decrypt("abcd");
@ -896,14 +896,14 @@ hUhMKMuiM3pRwdIyDOItkUWQmjEEw7/XmhgInkXsCw==
});
it('Supports signing with GnuPG stripped-key extension', async function() {
const priv_key_gnupg_ext = await openpgp.readArmoredKey(flowcrypt_stripped_key);
const priv_key_gnupg_ext = await openpgp.readKey({ armoredKey: flowcrypt_stripped_key });
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).to.match(/-----END PGP MESSAGE-----\n$/);
});
it('Supports non-human-readable notations', async function() {
const { packets: [signature] } = await openpgp.readArmoredMessage(signature_with_non_human_readable_notations);
const { packets: [signature] } = await openpgp.readSignature({ armoredSignature: signature_with_non_human_readable_notations });
// There are no human-readable notations so `notations` property does not
// expose the `test@key.com` notation.
expect(Object.keys(signature.notations).length).to.equal(0);
@ -920,7 +920,8 @@ hUhMKMuiM3pRwdIyDOItkUWQmjEEw7/XmhgInkXsCw==
it('Checks for critical bit in non-human-readable notations', async function() {
try {
openpgp.config.tolerant = false;
await openpgp.readArmoredMessage(`-----BEGIN PGP SIGNATURE-----
await openpgp.readSignature({
armoredSignature: `-----BEGIN PGP SIGNATURE-----
wsEfBAABCABJBYJfKDH0K5QAAAAAAB0ABXVua25vd25AdGVzdHMuc2VxdW9pYS1w
Z3Aub3JndmFsdWUWIQTRpm4aI7GCyZgPeIz7/MgqAV5zMAAKCRD7/MgqAV5zMLBK
@ -934,8 +935,9 @@ IYs+aFmldMg4p1t1Ab/bRHbBxIlzhtbNE6IyOfc17mgOcjQzVJBc/EaxD7S3KjU2
4ymAWpppg47NhCwuYh/EG5G1P4ccxksRj1GX2r5HxH8ZeAQWWdviINErgrUONWHy
bwM=
=0x2S
-----END PGP SIGNATURE-----`);
throw new Error('openpgp.readArmoredMessage should throw but it did not.');
-----END PGP SIGNATURE-----`
});
throw new Error('openpgp.readSignature should throw but it did not.');
} catch (e) {
expect(e.message).to.equal('Unknown critical notation: unknown@tests.sequoia-pgp.org');
} finally {
@ -959,8 +961,8 @@ bwM=
'=VH8F',
'-----END PGP MESSAGE-----'].join('\n');
const sMsg = await openpgp.readArmoredMessage(signedArmor);
const pub_key = await openpgp.readArmoredKey(pub_key_arm2);
const sMsg = await openpgp.readMessage({ armoredMessage: signedArmor });
const pub_key = await openpgp.readKey({ armoredKey: pub_key_arm2 });
const verified = await sMsg.verify([pub_key]);
openpgp.stream.pipe(sMsg.getLiteralData(), new openpgp.stream.WritableStream());
expect(verified).to.exist;
@ -990,9 +992,9 @@ bwM=
'-----END PGP MESSAGE-----'].join('\n');
const plaintext = 'short message\nnext line\n한국어/조선말';
const esMsg = await openpgp.readArmoredMessage(msg_armor);
const pubKey = await openpgp.readArmoredKey(pub_key_arm2);
const privKey = await openpgp.readArmoredKey(priv_key_arm2);
const esMsg = await openpgp.readMessage({ armoredMessage: msg_armor });
const pubKey = await openpgp.readKey({ armoredKey: pub_key_arm2 });
const privKey = await openpgp.readKey({ armoredKey: priv_key_arm2 });
await Promise.all(esMsg.getEncryptionKeyIds().map(keyId => privKey.decrypt('hello world', keyId)));
@ -1025,9 +1027,9 @@ bwM=
'-----END PGP MESSAGE-----'].join('\n');
const plaintext = 'short message\nnext line\n한국어/조선말';
const sMsg = await openpgp.readArmoredMessage(msg_armor);
const pubKey2 = await openpgp.readArmoredKey(pub_key_arm2);
const pubKey3 = await openpgp.readArmoredKey(pub_key_arm3);
const sMsg = await openpgp.readMessage({ armoredMessage: msg_armor });
const pubKey2 = await openpgp.readKey({ armoredKey: pub_key_arm2 });
const pubKey3 = await openpgp.readKey({ armoredKey: pub_key_arm3 });
const keyids = sMsg.getSigningKeyIds();
@ -1049,8 +1051,8 @@ bwM=
let testFailed = true;
try {
openpgp.config.tolerant = false;
const sMsg = await openpgp.readArmoredMessage(signature_with_critical_notation);
const pub_key = await openpgp.readArmoredKey(pub_key_arm2);
const sMsg = await openpgp.readMessage({ armoredMessage: signature_with_critical_notation });
const pub_key = await openpgp.readKey({ armoredKey: pub_key_arm2 });
const verified = await sMsg.verify([pub_key]);
await verified[0].verified;
testFailed = false;
@ -1067,8 +1069,8 @@ bwM=
openpgp.config.tolerant = false;
openpgp.config.knownNotations.push('test@example.com');
try {
const sMsg = await openpgp.readArmoredMessage(signature_with_critical_notation);
const pub_key = await openpgp.readArmoredKey(pub_key_arm2);
const sMsg = await openpgp.readMessage({ armoredMessage: signature_with_critical_notation });
const pub_key = await openpgp.readKey({ armoredKey: pub_key_arm2 });
const verified = await sMsg.verify([pub_key]);
openpgp.stream.pipe(sMsg.getLiteralData(), new openpgp.stream.WritableStream());
expect(await verified[0].verified).to.be.true;
@ -1103,9 +1105,9 @@ bwM=
'-----END PGP SIGNATURE-----'].join('\n');
const plaintext = 'short message\nnext line\n한국어/조선말';
const csMsg = await openpgp.readArmoredCleartextMessage(msg_armor);
const pubKey2 = await openpgp.readArmoredKey(pub_key_arm2);
const pubKey3 = await openpgp.readArmoredKey(pub_key_arm3);
const csMsg = await openpgp.readCleartextMessage({ cleartextMessage: msg_armor });
const pubKey2 = await openpgp.readKey({ armoredKey: pub_key_arm2 });
const pubKey3 = await openpgp.readKey({ armoredKey: pub_key_arm3 });
const keyids = csMsg.getSigningKeyIds();
@ -1144,7 +1146,7 @@ PAAeuQTUrcJdZeJ86eQ9cCUB216HCwSKOWTQRzL+hBWKXij4WD4=
=ZEFm
-----END PGP SIGNATURE-----`);
const pubKey = await openpgp.readArmoredKey(pub_latin1_msg);
const pubKey = await openpgp.readKey({ armoredKey: pub_latin1_msg });
return message.verify([pubKey]).then(async verifiedSig => {
expect(await openpgp.stream.readToEnd(message.getLiteralData())).to.equal(latin1Binary);
@ -1181,8 +1183,8 @@ zmuVOdNuWQqxT9Sqa84=
-----END PGP SIGNATURE-----`;
const plaintext = 'space: \nspace and tab: \t\nno trailing space\n \ntab:\t\ntab and space:\t ';
const csMsg = await openpgp.readArmoredCleartextMessage(msg_armor);
const pubKey = await openpgp.readArmoredKey(pub_key_arm2);
const csMsg = await openpgp.readCleartextMessage({ cleartextMessage: msg_armor });
const pubKey = await openpgp.readKey({ armoredKey: pub_key_arm2 });
const keyids = csMsg.getSigningKeyIds();
@ -1215,8 +1217,8 @@ yYDnCgA=
-----END PGP MESSAGE-----`;
const plaintext = 'space: \nspace and tab: \t\nno trailing space\n \ntab:\t\ntab and space:\t ';
const sMsg = await openpgp.readArmoredMessage(msg_armor);
const pubKey = await openpgp.readArmoredKey(pub_key_arm2);
const sMsg = await openpgp.readMessage({ armoredMessage: msg_armor });
const pubKey = await openpgp.readKey({ armoredKey: pub_key_arm2 });
const keyids = sMsg.getSigningKeyIds();
@ -1246,14 +1248,16 @@ yYDnCgA=
-----END PGP MESSAGE-----`.split('');
const plaintext = 'space: \nspace and tab: \t\nno trailing space\n \ntab:\t\ntab and space:\t ';
const sMsg = await openpgp.readArmoredMessage(new openpgp.stream.ReadableStream({
async pull(controller) {
await new Promise(setTimeout);
controller.enqueue(msg_armor.shift());
if (!msg_armor.length) controller.close();
}
}));
const pubKey = await openpgp.readArmoredKey(pub_key_arm2);
const sMsg = await openpgp.readMessage({
armoredMessage: new openpgp.stream.ReadableStream({
async pull(controller) {
await new Promise(setTimeout);
controller.enqueue(msg_armor.shift());
if (!msg_armor.length) controller.close();
}
})
});
const pubKey = await openpgp.readKey({ armoredKey: pub_key_arm2 });
const keyids = sMsg.getSigningKeyIds();
@ -1285,8 +1289,8 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
-----END PGP MESSAGE-----`;
const plaintext = 'space: \nspace and tab: \t\nno trailing space\n \ntab:\t\ntab and space:\t ';
const sMsg = await openpgp.readArmoredMessage(msg_armor);
const pubKey = await openpgp.readArmoredKey(pub_key_arm2);
const sMsg = await openpgp.readMessage({ armoredMessage: msg_armor });
const pubKey = await openpgp.readKey({ armoredKey: pub_key_arm2 });
const keyids = sMsg.getSigningKeyIds();
@ -1312,14 +1316,16 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
-----END PGP MESSAGE-----`.split('');
const plaintext = 'space: \nspace and tab: \t\nno trailing space\n \ntab:\t\ntab and space:\t ';
const sMsg = await openpgp.readArmoredMessage(new openpgp.stream.ReadableStream({
async pull(controller) {
await new Promise(setTimeout);
controller.enqueue(msg_armor.shift());
if (!msg_armor.length) controller.close();
}
}));
const pubKey = await openpgp.readArmoredKey(pub_key_arm2);
const sMsg = await openpgp.readMessage({
armoredMessage: new openpgp.stream.ReadableStream({
async pull(controller) {
await new Promise(setTimeout);
controller.enqueue(msg_armor.shift());
if (!msg_armor.length) controller.close();
}
})
});
const pubKey = await openpgp.readKey({ armoredKey: pub_key_arm2 });
const keyids = sMsg.getSigningKeyIds();
@ -1351,13 +1357,13 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
it('Sign text with openpgp.sign and verify with openpgp.verify leads to same string cleartext and valid signatures', async function() {
const plaintext = 'short message\nnext line \n한국어/조선말';
const pubKey = await openpgp.readArmoredKey(pub_key_arm2);
const privKey = await openpgp.readArmoredKey(priv_key_arm2);
const pubKey = await openpgp.readKey({ armoredKey: pub_key_arm2 });
const privKey = await openpgp.readKey({ armoredKey: priv_key_arm2 });
await privKey.decrypt('hello world');
return openpgp.sign({ privateKeys:[privKey], message: openpgp.CleartextMessage.fromText(plaintext) }).then(async function(signed) {
const csMsg = await openpgp.readArmoredCleartextMessage(signed);
const csMsg = await openpgp.readCleartextMessage({ cleartextMessage: signed });
return openpgp.verify({ publicKeys:[pubKey], message:csMsg });
}).then(function(cleartextSig) {
@ -1371,13 +1377,13 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
it('Sign text with openpgp.sign and verify with openpgp.verify leads to same string cleartext and valid signatures -- escape armored message', async function() {
const plaintext = pub_key_arm2;
const pubKey = await openpgp.readArmoredKey(pub_key_arm2);
const privKey = await openpgp.readArmoredKey(priv_key_arm2);
const pubKey = await openpgp.readKey({ armoredKey: pub_key_arm2 });
const privKey = await openpgp.readKey({ armoredKey: priv_key_arm2 });
await privKey.decrypt('hello world');
return openpgp.sign({ privateKeys:[privKey], message: openpgp.CleartextMessage.fromText(plaintext) }).then(async function(signed) {
const csMsg = await openpgp.readArmoredCleartextMessage(signed);
const csMsg = await openpgp.readCleartextMessage({ cleartextMessage: signed });
return openpgp.verify({ publicKeys:[pubKey], message:csMsg });
}).then(function(cleartextSig) {
@ -1391,13 +1397,13 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
it('Sign text with openpgp.sign and verify with openpgp.verify leads to same string cleartext and valid signatures -- trailing spaces', async function() {
const plaintext = 'space: \nspace and tab: \t\nno trailing space\n \ntab:\t\ntab and space:\t ';
const pubKey = await openpgp.readArmoredKey(pub_key_arm2);
const privKey = await openpgp.readArmoredKey(priv_key_arm2);
const pubKey = await openpgp.readKey({ armoredKey: pub_key_arm2 });
const privKey = await openpgp.readKey({ armoredKey: priv_key_arm2 });
await privKey.decrypt('hello world');
return openpgp.sign({ privateKeys:[privKey], message: openpgp.CleartextMessage.fromText(plaintext) }).then(async function(signed) {
const csMsg = await openpgp.readArmoredCleartextMessage(signed);
const csMsg = await openpgp.readCleartextMessage({ cleartextMessage: signed });
return openpgp.verify({ publicKeys:[pubKey], message:csMsg });
}).then(function(cleartextSig) {
@ -1411,13 +1417,13 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
it('Sign text with openpgp.sign and verify with openpgp.verify leads to same bytes cleartext and valid signatures - armored', async function() {
const plaintext = util.strToUint8Array('short message\nnext line \n한국어/조선말');
const pubKey = await openpgp.readArmoredKey(pub_key_arm2);
const privKey = await openpgp.readArmoredKey(priv_key_arm2);
const pubKey = await openpgp.readKey({ armoredKey: pub_key_arm2 });
const privKey = await openpgp.readKey({ armoredKey: priv_key_arm2 });
await privKey.decrypt('hello world');
return openpgp.sign({ privateKeys:[privKey], message: openpgp.Message.fromBinary(plaintext) }).then(async function(signed) {
const csMsg = await openpgp.readArmoredMessage(signed);
const csMsg = await openpgp.readMessage({ armoredMessage: signed });
return openpgp.verify({ publicKeys:[pubKey], message:csMsg, format: 'binary' });
}).then(async function(cleartextSig) {
@ -1431,13 +1437,13 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
it('Sign text with openpgp.sign and verify with openpgp.verify leads to same bytes cleartext and valid signatures - not armored', async function() {
const plaintext = util.strToUint8Array('short message\nnext line \n한국어/조선말');
const pubKey = await openpgp.readArmoredKey(pub_key_arm2);
const privKey = await openpgp.readArmoredKey(priv_key_arm2);
const pubKey = await openpgp.readKey({ armoredKey: pub_key_arm2 });
const privKey = await openpgp.readKey({ armoredKey: priv_key_arm2 });
await privKey.decrypt('hello world');
return openpgp.sign({ privateKeys:[privKey], message: openpgp.Message.fromBinary(plaintext), armor:false }).then(async function(signed) {
const csMsg = await openpgp.readMessage(signed);
const csMsg = await openpgp.readMessage({ binaryMessage: signed });
return openpgp.verify({ publicKeys:[pubKey], message:csMsg, format: 'binary' });
}).then(function(cleartextSig) {
@ -1451,11 +1457,11 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
it('Should verify cleartext message correctly when using a detached cleartext signature and binary literal data', async function () {
const plaintext = 'short message\nnext line \n한국어/조선말';
const pubKey = await openpgp.readArmoredKey(pub_key_arm2);
const privKey = await openpgp.readArmoredKey(priv_key_arm2);
const pubKey = await openpgp.readKey({ armoredKey: pub_key_arm2 });
const privKey = await openpgp.readKey({ armoredKey: priv_key_arm2 });
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.readArmoredSignature(signed);
return openpgp.sign({ privateKeys:[privKey], message: openpgp.Message.fromText(plaintext), detached: true }).then(async function(armoredSignature) {
const signature = await openpgp.readSignature({ armoredSignature });
return openpgp.verify({ publicKeys:[pubKey], message: openpgp.Message.fromBinary(util.encodeUtf8(plaintext)), signature: signature });
}).then(function(cleartextSig) {
expect(cleartextSig).to.exist;
@ -1468,11 +1474,11 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
it('Should verify cleartext message correctly when using a detached binary signature and text literal data', async function () {
const plaintext = 'short message\nnext line \n한국어/조선말';
const plaintextArray = util.encodeUtf8(plaintext);
const pubKey = await openpgp.readArmoredKey(pub_key_arm2);
const privKey = await openpgp.readArmoredKey(priv_key_arm2);
const pubKey = await openpgp.readKey({ armoredKey: pub_key_arm2 });
const privKey = await openpgp.readKey({ armoredKey: priv_key_arm2 });
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.readArmoredSignature(signed);
return openpgp.sign({ privateKeys:[privKey], message:openpgp.Message.fromBinary(plaintextArray), detached: true }).then(async function(armoredSignature) {
const signature = await openpgp.readSignature({ armoredSignature });
return openpgp.verify({ publicKeys:[pubKey], message: openpgp.Message.fromText(plaintext), signature: signature });
}).then(function(cleartextSig) {
expect(cleartextSig).to.exist;
@ -1484,14 +1490,14 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
it('Should verify encrypted cleartext message correctly when encrypting binary literal data with a canonical text signature', async function () {
const plaintext = 'short message\nnext line \n한국어/조선말';
const pubKey = await openpgp.readArmoredKey(pub_key_arm2);
const privKey = await openpgp.readArmoredKey(priv_key_arm2);
const pubKey = await openpgp.readKey({ armoredKey: pub_key_arm2 });
const privKey = await openpgp.readKey({ armoredKey: priv_key_arm2 });
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.readArmoredSignature(signed);
return openpgp.sign({ privateKeys:[privKey], message: openpgp.Message.fromText(plaintext), detached: true }).then(async function(armoredSignature) {
const signature = await openpgp.readSignature({ armoredSignature });
return openpgp.encrypt({ message: openpgp.Message.fromBinary(util.encodeUtf8(plaintext)), publicKeys: [pubKey], signature });
}).then(async data => {
const csMsg = await openpgp.readArmoredMessage(data);
}).then(async armoredMessage => {
const csMsg = await openpgp.readMessage({ armoredMessage });
return openpgp.decrypt({ message: csMsg, privateKeys: [privKey], publicKeys: [pubKey] });
}).then(function(cleartextSig) {
expect(cleartextSig).to.exist;
@ -1502,8 +1508,8 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
});
it('Verify test with expired verification public key', async function() {
const pubKey = await openpgp.readArmoredKey(pub_expired);
const message = await openpgp.readArmoredMessage(msg_sig_expired);
const pubKey = await openpgp.readKey({ armoredKey: pub_expired });
const message = await openpgp.readMessage({ armoredMessage: msg_sig_expired });
return openpgp.verify({ publicKeys:[pubKey], message:message }).then(function(verified) {
expect(verified).to.exist;
expect(verified.signatures).to.have.length(1);
@ -1513,8 +1519,8 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
});
it('Verify test with expired verification public key and disable expiration checks using null date', async function() {
const pubKey = await openpgp.readArmoredKey(pub_expired);
const message = await openpgp.readArmoredMessage(msg_sig_expired);
const pubKey = await openpgp.readKey({ armoredKey: pub_expired });
const message = await openpgp.readMessage({ armoredMessage: msg_sig_expired });
return openpgp.verify({ publicKeys:[pubKey], message:message, date: null }).then(function(verified) {
expect(verified).to.exist;
expect(verified.signatures).to.have.length(1);
@ -1525,7 +1531,7 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
// TODO add test with multiple revocation signatures
it('Verify primary key revocation signatures', async function() {
const pubKey = await openpgp.readArmoredKey(pub_revoked);
const pubKey = await openpgp.readKey({ armoredKey: pub_revoked });
const revSig = pubKey.revocationSignatures[0];
revSig.verified = null;
await pubKey.revocationSignatures[0].verify(
@ -1535,7 +1541,7 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
// TODO add test with multiple revocation signatures
it('Verify subkey revocation signatures', async function() {
const pubKey = await openpgp.readArmoredKey(pub_revoked);
const pubKey = await openpgp.readKey({ armoredKey: pub_revoked });
const revSig = pubKey.subKeys[0].revocationSignatures[0];
revSig.verified = null;
await revSig.verify(
@ -1544,7 +1550,7 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
});
it('Verify key expiration date', async function() {
const pubKey = await openpgp.readArmoredKey(pub_revoked);
const pubKey = await openpgp.readKey({ armoredKey: pub_revoked });
expect(pubKey).to.exist;
expect(pubKey.users[0].selfCertifications[0].keyNeverExpires).to.be.false;
@ -1552,15 +1558,15 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
});
it('Write unhashed subpackets', async function() {
let pubKey = await openpgp.readArmoredKey(pub_key_arm2);
let pubKey = await openpgp.readKey({ armoredKey: pub_key_arm2 });
expect(pubKey.users[0].selfCertifications).to.exist;
pubKey = await openpgp.readArmoredKey(pubKey.armor());
pubKey = await openpgp.readKey({ armoredKey: pubKey.armor() });
expect(pubKey.users[0].selfCertifications).to.exist;
});
it('Write V4 signatures', async function() {
const pubKey = await openpgp.readArmoredKey(pub_key_arm2);
const pubKey2 = await openpgp.readArmoredKey(pubKey.armor());
const pubKey = await openpgp.readKey({ armoredKey: pub_key_arm2 });
const pubKey2 = await openpgp.readKey({ armoredKey: pubKey.armor() });
expect(pubKey2).to.exist;
expect(pubKey.users[0].selfCertifications).to.eql(pubKey2.users[0].selfCertifications);
});
@ -1602,7 +1608,7 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
''].join('\r\n');
const publicKeyArmored = '-----BEGIN PGP PUBLIC KEY BLOCK-----\r\nVersion: OpenPGP.js v.1.20131116\r\nComment: Whiteout Mail - https://whiteout.io\r\n\r\nxsBNBFKODs4BB/9iOF4THsjQMY+WEpT7ShgKxj4bHzRRaQkqczS4nZvP0U3g\r\nqeqCnbpagyeKXA+bhWFQW4GmXtgAoeD5PXs6AZYrw3tWNxLKu2Oe6Tp9K/XI\r\nxTMQ2wl4qZKDXHvuPsJ7cmgaWqpPyXtxA4zHHS3WrkI/6VzHAcI/y6x4szSB\r\nKgSuhI3hjh3s7TybUC1U6AfoQGx/S7e3WwlCOrK8GTClirN/2mCPRC5wuIft\r\nnkoMfA6jK8d2OPrJ63shy5cgwHOjQg/xuk46dNS7tkvGmbaa+X0PgqSKB+Hf\r\nYPPNS/ylg911DH9qa8BqYU2QpNh9jUKXSF+HbaOM+plWkCSAL7czV+R3ABEB\r\nAAHNLVdoaXRlb3V0IFVzZXIgPHNhZmV3aXRobWUudGVzdHVzZXJAZ21haWwu\r\nY29tPsLAXAQQAQgAEAUCUo4O2gkQ1/uT/N+/wjwAAN2cB/9gFRmAfvEQ2qz+\r\nWubmT2EsSSnjPMxzG4uyykFoa+TaZCWo2Xa2tQghmU103kEkQb1OEjRjpgwJ\r\nYX9Kghnl8DByM686L5AXnRyHP78qRJCLXSXl0AGicboUDp5sovaa4rswQceH\r\nvcdWgZ/mgHTRoiQeJddy9k+H6MPFiyFaVcFwegVsmpc+dCcC8yT+qh8ZIbyG\r\nRJU60PmKKN7LUusP+8DbSv39zCGJCBlVVKyA4MzdF5uM+sqTdXbKzOrT5DGd\r\nCZaox4s+w16Sq1rHzZKFWfQPfKLDB9pyA0ufCVRA3AF6BUi7G3ZqhZiHNhMP\r\nNvE45V/hS1PbZcfPVoUjE2qc1Ix1\r\n=7Wpe\r\n-----END PGP PUBLIC KEY BLOCK-----';
const publicKey = await openpgp.readArmoredKey(publicKeyArmored);
const publicKey = await openpgp.readKey({ armoredKey: publicKeyArmored });
// Text
const msg = openpgp.Message.fromText(content);
@ -1615,8 +1621,8 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
it('Detached signature signing and verification', async function() {
const msg = openpgp.Message.fromText('hello');
const pubKey2 = await openpgp.readArmoredKey(pub_key_arm2);
const privKey2 = await openpgp.readArmoredKey(priv_key_arm2);
const pubKey2 = await openpgp.readKey({ armoredKey: pub_key_arm2 });
const privKey2 = await openpgp.readKey({ armoredKey: priv_key_arm2 });
await privKey2.decrypt('hello world');
const opt = { rsaBits: 512, userIds: { name:'test', email:'a@b.com' }, passphrase: null };
@ -1666,8 +1672,8 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
'-----END PGP PUBLIC KEY BLOCK-----'
].join('\n');
const signedKey = await openpgp.readArmoredKey(signedArmor);
const signerKey = await openpgp.readArmoredKey(priv_key_arm1);
const signedKey = await openpgp.readKey({ armoredKey: signedArmor });
const signerKey = await openpgp.readKey({ armoredKey: priv_key_arm1 });
return signedKey.verifyPrimaryUser([signerKey]).then(signatures => {
expect(signatures[0].valid).to.be.null;
expect(signatures[0].keyid.toHex()).to.equal(signedKey.getKeyId().toHex());
@ -1701,7 +1707,7 @@ iTuGu4fEU1UligAXSrZmCdE=
=VK6I
-----END PGP PUBLIC KEY BLOCK-----`;
const key = await openpgp.readArmoredKey(armoredKeyWithPhoto);
const key = await openpgp.readKey({ armoredKey: armoredKeyWithPhoto });
await Promise.all(key.users.map(async user => {
await user.verify(key.primaryKey);
}));
@ -1765,9 +1771,9 @@ CftAJDBez44ZofZ8ahPfkAhJe6opxaqgS47s4FIQVOEJcF9RgwLTU6uooSzA
oaBUyhCKt8tz6Q==
=52k1
-----END PGP PRIVATE KEY BLOCK-----`;
const key = await openpgp.readArmoredKey(armoredKey);
const key = await openpgp.readKey({ armoredKey: armoredKey });
const decrypted = await openpgp.decrypt({
message: await openpgp.readArmoredMessage(encrypted),
message: await openpgp.readMessage({ armoredMessage: encrypted }),
publicKeys: key,
privateKeys: key
});
@ -1775,7 +1781,8 @@ oaBUyhCKt8tz6Q==
});
it('should verify a shorter EdDSA signature', async function() {
const key = await openpgp.readArmoredKey(`-----BEGIN PGP PRIVATE KEY BLOCK-----
const key = await openpgp.readKey({
armoredKey: `-----BEGIN PGP PRIVATE KEY BLOCK-----
xVgEX8+jfBYJKwYBBAHaRw8BAQdA9GbdDjprR0sWf0R5a5IpulUauc0FsmzJ
mOYCfoowt8EAAP9UwaqC0LWWQ5RlX7mps3728vFa/If1KBVwAjk7Uqhi2BKL
@ -1789,7 +1796,8 @@ DAAhCRBuOuGldqHe+xYhBCHIOONTLSp8iZzw0W464aV2od773XcA/jlmX8/c
1/zIotEkyMZB4mI+GAg3FQ6bIACFBH1sz0MzAP9Snri0P4FRZ8D5THRCJoUm
GBgpBmrf6IVv484jBswGDA==
=8rBO
-----END PGP PRIVATE KEY BLOCK-----`);
-----END PGP PRIVATE KEY BLOCK-----`
});
const encrypted = `-----BEGIN PGP MESSAGE-----
wV4DWlRRjuYiLSsSAQdAWwDKQLN4ZUS5fqiwFtAMrRfZZe9J4SgClhG6avEe
@ -1801,12 +1809,13 @@ j+GItrR+QbbN13ODlcR3hf66cwjLLsJCx5VcBaRspKF05O3ix/u9KVjJqtbi
Ie6jnY0zP2ldtS4JmhKBa43qmOHCxHc=
=7B58
-----END PGP MESSAGE-----`;
const decrypted = await openpgp.decrypt({ message: await openpgp.readArmoredMessage(encrypted), privateKeys: key, publicKeys: key.toPublic() });
const decrypted = await openpgp.decrypt({ message: await openpgp.readMessage({ armoredMessage: encrypted }), privateKeys: key, publicKeys: key.toPublic() });
expect(decrypted.signatures[0].valid).to.be.true;
});
it('should verify a shorter ECDSA signature', async function() {
const key = await openpgp.readArmoredKey(`-----BEGIN PGP PRIVATE KEY BLOCK-----
const key = await openpgp.readKey({
armoredKey: `-----BEGIN PGP PRIVATE KEY BLOCK-----
xYAFX9JrLRMAAABMCCqGSM49AwEHAgMErtQdX4vh7ng/ut+k1mooYNh3Ywqt
wr0tSS8hxZMvQRIFQ53Weq0e97ioZKXGimprEL571yvAN7I19wtQtqi61AAA
@ -1822,7 +1831,8 @@ EYaN9YdDOU2jF+HOaSNaJAsPF8J6BRgTCAAJBQJf0mstAhsMACMiIQUee6Tb
AcvDfr9a0Cp4WAVzKDKLUzrRMgEAozi0VyjiBo1U2LcwTPJkA4PEQqQRVW1D
KZTMSAH7JEo=
=tqWy
-----END PGP PRIVATE KEY BLOCK-----`);
-----END PGP PRIVATE KEY BLOCK-----`
});
const signed = `-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA256
@ -1834,7 +1844,7 @@ A3X6psihFkcA+Nuog2qpAq20Zc2lzVjDZzQosb8MLvKMg3UFCX12Oc0BAJwd
JImeZLY02MctIpGZULbqgcUGK0P/yqrPL8Pe4lQM
=Pacb
-----END PGP SIGNATURE-----`;
const message = await openpgp.readArmoredCleartextMessage(signed);
const message = await openpgp.readCleartextMessage({ cleartextMessage: signed });
const verified = await openpgp.verify({ publicKeys: key, message });
expect(verified.signatures[0].valid).to.be.true;
});

122
test/general/streaming.js
View File

@ -194,7 +194,7 @@ function tests() {
passwords: ['test']
});
const msgAsciiArmored = await openpgp.stream.readToEnd(encrypted);
const message = await openpgp.readArmoredMessage(msgAsciiArmored);
const message = await openpgp.readMessage({ armoredMessage: msgAsciiArmored });
const decrypted = await openpgp.decrypt({
passwords: ['test'],
message
@ -212,7 +212,7 @@ function tests() {
dataArrived();
reader.releaseLock();
const msgAsciiArmored = await openpgp.stream.readToEnd(encrypted);
const message = await openpgp.readArmoredMessage(msgAsciiArmored);
const message = await openpgp.readMessage({ armoredMessage: msgAsciiArmored });
const decrypted = await openpgp.decrypt({
passwords: ['test'],
message,
@ -257,7 +257,7 @@ function tests() {
});
expect(openpgp.stream.isStream(encrypted)).to.equal(expectedType);
const message = await openpgp.readMessage(encrypted);
const message = await openpgp.readMessage({ binaryMessage: 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'],
@ -285,7 +285,7 @@ function tests() {
});
expect(openpgp.stream.isStream(encrypted)).to.equal(expectedType);
const message = await openpgp.readMessage(encrypted);
const message = await openpgp.readMessage({ binaryMessage: encrypted });
const decrypted = await openpgp.decrypt({
passwords: ['test'],
message,
@ -316,7 +316,7 @@ function tests() {
});
expect(openpgp.stream.isStream(encrypted)).to.equal(expectedType);
const message = await openpgp.readMessage(encrypted);
const message = await openpgp.readMessage({ binaryMessage: encrypted });
const decrypted = await openpgp.decrypt({
publicKeys: pubKey,
privateKeys: privKey,
@ -336,8 +336,8 @@ function tests() {
it('Encrypt and decrypt larger message roundtrip using curve x25519 (allowUnauthenticatedStream=true)', async function() {
const allowUnauthenticatedStreamValue = openpgp.config.allowUnauthenticatedStream;
openpgp.config.allowUnauthenticatedStream = true;
const priv = await openpgp.readArmoredKey(xPriv);
const pub = await openpgp.readArmoredKey(xPub);
const priv = await openpgp.readKey({ armoredKey: xPriv });
const pub = await openpgp.readKey({ armoredKey: xPub });
await priv.decrypt(xPass);
try {
const encrypted = await openpgp.encrypt({
@ -348,7 +348,7 @@ function tests() {
});
expect(openpgp.stream.isStream(encrypted)).to.equal(expectedType);
const message = await openpgp.readMessage(encrypted);
const message = await openpgp.readMessage({ binaryMessage: encrypted });
const decrypted = await openpgp.decrypt({
publicKeys: pub,
privateKeys: priv,
@ -368,8 +368,8 @@ function tests() {
it('Encrypt and decrypt larger message roundtrip using curve brainpool (allowUnauthenticatedStream=true)', async function() {
const allowUnauthenticatedStreamValue = openpgp.config.allowUnauthenticatedStream;
openpgp.config.allowUnauthenticatedStream = true;
const priv = await openpgp.readArmoredKey(brainpoolPriv);
const pub = await openpgp.readArmoredKey(brainpoolPub);
const priv = await openpgp.readKey({ armoredKey: brainpoolPriv });
const pub = await openpgp.readKey({ armoredKey: brainpoolPub });
await priv.decrypt(brainpoolPass);
try {
const encrypted = await openpgp.encrypt({
@ -380,7 +380,7 @@ function tests() {
});
expect(openpgp.stream.isStream(encrypted)).to.equal(expectedType);
const message = await openpgp.readMessage(encrypted);
const message = await openpgp.readMessage({ binaryMessage: encrypted });
const decrypted = await openpgp.decrypt({
publicKeys: pub,
privateKeys: priv,
@ -409,13 +409,15 @@ function tests() {
});
expect(openpgp.stream.isStream(encrypted)).to.equal(expectedType);
const message = await openpgp.readArmoredMessage(openpgp.stream.transform(encrypted, value => {
value += '';
if (value === '=' || value.length === 6) return; // Remove checksum
const newlineIndex = value.indexOf('\n', 500);
if (value.length > 1000) return value.slice(0, newlineIndex - 1) + (value[newlineIndex - 1] === 'a' ? 'b' : 'a') + value.slice(newlineIndex);
return value;
}));
const message = await openpgp.readMessage({
armoredMessage: openpgp.stream.transform(encrypted, value => {
value += '';
if (value === '=' || value.length === 6) return; // Remove checksum
const newlineIndex = value.indexOf('\n', 500);
if (value.length > 1000) return value.slice(0, newlineIndex - 1) + (value[newlineIndex - 1] === 'a' ? 'b' : 'a') + value.slice(newlineIndex);
return value;
})
});
const decrypted = await openpgp.decrypt({
passwords: ['test'],
message,
@ -445,12 +447,14 @@ function tests() {
});
expect(openpgp.stream.isStream(encrypted)).to.equal(expectedType);
const message = await openpgp.readArmoredMessage(openpgp.stream.transform(encrypted, value => {
value += '';
const newlineIndex = value.indexOf('\n', 500);
if (value.length > 1000) return value.slice(0, newlineIndex - 1) + (value[newlineIndex - 1] === 'a' ? 'b' : 'a') + value.slice(newlineIndex);
return value;
}));
const message = await openpgp.readMessage({
armoredMessage: openpgp.stream.transform(encrypted, value => {
value += '';
const newlineIndex = value.indexOf('\n', 500);
if (value.length > 1000) return value.slice(0, newlineIndex - 1) + (value[newlineIndex - 1] === 'a' ? 'b' : 'a') + value.slice(newlineIndex);
return value;
})
});
const decrypted = await openpgp.decrypt({
publicKeys: pubKey,
privateKeys: privKey,
@ -480,12 +484,14 @@ function tests() {
});
expect(openpgp.stream.isStream(encrypted)).to.equal(expectedType);
const message = await openpgp.readArmoredMessage(openpgp.stream.transform(encrypted, value => {
value += '';
const newlineIndex = value.indexOf('\n', 500);
if (value.length > 1000) return value.slice(0, newlineIndex - 1) + (value[newlineIndex - 1] === 'a' ? 'b' : 'a') + value.slice(newlineIndex);
return value;
}));
const message = await openpgp.readMessage({
armoredMessage: openpgp.stream.transform(encrypted, value => {
value += '';
const newlineIndex = value.indexOf('\n', 500);
if (value.length > 1000) return value.slice(0, newlineIndex - 1) + (value[newlineIndex - 1] === 'a' ? 'b' : 'a') + value.slice(newlineIndex);
return value;
})
});
const decrypted = await openpgp.decrypt({
privateKeys: privKey,
message,
@ -511,12 +517,14 @@ function tests() {
});
expect(openpgp.stream.isStream(signed)).to.equal(expectedType);
const message = await openpgp.readArmoredMessage(openpgp.stream.transform(signed, value => {
value += '';
const newlineIndex = value.indexOf('\n', 500);
if (value.length > 1000) return value.slice(0, newlineIndex - 1) + (value[newlineIndex - 1] === 'a' ? 'b' : 'a') + value.slice(newlineIndex);
return value;
}));
const message = await openpgp.readMessage({
armoredMessage: openpgp.stream.transform(signed, value => {
value += '';
const newlineIndex = value.indexOf('\n', 500);
if (value.length > 1000) return value.slice(0, newlineIndex - 1) + (value[newlineIndex - 1] === 'a' ? 'b' : 'a') + value.slice(newlineIndex);
return value;
})
});
const verified = await openpgp.verify({
publicKeys: pubKey,
message,
@ -563,7 +571,7 @@ function tests() {
});
expect(openpgp.stream.isStream(signed)).to.equal(expectedType);
const message = await openpgp.readArmoredMessage(signed);
const message = await openpgp.readMessage({ armoredMessage: signed });
const verified = await openpgp.verify({
publicKeys: pubKey,
message,
@ -614,7 +622,7 @@ function tests() {
privateKeys: privKey
});
expect(openpgp.stream.isStream(signed)).to.equal(expectedType);
const message = await openpgp.readArmoredMessage(signed);
const message = await openpgp.readMessage({ armoredMessage: signed });
const verified = await openpgp.verify({
publicKeys: pubKey,
message,
@ -644,8 +652,8 @@ function tests() {
streaming: expectedType
});
expect(openpgp.stream.isStream(signed)).to.equal(expectedType);
const sigArmored = await openpgp.stream.readToEnd(signed);
const signature = await openpgp.readArmoredMessage(sigArmored);
const armoredSignature = await openpgp.stream.readToEnd(signed);
const signature = await openpgp.readSignature({ armoredSignature });
const verified = await openpgp.verify({
signature,
publicKeys: pubKey,
@ -673,7 +681,7 @@ function tests() {
armor: false
});
expect(openpgp.stream.isStream(signed)).to.be.false;
const signature = await openpgp.readMessage(signed);
const signature = await openpgp.readMessage({ binaryMessage: signed });
const verified = await openpgp.verify({
signature,
publicKeys: pubKey,
@ -693,8 +701,8 @@ function tests() {
controller.close();
}
});
const priv = await openpgp.readArmoredKey(brainpoolPriv);
const pub = await openpgp.readArmoredKey(brainpoolPub);
const priv = await openpgp.readKey({ armoredKey: brainpoolPriv });
const pub = await openpgp.readKey({ armoredKey: brainpoolPub });
await priv.decrypt(brainpoolPass);
const signed = await openpgp.sign({
message: openpgp.Message.fromBinary(data),
@ -703,8 +711,8 @@ function tests() {
streaming: expectedType
});
expect(openpgp.stream.isStream(signed)).to.equal(expectedType);
const sigArmored = await openpgp.stream.readToEnd(signed);
const signature = await openpgp.readArmoredMessage(sigArmored);
const armoredSignature = await openpgp.stream.readToEnd(signed);
const signature = await openpgp.readSignature({ armoredSignature });
const verified = await openpgp.verify({
signature,
publicKeys: pub,
@ -724,8 +732,8 @@ function tests() {
controller.close();
}
});
const priv = await openpgp.readArmoredKey(xPriv);
const pub = await openpgp.readArmoredKey(xPub);
const priv = await openpgp.readKey({ armoredKey: xPriv });
const pub = await openpgp.readKey({ armoredKey: xPub });
await priv.decrypt(xPass);
const signed = await openpgp.sign({
message: openpgp.Message.fromBinary(data),
@ -734,8 +742,8 @@ function tests() {
streaming: expectedType
});
expect(openpgp.stream.isStream(signed)).to.equal(expectedType);
const sigArmored = await openpgp.stream.readToEnd(signed);
const signature = await openpgp.readArmoredMessage(sigArmored);
const armoredSignature = await openpgp.stream.readToEnd(signed);
const signature = await openpgp.readSignature({ armoredSignature });
const verified = await openpgp.verify({
signature,
publicKeys: pub,
@ -798,7 +806,7 @@ function tests() {
});
expect(openpgp.stream.isStream(encrypted)).to.equal(expectedType);
const message = await openpgp.readMessage(encrypted);
const message = await openpgp.readMessage({ binaryMessage: encrypted });
const decrypted = await openpgp.decrypt({
passwords: ['test'],
message,
@ -835,7 +843,7 @@ function tests() {
});
expect(openpgp.stream.isStream(encrypted)).to.equal(expectedType);
const message = await openpgp.readArmoredMessage(encrypted);
const message = await openpgp.readMessage({ armoredMessage: encrypted });
const decrypted = await openpgp.decrypt({
passwords: ['test'],
message
@ -863,7 +871,7 @@ function tests() {
passwords: ['test']
});
expect(openpgp.stream.isStream(encrypted)).to.equal(expectedType);
const message = await openpgp.readArmoredMessage(encrypted);
const message = await openpgp.readMessage({ armoredMessage: encrypted });
const decrypted = await openpgp.decrypt({
passwords: ['test'],
message,
@ -890,7 +898,7 @@ function tests() {
passwords: ['test']
});
const message = await openpgp.readArmoredMessage(encrypted);
const message = await openpgp.readMessage({ armoredMessage: encrypted });
const decrypted = await openpgp.decrypt({
passwords: ['test'],
message,
@ -911,8 +919,8 @@ module.exports = () => describe('Streaming', function() {
let currentTest = 0;
before(async function() {
pubKey = await openpgp.readArmoredKey(pub_key);
privKey = await openpgp.readArmoredKey(priv_key);
pubKey = await openpgp.readKey({ armoredKey: pub_key });
privKey = await openpgp.readKey({ armoredKey: priv_key });
await privKey.decrypt(passphrase);
});
@ -971,7 +979,7 @@ module.exports = () => describe('Streaming', function() {
});
expect(openpgp.stream.isStream(encrypted)).to.equal('node');
const message = await openpgp.readArmoredMessage(encrypted);
const message = await openpgp.readMessage({ armoredMessage: encrypted });
const decrypted = await openpgp.decrypt({
passwords: ['test'],
message
@ -991,7 +999,7 @@ module.exports = () => describe('Streaming', function() {
});
expect(openpgp.stream.isStream(encrypted)).to.equal('node');
const message = await openpgp.readMessage(encrypted);
const message = await openpgp.readMessage({ binaryMessage: encrypted });
const decrypted = await openpgp.decrypt({
passwords: ['test'],
message,

28
test/general/x25519.js
View File

@ -126,7 +126,7 @@ module.exports = () => (openpgp.config.ci ? describe.skip : describe)('X25519 Cr
if (data[name].pub_key) {
return data[name].pub_key;
}
const pub = await openpgp.readArmoredKey(data[name].pub);
const pub = await openpgp.readKey({ armoredKey: data[name].pub });
expect(pub).to.exist;
expect(pub.getKeyId().toHex()).to.equal(data[name].id);
data[name].pub_key = pub;
@ -137,7 +137,7 @@ module.exports = () => (openpgp.config.ci ? describe.skip : describe)('X25519 Cr
if (data[name].priv_key) {
return data[name].priv_key;
}
const pk = await openpgp.readArmoredKey(data[name].priv);
const pk = await openpgp.readKey({ armoredKey: data[name].priv });
expect(pk).to.exist;
expect(pk.getKeyId().toHex()).to.equal(data[name].id);
await pk.decrypt(data[name].pass);
@ -161,7 +161,7 @@ module.exports = () => (openpgp.config.ci ? describe.skip : describe)('X25519 Cr
it('Verify clear signed message', async function () {
const name = 'light';
const pub = await load_pub_key(name);
const msg = await openpgp.readArmoredCleartextMessage(data[name].message_signed);
const msg = await openpgp.readCleartextMessage({ cleartextMessage: data[name].message_signed });
return openpgp.verify({ publicKeys: [pub], message: msg }).then(function(result) {
expect(result).to.exist;
expect(result.data).to.equal(data[name].message);
@ -176,7 +176,7 @@ module.exports = () => (openpgp.config.ci ? describe.skip : describe)('X25519 Cr
const priv = await load_priv_key(name);
const signed = await openpgp.sign({ privateKeys: [priv], message: openpgp.CleartextMessage.fromText(randomData) });
const pub = await load_pub_key(name);
const msg = await openpgp.readArmoredCleartextMessage(signed);
const msg = await openpgp.readCleartextMessage({ cleartextMessage: signed });
const result = await openpgp.verify({ publicKeys: [pub], message: msg });
expect(result).to.exist;
@ -188,7 +188,7 @@ module.exports = () => (openpgp.config.ci ? describe.skip : describe)('X25519 Cr
it('Decrypt and verify message', async function () {
const light = await load_pub_key('light');
const night = await load_priv_key('night');
const msg = await openpgp.readArmoredMessage(data.night.message_encrypted);
const msg = await openpgp.readMessage({ armoredMessage: data.night.message_encrypted });
const result = await openpgp.decrypt({ privateKeys: night, publicKeys: [light], message: msg });
expect(result).to.exist;
@ -203,7 +203,7 @@ module.exports = () => (openpgp.config.ci ? describe.skip : describe)('X25519 Cr
const randomData = input.createSomeMessage();
const encrypted = await openpgp.encrypt({ publicKeys: [nightPublic], privateKeys: [lightPrivate], message: openpgp.Message.fromText(randomData) });
const message = await openpgp.readArmoredMessage(encrypted);
const message = await openpgp.readMessage({ armoredMessage: 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 });
@ -449,20 +449,18 @@ function omnibus() {
openpgp.sign(
{ message: openpgp.CleartextMessage.fromText('Hi, this is me, Hi!'), privateKeys: hi }
).then(async signed => {
const msg = await openpgp.readArmoredCleartextMessage(signed);
const msg = await openpgp.readCleartextMessage({ cleartextMessage: signed });
// Verifying signed message
return Promise.all([
openpgp.verify(
{ message: msg, publicKeys: hi.toPublic() }
).then(output => expect(output.signatures[0].valid).to.be.true),
// Verifying detached signature
openpgp.verify(
{
message: openpgp.Message.fromText('Hi, this is me, Hi!'),
publicKeys: hi.toPublic(),
signature: await openpgp.readArmoredSignature(signed)
}
).then(output => expect(output.signatures[0].valid).to.be.true)
openpgp.verify({
message: openpgp.Message.fromText('Hi, this is me, Hi!'),
publicKeys: hi.toPublic(),
signature: msg.signature
}).then(output => expect(output.signatures[0].valid).to.be.true)
]);
}),
// Encrypting and signing
@ -473,7 +471,7 @@ function omnibus() {
privateKeys: [hi]
}
).then(async encrypted => {
const msg = await openpgp.readArmoredMessage(encrypted);
const msg = await openpgp.readMessage({ armoredMessage: encrypted });
// Decrypting and verifying
return openpgp.decrypt(
{

13
test/security/message_signature_bypass.js
View File

@ -1,7 +1,7 @@
const openpgp = typeof window !== 'undefined' && window.openpgp ? window.openpgp : require('../..');
const util = require('../../src/util');
const { readArmoredKey, readArmoredCleartextMessage, SignaturePacket } = openpgp;
const { readKey, readCleartextMessage, SignaturePacket } = openpgp;
const chai = require('chai');
chai.use(require('chai-as-promised'));
@ -68,7 +68,7 @@ fhGyl7nA7UCwgsqf7ZPBhRg=
=nbjQ
-----END PGP SIGNATURE-----`;
async function getOtherPubKey() {
return readArmoredKey(OTHERPUBKEY);
return readKey({ armoredKey: OTHERPUBKEY });
}
/**
@ -78,10 +78,11 @@ const STANDALONE_PKT = util.hexToUint8Array(`04020108001005025bab730a091055208b2
async function fakeSignature() {
// read the template and modify the text to
// invalidate the signature.
let fake = await readArmoredCleartextMessage(
ORIGINAL.replace(
let fake = await readCleartextMessage({
cleartextMessage: ORIGINAL.replace(
'You owe me',
'I owe you'));
'I owe you')
});
// read the standalone signature packet
const tmp = new SignaturePacket();
await tmp.read(STANDALONE_PKT);
@ -92,7 +93,7 @@ async function fakeSignature() {
const faked_armored = await fake.armor();
// re-read the message to eliminate any
// behaviour due to cached values.
fake = await readArmoredCleartextMessage(faked_armored);
fake = await readCleartextMessage({ cleartextMessage: faked_armored });
// faked message now verifies correctly
const res = await openpgp.verify({
message: fake,

6
test/security/preferred_algo_mismatch.js
View File

@ -5,7 +5,7 @@ chai.use(require('chai-as-promised'));
const expect = chai.expect;
const messageArmor = `-----BEGIN PGP MESSAGE-----
const armoredMessage = `-----BEGIN PGP MESSAGE-----
Version: OpenPGP.js VERSION
Comment: https://openpgpjs.org
@ -41,7 +41,7 @@ EnxUPL95HuMKoVkf4w==
-----END PGP PRIVATE KEY BLOCK-----`;
module.exports = () => it('Does not accept message encrypted with algo not mentioned in preferred algorithms', async function() {
const message = await openpgp.readArmoredMessage(messageArmor);
const privKey = await openpgp.readArmoredKey(privateKeyArmor);
const message = await openpgp.readMessage({ armoredMessage });
const privKey = await openpgp.readKey({ armoredKey: privateKeyArmor });
await expect(openpgp.decrypt({ message, privateKeys: [privKey] })).to.be.rejectedWith('A non-preferred symmetric algorithm was used.');
});

6
test/security/subkey_trust.js
View File

@ -1,6 +1,6 @@
const openpgp = typeof window !== 'undefined' && window.openpgp ? window.openpgp : require('../..');
const { readArmoredKey, Key, readArmoredCleartextMessage, CleartextMessage, enums, PacketList, SignaturePacket } = openpgp;
const { readKey, Key, readCleartextMessage, CleartextMessage, enums, PacketList, SignaturePacket } = openpgp;
const key = require('../../src/key');
const chai = require('chai');
@ -66,9 +66,9 @@ async function testSubkeyTrust() {
fakeBindingSignature // faked key binding
]);
let fakeKey = new Key(newList);
fakeKey = await readArmoredKey(await fakeKey.toPublic().armor());
fakeKey = await readKey({ armoredKey: await fakeKey.toPublic().armor() });
const verifyAttackerIsBatman = await openpgp.verify({
message: (await readArmoredCleartextMessage(signed)),
message: await readCleartextMessage({ cleartextMessage: signed }),
publicKeys: fakeKey,
streaming: false
});

6
test/security/unsigned_subpackets.js
View File

@ -1,6 +1,6 @@
const openpgp = typeof window !== 'undefined' && window.openpgp ? window.openpgp : require('../..');
const { readArmoredKey, Key, message, enums, PacketList, SignaturePacket } = openpgp;
const { readKey, Key, message, enums, PacketList, SignaturePacket } = openpgp;
const chai = require('chai');
chai.use(require('chai-as-promised'));
@ -49,7 +49,7 @@ Dc2vwS83Aja9iWrIEg==
-----END PGP PRIVATE KEY BLOCK-----`;
async function getInvalidKey() {
return readArmoredKey(INVALID_KEY);
return readKey({ armoredKey: INVALID_KEY });
}
async function makeKeyValid() {
/**
@ -85,7 +85,7 @@ async function makeKeyValid() {
let modifiedkey = new Key(newlist);
// re-read the message to eliminate any
// behaviour due to cached values.
modifiedkey = await readArmoredKey(await modifiedkey.armor());
modifiedkey = await readKey({ armoredKey: await modifiedkey.armor() });
expect(await encryptFails(invalidkey)).to.be.true;
expect(await encryptFails(modifiedkey)).to.be.true;

16
test/typescript/definitions.ts
View File

@ -6,7 +6,7 @@
* - if it fails to run, edit this file to match the actual library API, then edit the definitions file (openpgp.d.ts) accordingly.
*/
import { generateKey, readArmoredKey, readArmoredKeys, Key, readMessage, readArmoredMessage, Message, CleartextMessage, encrypt, decrypt, sign, verify } from '../..';
import { generateKey, readKey, readKeys, Key, readMessage, Message, CleartextMessage, encrypt, decrypt, sign, verify } from '../..';
import { expect } from 'chai';
(async () => {
@ -18,8 +18,8 @@ import { expect } from 'chai';
const publicKeys = [key.toPublic()];
// Parse keys
expect(await readArmoredKey(publicKeyArmored)).to.be.instanceOf(Key);
expect(await readArmoredKeys(publicKeyArmored)).to.have.lengthOf(1);
expect(await readKey({ armoredKey: publicKeyArmored })).to.be.instanceOf(Key);
expect(await readKeys({ armoredKeys: publicKeyArmored })).to.have.lengthOf(1);
// Encrypt text message (armored)
const text = 'hello';
@ -36,19 +36,19 @@ import { expect } from 'chai';
expect(encryptedBinary).to.be.instanceOf(Uint8Array);
// Decrypt text message (armored)
const encryptedTextMessage = await readArmoredMessage(encryptedArmor);
const encryptedTextMessage = await readMessage({ armoredMessage: encryptedArmor });
const decryptedText = await decrypt({ privateKeys, message: encryptedTextMessage });
const decryptedTextData: string = decryptedText.data;
expect(decryptedTextData).to.equal(text);
// Decrypt binary message (unarmored)
const encryptedBinaryMessage = await readMessage(encryptedBinary);
const encryptedBinaryMessage = await readMessage({ binaryMessage: encryptedBinary });
const decryptedBinary = await decrypt({ privateKeys, message: encryptedBinaryMessage, format: 'binary' });
const decryptedBinaryData: Uint8Array = decryptedBinary.data;
expect(decryptedBinaryData).to.deep.equal(binary);
// Encrypt message (inspect packets)
const encryptedMessage = await readMessage(encryptedBinary);
const encryptedMessage = await readMessage({ binaryMessage: encryptedBinary });
expect(encryptedMessage).to.be.instanceOf(Message);
// Sign cleartext message (armored)
@ -65,13 +65,13 @@ import { expect } from 'chai';
expect(textSignedBinary).to.be.instanceOf(Uint8Array);
// Verify signed text message (armored)
const signedMessage = await readArmoredMessage(textSignedArmor);
const signedMessage = await readMessage({ armoredMessage: textSignedArmor });
const verifiedText = await verify({ publicKeys, message: signedMessage });
const verifiedTextData: string = verifiedText.data;
expect(verifiedTextData).to.equal(text);
// Verify signed binary message (unarmored)
const message = await readMessage(textSignedBinary);
const message = await readMessage({ binaryMessage: textSignedBinary });
const verifiedBinary = await verify({ publicKeys, message, format: 'binary' });
const verifiedBinaryData: Uint8Array = verifiedBinary.data;
expect(verifiedBinaryData).to.deep.equal(binary);

10
test/worker/worker_example.js
View File

@ -44,8 +44,8 @@ onmessage = async function({ data: { action, message }, ports: [port] }) {
let result;
switch (action) {
case 'encrypt': {
const publicKey = await openpgp.readArmoredKey(publicKeyArmored);
const privateKey = await openpgp.readArmoredKey(privateKeyArmored);
const publicKey = await openpgp.readKey({ armoredKey: publicKeyArmored });
const privateKey = await openpgp.readKey({ armoredKey: privateKeyArmored });
await privateKey.decrypt('test');
const data = await openpgp.encrypt({
message: openpgp.Message.fromText(message),
@ -56,11 +56,11 @@ onmessage = async function({ data: { action, message }, ports: [port] }) {
break;
}
case 'decrypt': {
const publicKey = await openpgp.readArmoredKey(publicKeyArmored);
const privateKey = await openpgp.readArmoredKey(privateKeyArmored);
const publicKey = await openpgp.readKey({ armoredKey: publicKeyArmored });
const privateKey = await openpgp.readKey({ armoredKey: privateKeyArmored });
await privateKey.decrypt('test');
const { data, signatures } = await openpgp.decrypt({
message: await openpgp.readArmoredMessage(message),
message: await openpgp.readMessage({ armoredMessage: message }),
publicKeys: publicKey,
privateKeys: privateKey
});