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

Replace Message.fromText and Message.fromBinary with createMessage

Browse Source 
Also, replace CleartextMessage.fromText with createCleartextMessage.
This commit is contained in:
Daniel Huigens 2021-03-25 21:01:49 +01:00
parent 18ec54bf4b
commit 91bd9e2c15
19 changed files with 245 additions and 267 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
README.md
View File

@ -173,7 +173,7 @@ Encryption will use the algorithm specified in config.preferredSymmetricAlgorith
```js ```js
(async () => { (async () => {
const message = await openpgp.Message.fromBinary(new Uint8Array([0x01, 0x01, 0x01])); const message = await openpgp.createMessage({ binary: new Uint8Array([0x01, 0x01, 0x01]) });
const encrypted = await openpgp.encrypt({ const encrypted = await openpgp.encrypt({
message, // input as Message object message, // input as Message object
passwords: ['secret stuff'], // multiple passwords possible passwords: ['secret stuff'], // multiple passwords possible
@ -216,7 +216,7 @@ const openpgp = require('openpgp'); // use as CommonJS, AMD, ES6 module or via w
await privateKey.decrypt(passphrase); await privateKey.decrypt(passphrase);
const encrypted = await openpgp.encrypt({ const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromText('Hello, World!'), // input as Message object message: await openpgp.createMessage({ text: 'Hello, World!' }), // input as Message object
publicKeys: publicKey, // for encryption publicKeys: publicKey, // for encryption
privateKeys: privateKey // for signing (optional) privateKeys: privateKey // for signing (optional)
}); });
@ -257,7 +257,7 @@ Encrypt with multiple public keys:
const privateKey = await openpgp.readKey({ armoredKey: privateKeyArmored }); const privateKey = await openpgp.readKey({ armoredKey: privateKeyArmored });
await privateKey.decrypt(passphrase) await privateKey.decrypt(passphrase)
const message = await openpgp.Message.fromText(message); const message = await openpgp.createMessage({ text: message });
const encrypted = await openpgp.encrypt({ const encrypted = await openpgp.encrypt({
message:, // input as Message object message:, // input as Message object
publicKeys, // for encryption publicKeys, // for encryption
@ -274,7 +274,7 @@ It's possible to change that behaviour by enabling compression through the confi
```js ```js
(async () => { (async () => {
const message = await openpgp.Message.fromBinary(new Uint8Array([0x01, 0x02, 0x03])); // or .fromText('string') const message = await openpgp.createMessage({ binary: new Uint8Array([0x01, 0x02, 0x03]) }); // or createMessage({ text: 'string' })
const encrypted = await openpgp.encrypt({ const encrypted = await openpgp.encrypt({
message, message,
passwords: ['secret stuff'], // multiple passwords possible passwords: ['secret stuff'], // multiple passwords possible
@ -306,7 +306,7 @@ Where the value can be any of:
} }
}); });
const message = await openpgp.Message.fromBinary(readableStream); const message = await openpgp.createMessage({ binary: readableStream });
const encrypted = await openpgp.encrypt({ const encrypted = await openpgp.encrypt({
message, // input as Message object message, // input as Message object
passwords: ['secret stuff'], // multiple passwords possible passwords: ['secret stuff'], // multiple passwords possible
@ -361,7 +361,7 @@ its [Reader class](https://openpgpjs.org/web-stream-tools/Reader.html).
}); });
const encrypted = await openpgp.encrypt({ const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromText(readableStream), // input as Message object message: await openpgp.createMessage({ text: readableStream }), // input as Message object
publicKeys: publicKey, // for encryption publicKeys: publicKey, // for encryption
privateKeys: privateKey // for signing (optional) privateKeys: privateKey // for signing (optional)
}); });
@ -457,7 +457,7 @@ Using the private key:
const privateKey = await openpgp.readKey({ armoredKey: privateKeyArmored }); const privateKey = await openpgp.readKey({ armoredKey: privateKeyArmored });
await privateKey.decrypt(passphrase); await privateKey.decrypt(passphrase);
const unsignedMessage = await openpgp.CleartextMessage.fromText('Hello, World!'); const unsignedMessage = await openpgp.createCleartextMessage({ text: 'Hello, World!' });
const cleartextMessage = await openpgp.sign({ const cleartextMessage = await openpgp.sign({
message: unsignedMessage, // CleartextMessage or Message object message: unsignedMessage, // CleartextMessage or Message object
privateKeys: privateKey // for signing privateKeys: privateKey // for signing
@ -497,7 +497,7 @@ Using the private key:
const privateKey = await openpgp.readKey({ armoredKey: privateKeyArmored }); const privateKey = await openpgp.readKey({ armoredKey: privateKeyArmored });
await privateKey.decrypt(passphrase); await privateKey.decrypt(passphrase);
const cleartextMessage = await openpgp.CleartextMessage.fromText('Hello, World!'); const cleartextMessage = await openpgp.createCleartextMessage({ text: 'Hello, World!' });
const detachedSignature = await openpgp.sign({ const detachedSignature = await openpgp.sign({
message: cleartextMessage, // CleartextMessage or Message object message: cleartextMessage, // CleartextMessage or Message object
privateKeys: privateKey, // for signing privateKeys: privateKey, // for signing
@ -544,7 +544,7 @@ Using the private key:
const privateKey = await openpgp.readKey({ armoredKey: privateKeyArmored }); const privateKey = await openpgp.readKey({ armoredKey: privateKeyArmored });
await privateKey.decrypt(passphrase); await privateKey.decrypt(passphrase);
const message = await openpgp.Message.fromBinary(readableStream); // or .fromText(readableStream: ReadableStream<String>) const message = await openpgp.createMessage({ binary: readableStream }); // or createMessage({ text: ReadableStream<String> })
const signatureArmored = await openpgp.sign({ const signatureArmored = await openpgp.sign({
message, message,
privateKeys: privateKey // for signing privateKeys: privateKey // for signing

12
openpgp.d.ts vendored
View File

@ -112,6 +112,8 @@ interface VerificationResult {
export function readCleartextMessage(options: { cleartextMessage: string, config?: PartialConfig }): Promise<CleartextMessage>; export function readCleartextMessage(options: { cleartextMessage: string, config?: PartialConfig }): Promise<CleartextMessage>;
export function createCleartextMessage(options: { text: string }): Promise<CleartextMessage>;
/** Class that represents an OpenPGP cleartext signed message. /** Class that represents an OpenPGP cleartext signed message.
*/ */
export class CleartextMessage { export class CleartextMessage {
@ -137,8 +139,6 @@ export class CleartextMessage {
* @param keys array of keys to verify signatures * @param keys array of keys to verify signatures
*/ */
verify(keys: Key[], date?: Date, config?: Config): Promise<VerificationResult[]>; verify(keys: Key[], date?: Date, config?: Config): Promise<VerificationResult[]>;
static fromText(text: string): CleartextMessage;
} }
/* ############## v5 MSG #################### */ /* ############## v5 MSG #################### */
@ -146,6 +146,9 @@ export class CleartextMessage {
export function readMessage<T extends MaybeStream<string>>(options: { armoredMessage: T, config?: PartialConfig }): Promise<Message<T>>; export function readMessage<T extends MaybeStream<string>>(options: { armoredMessage: T, config?: PartialConfig }): Promise<Message<T>>;
export function readMessage<T extends MaybeStream<Uint8Array>>(options: { binaryMessage: T, config?: PartialConfig }): Promise<Message<T>>; export function readMessage<T extends MaybeStream<Uint8Array>>(options: { binaryMessage: T, config?: PartialConfig }): Promise<Message<T>>;
export function createMessage<T extends MaybeStream<string>>(options: { text: T, filename?: string, date?: Date, type?: DataPacketType }): Message<T>;
export function createMessage<T extends MaybeStream<Uint8Array>>(options: { bytes: T, filename?: string, date?: Date, type?: DataPacketType }): Message<T>;
export function encrypt<T extends 'web' | 'node' | false>(options: EncryptOptions & { streaming: T, armor: false }): Promise< export function encrypt<T extends 'web' | 'node' | false>(options: EncryptOptions & { streaming: T, armor: false }): Promise<
T extends 'web' ? WebStream<Uint8Array> : T extends 'web' ? WebStream<Uint8Array> :
T extends 'node' ? NodeStream<Uint8Array> : T extends 'node' ? NodeStream<Uint8Array> :
@ -301,9 +304,6 @@ export class Message<T extends MaybeStream<Data>> {
* @param {String|Uint8Array} detachedSignature - The detached ASCII-armored or Uint8Array PGP signature * @param {String|Uint8Array} detachedSignature - The detached ASCII-armored or Uint8Array PGP signature
*/ */
public appendSignature(detachedSignature: string | Uint8Array): Promise<void>; public appendSignature(detachedSignature: string | Uint8Array): Promise<void>;
static fromText<T extends MaybeStream<string>>(text: T, filename?: string, date?: Date, type?: DataPacketType): Message<T>;
static fromBinary<T extends MaybeStream<Uint8Array>>(bytes: T, filename?: string, date?: Date, type?: DataPacketType): Message<T>;
} }
@ -551,7 +551,7 @@ export interface SessionKey { data: Uint8Array; algorithm: string; }
interface EncryptOptions { interface EncryptOptions {
/** message to be encrypted as created by Message.fromText or Message.fromBinary */ /** message to be encrypted as created by createMessage */
message: Message<MaybeStream<Data>>; message: Message<MaybeStream<Data>>;
/** (optional) array of keys or single key, used to encrypt the message */ /** (optional) array of keys or single key, used to encrypt the message */
publicKeys?: Key | Key[]; publicKeys?: Key | Key[];

24
src/cleartext.js
View File

@ -119,16 +119,6 @@ export class CleartextMessage {
}; };
return armor(enums.armor.signed, body, undefined, undefined, undefined, config); return armor(enums.armor.signed, body, undefined, undefined, undefined, config);
} }
/**
* Creates a new CleartextMessage object from text
* @param {String} text
* @static
* @async
*/
static async fromText(text) {
return new CleartextMessage(text);
}
} }
/** /**
@ -201,3 +191,17 @@ function verifyHeaders(headers, packetlist) {
throw new Error('Hash algorithm mismatch in armor header and signature'); throw new Error('Hash algorithm mismatch in armor header and signature');
} }
} }
/**
* Creates a new CleartextMessage object from text
* @param {Object} options
* @param {String} options.text
* @static
* @async
*/
export async function createCleartextMessage({ text }) {
if (!text) {
throw new Error('createCleartextMessage: must pass options object containing `text`');
}
return new CleartextMessage(text);
}

4
src/index.js
View File

@ -15,9 +15,9 @@ export { Key, readKey, readKeys } from './key';
export { Signature, readSignature } from './signature'; export { Signature, readSignature } from './signature';
export { Message, readMessage } from './message'; export { Message, readMessage, createMessage } from './message';
export { CleartextMessage, readCleartextMessage } from './cleartext'; export { CleartextMessage, readCleartextMessage, createCleartextMessage } from './cleartext';
export * from './packet'; export * from './packet';

104
src/message.js
View File

@ -644,71 +644,6 @@ export class Message {
armor(config = defaultConfig) { armor(config = defaultConfig) {
return armor(enums.armor.message, this.write(), null, null, null, config); return armor(enums.armor.message, this.write(), null, null, null, config);
} }
/**
* Creates new message object from text.
* @param {String | ReadableStream<String>} text - The message contents
* @param {String} [filename=""] - Name of the file (if any)
* @param {Date} [date=current date] - Date of the message, or modification date of the file
* @param {'utf8'|'binary'|'text'|'mime'} [type='utf8'] - Data packet type
* @returns {Message} New message object.
* @static
* @async
*/
static async fromText(text, filename, date = new Date(), type = 'utf8') {
const streamType = util.isStream(text);
if (streamType) {
await stream.loadStreamsPonyfill();
}
if (streamType === 'node') {
text = stream.nodeToWeb(text);
}
const literalDataPacket = new LiteralDataPacket(date);
// text will be converted to UTF8
literalDataPacket.setText(text, type);
if (filename !== undefined) {
literalDataPacket.setFilename(filename);
}
const literalDataPacketlist = new PacketList();
literalDataPacketlist.push(literalDataPacket);
const message = new Message(literalDataPacketlist);
message.fromStream = streamType;
return message;
}
/**
* Creates new message object from binary data.
* @param {Uint8Array | ReadableStream<Uint8Array>} bytes - The message contents
* @param {String} [filename=""] - Name of the file (if any)
* @param {Date} [date=current date] - Date of the message, or modification date of the file
* @param {'utf8'|'binary'|'text'|'mime'} [type='binary'] - Data packet type
* @returns {Message} New message object.
* @static
* @async
*/
static async fromBinary(bytes, filename, date = new Date(), type = 'binary') {
const streamType = util.isStream(bytes);
if (!util.isUint8Array(bytes) && !streamType) {
throw new Error('Data must be in the form of a Uint8Array or Stream');
}
if (streamType) {
await stream.loadStreamsPonyfill();
}
if (streamType === 'node') {
bytes = stream.nodeToWeb(bytes);
}
const literalDataPacket = new LiteralDataPacket(date);
literalDataPacket.setBytes(bytes, type);
if (filename !== undefined) {
literalDataPacket.setFilename(filename);
}
const literalDataPacketlist = new PacketList();
literalDataPacketlist.push(literalDataPacket);
const message = new Message(literalDataPacketlist);
message.fromStream = streamType;
return message;
}
} }
/** /**
@ -884,3 +819,42 @@ export async function readMessage({ armoredMessage, binaryMessage, config }) {
return message; return message;
} }
/**
* Creates new message object from text or binary data.
* @param {Object} options
* @param {String | ReadableStream<String>} [options.text] - The text message contents
* @param {Uint8Array | ReadableStream<Uint8Array>} [options.binary] - The binary message contents
* @param {String} [options.filename=""] - Name of the file (if any)
* @param {Date} [options.date=current date] - Date of the message, or modification date of the file
* @param {'utf8'|'binary'|'text'|'mime'} [options.format='utf8' if text is passed, 'binary' otherwise] - Data packet type
* @returns {Message} New message object.
* @async
* @static
*/
export async function createMessage({ text, binary, filename, date = new Date(), format = text !== undefined ? 'utf8' : 'binary' }) {
let input = text !== undefined ? text : binary;
if (input === undefined) {
throw new Error('createMessage: must pass options object containing `text` or `binary`');
}
const streamType = util.isStream(input);
if (streamType) {
await stream.loadStreamsPonyfill();
}
if (streamType === 'node') {
input = stream.nodeToWeb(input);
}
const literalDataPacket = new LiteralDataPacket(date);
if (text !== undefined) {
literalDataPacket.setText(input, format);
} else {
literalDataPacket.setBytes(input, format);
}
if (filename !== undefined) {
literalDataPacket.setFilename(filename);
}
const literalDataPacketlist = new PacketList();
literalDataPacketlist.push(literalDataPacket);
const message = new Message(literalDataPacketlist);
message.fromStream = streamType;
return message;
}

2
src/openpgp.js
View File

@ -231,7 +231,7 @@ export async function encryptKey({ privateKey, passphrase, config }) {
* Encrypts message text/data with public keys, passwords or both at once. At least either public keys or passwords * Encrypts message text/data with public keys, passwords or both at once. At least either public keys or passwords
* must be specified. If private keys are specified, those will be used to sign the message. * must be specified. If private keys are specified, those will be used to sign the message.
* @param {Object} options * @param {Object} options
* @param {Message} options.message - Message to be encrypted as created by {@link Message.fromText} or {@link Message.fromBinary} * @param {Message} options.message - Message to be encrypted as created by {@link createMessage}
* @param {Key|Array<Key>} [options.publicKeys] - Array of keys or single key, used to encrypt the message * @param {Key|Array<Key>} [options.publicKeys] - Array of keys or single key, used to encrypt the message
* @param {Key|Array<Key>} [options.privateKeys] - Private keys for signing. If omitted message will not be signed * @param {Key|Array<Key>} [options.privateKeys] - Private keys for signing. If omitted message will not be signed
* @param {String|Array<String>} [options.passwords] - Array of passwords or a single password to encrypt the message * @param {String|Array<String>} [options.passwords] - Array of passwords or a single password to encrypt the message

10
test/general/brainpool.js
View File

@ -210,7 +210,7 @@ EJ4QcD/oQ6x1M/8X/iKQCtxZP8RnlrbH7ExkNON5s5g=
}); });
it('Sign message', async function () { it('Sign message', async function () {
const romeoPrivate = await load_priv_key('romeo'); const romeoPrivate = await load_priv_key('romeo');
const signed = await openpgp.sign({ privateKeys: [romeoPrivate], message: await openpgp.CleartextMessage.fromText(data.romeo.message) }); const signed = await openpgp.sign({ privateKeys: [romeoPrivate], message: await openpgp.createCleartextMessage({ text: data.romeo.message }) });
const romeoPublic = await load_pub_key('romeo'); const romeoPublic = await load_pub_key('romeo');
const msg = await openpgp.readCleartextMessage({ cleartextMessage: signed }); const msg = await openpgp.readCleartextMessage({ cleartextMessage: signed });
const result = await openpgp.verify({ publicKeys: [romeoPublic], message: msg }); const result = await openpgp.verify({ publicKeys: [romeoPublic], message: msg });
@ -260,7 +260,7 @@ EJ4QcD/oQ6x1M/8X/iKQCtxZP8RnlrbH7ExkNON5s5g=
it('Encrypt and sign message', async function () { it('Encrypt and sign message', async function () {
const romeoPrivate = await load_priv_key('romeo'); const romeoPrivate = await load_priv_key('romeo');
const julietPublic = await load_pub_key('juliet'); const julietPublic = await load_pub_key('juliet');
const encrypted = await openpgp.encrypt({ publicKeys: [julietPublic], privateKeys: [romeoPrivate], message: await openpgp.Message.fromText(data.romeo.message) }); const encrypted = await openpgp.encrypt({ publicKeys: [julietPublic], privateKeys: [romeoPrivate], message: await openpgp.createMessage({ text: data.romeo.message }) });
const message = await openpgp.readMessage({ armoredMessage: encrypted }); const message = await openpgp.readMessage({ armoredMessage: encrypted });
const romeoPublic = await load_pub_key('romeo'); const romeoPublic = await load_pub_key('romeo');
@ -290,21 +290,21 @@ function omnibus() {
const bye = secondKey.key; const bye = secondKey.key;
const pubBye = bye.toPublic(); const pubBye = bye.toPublic();
const cleartextMessage = await openpgp.sign({ message: await openpgp.CleartextMessage.fromText(testData), privateKeys: hi }); const cleartextMessage = await openpgp.sign({ message: await openpgp.createCleartextMessage({ text: testData }), privateKeys: hi });
await openpgp.verify({ await openpgp.verify({
message: await openpgp.readCleartextMessage({ cleartextMessage }), message: await openpgp.readCleartextMessage({ cleartextMessage }),
publicKeys: pubHi publicKeys: pubHi
}).then(output => expect(output.signatures[0].valid).to.be.true); }).then(output => expect(output.signatures[0].valid).to.be.true);
// Verifying detached signature // Verifying detached signature
await openpgp.verify({ await openpgp.verify({
message: await openpgp.Message.fromText(util.removeTrailingSpaces(testData)), message: await openpgp.createMessage({ text: util.removeTrailingSpaces(testData) }),
publicKeys: pubHi, publicKeys: pubHi,
signature: (await openpgp.readCleartextMessage({ cleartextMessage })).signature signature: (await openpgp.readCleartextMessage({ cleartextMessage })).signature
}).then(output => expect(output.signatures[0].valid).to.be.true); }).then(output => expect(output.signatures[0].valid).to.be.true);
// Encrypting and signing // Encrypting and signing
const encrypted = await openpgp.encrypt({ const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromText(testData2), message: await openpgp.createMessage({ text: testData2 }),
publicKeys: [pubBye], publicKeys: [pubBye],
privateKeys: [hi] privateKeys: [hi]
}); });

12
test/general/config.js
View File

@ -149,7 +149,7 @@ module.exports = () => describe('Custom configuration', function() {
try { try {
const passwords = ['12345678']; const passwords = ['12345678'];
const message = await openpgp.Message.fromText("test"); const message = await openpgp.createMessage({ text: "test" });
const armored = await openpgp.encrypt({ message, passwords }); const armored = await openpgp.encrypt({ message, passwords });
const encrypted = await openpgp.readMessage({ armoredMessage: armored }); const encrypted = await openpgp.readMessage({ armoredMessage: armored });
@ -186,7 +186,7 @@ module.exports = () => describe('Custom configuration', function() {
it('openpgp.decrypt', async function() { it('openpgp.decrypt', async function() {
const plaintext = 'test'; const plaintext = 'test';
const message = openpgp.Message.fromText(plaintext); const message = await openpgp.createMessage({ text: plaintext });
const userIDs = { name: 'Test User', email: 'text2@example.com' }; const userIDs = { name: 'Test User', email: 'text2@example.com' };
const { key } = await openpgp.generateKey({ userIDs, type: 'rsa', rsaBits: 2048 }); const { key } = await openpgp.generateKey({ userIDs, type: 'rsa', rsaBits: 2048 });
@ -225,7 +225,7 @@ module.exports = () => describe('Custom configuration', function() {
const { privateKeyArmored } = await openpgp.generateKey({ userIDs }); const { privateKeyArmored } = await openpgp.generateKey({ userIDs });
const key = await openpgp.readKey({ armoredKey: privateKeyArmored }); const key = await openpgp.readKey({ armoredKey: privateKeyArmored });
const message = await openpgp.Message.fromText("test"); const message = await openpgp.createMessage({ text: "test" });
const opt = { const opt = {
message, message,
privateKeys: key, privateKeys: key,
@ -235,7 +235,7 @@ module.exports = () => describe('Custom configuration', function() {
opt.detached = true; opt.detached = true;
await expect(openpgp.sign(opt)).to.be.rejectedWith(/Insecure hash algorithm/); await expect(openpgp.sign(opt)).to.be.rejectedWith(/Insecure hash algorithm/);
const clearText = await openpgp.CleartextMessage.fromText("test"); const clearText = await openpgp.createCleartextMessage({ text: "test" });
const opt2 = { const opt2 = {
message: clearText, message: clearText,
privateKeys: key, privateKeys: key,
@ -255,7 +255,7 @@ module.exports = () => describe('Custom configuration', function() {
const config = { rejectMessageHashAlgorithms: new Set([openpgp.enums.hash.sha256, openpgp.enums.hash.sha512]) }; const config = { rejectMessageHashAlgorithms: new Set([openpgp.enums.hash.sha256, openpgp.enums.hash.sha512]) };
const message = await openpgp.Message.fromText("test"); const message = await openpgp.createMessage({ text: "test" });
const signed = await openpgp.sign({ message, privateKeys: key }); const signed = await openpgp.sign({ message, privateKeys: key });
const opt = { const opt = {
message: await openpgp.readMessage({ armoredMessage: signed }), message: await openpgp.readMessage({ armoredMessage: signed }),
@ -274,7 +274,7 @@ module.exports = () => describe('Custom configuration', function() {
const { signatures: [sig2] } = await openpgp.verify(opt2); const { signatures: [sig2] } = await openpgp.verify(opt2);
await expect(sig2.error).to.match(/Insecure message hash algorithm/); await expect(sig2.error).to.match(/Insecure message hash algorithm/);
const cleartext = await openpgp.CleartextMessage.fromText("test"); const cleartext = await openpgp.createCleartextMessage({ text: "test" });
const signedCleartext = await openpgp.sign({ message: cleartext, privateKeys: key }); const signedCleartext = await openpgp.sign({ message: cleartext, privateKeys: key });
const opt3 = { const opt3 = {
message: await openpgp.readCleartextMessage({ cleartextMessage: signedCleartext }), message: await openpgp.readCleartextMessage({ cleartextMessage: signedCleartext }),

10
test/general/ecc_nist.js
View File

@ -20,21 +20,21 @@ module.exports = () => describe('Elliptic Curve Cryptography for NIST P-256,P-38
const bye = secondKey.key; const bye = secondKey.key;
const pubBye = bye.toPublic(); const pubBye = bye.toPublic();
const cleartextMessage = await openpgp.sign({ message: await openpgp.CleartextMessage.fromText(testData), privateKeys: hi }); const cleartextMessage = await openpgp.sign({ message: await openpgp.createCleartextMessage({ text: testData }), privateKeys: hi });
await openpgp.verify({ await openpgp.verify({
message: await openpgp.readCleartextMessage({ cleartextMessage }), message: await openpgp.readCleartextMessage({ cleartextMessage }),
publicKeys: pubHi publicKeys: pubHi
}).then(output => expect(output.signatures[0].valid).to.be.true); }).then(output => expect(output.signatures[0].valid).to.be.true);
// Verifying detached signature // Verifying detached signature
await openpgp.verify({ await openpgp.verify({
message: await openpgp.Message.fromText(util.removeTrailingSpaces(testData)), message: await openpgp.createMessage({ text: util.removeTrailingSpaces(testData) }),
publicKeys: pubHi, publicKeys: pubHi,
signature: (await openpgp.readCleartextMessage({ cleartextMessage })).signature signature: (await openpgp.readCleartextMessage({ cleartextMessage })).signature
}).then(output => expect(output.signatures[0].valid).to.be.true); }).then(output => expect(output.signatures[0].valid).to.be.true);
// Encrypting and signing // Encrypting and signing
const encrypted = await openpgp.encrypt({ const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromText(testData2), message: await openpgp.createMessage({ text: testData2 }),
publicKeys: [pubBye], publicKeys: [pubBye],
privateKeys: [hi] privateKeys: [hi]
}); });
@ -56,7 +56,7 @@ module.exports = () => describe('Elliptic Curve Cryptography for NIST P-256,P-38
const testData = input.createSomeMessage(); const testData = input.createSomeMessage();
const options = { userIDs: { name: "Hi", email: "hi@hel.lo" }, curve: "p256" }; const options = { userIDs: { name: "Hi", email: "hi@hel.lo" }, curve: "p256" };
const firstKey = await openpgp.generateKey(options); const firstKey = await openpgp.generateKey(options);
const signature = await openpgp.sign({ message: await openpgp.CleartextMessage.fromText(testData), privateKeys: firstKey.key }); const signature = await openpgp.sign({ message: await openpgp.createCleartextMessage({ text: testData }), privateKeys: firstKey.key });
const msg = await openpgp.readCleartextMessage({ cleartextMessage: signature }); const msg = await openpgp.readCleartextMessage({ cleartextMessage: signature });
const result = await openpgp.verify({ message: msg, publicKeys: firstKey.key.toPublic() }); const result = await openpgp.verify({ message: msg, publicKeys: firstKey.key.toPublic() });
expect(result.signatures[0].valid).to.be.true; expect(result.signatures[0].valid).to.be.true;
@ -69,7 +69,7 @@ module.exports = () => describe('Elliptic Curve Cryptography for NIST P-256,P-38
options = { userIDs: { name: "Bye", email: "bye@good.bye" }, curve: "p256" }; options = { userIDs: { name: "Bye", email: "bye@good.bye" }, curve: "p256" };
const secondKey = await openpgp.generateKey(options); const secondKey = await openpgp.generateKey(options);
const encrypted = await openpgp.encrypt( const encrypted = await openpgp.encrypt(
{ message: await openpgp.Message.fromText(testData), { message: await openpgp.createMessage({ text: testData }),
publicKeys: [secondKey.key.toPublic()], publicKeys: [secondKey.key.toPublic()],
privateKeys: [firstKey.key] } privateKeys: [firstKey.key] }
); );

4
test/general/ecc_secp256k1.js
View File

@ -184,7 +184,7 @@ module.exports = () => describe('Elliptic Curve Cryptography for secp256k1 curve
}); });
it('Sign message', async function () { it('Sign message', async function () {
const romeoPrivate = await load_priv_key('romeo'); const romeoPrivate = await load_priv_key('romeo');
const signed = await openpgp.sign({ privateKeys: [romeoPrivate], message: await openpgp.CleartextMessage.fromText(data.romeo.message) }); const signed = await openpgp.sign({ privateKeys: [romeoPrivate], message: await openpgp.createCleartextMessage({ text: data.romeo.message }) });
const romeoPublic = await load_pub_key('romeo'); const romeoPublic = await load_pub_key('romeo');
const msg = await openpgp.readCleartextMessage({ cleartextMessage: signed }); const msg = await openpgp.readCleartextMessage({ cleartextMessage: signed });
const result = await openpgp.verify({ publicKeys: [romeoPublic], message: msg }); const result = await openpgp.verify({ publicKeys: [romeoPublic], message: msg });
@ -208,7 +208,7 @@ module.exports = () => describe('Elliptic Curve Cryptography for secp256k1 curve
it('Encrypt and sign message', async function () { it('Encrypt and sign message', async function () {
const romeoPrivate = await load_priv_key('romeo'); const romeoPrivate = await load_priv_key('romeo');
const julietPublic = await load_pub_key('juliet'); const julietPublic = await load_pub_key('juliet');
const encrypted = await openpgp.encrypt({ publicKeys: [julietPublic], privateKeys: [romeoPrivate], message: await openpgp.Message.fromText(data.romeo.message) }); const encrypted = await openpgp.encrypt({ publicKeys: [julietPublic], privateKeys: [romeoPrivate], message: await openpgp.createMessage({ text: data.romeo.message }) });
const message = await openpgp.readMessage({ armoredMessage: encrypted }); const message = await openpgp.readMessage({ armoredMessage: encrypted });
const romeoPublic = await load_pub_key('romeo'); const romeoPublic = await load_pub_key('romeo');

34
test/general/key.js
View File

@ -2166,7 +2166,7 @@ function versionSpecificTests() {
const opt = { userIDs: { name: 'test', email: 'a@b.com' }, passphrase: '123' }; const opt = { userIDs: { name: 'test', email: 'a@b.com' }, passphrase: '123' };
const { key } = await openpgp.generateKey(opt); const { key } = await openpgp.generateKey(opt);
return openpgp.encrypt({ return openpgp.encrypt({
message: await openpgp.Message.fromText('hello'), message: await openpgp.createMessage({ text: 'hello' }),
publicKeys: key publicKeys: key
}).then(async armoredMessage => openpgp.decrypt({ }).then(async armoredMessage => openpgp.decrypt({
message: await openpgp.readMessage({ armoredMessage }), message: await openpgp.readMessage({ armoredMessage }),
@ -2586,7 +2586,7 @@ function versionSpecificTests() {
expect(newKey.users.length).to.equal(1); expect(newKey.users.length).to.equal(1);
expect(newKey.users[0].userID.userID).to.equal('test <a@b.com>'); expect(newKey.users[0].userID.userID).to.equal('test <a@b.com>');
expect(newKey.isDecrypted()).to.be.true; expect(newKey.isDecrypted()).to.be.true;
return openpgp.sign({ message: await openpgp.CleartextMessage.fromText('hello'), privateKeys: newKey, armor: true }).then(async function(signed) { return openpgp.sign({ message: await openpgp.createCleartextMessage({ text: 'hello' }), privateKeys: newKey, armor: true }).then(async function(signed) {
return openpgp.verify( return openpgp.verify(
{ message: await openpgp.readCleartextMessage({ cleartextMessage: signed }), publicKeys: newKey.toPublic() } { message: await openpgp.readCleartextMessage({ cleartextMessage: signed }), publicKeys: newKey.toPublic() }
).then(async function(verified) { ).then(async function(verified) {
@ -2630,7 +2630,7 @@ function versionSpecificTests() {
opt.userIDs = userID2; opt.userIDs = userID2;
return openpgp.reformatKey(opt).then(async function(newKey) { return openpgp.reformatKey(opt).then(async function(newKey) {
newKey = newKey.key; newKey = newKey.key;
return openpgp.encrypt({ message: await openpgp.Message.fromText('hello'), publicKeys: newKey.toPublic(), privateKeys: newKey, armor: true }).then(async function(encrypted) { return openpgp.encrypt({ message: await openpgp.createMessage({ text: 'hello' }), publicKeys: newKey.toPublic(), privateKeys: newKey, armor: true }).then(async function(encrypted) {
return openpgp.decrypt({ message: await openpgp.readMessage({ armoredMessage: 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.data).to.equal('hello');
expect(decrypted.signatures[0].valid).to.be.true; expect(decrypted.signatures[0].valid).to.be.true;
@ -3016,7 +3016,7 @@ module.exports = () => describe('Key', function() {
expect(key.primaryKey.isDummy()).to.be.false; expect(key.primaryKey.isDummy()).to.be.false;
key.primaryKey.makeDummy(); key.primaryKey.makeDummy();
expect(key.primaryKey.isDummy()).to.be.true; expect(key.primaryKey.isDummy()).to.be.true;
await expect(openpgp.sign({ message: await openpgp.Message.fromText('test'), privateKeys: [key], config: { minRSABits: 1024 } })).to.be.fulfilled; await expect(openpgp.sign({ message: await openpgp.createMessage({ text: 'test' }), privateKeys: [key], config: { minRSABits: 1024 } })).to.be.fulfilled;
}); });
it('makeDummy() - should work for encrypted keys', async function() { it('makeDummy() - should work for encrypted keys', async function() {
@ -3423,10 +3423,10 @@ VYGdb3eNlV8CfoEC
expect(sessionKey.algorithm).to.equal('aes128'); expect(sessionKey.algorithm).to.equal('aes128');
const config = { minRSABits: 1024 }; const config = { minRSABits: 1024 };
await openpgp.encrypt({ await openpgp.encrypt({
message: await openpgp.Message.fromText('hello'), publicKeys: publicKey, privateKeys: privateKey, toUserIDs: { name: 'Test User', email: 'b@c.com' }, armor: false, config message: await openpgp.createMessage({ text: 'hello' }), publicKeys: publicKey, privateKeys: privateKey, toUserIDs: { name: 'Test User', email: 'b@c.com' }, armor: false, config
}); });
await expect(openpgp.encrypt({ await expect(openpgp.encrypt({
message: await openpgp.Message.fromText('hello'), publicKeys: publicKey, privateKeys: privateKey, toUserIDs: { name: 'Test User', email: 'c@c.com' }, armor: false, config message: await openpgp.createMessage({ text: 'hello' }), publicKeys: publicKey, privateKeys: privateKey, toUserIDs: { name: 'Test User', email: 'c@c.com' }, armor: false, config
})).to.be.rejectedWith('Could not find user that matches that user ID'); })).to.be.rejectedWith('Could not find user that matches that user ID');
}); });
@ -3435,7 +3435,7 @@ VYGdb3eNlV8CfoEC
expect(publicKey.users.length).to.equal(0); expect(publicKey.users.length).to.equal(0);
const privateKey = await openpgp.readKey({ armoredKey: uidlessKey }); const privateKey = await openpgp.readKey({ armoredKey: uidlessKey });
await privateKey.decrypt('correct horse battery staple'); await privateKey.decrypt('correct horse battery staple');
await expect(openpgp.encrypt({ message: await openpgp.Message.fromText('hello'), publicKeys: publicKey, privateKeys: privateKey, armor: false })).to.be.rejectedWith('Could not find primary user'); await expect(openpgp.encrypt({ message: await openpgp.createMessage({ text: 'hello' }), publicKeys: publicKey, privateKeys: privateKey, armor: false })).to.be.rejectedWith('Could not find primary user');
}); });
it('Sign - specific user', async function() { it('Sign - specific user', async function() {
@ -3453,17 +3453,17 @@ VYGdb3eNlV8CfoEC
privateKey.users[1].selfCertifications[0].preferredHashAlgorithms = [openpgp.enums.hash.sha512]; privateKey.users[1].selfCertifications[0].preferredHashAlgorithms = [openpgp.enums.hash.sha512];
const config = { minRSABits: 1024 }; const config = { minRSABits: 1024 };
const signed = await openpgp.sign({ const signed = await openpgp.sign({
message: await openpgp.Message.fromText('hello'), privateKeys: privateKey, fromUserIDs: { name: 'Test McTestington', email: 'test@example.com' }, armor: false, config message: await openpgp.createMessage({ text: 'hello' }), privateKeys: privateKey, fromUserIDs: { name: 'Test McTestington', email: 'test@example.com' }, armor: false, config
}); });
const signature = await openpgp.readMessage({ binaryMessage: signed }); const signature = await openpgp.readMessage({ binaryMessage: signed });
expect(signature.packets[0].hashAlgorithm).to.equal(openpgp.enums.hash.sha512); expect(signature.packets[0].hashAlgorithm).to.equal(openpgp.enums.hash.sha512);
const encrypted = await openpgp.encrypt({ const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromText('hello'), passwords: 'test', privateKeys: privateKey, fromUserIDs: { name: 'Test McTestington', email: 'test@example.com' }, armor: false, config message: await openpgp.createMessage({ text: 'hello' }), passwords: 'test', privateKeys: privateKey, fromUserIDs: { name: 'Test McTestington', email: 'test@example.com' }, armor: false, config
}); });
const { signatures } = await openpgp.decrypt({ message: await openpgp.readMessage({ binaryMessage: 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); expect(signatures[0].signature.packets[0].hashAlgorithm).to.equal(openpgp.enums.hash.sha512);
await expect(openpgp.encrypt({ await expect(openpgp.encrypt({
message: await openpgp.Message.fromText('hello'), publicKeys: publicKey, privateKeys: privateKey, fromUserIDs: { name: 'Not Test McTestington', email: 'test@example.com' }, armor: false, config message: await openpgp.createMessage({ text: 'hello' }), publicKeys: publicKey, privateKeys: privateKey, fromUserIDs: { name: 'Not Test McTestington', email: 'test@example.com' }, armor: false, config
})).to.be.rejectedWith('Could not find user that matches that user ID'); })).to.be.rejectedWith('Could not find user that matches that user ID');
}); });
@ -3499,7 +3499,7 @@ VYGdb3eNlV8CfoEC
it('Reject encryption with revoked primary user', async function() { it('Reject encryption with revoked primary user', async function() {
const key = await openpgp.readKey({ armoredKey: pub_revoked_subkeys }); const key = await openpgp.readKey({ armoredKey: pub_revoked_subkeys });
return openpgp.encrypt({ publicKeys: [key], message: await openpgp.Message.fromText('random data') }).then(() => { return openpgp.encrypt({ publicKeys: [key], message: await openpgp.createMessage({ text: 'random data' }) }).then(() => {
throw new Error('encryptSessionKey should not encrypt with revoked public key'); throw new Error('encryptSessionKey should not encrypt with revoked public key');
}).catch(function(error) { }).catch(function(error) {
expect(error.message).to.equal('Error encrypting message: Primary user is revoked'); expect(error.message).to.equal('Error encrypting message: Primary user is revoked');
@ -3510,7 +3510,7 @@ VYGdb3eNlV8CfoEC
const key = await openpgp.readKey({ armoredKey: pub_revoked_subkeys }); const key = await openpgp.readKey({ armoredKey: pub_revoked_subkeys });
key.revocationSignatures = []; key.revocationSignatures = [];
key.users[0].revocationSignatures = []; key.users[0].revocationSignatures = [];
return openpgp.encrypt({ publicKeys: [key], message: await openpgp.Message.fromText('random data'), date: new Date(1386842743000) }).then(() => { return openpgp.encrypt({ publicKeys: [key], message: await openpgp.createMessage({ text: 'random data' }), date: new Date(1386842743000) }).then(() => {
throw new Error('encryptSessionKey should not encrypt with revoked public key'); throw new Error('encryptSessionKey should not encrypt with revoked public key');
}).catch(function(error) { }).catch(function(error) {
expect(error.message).to.equal('Error encrypting message: Could not find valid encryption key packet in key ' + key.getKeyID().toHex() + ': Subkey is revoked'); expect(error.message).to.equal('Error encrypting message: Could not find valid encryption key packet in key ' + key.getKeyID().toHex() + ': Subkey is revoked');
@ -3519,7 +3519,7 @@ VYGdb3eNlV8CfoEC
it('Reject encryption with key revoked with appended revocation cert', async function() { it('Reject encryption with key revoked with appended revocation cert', async function() {
const key = await openpgp.readKey({ armoredKey: pub_revoked_with_cert }); const key = await openpgp.readKey({ armoredKey: pub_revoked_with_cert });
return openpgp.encrypt({ publicKeys: [key], message: await openpgp.Message.fromText('random data') }).then(() => { return openpgp.encrypt({ publicKeys: [key], message: await openpgp.createMessage({ text: 'random data' }) }).then(() => {
throw new Error('encryptSessionKey should not encrypt with revoked public key'); throw new Error('encryptSessionKey should not encrypt with revoked public key');
}).catch(function(error) { }).catch(function(error) {
expect(error.message).to.equal('Error encrypting message: Primary key is revoked'); expect(error.message).to.equal('Error encrypting message: Primary key is revoked');
@ -3734,7 +3734,7 @@ VYGdb3eNlV8CfoEC
expect(subKey.getAlgorithmInfo().algorithm).to.be.equal('eddsa'); expect(subKey.getAlgorithmInfo().algorithm).to.be.equal('eddsa');
await subKey.verify(newPrivateKey.primaryKey); await subKey.verify(newPrivateKey.primaryKey);
expect(await newPrivateKey.getSigningKey()).to.be.equal(subKey); expect(await newPrivateKey.getSigningKey()).to.be.equal(subKey);
const signed = await openpgp.sign({ message: await openpgp.Message.fromText('the data to signed'), privateKeys: newPrivateKey, armor:false }); const signed = await openpgp.sign({ message: await openpgp.createMessage({ text: 'the data to signed' }), privateKeys: newPrivateKey, armor:false });
const message = await openpgp.readMessage({ binaryMessage: signed }); const message = await openpgp.readMessage({ binaryMessage: signed });
const { signatures } = await openpgp.verify({ message, publicKeys: [newPrivateKey.toPublic()] }); const { signatures } = await openpgp.verify({ message, publicKeys: [newPrivateKey.toPublic()] });
expect(signatures).to.exist; expect(signatures).to.exist;
@ -3756,7 +3756,7 @@ VYGdb3eNlV8CfoEC
const publicKey = newPrivateKey.toPublic(); const publicKey = newPrivateKey.toPublic();
await subKey.verify(newPrivateKey.primaryKey); await subKey.verify(newPrivateKey.primaryKey);
expect(await newPrivateKey.getEncryptionKey()).to.be.equal(subKey); expect(await newPrivateKey.getEncryptionKey()).to.be.equal(subKey);
const encrypted = await openpgp.encrypt({ message: await openpgp.Message.fromText(vData), publicKeys: publicKey, armor:false }); const encrypted = await openpgp.encrypt({ message: await openpgp.createMessage({ text: vData }), publicKeys: publicKey, armor:false });
expect(encrypted).to.be.exist; expect(encrypted).to.be.exist;
const message = await openpgp.readMessage({ binaryMessage: encrypted }); const message = await openpgp.readMessage({ binaryMessage: encrypted });
const pkSessionKeys = message.packets.filterByTag(openpgp.enums.packet.publicKeyEncryptedSessionKey); const pkSessionKeys = message.packets.filterByTag(openpgp.enums.packet.publicKeyEncryptedSessionKey);
@ -3780,7 +3780,7 @@ VYGdb3eNlV8CfoEC
expect(subKey.getAlgorithmInfo().algorithm).to.be.equal('rsaEncryptSign'); expect(subKey.getAlgorithmInfo().algorithm).to.be.equal('rsaEncryptSign');
await subKey.verify(newPrivateKey.primaryKey); await subKey.verify(newPrivateKey.primaryKey);
expect(await newPrivateKey.getSigningKey()).to.be.equal(subKey); expect(await newPrivateKey.getSigningKey()).to.be.equal(subKey);
const signed = await openpgp.sign({ message: await openpgp.Message.fromText('the data to signed'), privateKeys: newPrivateKey, armor:false }); const signed = await openpgp.sign({ message: await openpgp.createMessage({ text: 'the data to signed' }), privateKeys: newPrivateKey, armor:false });
const message = await openpgp.readMessage({ binaryMessage: signed }); const message = await openpgp.readMessage({ binaryMessage: signed });
const { signatures } = await openpgp.verify({ message, publicKeys: [newPrivateKey.toPublic()] }); const { signatures } = await openpgp.verify({ message, publicKeys: [newPrivateKey.toPublic()] });
expect(signatures).to.exist; expect(signatures).to.exist;
@ -3800,7 +3800,7 @@ VYGdb3eNlV8CfoEC
const publicKey = newPrivateKey.toPublic(); const publicKey = newPrivateKey.toPublic();
const vData = 'the data to encrypted!'; const vData = 'the data to encrypted!';
expect(await newPrivateKey.getEncryptionKey()).to.be.equal(subKey); expect(await newPrivateKey.getEncryptionKey()).to.be.equal(subKey);
const encrypted = await openpgp.encrypt({ message: await openpgp.Message.fromText(vData), publicKeys: publicKey, armor:false }); const encrypted = await openpgp.encrypt({ message: await openpgp.createMessage({ text: vData }), publicKeys: publicKey, armor:false });
expect(encrypted).to.be.exist; expect(encrypted).to.be.exist;
const message = await openpgp.readMessage({ binaryMessage: encrypted }); const message = await openpgp.readMessage({ binaryMessage: encrypted });
const pkSessionKeys = message.packets.filterByTag(openpgp.enums.packet.publicKeyEncryptedSessionKey); const pkSessionKeys = message.packets.filterByTag(openpgp.enums.packet.publicKeyEncryptedSessionKey);

138
test/general/openpgp.js
View File

@ -864,14 +864,14 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
const commentStringVal = openpgp.config.commentString; const commentStringVal = openpgp.config.commentString;
try { try {
const encryptedDefault = await openpgp.encrypt({ publicKeys:publicKey, message:await openpgp.Message.fromText(plaintext) }); const encryptedDefault = await openpgp.encrypt({ publicKeys:publicKey, message:await openpgp.createMessage({ text: plaintext }) });
expect(encryptedDefault).to.exist; expect(encryptedDefault).to.exist;
expect(encryptedDefault).not.to.match(/^Version:/); expect(encryptedDefault).not.to.match(/^Version:/);
expect(encryptedDefault).not.to.match(/^Comment:/); expect(encryptedDefault).not.to.match(/^Comment:/);
openpgp.config.showComment = true; openpgp.config.showComment = true;
openpgp.config.commentString = 'different'; openpgp.config.commentString = 'different';
const encryptedWithComment = await openpgp.encrypt({ publicKeys:publicKey, message:await openpgp.Message.fromText(plaintext) }); const encryptedWithComment = await openpgp.encrypt({ publicKeys:publicKey, message:await openpgp.createMessage({ text: plaintext }) });
expect(encryptedWithComment).to.exist; expect(encryptedWithComment).to.exist;
expect(encryptedWithComment).not.to.match(/^Version:/); expect(encryptedWithComment).not.to.match(/^Version:/);
expect(encryptedWithComment).to.match(/Comment: different/); expect(encryptedWithComment).to.match(/Comment: different/);
@ -1019,7 +1019,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
it('Calling decrypt with not decrypted key leads to exception', async function() { it('Calling decrypt with not decrypted key leads to exception', async function() {
const encOpt = { const encOpt = {
message: await openpgp.Message.fromText(plaintext), message: await openpgp.createMessage({ text: plaintext }),
publicKeys: publicKey publicKeys: publicKey
}; };
const decOpt = { const decOpt = {
@ -1147,7 +1147,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
it('roundtrip workflow: encrypt, decryptSessionKeys, decrypt with pgp key pair', async function () { it('roundtrip workflow: encrypt, decryptSessionKeys, decrypt with pgp key pair', async function () {
const encrypted = await openpgp.encrypt({ const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromText(plaintext), message: await openpgp.createMessage({ text: plaintext }),
publicKeys: publicKey publicKeys: publicKey
}); });
const decryptedSessionKeys = await openpgp.decryptSessionKeys({ const decryptedSessionKeys = await openpgp.decryptSessionKeys({
@ -1164,7 +1164,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
it('roundtrip workflow: encrypt, decryptSessionKeys, decrypt with pgp key pair -- trailing spaces', async function () { it('roundtrip workflow: encrypt, decryptSessionKeys, decrypt with pgp key pair -- trailing spaces', async function () {
const plaintext = 'space: \nspace and tab: \t\nno trailing space\n \ntab:\t\ntab and space:\t '; const plaintext = 'space: \nspace and tab: \t\nno trailing space\n \ntab:\t\ntab and space:\t ';
const encrypted = await openpgp.encrypt({ const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromText(plaintext), message: await openpgp.createMessage({ text: plaintext }),
publicKeys: publicKey publicKeys: publicKey
}); });
const decryptedSessionKeys = await openpgp.decryptSessionKeys({ const decryptedSessionKeys = await openpgp.decryptSessionKeys({
@ -1180,7 +1180,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
it('roundtrip workflow: encrypt, decryptSessionKeys, decrypt with password', async function () { it('roundtrip workflow: encrypt, decryptSessionKeys, decrypt with password', async function () {
const encrypted = await openpgp.encrypt({ const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromText(plaintext), message: await openpgp.createMessage({ text: plaintext }),
passwords: password1 passwords: password1
}); });
const decryptedSessionKeys = await openpgp.decryptSessionKeys({ const decryptedSessionKeys = await openpgp.decryptSessionKeys({
@ -1196,7 +1196,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
it('roundtrip workflow: encrypt with multiple passwords, decryptSessionKeys, decrypt with multiple passwords', async function () { it('roundtrip workflow: encrypt with multiple passwords, decryptSessionKeys, decrypt with multiple passwords', async function () {
const encrypted = await openpgp.encrypt({ const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromText(plaintext), message: await openpgp.createMessage({ text: plaintext }),
passwords: [password1, password2] passwords: [password1, password2]
}); });
const decryptedSessionKeys = await openpgp.decryptSessionKeys({ const decryptedSessionKeys = await openpgp.decryptSessionKeys({
@ -1212,7 +1212,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
it('roundtrip workflow: encrypt twice with one password, decryptSessionKeys, only one session key', async function () { it('roundtrip workflow: encrypt twice with one password, decryptSessionKeys, only one session key', async function () {
const encrypted = await openpgp.encrypt({ const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromText(plaintext), message: await openpgp.createMessage({ text: plaintext }),
passwords: [password1, password1] passwords: [password1, password1]
}); });
const decryptedSessionKeys = await openpgp.decryptSessionKeys({ const decryptedSessionKeys = await openpgp.decryptSessionKeys({
@ -1252,7 +1252,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
it('should encrypt then decrypt', async function () { it('should encrypt then decrypt', async function () {
const encOpt = { const encOpt = {
message: await openpgp.Message.fromText(plaintext), message: await openpgp.createMessage({ text: plaintext }),
publicKeys: publicKey publicKeys: publicKey
}; };
const decOpt = { const decOpt = {
@ -1274,7 +1274,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
await privKeyDE.decrypt(passphrase); await privKeyDE.decrypt(passphrase);
const encOpt = { const encOpt = {
message: await openpgp.Message.fromText(plaintext), message: await openpgp.createMessage({ text: plaintext }),
publicKeys: publicKey publicKeys: publicKey
}; };
const decOpt = { const decOpt = {
@ -1293,7 +1293,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
it('should encrypt then decrypt with wildcard', async function () { it('should encrypt then decrypt with wildcard', async function () {
const encOpt = { const encOpt = {
message: await openpgp.Message.fromText(plaintext), message: await openpgp.createMessage({ text: plaintext }),
publicKeys: publicKey, publicKeys: publicKey,
wildcard: true wildcard: true
}; };
@ -1316,7 +1316,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
await privKeyDE.decrypt(passphrase); await privKeyDE.decrypt(passphrase);
const encOpt = { const encOpt = {
message: await openpgp.Message.fromText(plaintext), message: await openpgp.createMessage({ text: plaintext }),
publicKeys: publicKey, publicKeys: publicKey,
wildcard: true wildcard: true
}; };
@ -1339,7 +1339,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
publicKeys: publicKey publicKeys: publicKey
}); });
const encrypted = await openpgp.encrypt({ const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromText(plaintext), message: await openpgp.createMessage({ text: plaintext }),
sessionKey sessionKey
}); });
expect(encrypted).to.match(/^-----BEGIN PGP MESSAGE/); expect(encrypted).to.match(/^-----BEGIN PGP MESSAGE/);
@ -1358,7 +1358,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
algorithm: 'aes256' algorithm: 'aes256'
}; };
const encOpt = { const encOpt = {
message: await openpgp.Message.fromText(plaintext), message: await openpgp.createMessage({ text: plaintext }),
sessionKey: sessionKey, sessionKey: sessionKey,
publicKeys: publicKey publicKeys: publicKey
}; };
@ -1381,7 +1381,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
algorithm: 'aes128' algorithm: 'aes128'
}; };
const encOpt = { const encOpt = {
message: await openpgp.Message.fromText(plaintext), message: await openpgp.createMessage({ text: plaintext }),
sessionKey: sessionKey, sessionKey: sessionKey,
publicKeys: publicKey publicKeys: publicKey
}; };
@ -1400,7 +1400,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
it('should encrypt/sign and decrypt/verify', async function () { it('should encrypt/sign and decrypt/verify', async function () {
const encOpt = { const encOpt = {
message: await openpgp.Message.fromText(plaintext), message: await openpgp.createMessage({ text: plaintext }),
publicKeys: publicKey, publicKeys: publicKey,
privateKeys: privateKey privateKeys: privateKey
}; };
@ -1423,7 +1423,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
it('should encrypt/sign and decrypt/verify (no AEAD support)', async function () { it('should encrypt/sign and decrypt/verify (no AEAD support)', async function () {
const encOpt = { const encOpt = {
message: await openpgp.Message.fromText(plaintext), message: await openpgp.createMessage({ text: plaintext }),
publicKeys: publicKeyNoAEAD, publicKeys: publicKeyNoAEAD,
privateKeys: privateKey privateKeys: privateKey
}; };
@ -1454,7 +1454,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
const newPrivateKey = await openpgp.readKey({ armoredKey: newKey.privateKeyArmored }); const newPrivateKey = await openpgp.readKey({ armoredKey: newKey.privateKeyArmored });
const encOpt = { const encOpt = {
message: await openpgp.Message.fromText(plaintext), message: await openpgp.createMessage({ text: plaintext }),
publicKeys: newPublicKey, publicKeys: newPublicKey,
privateKeys: newPrivateKey privateKeys: newPrivateKey
}; };
@ -1484,11 +1484,11 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
const newPrivateKey = await openpgp.readKey({ armoredKey: newKey.privateKeyArmored }); const newPrivateKey = await openpgp.readKey({ armoredKey: newKey.privateKeyArmored });
const encrypted = await openpgp.encrypt({ const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromText(plaintext), message: await openpgp.createMessage({ text: plaintext }),
publicKeys: newPublicKey publicKeys: newPublicKey
}); });
const signed = await openpgp.sign({ const signed = await openpgp.sign({
message: await openpgp.Message.fromText(plaintext), message: await openpgp.createMessage({ text: plaintext }),
privateKeys: newPrivateKey, privateKeys: newPrivateKey,
detached: true detached: true
}); });
@ -1509,7 +1509,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
it('should encrypt/sign and decrypt/verify with null string input', async function () { it('should encrypt/sign and decrypt/verify with null string input', async function () {
const encOpt = { const encOpt = {
message: await openpgp.Message.fromText(''), message: await openpgp.createMessage({ text: '' }),
publicKeys: publicKey, publicKeys: publicKey,
privateKeys: privateKey privateKeys: privateKey
}; };
@ -1531,11 +1531,11 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
it('should encrypt/sign and decrypt/verify with detached signatures', async function () { it('should encrypt/sign and decrypt/verify with detached signatures', async function () {
const encrypted = await openpgp.encrypt({ const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromText(plaintext), message: await openpgp.createMessage({ text: plaintext }),
publicKeys: publicKey publicKeys: publicKey
}); });
const signed = await openpgp.sign({ const signed = await openpgp.sign({
message: await openpgp.Message.fromText(plaintext), message: await openpgp.createMessage({ text: plaintext }),
privateKeys: privateKey, privateKeys: privateKey,
detached: true detached: true
}); });
@ -1565,13 +1565,13 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
const pubKeyDE = await openpgp.readKey({ armoredKey: pub_key_de }); const pubKeyDE = await openpgp.readKey({ armoredKey: pub_key_de });
const signOpt = { const signOpt = {
message: await openpgp.Message.fromText(plaintext), message: await openpgp.createMessage({ text: plaintext }),
privateKeys: privKeyDE, privateKeys: privKeyDE,
detached: true detached: true
}; };
const encOpt = { const encOpt = {
message: await openpgp.Message.fromText(plaintext), message: await openpgp.createMessage({ text: plaintext }),
publicKeys: publicKey, publicKeys: publicKey,
privateKeys: privateKey privateKeys: privateKey
}; };
@ -1606,13 +1606,13 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
it('should fail to encrypt and decrypt/verify with detached signature as input for encryption with wrong public key', async function () { it('should fail to encrypt and decrypt/verify with detached signature as input for encryption with wrong public key', async function () {
const signOpt = { const signOpt = {
message: await openpgp.Message.fromText(plaintext), message: await openpgp.createMessage({ text: plaintext }),
privateKeys: privateKey, privateKeys: privateKey,
detached: true detached: true
}; };
const encOpt = { const encOpt = {
message: await openpgp.Message.fromText(plaintext), message: await openpgp.createMessage({ text: plaintext }),
publicKeys: publicKey publicKeys: publicKey
}; };
@ -1639,7 +1639,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
it('should fail to verify decrypted data with wrong public pgp key', async function () { it('should fail to verify decrypted data with wrong public pgp key', async function () {
const encOpt = { const encOpt = {
message: await openpgp.Message.fromText(plaintext), message: await openpgp.createMessage({ text: plaintext }),
publicKeys: publicKey, publicKeys: publicKey,
privateKeys: privateKey privateKeys: privateKey
}; };
@ -1662,7 +1662,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
it('should fail to verify decrypted null string with wrong public pgp key', async function () { it('should fail to verify decrypted null string with wrong public pgp key', async function () {
const encOpt = { const encOpt = {
message: await openpgp.Message.fromText(''), message: await openpgp.createMessage({ text: '' }),
publicKeys: publicKey, publicKeys: publicKey,
privateKeys: privateKey privateKeys: privateKey
}; };
@ -1685,7 +1685,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
it('should successfully decrypt signed message without public keys to verify', async function () { it('should successfully decrypt signed message without public keys to verify', async function () {
const encOpt = { const encOpt = {
message: await openpgp.Message.fromText(plaintext), message: await openpgp.createMessage({ text: plaintext }),
publicKeys: publicKey, publicKeys: publicKey,
privateKeys: privateKey privateKeys: privateKey
}; };
@ -1707,11 +1707,11 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
it('should fail to verify decrypted data with wrong public pgp key with detached signatures', async function () { it('should fail to verify decrypted data with wrong public pgp key with detached signatures', async function () {
const encrypted = await openpgp.encrypt({ const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromText(plaintext), message: await openpgp.createMessage({ text: plaintext }),
publicKeys: publicKey publicKeys: publicKey
}); });
const signed = await openpgp.sign({ const signed = await openpgp.sign({
message: await openpgp.Message.fromText(plaintext), message: await openpgp.createMessage({ text: plaintext }),
privateKeys: privateKey, privateKeys: privateKey,
detached: true detached: true
}); });
@ -1740,7 +1740,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
const pubKeyDE = await openpgp.readKey({ armoredKey: pub_key_de }); const pubKeyDE = await openpgp.readKey({ armoredKey: pub_key_de });
const encOpt = { const encOpt = {
message: await openpgp.Message.fromText(plaintext), message: await openpgp.createMessage({ text: plaintext }),
publicKeys: publicKey, publicKeys: publicKey,
privateKeys: [privateKey, privKeyDE] privateKeys: [privateKey, privKeyDE]
}; };
@ -1773,7 +1773,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
it('should fail to decrypt modified message', async function() { it('should fail to decrypt modified message', async function() {
const { privateKeyArmored } = await openpgp.generateKey({ curve: 'curve25519', userIDs: [{ email: 'test@email.com' }] }); const { privateKeyArmored } = await openpgp.generateKey({ curve: 'curve25519', userIDs: [{ email: 'test@email.com' }] });
const key = await openpgp.readKey({ armoredKey: privateKeyArmored }); const key = await openpgp.readKey({ armoredKey: privateKeyArmored });
const data = await openpgp.encrypt({ message: await openpgp.Message.fromBinary(new Uint8Array(500)), publicKeys: [key.toPublic()] }); const data = await openpgp.encrypt({ message: await openpgp.createMessage({ binary: new Uint8Array(500) }), publicKeys: [key.toPublic()] });
let badSumEncrypted = data.replace(/\n=[a-zA-Z0-9/+]{4}/, '\n=aaaa'); let badSumEncrypted = data.replace(/\n=[a-zA-Z0-9/+]{4}/, '\n=aaaa');
if (badSumEncrypted === data) { // checksum was already =aaaa if (badSumEncrypted === data) { // checksum was already =aaaa
badSumEncrypted = data.replace(/\n=[a-zA-Z0-9/+]{4}/, '\n=bbbb'); badSumEncrypted = data.replace(/\n=[a-zA-Z0-9/+]{4}/, '\n=bbbb');
@ -1826,7 +1826,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
it('should fail to decrypt unarmored message with garbage data appended', async function() { it('should fail to decrypt unarmored message with garbage data appended', async function() {
const { key } = await openpgp.generateKey({ userIDs: {} }); const { key } = await openpgp.generateKey({ userIDs: {} });
const message = await openpgp.encrypt({ message: await openpgp.Message.fromText('test'), publicKeys: key, privateKeys: key, armor: false }); const message = await openpgp.encrypt({ message: await openpgp.createMessage({ text: 'test' }), publicKeys: key, privateKeys: key, armor: false });
const encrypted = util.concat([message, new Uint8Array([11])]); const encrypted = util.concat([message, new Uint8Array([11])]);
await expect((async () => { await expect((async () => {
await openpgp.decrypt({ message: await openpgp.readMessage({ binaryMessage: encrypted }), privateKeys: key, publicKeys: key }); await openpgp.decrypt({ message: await openpgp.readMessage({ binaryMessage: encrypted }), privateKeys: key, publicKeys: key });
@ -1848,7 +1848,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
await openpgp.encrypt({ await openpgp.encrypt({
publicKeys: pubKeyDE, publicKeys: pubKeyDE,
privateKeys: privKeyDE, privateKeys: privKeyDE,
message: await openpgp.Message.fromText(plaintext) message: await openpgp.createMessage({ text: plaintext })
}).then(async function (encrypted) { }).then(async function (encrypted) {
return openpgp.decrypt({ return openpgp.decrypt({
privateKeys: privKeyDE, privateKeys: privKeyDE,
@ -1939,7 +1939,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
it('should encrypt and decrypt with one password', async function () { it('should encrypt and decrypt with one password', async function () {
const encOpt = { const encOpt = {
message: await openpgp.Message.fromText(plaintext), message: await openpgp.createMessage({ text: plaintext }),
passwords: password1 passwords: password1
}; };
const decOpt = { const decOpt = {
@ -1956,7 +1956,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
it('should encrypt and decrypt with two passwords', async function () { it('should encrypt and decrypt with two passwords', async function () {
const encOpt = { const encOpt = {
message: await openpgp.Message.fromText(plaintext), message: await openpgp.createMessage({ text: plaintext }),
passwords: [password1, password2] passwords: [password1, password2]
}; };
const decOpt = { const decOpt = {
@ -1973,7 +1973,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
it('should encrypt and decrypt with password and not ascii armor', async function () { it('should encrypt and decrypt with password and not ascii armor', async function () {
const encOpt = { const encOpt = {
message: await openpgp.Message.fromText(plaintext), message: await openpgp.createMessage({ text: plaintext }),
passwords: password1, passwords: password1,
armor: false armor: false
}; };
@ -1991,7 +1991,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
it('should encrypt and decrypt with binary data', async function () { it('should encrypt and decrypt with binary data', async function () {
const encOpt = { const encOpt = {
message: await openpgp.Message.fromBinary(new Uint8Array([0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01])), message: await openpgp.createMessage({ binary: new Uint8Array([0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01]) }),
passwords: password1, passwords: password1,
armor: false armor: false
}; };
@ -2013,7 +2013,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
withCompression(function (modifyCompressionEncryptOptions, verifyCompressionDecrypted) { withCompression(function (modifyCompressionEncryptOptions, verifyCompressionDecrypted) {
it('should encrypt and decrypt with one password', async function () { it('should encrypt and decrypt with one password', async function () {
const encOpt = modifyCompressionEncryptOptions({ const encOpt = modifyCompressionEncryptOptions({
message: await openpgp.Message.fromText(plaintext), message: await openpgp.createMessage({ text: plaintext }),
passwords: password1 passwords: password1
}); });
const decOpt = { const decOpt = {
@ -2046,7 +2046,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
} }
}); });
const encrypted = await openpgp.encrypt(modifyCompressionEncryptOptions({ const encrypted = await openpgp.encrypt(modifyCompressionEncryptOptions({
message: await openpgp.Message.fromBinary(data), message: await openpgp.createMessage({ binary: data }),
passwords: ['test'] passwords: ['test']
})); }));
expect(openpgp.stream.isStream(encrypted)).to.equal(useNativeStream ? 'web' : 'ponyfill'); expect(openpgp.stream.isStream(encrypted)).to.equal(useNativeStream ? 'web' : 'ponyfill');
@ -2088,7 +2088,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
}); });
it('should sign and verify cleartext message', async function () { it('should sign and verify cleartext message', async function () {
const message = await openpgp.CleartextMessage.fromText(plaintext); const message = await openpgp.createCleartextMessage({ text: plaintext });
const signOpt = { const signOpt = {
message, message,
privateKeys: privateKey privateKeys: privateKey
@ -2117,7 +2117,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
const privKeyDE = await openpgp.readKey({ armoredKey: priv_key_de }); const privKeyDE = await openpgp.readKey({ armoredKey: priv_key_de });
await privKeyDE.decrypt(passphrase); await privKeyDE.decrypt(passphrase);
const message = await openpgp.CleartextMessage.fromText(plaintext); const message = await openpgp.createCleartextMessage({ text: plaintext });
const signOpt = { const signOpt = {
message, message,
privateKeys: [privateKey, privKeyDE] privateKeys: [privateKey, privKeyDE]
@ -2147,7 +2147,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
}); });
it('should sign and verify data with detached signatures', async function () { it('should sign and verify data with detached signatures', async function () {
const message = await openpgp.Message.fromText(plaintext); const message = await openpgp.createMessage({ text: plaintext });
const signOpt = { const signOpt = {
message, message,
privateKeys: privateKey, privateKeys: privateKey,
@ -2170,7 +2170,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
}); });
it('should sign and fail to verify cleartext message with wrong public pgp key', async function () { it('should sign and fail to verify cleartext message with wrong public pgp key', async function () {
const message = await openpgp.CleartextMessage.fromText(plaintext); const message = await openpgp.createCleartextMessage({ text: plaintext });
const signOpt = { const signOpt = {
message, message,
privateKeys: privateKey privateKeys: privateKey
@ -2192,7 +2192,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
}); });
it('should sign and fail to verify data with wrong public pgp key with detached signature', async function () { it('should sign and fail to verify data with wrong public pgp key with detached signature', async function () {
const message = await openpgp.Message.fromText(plaintext); const message = await openpgp.createMessage({ text: plaintext });
const signOpt = { const signOpt = {
message, message,
privateKeys: privateKey, privateKeys: privateKey,
@ -2216,7 +2216,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
}); });
it('should sign and verify data and not armor', async function () { it('should sign and verify data and not armor', async function () {
const message = await openpgp.Message.fromText(plaintext); const message = await openpgp.createMessage({ text: plaintext });
const signOpt = { const signOpt = {
message, message,
privateKeys: privateKey, privateKeys: privateKey,
@ -2239,7 +2239,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
it('should sign and verify data and not armor with detached signatures', async function () { it('should sign and verify data and not armor with detached signatures', async function () {
const start = util.normalizeDate(); const start = util.normalizeDate();
const message = await openpgp.Message.fromText(plaintext); const message = await openpgp.createMessage({ text: plaintext });
const signOpt = { const signOpt = {
message, message,
privateKeys: privateKey, privateKeys: privateKey,
@ -2265,7 +2265,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
}); });
it('should sign and verify data with a date in the past', async function () { it('should sign and verify data with a date in the past', async function () {
const message = await openpgp.Message.fromText(plaintext); const message = await openpgp.createMessage({ text: plaintext });
const past = new Date(2000); const past = new Date(2000);
const signOpt = { const signOpt = {
message, message,
@ -2306,7 +2306,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
const future = new Date(2040, 5, 5, 5, 5, 5, 0); const future = new Date(2040, 5, 5, 5, 5, 5, 0);
const data = new Uint8Array([3, 14, 15, 92, 65, 35, 59]); const data = new Uint8Array([3, 14, 15, 92, 65, 35, 59]);
const signOpt = { const signOpt = {
message: await openpgp.Message.fromBinary(data), message: await openpgp.createMessage({ binary: data }),
privateKeys: privateKey_2038_2045, privateKeys: privateKey_2038_2045,
detached: true, detached: true,
date: future, date: future,
@ -2318,7 +2318,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
format: 'binary' format: 'binary'
}; };
return openpgp.sign(signOpt).then(async function (signed) { return openpgp.sign(signOpt).then(async function (signed) {
verifyOpt.message = await openpgp.Message.fromBinary(data); verifyOpt.message = await openpgp.createMessage({ binary: data });
verifyOpt.signature = await openpgp.readSignature({ binarySignature: signed }); verifyOpt.signature = await openpgp.readSignature({ binarySignature: signed });
return openpgp.verify(verifyOpt); return openpgp.verify(verifyOpt);
}).then(async function (verified) { }).then(async function (verified) {
@ -2334,7 +2334,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
it('should sign and verify binary data without one-pass signature', async function () { it('should sign and verify binary data without one-pass signature', async function () {
const data = new Uint8Array([3, 14, 15, 92, 65, 35, 59]); const data = new Uint8Array([3, 14, 15, 92, 65, 35, 59]);
const signOpt = { const signOpt = {
message: await openpgp.Message.fromBinary(data), message: await openpgp.createMessage({ binary: data }),
privateKeys: privateKey, privateKeys: privateKey,
armor: false armor: false
}; };
@ -2362,7 +2362,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
it('should streaming sign and verify binary data without one-pass signature', async function () { it('should streaming sign and verify binary data without one-pass signature', async function () {
const data = new Uint8Array([3, 14, 15, 92, 65, 35, 59]); const data = new Uint8Array([3, 14, 15, 92, 65, 35, 59]);
const signOpt = { const signOpt = {
message: await openpgp.Message.fromBinary(data), message: await openpgp.createMessage({ binary: data }),
privateKeys: privateKey, privateKeys: privateKey,
armor: false, armor: false,
streaming: 'web' streaming: 'web'
@ -2395,7 +2395,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
it('should encrypt and decrypt data with a date in the future', async function () { it('should encrypt and decrypt data with a date in the future', async function () {
const future = new Date(2040, 5, 5, 5, 5, 5, 0); const future = new Date(2040, 5, 5, 5, 5, 5, 0);
const encryptOpt = { const encryptOpt = {
message: await openpgp.Message.fromText(plaintext, undefined, future), message: await openpgp.createMessage({ text: plaintext, date: future }),
publicKeys: publicKey_2038_2045, publicKeys: publicKey_2038_2045,
date: future, date: future,
armor: false armor: false
@ -2416,7 +2416,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
const past = new Date(2005, 5, 5, 5, 5, 5, 0); const past = new Date(2005, 5, 5, 5, 5, 5, 0);
const data = new Uint8Array([3, 14, 15, 92, 65, 35, 59]); const data = new Uint8Array([3, 14, 15, 92, 65, 35, 59]);
const encryptOpt = { const encryptOpt = {
message: await openpgp.Message.fromBinary(data, undefined, past), message: await openpgp.createMessage({ binary: data, date: past }),
publicKeys: publicKey_2000_2008, publicKeys: publicKey_2000_2008,
date: past, date: past,
armor: false armor: false
@ -2436,7 +2436,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
it('should sign, encrypt and decrypt, verify data with a date in the past', async function () { it('should sign, encrypt and decrypt, verify data with a date in the past', async function () {
const past = new Date(2005, 5, 5, 5, 5, 5, 0); const past = new Date(2005, 5, 5, 5, 5, 5, 0);
const encryptOpt = { const encryptOpt = {
message: await openpgp.Message.fromText(plaintext, undefined, past), message: await openpgp.createMessage({ text: plaintext, date: past }),
publicKeys: publicKey_2000_2008, publicKeys: publicKey_2000_2008,
privateKeys: privateKey_2000_2008, privateKeys: privateKey_2000_2008,
date: past, date: past,
@ -2464,7 +2464,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
const future = new Date(2040, 5, 5, 5, 5, 5, 0); const future = new Date(2040, 5, 5, 5, 5, 5, 0);
const data = new Uint8Array([3, 14, 15, 92, 65, 35, 59]); const data = new Uint8Array([3, 14, 15, 92, 65, 35, 59]);
const encryptOpt = { const encryptOpt = {
message: await openpgp.Message.fromBinary(data, undefined, future), message: await openpgp.createMessage({ binary: data, date: future }),
publicKeys: publicKey_2038_2045, publicKeys: publicKey_2038_2045,
privateKeys: privateKey_2038_2045, privateKeys: privateKey_2038_2045,
date: future, date: future,
@ -2493,7 +2493,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
const future = new Date(2040, 5, 5, 5, 5, 5, 0); const future = new Date(2040, 5, 5, 5, 5, 5, 0);
const data = new Uint8Array([3, 14, 15, 92, 65, 35, 59]); const data = new Uint8Array([3, 14, 15, 92, 65, 35, 59]);
const encryptOpt = { const encryptOpt = {
message: await openpgp.Message.fromBinary(data, undefined, future, 'mime'), message: await openpgp.createMessage({ binary: data, date: future, format: 'mime' }),
publicKeys: publicKey_2038_2045, publicKeys: publicKey_2038_2045,
privateKeys: privateKey_2038_2045, privateKeys: privateKey_2038_2045,
date: future, date: future,
@ -2523,7 +2523,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
key: privateKey key: privateKey
}).then(async function(revKey) { }).then(async function(revKey) {
return openpgp.encrypt({ return openpgp.encrypt({
message: await openpgp.Message.fromText(plaintext), message: await openpgp.createMessage({ text: plaintext }),
publicKeys: revKey.publicKey publicKeys: revKey.publicKey
}).then(function() { }).then(function() {
throw new Error('Should not encrypt with revoked key'); throw new Error('Should not encrypt with revoked key');
@ -2540,7 +2540,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
return privKeyDE.subKeys[0].revoke(privKeyDE.primaryKey).then(async function(revSubKey) { return privKeyDE.subKeys[0].revoke(privKeyDE.primaryKey).then(async function(revSubKey) {
pubKeyDE.subKeys[0] = revSubKey; pubKeyDE.subKeys[0] = revSubKey;
return openpgp.encrypt({ return openpgp.encrypt({
message: await openpgp.Message.fromText(plaintext), message: await openpgp.createMessage({ text: plaintext }),
publicKeys: pubKeyDE, publicKeys: pubKeyDE,
config: { rejectPublicKeyAlgorithms: new Set() } config: { rejectPublicKeyAlgorithms: new Set() }
}).then(function() { }).then(function() {
@ -2556,7 +2556,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
const privKeyDE = await openpgp.readKey({ armoredKey: priv_key_de }); const privKeyDE = await openpgp.readKey({ armoredKey: priv_key_de });
await privKeyDE.decrypt(passphrase); await privKeyDE.decrypt(passphrase);
const encrypted = await openpgp.encrypt({ const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromText(plaintext), message: await openpgp.createMessage({ text: plaintext }),
publicKeys: pubKeyDE, publicKeys: pubKeyDE,
config: { rejectPublicKeyAlgorithms: new Set() } config: { rejectPublicKeyAlgorithms: new Set() }
}); });
@ -2578,7 +2578,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
// validation will not check the decryption subkey and will succeed // validation will not check the decryption subkey and will succeed
await privKeyDE.decrypt(passphrase); await privKeyDE.decrypt(passphrase);
const encrypted = await openpgp.encrypt({ const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromText(plaintext), message: await openpgp.createMessage({ text: plaintext }),
publicKeys: pubKeyDE, publicKeys: pubKeyDE,
config: { rejectPublicKeyAlgorithms: new Set() } config: { rejectPublicKeyAlgorithms: new Set() }
}); });
@ -2690,7 +2690,7 @@ amnR6g==
}); });
it('should normalize newlines in encrypted text message', async function() { it('should normalize newlines in encrypted text message', async function() {
const message = await openpgp.Message.fromText('"BEGIN:VCALENDAR\nVERSION:2.0\nBEGIN:VEVENT\r\nUID:123\r\nDTSTART:20191211T121212Z\r\nDTEND:20191212T121212Z\r\nEND:VEVENT\nEND:VCALENDAR"'); const message = await openpgp.createMessage({ text: '"BEGIN:VCALENDAR\nVERSION:2.0\nBEGIN:VEVENT\r\nUID:123\r\nDTSTART:20191211T121212Z\r\nDTEND:20191212T121212Z\r\nEND:VEVENT\nEND:VCALENDAR"' });
const encrypted = await openpgp.encrypt({ const encrypted = await openpgp.encrypt({
passwords: 'test', passwords: 'test',
message message
@ -2710,7 +2710,7 @@ amnR6g==
it(`sign/verify with ${curve}`, async function() { it(`sign/verify with ${curve}`, async function() {
const plaintext = 'short message'; const plaintext = 'short message';
const key = (await openpgp.generateKey({ curve, userIDs: { name: 'Alice', email: 'info@alice.com' } })).key; const key = (await openpgp.generateKey({ curve, userIDs: { name: 'Alice', email: 'info@alice.com' } })).key;
const signed = await openpgp.sign({ privateKeys:[key], message: await openpgp.CleartextMessage.fromText(plaintext) }); const signed = await openpgp.sign({ privateKeys:[key], message: await openpgp.createCleartextMessage({ text: plaintext }) });
const verified = await openpgp.verify({ publicKeys:[key], message: await openpgp.readCleartextMessage({ cleartextMessage: signed }) }); const verified = await openpgp.verify({ publicKeys:[key], message: await openpgp.readCleartextMessage({ cleartextMessage: signed }) });
expect(verified.signatures[0].valid).to.be.true; expect(verified.signatures[0].valid).to.be.true;
}); });
@ -2825,7 +2825,7 @@ bsZgJWVlAa5eil6J9ePX2xbo1vVAkLQdzE9+1jL+l7PRIZuVBQ==
it('Error message should contain the original error message', async function() { it('Error message should contain the original error message', async function() {
return openpgp.encrypt({ return openpgp.encrypt({
message: await openpgp.Message.fromBinary(new Uint8Array([0x01, 0x01, 0x01])), message: await openpgp.createMessage({ binary: new Uint8Array([0x01, 0x01, 0x01]) }),
passwords: null passwords: null
}).then(function() { }).then(function() {
throw new Error('Error expected.'); throw new Error('Error expected.');
@ -2858,7 +2858,7 @@ bsZgJWVlAa5eil6J9ePX2xbo1vVAkLQdzE9+1jL+l7PRIZuVBQ==
for (let i = 0; i < encryptionKeyIDs.length; i++) { for (let i = 0; i < encryptionKeyIDs.length; i++) {
m = await openpgp.readMessage({ m = await openpgp.readMessage({
armoredMessage: await openpgp.encrypt({ armoredMessage: await openpgp.encrypt({
message: await openpgp.Message.fromText("Hello World\n"), message: await openpgp.createMessage({ text: "Hello World\n" }),
publicKeys: primaryKey, publicKeys: primaryKey,
encryptionKeyIDs: [encryptionKeyIDs[i]] encryptionKeyIDs: [encryptionKeyIDs[i]]
}) })
@ -2876,7 +2876,7 @@ bsZgJWVlAa5eil6J9ePX2xbo1vVAkLQdzE9+1jL+l7PRIZuVBQ==
for (let i = 0; i < signingKeyIDs.length; i++) { for (let i = 0; i < signingKeyIDs.length; i++) {
s = await openpgp.readSignature({ s = await openpgp.readSignature({
armoredSignature: await openpgp.sign({ armoredSignature: await openpgp.sign({
message: await openpgp.Message.fromText("Hello World\n"), message: await openpgp.createMessage({ text: "Hello World\n" }),
privateKeys: primaryKey, privateKeys: primaryKey,
signingKeyIDs: [signingKeyIDs[i]], signingKeyIDs: [signingKeyIDs[i]],
detached: true detached: true
@ -2890,7 +2890,7 @@ bsZgJWVlAa5eil6J9ePX2xbo1vVAkLQdzE9+1jL+l7PRIZuVBQ==
it('Encrypt and sign with specific encryption/signing key ids', async function () { it('Encrypt and sign with specific encryption/signing key ids', async function () {
const primaryKey = await getPrimaryKey(); const primaryKey = await getPrimaryKey();
const plaintextMessage = await openpgp.Message.fromText("Hello World\n"); const plaintextMessage = await openpgp.createMessage({ text: "Hello World\n" });
const checkEncryptedPackets = (encryptionKeyIDs, pKESKList) => { const checkEncryptedPackets = (encryptionKeyIDs, pKESKList) => {
pKESKList.forEach(({ publicKeyID }, i) => { pKESKList.forEach(({ publicKeyID }, i) => {

38
test/general/signature.js
View File

@ -882,7 +882,7 @@ hUhMKMuiM3pRwdIyDOItkUWQmjEEw7/XmhgInkXsCw==
expect(msg.signatures[0].valid).to.be.true; expect(msg.signatures[0].valid).to.be.true;
expect(msg.signatures[0].signature.packets.length).to.equal(1); expect(msg.signatures[0].signature.packets.length).to.equal(1);
await expect(openpgp.sign({ await expect(openpgp.sign({
message: await openpgp.Message.fromText('test'), privateKeys: [priv_key_gnupg_ext], config: { rejectPublicKeyAlgorithms: new Set() } message: await openpgp.createMessage({ text: 'test' }), privateKeys: [priv_key_gnupg_ext], config: { rejectPublicKeyAlgorithms: new Set() }
})).to.eventually.be.rejectedWith(/Cannot sign with a gnu-dummy key/); })).to.eventually.be.rejectedWith(/Cannot sign with a gnu-dummy key/);
await expect(openpgp.reformatKey({ userIDs: { name: 'test' }, privateKey: priv_key_gnupg_ext })).to.eventually.be.rejectedWith(/Cannot reformat a gnu-dummy primary key/); await expect(openpgp.reformatKey({ userIDs: { name: 'test' }, privateKey: priv_key_gnupg_ext })).to.eventually.be.rejectedWith(/Cannot reformat a gnu-dummy primary key/);
await expect(openpgp.reformatKey({ userIDs: { name: 'test' }, privateKey: priv_key_gnupg_ext_2, passphrase: 'test' })).to.eventually.be.rejectedWith(/Cannot reformat a gnu-dummy primary key/); await expect(openpgp.reformatKey({ userIDs: { name: 'test' }, privateKey: priv_key_gnupg_ext_2, passphrase: 'test' })).to.eventually.be.rejectedWith(/Cannot reformat a gnu-dummy primary key/);
@ -898,7 +898,7 @@ hUhMKMuiM3pRwdIyDOItkUWQmjEEw7/XmhgInkXsCw==
it('Supports signing with GnuPG stripped-key extension', async function() { it('Supports signing with GnuPG stripped-key extension', async function() {
const priv_key_gnupg_ext = await openpgp.readKey({ armoredKey: flowcrypt_stripped_key }); const priv_key_gnupg_ext = await openpgp.readKey({ armoredKey: flowcrypt_stripped_key });
await priv_key_gnupg_ext.decrypt('FlowCrypt'); await priv_key_gnupg_ext.decrypt('FlowCrypt');
const sig = await openpgp.sign({ message: await openpgp.Message.fromText('test'), privateKeys: [priv_key_gnupg_ext], date: new Date('2018-12-17T03:24:00') }); const sig = await openpgp.sign({ message: await openpgp.createMessage({ text: 'test' }), privateKeys: [priv_key_gnupg_ext], date: new Date('2018-12-17T03:24:00') });
expect(sig).to.match(/-----END PGP MESSAGE-----\n$/); expect(sig).to.match(/-----END PGP MESSAGE-----\n$/);
}); });
@ -1083,7 +1083,7 @@ hUhMKMuiM3pRwdIyDOItkUWQmjEEw7/XmhgInkXsCw==
it('Verify latin-1 signed message', async function() { it('Verify latin-1 signed message', async function() {
const latin1Binary = util.hexToUint8Array('48e46c6cf62057e86c74'); const latin1Binary = util.hexToUint8Array('48e46c6cf62057e86c74');
const message = await openpgp.Message.fromBinary(latin1Binary); const message = await openpgp.createMessage({ binary: latin1Binary });
message.appendSignature(`-----BEGIN PGP SIGNATURE----- message.appendSignature(`-----BEGIN PGP SIGNATURE-----
@ -1212,10 +1212,10 @@ yYDnCgA=
async read() { async read() {
while (true) { while (true) {
await new Promise(setTimeout); await new Promise(setTimeout);
if (!msg_armor.length) { if (!armoredMessage.length) {
return this.push(null); return this.push(null);
} }
if (!this.push(msg_armor.shift())) { if (!this.push(armoredMessage.shift())) {
break; break;
} }
} }
@ -1322,7 +1322,7 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
await privKey.decrypt('hello world'); await privKey.decrypt('hello world');
const config = { minRSABits: 1024 }; const config = { minRSABits: 1024 };
return openpgp.sign({ privateKeys:[privKey], message: await openpgp.CleartextMessage.fromText(plaintext), config }).then(async function(signed) { return openpgp.sign({ privateKeys:[privKey], message: await openpgp.createCleartextMessage({ text: plaintext }), config }).then(async function(signed) {
const message = await openpgp.readCleartextMessage({ cleartextMessage: signed }); const message = await openpgp.readCleartextMessage({ cleartextMessage: signed });
return openpgp.verify({ publicKeys:[pubKey], message, config }); return openpgp.verify({ publicKeys:[pubKey], message, config });
@ -1342,7 +1342,7 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
await privKey.decrypt('hello world'); await privKey.decrypt('hello world');
const config = { minRSABits: 1024 }; const config = { minRSABits: 1024 };
return openpgp.sign({ privateKeys:[privKey], message: await openpgp.CleartextMessage.fromText(plaintext), config }).then(async function(signed) { return openpgp.sign({ privateKeys:[privKey], message: await openpgp.createCleartextMessage({ text: plaintext }), config }).then(async function(signed) {
const message = await openpgp.readCleartextMessage({ cleartextMessage: signed }); const message = await openpgp.readCleartextMessage({ cleartextMessage: signed });
return openpgp.verify({ publicKeys:[pubKey], message, config }); return openpgp.verify({ publicKeys:[pubKey], message, config });
@ -1362,7 +1362,7 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
await privKey.decrypt('hello world'); await privKey.decrypt('hello world');
const config = { minRSABits: 1024 }; const config = { minRSABits: 1024 };
return openpgp.sign({ privateKeys:[privKey], message: await openpgp.CleartextMessage.fromText(plaintext), config }).then(async function(signed) { return openpgp.sign({ privateKeys:[privKey], message: await openpgp.createCleartextMessage({ text: plaintext }), config }).then(async function(signed) {
const message = await openpgp.readCleartextMessage({ cleartextMessage: signed }); const message = await openpgp.readCleartextMessage({ cleartextMessage: signed });
return openpgp.verify({ publicKeys:[pubKey], message, config }); return openpgp.verify({ publicKeys:[pubKey], message, config });
@ -1382,7 +1382,7 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
await privKey.decrypt('hello world'); await privKey.decrypt('hello world');
const config = { minRSABits: 1024 }; const config = { minRSABits: 1024 };
return openpgp.sign({ privateKeys:[privKey], message: await openpgp.Message.fromBinary(plaintext), config }).then(async function(signed) { return openpgp.sign({ privateKeys:[privKey], message: await openpgp.createMessage({ binary: plaintext }), config }).then(async function(signed) {
const message = await openpgp.readMessage({ armoredMessage: signed }); const message = await openpgp.readMessage({ armoredMessage: signed });
return openpgp.verify({ publicKeys:[pubKey], message, format: 'binary', config }); return openpgp.verify({ publicKeys:[pubKey], message, format: 'binary', config });
@ -1402,7 +1402,7 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
await privKey.decrypt('hello world'); await privKey.decrypt('hello world');
const config = { minRSABits: 1024 }; const config = { minRSABits: 1024 };
return openpgp.sign({ privateKeys:[privKey], message: await openpgp.Message.fromBinary(plaintext), armor:false, config }).then(async function(signed) { return openpgp.sign({ privateKeys:[privKey], message: await openpgp.createMessage({ binary: plaintext }), armor:false, config }).then(async function(signed) {
const message = await openpgp.readMessage({ binaryMessage: signed }); const message = await openpgp.readMessage({ binaryMessage: signed });
return openpgp.verify({ publicKeys:[pubKey], message, format: 'binary', config }); return openpgp.verify({ publicKeys:[pubKey], message, format: 'binary', config });
@ -1422,9 +1422,9 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
await privKey.decrypt('hello world'); await privKey.decrypt('hello world');
const config = { minRSABits: 1024 }; const config = { minRSABits: 1024 };
return openpgp.sign({ privateKeys:[privKey], message: await openpgp.Message.fromText(plaintext), detached: true, config }).then(async function(armoredSignature) { return openpgp.sign({ privateKeys:[privKey], message: await openpgp.createMessage({ text: plaintext }), detached: true, config }).then(async function(armoredSignature) {
const signature = await openpgp.readSignature({ armoredSignature }); const signature = await openpgp.readSignature({ armoredSignature });
return openpgp.verify({ publicKeys:[pubKey], message: await openpgp.Message.fromBinary(util.encodeUTF8(plaintext)), signature, config }); return openpgp.verify({ publicKeys:[pubKey], message: await openpgp.createMessage({ binary: util.encodeUTF8(plaintext) }), signature, config });
}).then(function({ data, signatures }) { }).then(function({ data, signatures }) {
expect(data).to.equal(plaintext); expect(data).to.equal(plaintext);
expect(signatures).to.have.length(1); expect(signatures).to.have.length(1);
@ -1441,9 +1441,9 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
await privKey.decrypt('hello world'); await privKey.decrypt('hello world');
const config = { minRSABits: 1024 }; const config = { minRSABits: 1024 };
return openpgp.sign({ privateKeys:[privKey], message:await openpgp.Message.fromBinary(binaryPlaintext), detached: true, config }).then(async function(armoredSignature) { return openpgp.sign({ privateKeys:[privKey], message:await openpgp.createMessage({ binary: binaryPlaintext }), detached: true, config }).then(async function(armoredSignature) {
const signature = await openpgp.readSignature({ armoredSignature }); const signature = await openpgp.readSignature({ armoredSignature });
return openpgp.verify({ publicKeys:[pubKey], message: await openpgp.Message.fromText(plaintext), signature, config }); return openpgp.verify({ publicKeys:[pubKey], message: await openpgp.createMessage({ text: plaintext }), signature, config });
}).then(function({ data, signatures }) { }).then(function({ data, signatures }) {
expect(data).to.equal(plaintext); expect(data).to.equal(plaintext);
expect(signatures).to.have.length(1); expect(signatures).to.have.length(1);
@ -1459,9 +1459,9 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
await privKey.decrypt('hello world'); await privKey.decrypt('hello world');
const config = { minRSABits: 1024 }; const config = { minRSABits: 1024 };
return openpgp.sign({ privateKeys:[privKey], message: await openpgp.Message.fromText(plaintext), detached: true, config }).then(async function(armoredSignature) { return openpgp.sign({ privateKeys:[privKey], message: await openpgp.createMessage({ text: plaintext }), detached: true, config }).then(async function(armoredSignature) {
const signature = await openpgp.readSignature({ armoredSignature }); const signature = await openpgp.readSignature({ armoredSignature });
return openpgp.encrypt({ message: await openpgp.Message.fromBinary(util.encodeUTF8(plaintext)), publicKeys: [pubKey], signature, config }); return openpgp.encrypt({ message: await openpgp.createMessage({ binary: util.encodeUTF8(plaintext) }), publicKeys: [pubKey], signature, config });
}).then(async armoredMessage => { }).then(async armoredMessage => {
const message = await openpgp.readMessage({ armoredMessage }); const message = await openpgp.readMessage({ armoredMessage });
@ -1578,7 +1578,7 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
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 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.readKey({ armoredKey: publicKeyArmored }); const publicKey = await openpgp.readKey({ armoredKey: publicKeyArmored });
const message = await openpgp.Message.fromText(content); const message = await openpgp.createMessage({ text: content });
await message.appendSignature(detachedSig); await message.appendSignature(detachedSig);
const { data, signatures } = await openpgp.verify({ publicKeys:[publicKey], message, config: { minRSABits: 1024 } }); const { data, signatures } = await openpgp.verify({ publicKeys:[publicKey], message, config: { minRSABits: 1024 } });
expect(data).to.equal(content); expect(data).to.equal(content);
@ -1589,7 +1589,7 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
}); });
it('Detached signature signing and verification', async function() { it('Detached signature signing and verification', async function() {
const message = await openpgp.Message.fromText('hello'); const message = await openpgp.createMessage({ text: 'hello' });
const pubKey2 = await openpgp.readKey({ armoredKey: pub_key_arm2 }); const pubKey2 = await openpgp.readKey({ armoredKey: pub_key_arm2 });
const privKey2 = await openpgp.readKey({ armoredKey: priv_key_arm2 }); const privKey2 = await openpgp.readKey({ armoredKey: priv_key_arm2 });
await privKey2.decrypt('hello world'); await privKey2.decrypt('hello world');
@ -1608,7 +1608,7 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
const opt = { userIDs: { name:'test', email:'a@b.com' }, passphrase: null }; const opt = { userIDs: { name:'test', email:'a@b.com' }, passphrase: null };
return openpgp.generateKey(opt).then(async function(gen) { return openpgp.generateKey(opt).then(async function(gen) {
const key = gen.key; const key = gen.key;
const message = await openpgp.Message.fromText('hello world'); const message = await openpgp.createMessage({ text: 'hello world' });
return message.sign([key]); return message.sign([key]);
}); });
}); });

66
test/general/streaming.js
View File

@ -196,7 +196,7 @@ function tests() {
} }
}); });
const encrypted = await openpgp.encrypt({ const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromBinary(data), message: await openpgp.createMessage({ binary: data }),
passwords: ['test'] passwords: ['test']
}); });
const msgAsciiArmored = await openpgp.stream.readToEnd(encrypted); const msgAsciiArmored = await openpgp.stream.readToEnd(encrypted);
@ -210,7 +210,7 @@ function tests() {
it('Encrypt larger message', async function() { it('Encrypt larger message', async function() {
const encrypted = await openpgp.encrypt({ const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromBinary(data), message: await openpgp.createMessage({ binary: data }),
passwords: ['test'] passwords: ['test']
}); });
const reader = openpgp.stream.getReader(encrypted); const reader = openpgp.stream.getReader(encrypted);
@ -229,7 +229,7 @@ function tests() {
it('Input stream should be canceled when canceling encrypted stream', async function() { it('Input stream should be canceled when canceling encrypted stream', async function() {
const encrypted = await openpgp.encrypt({ const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromBinary(data), message: await openpgp.createMessage({ binary: data }),
passwords: ['test'] passwords: ['test']
}); });
const reader = openpgp.stream.getReader(encrypted); const reader = openpgp.stream.getReader(encrypted);
@ -242,7 +242,7 @@ function tests() {
it('Sign: Input stream should be canceled when canceling encrypted stream', async function() { it('Sign: Input stream should be canceled when canceling encrypted stream', async function() {
const signed = await openpgp.sign({ const signed = await openpgp.sign({
message: await openpgp.Message.fromBinary(data), message: await openpgp.createMessage({ binary: data }),
privateKeys: privKey, privateKeys: privKey,
config: { minRSABits: 1024 } config: { minRSABits: 1024 }
}); });
@ -258,7 +258,7 @@ function tests() {
const aeadProtectValue = openpgp.config.aeadProtect; const aeadProtectValue = openpgp.config.aeadProtect;
openpgp.config.aeadProtect = false; openpgp.config.aeadProtect = false;
const encrypted = await openpgp.encrypt({ const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromBinary(data), message: await openpgp.createMessage({ binary: data }),
passwords: ['test'], passwords: ['test'],
armor: false armor: false
}); });
@ -286,7 +286,7 @@ function tests() {
openpgp.config.allowUnauthenticatedStream = true; openpgp.config.allowUnauthenticatedStream = true;
try { try {
const encrypted = await openpgp.encrypt({ const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromBinary(data), message: await openpgp.createMessage({ binary: data }),
passwords: ['test'], passwords: ['test'],
armor: false armor: false
}); });
@ -316,7 +316,7 @@ function tests() {
openpgp.config.allowUnauthenticatedStream = true; openpgp.config.allowUnauthenticatedStream = true;
try { try {
const encrypted = await openpgp.encrypt({ const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromBinary(data), message: await openpgp.createMessage({ binary: data }),
publicKeys: pubKey, publicKeys: pubKey,
privateKeys: privKey, privateKeys: privKey,
armor: false, armor: false,
@ -349,7 +349,7 @@ function tests() {
await priv.decrypt(xPass); await priv.decrypt(xPass);
try { try {
const encrypted = await openpgp.encrypt({ const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromBinary(data), message: await openpgp.createMessage({ binary: data }),
publicKeys: pub, publicKeys: pub,
privateKeys: priv, privateKeys: priv,
armor: false armor: false
@ -381,7 +381,7 @@ function tests() {
await priv.decrypt(brainpoolPass); await priv.decrypt(brainpoolPass);
try { try {
const encrypted = await openpgp.encrypt({ const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromBinary(data), message: await openpgp.createMessage({ binary: data }),
publicKeys: pub, publicKeys: pub,
privateKeys: priv, privateKeys: priv,
armor: false armor: false
@ -412,7 +412,7 @@ function tests() {
openpgp.config.allowUnauthenticatedStream = true; openpgp.config.allowUnauthenticatedStream = true;
try { try {
const encrypted = await openpgp.encrypt({ const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromBinary(data, 'msg.bin'), message: await openpgp.createMessage({ binary: data, filename: 'msg.bin' }),
passwords: ['test'] passwords: ['test']
}); });
expect(openpgp.stream.isStream(encrypted)).to.equal(expectedType); expect(openpgp.stream.isStream(encrypted)).to.equal(expectedType);
@ -449,7 +449,7 @@ function tests() {
openpgp.config.allowUnauthenticatedStream = true; openpgp.config.allowUnauthenticatedStream = true;
try { try {
const encrypted = await openpgp.encrypt({ const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromBinary(data), message: await openpgp.createMessage({ binary: data }),
publicKeys: pubKey, publicKeys: pubKey,
privateKeys: privKey, privateKeys: privKey,
config: { minRSABits: 1024 } config: { minRSABits: 1024 }
@ -487,7 +487,7 @@ function tests() {
openpgp.config.allowUnauthenticatedStream = true; openpgp.config.allowUnauthenticatedStream = true;
try { try {
const encrypted = await openpgp.encrypt({ const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromBinary(data), message: await openpgp.createMessage({ binary: data }),
publicKeys: pubKey, publicKeys: pubKey,
privateKeys: privKey, privateKeys: privKey,
config: { minRSABits: 1024 } config: { minRSABits: 1024 }
@ -522,7 +522,7 @@ function tests() {
it('Sign/verify: Detect armor checksum error', async function() { it('Sign/verify: Detect armor checksum error', async function() {
const signed = await openpgp.sign({ const signed = await openpgp.sign({
message: await openpgp.Message.fromBinary(data), message: await openpgp.createMessage({ binary: data }),
privateKeys: privKey, privateKeys: privKey,
config: { minRSABits: 1024 } config: { minRSABits: 1024 }
}); });
@ -578,7 +578,7 @@ function tests() {
it('Sign/verify: Input stream should be canceled when canceling verified stream', async function() { it('Sign/verify: Input stream should be canceled when canceling verified stream', async function() {
const signed = await openpgp.sign({ const signed = await openpgp.sign({
message: await openpgp.Message.fromBinary(data), message: await openpgp.createMessage({ binary: data }),
privateKeys: privKey, privateKeys: privKey,
config: { minRSABits: 1024 } config: { minRSABits: 1024 }
}); });
@ -604,7 +604,7 @@ function tests() {
it("Don't pull entire input stream when we're not pulling encrypted stream", async function() { it("Don't pull entire input stream when we're not pulling encrypted stream", async function() {
const encrypted = await openpgp.encrypt({ const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromBinary(data), message: await openpgp.createMessage({ binary: data }),
passwords: ['test'] passwords: ['test']
}); });
expect(openpgp.stream.isStream(encrypted)).to.equal(expectedType); expect(openpgp.stream.isStream(encrypted)).to.equal(expectedType);
@ -618,7 +618,7 @@ function tests() {
it("Sign: Don't pull entire input stream when we're not pulling signed stream", async function() { it("Sign: Don't pull entire input stream when we're not pulling signed stream", async function() {
const signed = await openpgp.sign({ const signed = await openpgp.sign({
message: await openpgp.Message.fromBinary(data), message: await openpgp.createMessage({ binary: data }),
privateKeys: privKey, privateKeys: privKey,
config: { minRSABits: 1024 } config: { minRSABits: 1024 }
}); });
@ -633,7 +633,7 @@ function tests() {
it("Sign/verify: Don't pull entire input stream when we're not pulling verified stream", async function() { it("Sign/verify: Don't pull entire input stream when we're not pulling verified stream", async function() {
const signed = await openpgp.sign({ const signed = await openpgp.sign({
message: await openpgp.Message.fromBinary(data), message: await openpgp.createMessage({ binary: data }),
privateKeys: privKey, privateKeys: privKey,
config: { minRSABits: 1024 } config: { minRSABits: 1024 }
}); });
@ -668,7 +668,7 @@ function tests() {
} }
}); });
const signed = await openpgp.sign({ const signed = await openpgp.sign({
message: await openpgp.Message.fromBinary(data), message: await openpgp.createMessage({ binary: data }),
privateKeys: privKey, privateKeys: privKey,
detached: true, detached: true,
streaming: expectedType, streaming: expectedType,
@ -680,7 +680,7 @@ function tests() {
const verified = await openpgp.verify({ const verified = await openpgp.verify({
signature, signature,
publicKeys: pubKey, publicKeys: pubKey,
message: await openpgp.Message.fromText('hello world'), message: await openpgp.createMessage({ text: 'hello world' }),
config: { minRSABits: 1024 } config: { minRSABits: 1024 }
}); });
expect(verified.data).to.equal('hello world'); expect(verified.data).to.equal('hello world');
@ -704,7 +704,7 @@ function tests() {
} }
}); });
const signed = await openpgp.sign({ const signed = await openpgp.sign({
message: await openpgp.Message.fromBinary(data), message: await openpgp.createMessage({ binary: data }),
privateKeys: privKey, privateKeys: privKey,
detached: true, detached: true,
streaming: false, streaming: false,
@ -716,7 +716,7 @@ function tests() {
const verified = await openpgp.verify({ const verified = await openpgp.verify({
signature, signature,
publicKeys: pubKey, publicKeys: pubKey,
message: await openpgp.Message.fromText('hello world'), message: await openpgp.createMessage({ text: 'hello world' }),
config: { minRSABits: 1024 } config: { minRSABits: 1024 }
}); });
expect(verified.data).to.equal('hello world'); expect(verified.data).to.equal('hello world');
@ -743,7 +743,7 @@ function tests() {
const pub = await openpgp.readKey({ armoredKey: brainpoolPub }); const pub = await openpgp.readKey({ armoredKey: brainpoolPub });
await priv.decrypt(brainpoolPass); await priv.decrypt(brainpoolPass);
const signed = await openpgp.sign({ const signed = await openpgp.sign({
message: await openpgp.Message.fromBinary(data), message: await openpgp.createMessage({ binary: data }),
privateKeys: priv, privateKeys: priv,
detached: true, detached: true,
streaming: expectedType streaming: expectedType
@ -754,7 +754,7 @@ function tests() {
const verified = await openpgp.verify({ const verified = await openpgp.verify({
signature, signature,
publicKeys: pub, publicKeys: pub,
message: await openpgp.Message.fromText('hello world') message: await openpgp.createMessage({ text: 'hello world' })
}); });
expect(verified.data).to.equal('hello world'); expect(verified.data).to.equal('hello world');
expect(verified.signatures).to.exist.and.have.length(1); expect(verified.signatures).to.exist.and.have.length(1);
@ -780,7 +780,7 @@ function tests() {
const pub = await openpgp.readKey({ armoredKey: xPub }); const pub = await openpgp.readKey({ armoredKey: xPub });
await priv.decrypt(xPass); await priv.decrypt(xPass);
const signed = await openpgp.sign({ const signed = await openpgp.sign({
message: await openpgp.Message.fromBinary(data), message: await openpgp.createMessage({ binary: data }),
privateKeys: priv, privateKeys: priv,
detached: true, detached: true,
streaming: expectedType streaming: expectedType
@ -791,7 +791,7 @@ function tests() {
const verified = await openpgp.verify({ const verified = await openpgp.verify({
signature, signature,
publicKeys: pub, publicKeys: pub,
message: await openpgp.Message.fromText('hello world') message: await openpgp.createMessage({ text: 'hello world' })
}); });
expect(verified.data).to.equal('hello world'); expect(verified.data).to.equal('hello world');
expect(verified.signatures).to.exist.and.have.length(1); expect(verified.signatures).to.exist.and.have.length(1);
@ -800,7 +800,7 @@ function tests() {
it("Detached sign is expected to pull entire input stream when we're not pulling signed stream", async function() { it("Detached sign is expected to pull entire input stream when we're not pulling signed stream", async function() {
const signed = await openpgp.sign({ const signed = await openpgp.sign({
message: await openpgp.Message.fromBinary(data), message: await openpgp.createMessage({ binary: data }),
privateKeys: privKey, privateKeys: privKey,
detached: true, detached: true,
config: { minRSABits: 1024 } config: { minRSABits: 1024 }
@ -815,7 +815,7 @@ function tests() {
it('Detached sign: Input stream should be canceled when canceling signed stream', async function() { it('Detached sign: Input stream should be canceled when canceling signed stream', async function() {
const signed = await openpgp.sign({ const signed = await openpgp.sign({
message: await openpgp.Message.fromBinary(data), message: await openpgp.createMessage({ binary: data }),
privateKeys: privKey, privateKeys: privKey,
detached: true, detached: true,
config: { minRSABits: 1024 } config: { minRSABits: 1024 }
@ -846,7 +846,7 @@ function tests() {
it('Encrypt and decrypt larger message roundtrip (AEAD)', async function() { it('Encrypt and decrypt larger message roundtrip (AEAD)', async function() {
const encrypted = await openpgp.encrypt({ const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromBinary(data), message: await openpgp.createMessage({ binary: data }),
passwords: ['test'], passwords: ['test'],
armor: false armor: false
}); });
@ -897,7 +897,7 @@ function tests() {
} }
}); });
const encrypted = await openpgp.encrypt({ const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromText(data), message: await openpgp.createMessage({ text: data }),
streaming: expectedType, streaming: expectedType,
passwords: ['test'] passwords: ['test']
}); });
@ -927,7 +927,7 @@ function tests() {
} }
try { try {
const encrypted = await openpgp.encrypt({ const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromBinary(data), message: await openpgp.createMessage({ binary: data }),
passwords: ['test'] passwords: ['test']
}); });
expect(openpgp.stream.isStream(encrypted)).to.equal(expectedType); expect(openpgp.stream.isStream(encrypted)).to.equal(expectedType);
@ -954,7 +954,7 @@ function tests() {
it('Input stream should be canceled when canceling decrypted stream (AEAD)', async function() { it('Input stream should be canceled when canceling decrypted stream (AEAD)', async function() {
const encrypted = await openpgp.encrypt({ const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromBinary(data), message: await openpgp.createMessage({ binary: data }),
passwords: ['test'] passwords: ['test']
}); });
@ -1045,7 +1045,7 @@ module.exports = () => describe('Streaming', function() {
const plaintext = fs.readFileSync(__filename.replace('streaming.js', 'openpgp.js'), 'utf8'); // eslint-disable-line no-sync const plaintext = fs.readFileSync(__filename.replace('streaming.js', 'openpgp.js'), 'utf8'); // eslint-disable-line no-sync
const data = fs.createReadStream(__filename.replace('streaming.js', 'openpgp.js'), { encoding: 'utf8' }); const data = fs.createReadStream(__filename.replace('streaming.js', 'openpgp.js'), { encoding: 'utf8' });
const encrypted = await openpgp.encrypt({ const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromText(data), message: await openpgp.createMessage({ text: data }),
passwords: ['test'] passwords: ['test']
}); });
expect(openpgp.stream.isStream(encrypted)).to.equal('node'); expect(openpgp.stream.isStream(encrypted)).to.equal('node');
@ -1064,7 +1064,7 @@ module.exports = () => describe('Streaming', function() {
const plaintext = fs.readFileSync(__filename.replace('streaming.js', 'openpgp.js')); // eslint-disable-line no-sync const plaintext = fs.readFileSync(__filename.replace('streaming.js', 'openpgp.js')); // eslint-disable-line no-sync
const data = fs.createReadStream(__filename.replace('streaming.js', 'openpgp.js')); const data = fs.createReadStream(__filename.replace('streaming.js', 'openpgp.js'));
const encrypted = await openpgp.encrypt({ const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromBinary(data), message: await openpgp.createMessage({ binary: data }),
passwords: ['test'], passwords: ['test'],
armor: false armor: false
}); });

10
test/general/x25519.js
View File

@ -174,7 +174,7 @@ module.exports = () => (openpgp.config.ci ? describe.skip : describe)('X25519 Cr
const name = 'light'; const name = 'light';
const randomData = input.createSomeMessage(); const randomData = input.createSomeMessage();
const priv = await load_priv_key(name); const priv = await load_priv_key(name);
const signed = await openpgp.sign({ privateKeys: [priv], message: await openpgp.CleartextMessage.fromText(randomData) }); const signed = await openpgp.sign({ privateKeys: [priv], message: await openpgp.createCleartextMessage({ text: randomData }) });
const pub = await load_pub_key(name); const pub = await load_pub_key(name);
const msg = await openpgp.readCleartextMessage({ cleartextMessage: signed }); const msg = await openpgp.readCleartextMessage({ cleartextMessage: signed });
const result = await openpgp.verify({ publicKeys: [pub], message: msg }); const result = await openpgp.verify({ publicKeys: [pub], message: msg });
@ -201,7 +201,7 @@ module.exports = () => (openpgp.config.ci ? describe.skip : describe)('X25519 Cr
const nightPublic = await load_pub_key('night'); const nightPublic = await load_pub_key('night');
const lightPrivate = await load_priv_key('light'); const lightPrivate = await load_priv_key('light');
const randomData = input.createSomeMessage(); const randomData = input.createSomeMessage();
const encrypted = await openpgp.encrypt({ publicKeys: [nightPublic], privateKeys: [lightPrivate], message: await openpgp.Message.fromText(randomData) }); const encrypted = await openpgp.encrypt({ publicKeys: [nightPublic], privateKeys: [lightPrivate], message: await openpgp.createMessage({ text: randomData }) });
const message = await openpgp.readMessage({ armoredMessage: encrypted }); const message = await openpgp.readMessage({ armoredMessage: encrypted });
const lightPublic = await load_pub_key('light'); const lightPublic = await load_pub_key('light');
@ -447,7 +447,7 @@ function omnibus() {
}), }),
// Signing message // Signing message
openpgp.sign( openpgp.sign(
{ message: await openpgp.CleartextMessage.fromText('Hi, this is me, Hi!'), privateKeys: hi } { message: await openpgp.createCleartextMessage({ text: 'Hi, this is me, Hi!' }), privateKeys: hi }
).then(async signed => { ).then(async signed => {
const msg = await openpgp.readCleartextMessage({ cleartextMessage: signed }); const msg = await openpgp.readCleartextMessage({ cleartextMessage: signed });
// Verifying signed message // Verifying signed message
@ -457,7 +457,7 @@ function omnibus() {
).then(output => expect(output.signatures[0].valid).to.be.true), ).then(output => expect(output.signatures[0].valid).to.be.true),
// Verifying detached signature // Verifying detached signature
openpgp.verify({ openpgp.verify({
message: await openpgp.Message.fromText('Hi, this is me, Hi!'), message: await openpgp.createMessage({ text: 'Hi, this is me, Hi!' }),
publicKeys: hi.toPublic(), publicKeys: hi.toPublic(),
signature: msg.signature signature: msg.signature
}).then(output => expect(output.signatures[0].valid).to.be.true) }).then(output => expect(output.signatures[0].valid).to.be.true)
@ -466,7 +466,7 @@ function omnibus() {
// Encrypting and signing // Encrypting and signing
openpgp.encrypt( openpgp.encrypt(
{ {
message: await openpgp.Message.fromText('Hi, Hi wrote this but only Bye can read it!'), message: await openpgp.createMessage({ text: 'Hi, Hi wrote this but only Bye can read it!' }),
publicKeys: [bye.toPublic()], publicKeys: [bye.toPublic()],
privateKeys: [hi] privateKeys: [hi]
} }

4
test/security/subkey_trust.js
View File

@ -1,6 +1,6 @@
const openpgp = typeof window !== 'undefined' && window.openpgp ? window.openpgp : require('../..'); const openpgp = typeof window !== 'undefined' && window.openpgp ? window.openpgp : require('../..');
const { readKey, Key, readCleartextMessage, CleartextMessage, enums, PacketList, SignaturePacket } = openpgp; const { readKey, Key, readCleartextMessage, createCleartextMessage, enums, PacketList, SignaturePacket } = openpgp;
const chai = require('chai'); const chai = require('chai');
chai.use(require('chai-as-promised')); chai.use(require('chai-as-promised'));
@ -27,7 +27,7 @@ async function generateTestData() {
})).key; })).key;
attackerPrivKey.revocationSignatures = []; attackerPrivKey.revocationSignatures = [];
const signed = await openpgp.sign({ const signed = await openpgp.sign({
message: await CleartextMessage.fromText('I am batman'), message: await createCleartextMessage({ text: 'I am batman' }),
privateKeys: victimPrivKey, privateKeys: victimPrivKey,
streaming: false, streaming: false,
armor: true armor: true

4
test/security/unsigned_subpackets.js
View File

@ -1,6 +1,6 @@
const openpgp = typeof window !== 'undefined' && window.openpgp ? window.openpgp : require('../..'); const openpgp = typeof window !== 'undefined' && window.openpgp ? window.openpgp : require('../..');
const { readKey, Key, message, enums, PacketList, SignaturePacket } = openpgp; const { readKey, Key, createMessage, enums, PacketList, SignaturePacket } = openpgp;
const chai = require('chai'); const chai = require('chai');
chai.use(require('chai-as-promised')); chai.use(require('chai-as-promised'));
@ -58,7 +58,7 @@ async function makeKeyValid() {
async function encryptFails(k) { async function encryptFails(k) {
try { try {
await openpgp.encrypt({ await openpgp.encrypt({
message: await Message.fromText('Hello', 'hello.txt'), message: await createMessage({ text: 'Hello', filename: 'hello.txt' }),
publicKeys: k publicKeys: k
}); });
return false; return false;

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. * - 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, readKey, readKeys, Key, readMessage, Message, CleartextMessage, encrypt, decrypt, sign, verify, config } from '../..'; import { generateKey, readKey, readKeys, Key, readMessage, createMessage, createCleartextMessage, encrypt, decrypt, sign, verify, config } from '../..';
import { expect } from 'chai'; import { expect } from 'chai';
@ -25,7 +25,7 @@ import { expect } from 'chai';
// Encrypt text message (armored) // Encrypt text message (armored)
const text = 'hello'; const text = 'hello';
const textMessage = await Message.fromText('hello'); const textMessage = await createMessage({ text: 'hello' });
const encryptedArmor: string = await encrypt({ publicKeys, message: textMessage }); const encryptedArmor: string = await encrypt({ publicKeys, message: textMessage });
expect(encryptedArmor).to.include('-----BEGIN PGP MESSAGE-----'); expect(encryptedArmor).to.include('-----BEGIN PGP MESSAGE-----');
@ -33,7 +33,7 @@ import { expect } from 'chai';
const binary = new Uint8Array(2); const binary = new Uint8Array(2);
binary[0] = 1; binary[0] = 1;
binary[1] = 2; binary[1] = 2;
const binaryMessage = await Message.fromBinary(binary); const binaryMessage = await createMessage({ binary });
const encryptedBinary: Uint8Array = await encrypt({ publicKeys, message: binaryMessage, armor: false }); const encryptedBinary: Uint8Array = await encrypt({ publicKeys, message: binaryMessage, armor: false });
expect(encryptedBinary).to.be.instanceOf(Uint8Array); expect(encryptedBinary).to.be.instanceOf(Uint8Array);
@ -54,7 +54,7 @@ import { expect } from 'chai';
expect(encryptedMessage).to.be.instanceOf(Message); expect(encryptedMessage).to.be.instanceOf(Message);
// Sign cleartext message (armored) // Sign cleartext message (armored)
const cleartextMessage = await CleartextMessage.fromText('hello'); const cleartextMessage = await createCleartextMessage({ text: 'hello' });
const clearSignedArmor = await sign({ privateKeys, message: cleartextMessage }); const clearSignedArmor = await sign({ privateKeys, message: cleartextMessage });
expect(clearSignedArmor).to.include('-----BEGIN PGP SIGNED MESSAGE-----'); expect(clearSignedArmor).to.include('-----BEGIN PGP SIGNED MESSAGE-----');
@ -80,12 +80,12 @@ import { expect } from 'chai';
// // Detached - sign cleartext message (armored) // // Detached - sign cleartext message (armored)
// import { Message, sign } from 'openpgp'; // import { Message, sign } from 'openpgp';
// const message = await Message.fromText(util.removeTrailingSpaces(text)); // const message = await createMessage({ text: util.removeTrailingSpaces(text) });
// const signed = await sign({ privateKeys, message, detached: true }); // const signed = await sign({ privateKeys, message, detached: true });
// console.log(signed); // String // console.log(signed); // String
// // Detached - sign binary message (unarmored) // // Detached - sign binary message (unarmored)
// const message = await Message.fromText(text); // const message = await createMessage({ text });
// const signed = await sign({ privateKeys, message, detached: true, armor: false }); // const signed = await sign({ privateKeys, message, detached: true, armor: false });
// console.log(signed); // Uint8Array // console.log(signed); // Uint8Array
@ -99,7 +99,7 @@ import { expect } from 'chai';
// // Streaming - encrypt text message on Node.js (armored) // // Streaming - encrypt text message on Node.js (armored)
// const data = fs.createReadStream(filename, { encoding: 'utf8' }); // const data = fs.createReadStream(filename, { encoding: 'utf8' });
// const message = await Message.fromText(data); // const message = await createMessage({ text: data });
// const encrypted = await encrypt({ publicKeys, message }); // const encrypted = await encrypt({ publicKeys, message });
// encrypted.on('data', chunk => { // encrypted.on('data', chunk => {
// console.log(chunk); // String // console.log(chunk); // String
@ -107,7 +107,7 @@ import { expect } from 'chai';
// // Streaming - encrypt binary message on Node.js (unarmored) // // Streaming - encrypt binary message on Node.js (unarmored)
// const data = fs.createReadStream(filename); // const data = fs.createReadStream(filename);
// const message = await Message.fromBinary(data); // const message = await createMessage({ binary: data });
// const encrypted = await encrypt({ publicKeys, message, armor: false }); // const encrypted = await encrypt({ publicKeys, message, armor: false });
// encrypted.pipe(targetStream); // encrypted.pipe(targetStream);

2
test/worker/worker_example.js
View File

@ -48,7 +48,7 @@ onmessage = async function({ data: { action, message }, ports: [port] }) {
const privateKey = await openpgp.readKey({ armoredKey: privateKeyArmored }); const privateKey = await openpgp.readKey({ armoredKey: privateKeyArmored });
await privateKey.decrypt('test'); await privateKey.decrypt('test');
const data = await openpgp.encrypt({ const data = await openpgp.encrypt({
message: await openpgp.Message.fromText(message), message: await openpgp.createMessage({ text: message }),
publicKeys: publicKey, publicKeys: publicKey,
privateKeys: privateKey privateKeys: privateKey
}); });