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
(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({
message, // input as Message object
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);
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
privateKeys: privateKey // for signing (optional)
});
@ -257,7 +257,7 @@ Encrypt with multiple public keys:
const privateKey = await openpgp.readKey({ armoredKey: privateKeyArmored });
await privateKey.decrypt(passphrase)
const message = await openpgp.Message.fromText(message);
const message = await openpgp.createMessage({ text: message });
const encrypted = await openpgp.encrypt({
message:, // input as Message object
publicKeys, // for encryption
@ -274,7 +274,7 @@ It's possible to change that behaviour by enabling compression through the confi
```js
(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({
message,
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({
message, // input as Message object
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({
message: await openpgp.Message.fromText(readableStream), // input as Message object
message: await openpgp.createMessage({ text: readableStream }), // input as Message object
publicKeys: publicKey, // for encryption
privateKeys: privateKey // for signing (optional)
});
@ -457,7 +457,7 @@ Using the private key:
const privateKey = await openpgp.readKey({ armoredKey: privateKeyArmored });
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({
message: unsignedMessage, // CleartextMessage or Message object
privateKeys: privateKey // for signing
@ -497,7 +497,7 @@ Using the private key:
const privateKey = await openpgp.readKey({ armoredKey: privateKeyArmored });
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({
message: cleartextMessage, // CleartextMessage or Message object
privateKeys: privateKey, // for signing
@ -544,7 +544,7 @@ Using the private key:
const privateKey = await openpgp.readKey({ armoredKey: privateKeyArmored });
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({
message,
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 createCleartextMessage(options: { text: string }): Promise<CleartextMessage>;
/** Class that represents an OpenPGP cleartext signed message.
*/
export class CleartextMessage {
@ -137,8 +139,6 @@ export class CleartextMessage {
* @param keys array of keys to verify signatures
*/
verify(keys: Key[], date?: Date, config?: Config): Promise<VerificationResult[]>;
static fromText(text: string): CleartextMessage;
}
/* ############## 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<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<
T extends 'web' ? WebStream<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
*/
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 {
/** message to be encrypted as created by Message.fromText or Message.fromBinary */
/** message to be encrypted as created by createMessage */
message: Message<MaybeStream<Data>>;
/** (optional) array of keys or single key, used to encrypt the message */
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);
}
/**
* 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');
}
}
/**
* 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 { Message, readMessage } from './message';
export { Message, readMessage, createMessage } from './message';
export { CleartextMessage, readCleartextMessage } from './cleartext';
export { CleartextMessage, readCleartextMessage, createCleartextMessage } from './cleartext';
export * from './packet';

104
src/message.js
View File

@ -644,71 +644,6 @@ export class Message {
armor(config = defaultConfig) {
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;
}
/**
* 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
* must be specified. If private keys are specified, those will be used to sign the message.
* @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.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

10
test/general/brainpool.js
View File

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

12
test/general/config.js
View File

@ -149,7 +149,7 @@ module.exports = () => describe('Custom configuration', function() {
try {
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 encrypted = await openpgp.readMessage({ armoredMessage: armored });
@ -186,7 +186,7 @@ module.exports = () => describe('Custom configuration', function() {
it('openpgp.decrypt', async function() {
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 { 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 key = await openpgp.readKey({ armoredKey: privateKeyArmored });
const message = await openpgp.Message.fromText("test");
const message = await openpgp.createMessage({ text: "test" });
const opt = {
message,
privateKeys: key,
@ -235,7 +235,7 @@ module.exports = () => describe('Custom configuration', function() {
opt.detached = true;
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 = {
message: clearText,
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 message = await openpgp.Message.fromText("test");
const message = await openpgp.createMessage({ text: "test" });
const signed = await openpgp.sign({ message, privateKeys: key });
const opt = {
message: await openpgp.readMessage({ armoredMessage: signed }),
@ -274,7 +274,7 @@ module.exports = () => describe('Custom configuration', function() {
const { signatures: [sig2] } = await openpgp.verify(opt2);
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 opt3 = {
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 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({
message: await openpgp.readCleartextMessage({ cleartextMessage }),
publicKeys: pubHi
}).then(output => expect(output.signatures[0].valid).to.be.true);
// Verifying detached signature
await openpgp.verify({
message: await openpgp.Message.fromText(util.removeTrailingSpaces(testData)),
message: await openpgp.createMessage({ text: util.removeTrailingSpaces(testData) }),
publicKeys: pubHi,
signature: (await openpgp.readCleartextMessage({ cleartextMessage })).signature
}).then(output => expect(output.signatures[0].valid).to.be.true);
// Encrypting and signing
const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromText(testData2),
message: await openpgp.createMessage({ text: testData2 }),
publicKeys: [pubBye],
privateKeys: [hi]
});
@ -56,7 +56,7 @@ module.exports = () => describe('Elliptic Curve Cryptography for NIST P-256,P-38
const testData = input.createSomeMessage();
const options = { userIDs: { name: "Hi", email: "hi@hel.lo" }, curve: "p256" };
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 result = await openpgp.verify({ message: msg, publicKeys: firstKey.key.toPublic() });
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" };
const secondKey = await openpgp.generateKey(options);
const encrypted = await openpgp.encrypt(
{ message: await openpgp.Message.fromText(testData),
{ message: await openpgp.createMessage({ text: testData }),
publicKeys: [secondKey.key.toPublic()],
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 () {
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 msg = await openpgp.readCleartextMessage({ cleartextMessage: signed });
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 () {
const romeoPrivate = await load_priv_key('romeo');
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 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 { key } = await openpgp.generateKey(opt);
return openpgp.encrypt({
message: await openpgp.Message.fromText('hello'),
message: await openpgp.createMessage({ text: 'hello' }),
publicKeys: key
}).then(async armoredMessage => openpgp.decrypt({
message: await openpgp.readMessage({ armoredMessage }),
@ -2586,7 +2586,7 @@ function versionSpecificTests() {
expect(newKey.users.length).to.equal(1);
expect(newKey.users[0].userID.userID).to.equal('test <a@b.com>');
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(
{ message: await openpgp.readCleartextMessage({ cleartextMessage: signed }), publicKeys: newKey.toPublic() }
).then(async function(verified) {
@ -2630,7 +2630,7 @@ function versionSpecificTests() {
opt.userIDs = userID2;
return openpgp.reformatKey(opt).then(async function(newKey) {
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) {
expect(decrypted.data).to.equal('hello');
expect(decrypted.signatures[0].valid).to.be.true;
@ -3016,7 +3016,7 @@ module.exports = () => describe('Key', function() {
expect(key.primaryKey.isDummy()).to.be.false;
key.primaryKey.makeDummy();
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() {
@ -3423,10 +3423,10 @@ VYGdb3eNlV8CfoEC
expect(sessionKey.algorithm).to.equal('aes128');
const config = { minRSABits: 1024 };
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({
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');
});
@ -3435,7 +3435,7 @@ VYGdb3eNlV8CfoEC
expect(publicKey.users.length).to.equal(0);
const privateKey = await openpgp.readKey({ armoredKey: uidlessKey });
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() {
@ -3453,17 +3453,17 @@ VYGdb3eNlV8CfoEC
privateKey.users[1].selfCertifications[0].preferredHashAlgorithms = [openpgp.enums.hash.sha512];
const config = { minRSABits: 1024 };
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 });
expect(signature.packets[0].hashAlgorithm).to.equal(openpgp.enums.hash.sha512);
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' });
expect(signatures[0].signature.packets[0].hashAlgorithm).to.equal(openpgp.enums.hash.sha512);
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');
});
@ -3499,7 +3499,7 @@ VYGdb3eNlV8CfoEC
it('Reject encryption with revoked primary user', async function() {
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');
}).catch(function(error) {
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 });
key.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');
}).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');
@ -3519,7 +3519,7 @@ VYGdb3eNlV8CfoEC
it('Reject encryption with key revoked with appended revocation cert', async function() {
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');
}).catch(function(error) {
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');
await subKey.verify(newPrivateKey.primaryKey);
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 { signatures } = await openpgp.verify({ message, publicKeys: [newPrivateKey.toPublic()] });
expect(signatures).to.exist;
@ -3756,7 +3756,7 @@ VYGdb3eNlV8CfoEC
const publicKey = newPrivateKey.toPublic();
await subKey.verify(newPrivateKey.primaryKey);
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;
const message = await openpgp.readMessage({ binaryMessage: encrypted });
const pkSessionKeys = message.packets.filterByTag(openpgp.enums.packet.publicKeyEncryptedSessionKey);
@ -3780,7 +3780,7 @@ VYGdb3eNlV8CfoEC
expect(subKey.getAlgorithmInfo().algorithm).to.be.equal('rsaEncryptSign');
await subKey.verify(newPrivateKey.primaryKey);
expect(await newPrivateKey.getSigningKey()).to.be.equal(subKey);
const signed = await openpgp.sign({ message: 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 { signatures } = await openpgp.verify({ message, publicKeys: [newPrivateKey.toPublic()] });
expect(signatures).to.exist;
@ -3800,7 +3800,7 @@ VYGdb3eNlV8CfoEC
const publicKey = newPrivateKey.toPublic();
const vData = 'the data to encrypted!';
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;
const message = await openpgp.readMessage({ binaryMessage: encrypted });
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;
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).not.to.match(/^Version:/);
expect(encryptedDefault).not.to.match(/^Comment:/);
openpgp.config.showComment = true;
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).not.to.match(/^Version:/);
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() {
const encOpt = {
message: await openpgp.Message.fromText(plaintext),
message: await openpgp.createMessage({ text: plaintext }),
publicKeys: publicKey
};
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 () {
const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromText(plaintext),
message: await openpgp.createMessage({ text: plaintext }),
publicKeys: publicKey
});
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 () {
const plaintext = 'space: \nspace and tab: \t\nno trailing space\n \ntab:\t\ntab and space:\t ';
const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromText(plaintext),
message: await openpgp.createMessage({ text: plaintext }),
publicKeys: publicKey
});
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 () {
const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromText(plaintext),
message: await openpgp.createMessage({ text: plaintext }),
passwords: password1
});
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 () {
const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromText(plaintext),
message: await openpgp.createMessage({ text: plaintext }),
passwords: [password1, password2]
});
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 () {
const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromText(plaintext),
message: await openpgp.createMessage({ text: plaintext }),
passwords: [password1, password1]
});
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 () {
const encOpt = {
message: await openpgp.Message.fromText(plaintext),
message: await openpgp.createMessage({ text: plaintext }),
publicKeys: publicKey
};
const decOpt = {
@ -1274,7 +1274,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
await privKeyDE.decrypt(passphrase);
const encOpt = {
message: await openpgp.Message.fromText(plaintext),
message: await openpgp.createMessage({ text: plaintext }),
publicKeys: publicKey
};
const decOpt = {
@ -1293,7 +1293,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
it('should encrypt then decrypt with wildcard', async function () {
const encOpt = {
message: await openpgp.Message.fromText(plaintext),
message: await openpgp.createMessage({ text: plaintext }),
publicKeys: publicKey,
wildcard: true
};
@ -1316,7 +1316,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
await privKeyDE.decrypt(passphrase);
const encOpt = {
message: await openpgp.Message.fromText(plaintext),
message: await openpgp.createMessage({ text: plaintext }),
publicKeys: publicKey,
wildcard: true
};
@ -1339,7 +1339,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
publicKeys: publicKey
});
const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromText(plaintext),
message: await openpgp.createMessage({ text: plaintext }),
sessionKey
});
expect(encrypted).to.match(/^-----BEGIN PGP MESSAGE/);
@ -1358,7 +1358,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
algorithm: 'aes256'
};
const encOpt = {
message: await openpgp.Message.fromText(plaintext),
message: await openpgp.createMessage({ text: plaintext }),
sessionKey: sessionKey,
publicKeys: publicKey
};
@ -1381,7 +1381,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
algorithm: 'aes128'
};
const encOpt = {
message: await openpgp.Message.fromText(plaintext),
message: await openpgp.createMessage({ text: plaintext }),
sessionKey: sessionKey,
publicKeys: publicKey
};
@ -1400,7 +1400,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
it('should encrypt/sign and decrypt/verify', async function () {
const encOpt = {
message: await openpgp.Message.fromText(plaintext),
message: await openpgp.createMessage({ text: plaintext }),
publicKeys: publicKey,
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 () {
const encOpt = {
message: await openpgp.Message.fromText(plaintext),
message: await openpgp.createMessage({ text: plaintext }),
publicKeys: publicKeyNoAEAD,
privateKeys: privateKey
};
@ -1454,7 +1454,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
const newPrivateKey = await openpgp.readKey({ armoredKey: newKey.privateKeyArmored });
const encOpt = {
message: await openpgp.Message.fromText(plaintext),
message: await openpgp.createMessage({ text: plaintext }),
publicKeys: newPublicKey,
privateKeys: newPrivateKey
};
@ -1484,11 +1484,11 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
const newPrivateKey = await openpgp.readKey({ armoredKey: newKey.privateKeyArmored });
const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromText(plaintext),
message: await openpgp.createMessage({ text: plaintext }),
publicKeys: newPublicKey
});
const signed = await openpgp.sign({
message: await openpgp.Message.fromText(plaintext),
message: await openpgp.createMessage({ text: plaintext }),
privateKeys: newPrivateKey,
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 () {
const encOpt = {
message: await openpgp.Message.fromText(''),
message: await openpgp.createMessage({ text: '' }),
publicKeys: publicKey,
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 () {
const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromText(plaintext),
message: await openpgp.createMessage({ text: plaintext }),
publicKeys: publicKey
});
const signed = await openpgp.sign({
message: await openpgp.Message.fromText(plaintext),
message: await openpgp.createMessage({ text: plaintext }),
privateKeys: privateKey,
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 signOpt = {
message: await openpgp.Message.fromText(plaintext),
message: await openpgp.createMessage({ text: plaintext }),
privateKeys: privKeyDE,
detached: true
};
const encOpt = {
message: await openpgp.Message.fromText(plaintext),
message: await openpgp.createMessage({ text: plaintext }),
publicKeys: publicKey,
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 () {
const signOpt = {
message: await openpgp.Message.fromText(plaintext),
message: await openpgp.createMessage({ text: plaintext }),
privateKeys: privateKey,
detached: true
};
const encOpt = {
message: await openpgp.Message.fromText(plaintext),
message: await openpgp.createMessage({ text: plaintext }),
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 () {
const encOpt = {
message: await openpgp.Message.fromText(plaintext),
message: await openpgp.createMessage({ text: plaintext }),
publicKeys: publicKey,
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 () {
const encOpt = {
message: await openpgp.Message.fromText(''),
message: await openpgp.createMessage({ text: '' }),
publicKeys: publicKey,
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 () {
const encOpt = {
message: await openpgp.Message.fromText(plaintext),
message: await openpgp.createMessage({ text: plaintext }),
publicKeys: publicKey,
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 () {
const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromText(plaintext),
message: await openpgp.createMessage({ text: plaintext }),
publicKeys: publicKey
});
const signed = await openpgp.sign({
message: await openpgp.Message.fromText(plaintext),
message: await openpgp.createMessage({ text: plaintext }),
privateKeys: privateKey,
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 encOpt = {
message: await openpgp.Message.fromText(plaintext),
message: await openpgp.createMessage({ text: plaintext }),
publicKeys: publicKey,
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() {
const { privateKeyArmored } = await openpgp.generateKey({ curve: 'curve25519', userIDs: [{ email: 'test@email.com' }] });
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');
if (badSumEncrypted === data) { // checksum was already =aaaa
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() {
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])]);
await expect((async () => {
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({
publicKeys: pubKeyDE,
privateKeys: privKeyDE,
message: await openpgp.Message.fromText(plaintext)
message: await openpgp.createMessage({ text: plaintext })
}).then(async function (encrypted) {
return openpgp.decrypt({
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 () {
const encOpt = {
message: await openpgp.Message.fromText(plaintext),
message: await openpgp.createMessage({ text: plaintext }),
passwords: password1
};
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 () {
const encOpt = {
message: await openpgp.Message.fromText(plaintext),
message: await openpgp.createMessage({ text: plaintext }),
passwords: [password1, password2]
};
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 () {
const encOpt = {
message: await openpgp.Message.fromText(plaintext),
message: await openpgp.createMessage({ text: plaintext }),
passwords: password1,
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 () {
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,
armor: false
};
@ -2013,7 +2013,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
withCompression(function (modifyCompressionEncryptOptions, verifyCompressionDecrypted) {
it('should encrypt and decrypt with one password', async function () {
const encOpt = modifyCompressionEncryptOptions({
message: await openpgp.Message.fromText(plaintext),
message: await openpgp.createMessage({ text: plaintext }),
passwords: password1
});
const decOpt = {
@ -2046,7 +2046,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
}
});
const encrypted = await openpgp.encrypt(modifyCompressionEncryptOptions({
message: await openpgp.Message.fromBinary(data),
message: await openpgp.createMessage({ binary: data }),
passwords: ['test']
}));
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 () {
const message = await openpgp.CleartextMessage.fromText(plaintext);
const message = await openpgp.createCleartextMessage({ text: plaintext });
const signOpt = {
message,
privateKeys: privateKey
@ -2117,7 +2117,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
const privKeyDE = await openpgp.readKey({ armoredKey: priv_key_de });
await privKeyDE.decrypt(passphrase);
const message = await openpgp.CleartextMessage.fromText(plaintext);
const message = await openpgp.createCleartextMessage({ text: plaintext });
const signOpt = {
message,
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 () {
const message = await openpgp.Message.fromText(plaintext);
const message = await openpgp.createMessage({ text: plaintext });
const signOpt = {
message,
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 () {
const message = await openpgp.CleartextMessage.fromText(plaintext);
const message = await openpgp.createCleartextMessage({ text: plaintext });
const signOpt = {
message,
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 () {
const message = await openpgp.Message.fromText(plaintext);
const message = await openpgp.createMessage({ text: plaintext });
const signOpt = {
message,
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 () {
const message = await openpgp.Message.fromText(plaintext);
const message = await openpgp.createMessage({ text: plaintext });
const signOpt = {
message,
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 () {
const start = util.normalizeDate();
const message = await openpgp.Message.fromText(plaintext);
const message = await openpgp.createMessage({ text: plaintext });
const signOpt = {
message,
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 () {
const message = await openpgp.Message.fromText(plaintext);
const message = await openpgp.createMessage({ text: plaintext });
const past = new Date(2000);
const signOpt = {
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 data = new Uint8Array([3, 14, 15, 92, 65, 35, 59]);
const signOpt = {
message: await openpgp.Message.fromBinary(data),
message: await openpgp.createMessage({ binary: data }),
privateKeys: privateKey_2038_2045,
detached: true,
date: future,
@ -2318,7 +2318,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
format: 'binary'
};
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 });
return openpgp.verify(verifyOpt);
}).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 () {
const data = new Uint8Array([3, 14, 15, 92, 65, 35, 59]);
const signOpt = {
message: await openpgp.Message.fromBinary(data),
message: await openpgp.createMessage({ binary: data }),
privateKeys: privateKey,
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 () {
const data = new Uint8Array([3, 14, 15, 92, 65, 35, 59]);
const signOpt = {
message: await openpgp.Message.fromBinary(data),
message: await openpgp.createMessage({ binary: data }),
privateKeys: privateKey,
armor: false,
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 () {
const future = new Date(2040, 5, 5, 5, 5, 5, 0);
const encryptOpt = {
message: await openpgp.Message.fromText(plaintext, undefined, future),
message: await openpgp.createMessage({ text: plaintext, date: future }),
publicKeys: publicKey_2038_2045,
date: future,
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 data = new Uint8Array([3, 14, 15, 92, 65, 35, 59]);
const encryptOpt = {
message: await openpgp.Message.fromBinary(data, undefined, past),
message: await openpgp.createMessage({ binary: data, date: past }),
publicKeys: publicKey_2000_2008,
date: past,
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 () {
const past = new Date(2005, 5, 5, 5, 5, 5, 0);
const encryptOpt = {
message: await openpgp.Message.fromText(plaintext, undefined, past),
message: await openpgp.createMessage({ text: plaintext, date: past }),
publicKeys: publicKey_2000_2008,
privateKeys: privateKey_2000_2008,
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 data = new Uint8Array([3, 14, 15, 92, 65, 35, 59]);
const encryptOpt = {
message: await openpgp.Message.fromBinary(data, undefined, future),
message: await openpgp.createMessage({ binary: data, date: future }),
publicKeys: publicKey_2038_2045,
privateKeys: privateKey_2038_2045,
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 data = new Uint8Array([3, 14, 15, 92, 65, 35, 59]);
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,
privateKeys: privateKey_2038_2045,
date: future,
@ -2523,7 +2523,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
key: privateKey
}).then(async function(revKey) {
return openpgp.encrypt({
message: await openpgp.Message.fromText(plaintext),
message: await openpgp.createMessage({ text: plaintext }),
publicKeys: revKey.publicKey
}).then(function() {
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) {
pubKeyDE.subKeys[0] = revSubKey;
return openpgp.encrypt({
message: await openpgp.Message.fromText(plaintext),
message: await openpgp.createMessage({ text: plaintext }),
publicKeys: pubKeyDE,
config: { rejectPublicKeyAlgorithms: new Set() }
}).then(function() {
@ -2556,7 +2556,7 @@ module.exports = () => describe('OpenPGP.js public api tests', function() {
const privKeyDE = await openpgp.readKey({ armoredKey: priv_key_de });
await privKeyDE.decrypt(passphrase);
const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromText(plaintext),
message: await openpgp.createMessage({ text: plaintext }),
publicKeys: pubKeyDE,
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
await privKeyDE.decrypt(passphrase);
const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromText(plaintext),
message: await openpgp.createMessage({ text: plaintext }),
publicKeys: pubKeyDE,
config: { rejectPublicKeyAlgorithms: new Set() }
});
@ -2690,7 +2690,7 @@ amnR6g==
});
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({
passwords: 'test',
message
@ -2710,7 +2710,7 @@ amnR6g==
it(`sign/verify with ${curve}`, async function() {
const plaintext = 'short message';
const key = (await openpgp.generateKey({ curve, userIDs: { name: 'Alice', email: 'info@alice.com' } })).key;
const signed = await openpgp.sign({ privateKeys:[key], message: 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 }) });
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() {
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
}).then(function() {
throw new Error('Error expected.');
@ -2858,7 +2858,7 @@ bsZgJWVlAa5eil6J9ePX2xbo1vVAkLQdzE9+1jL+l7PRIZuVBQ==
for (let i = 0; i < encryptionKeyIDs.length; i++) {
m = await openpgp.readMessage({
armoredMessage: await openpgp.encrypt({
message: await openpgp.Message.fromText("Hello World\n"),
message: await openpgp.createMessage({ text: "Hello World\n" }),
publicKeys: primaryKey,
encryptionKeyIDs: [encryptionKeyIDs[i]]
})
@ -2876,7 +2876,7 @@ bsZgJWVlAa5eil6J9ePX2xbo1vVAkLQdzE9+1jL+l7PRIZuVBQ==
for (let i = 0; i < signingKeyIDs.length; i++) {
s = await openpgp.readSignature({
armoredSignature: await openpgp.sign({
message: await openpgp.Message.fromText("Hello World\n"),
message: await openpgp.createMessage({ text: "Hello World\n" }),
privateKeys: primaryKey,
signingKeyIDs: [signingKeyIDs[i]],
detached: true
@ -2890,7 +2890,7 @@ bsZgJWVlAa5eil6J9ePX2xbo1vVAkLQdzE9+1jL+l7PRIZuVBQ==
it('Encrypt and sign with specific encryption/signing key ids', async function () {
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) => {
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].signature.packets.length).to.equal(1);
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/);
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/);
@ -898,7 +898,7 @@ hUhMKMuiM3pRwdIyDOItkUWQmjEEw7/XmhgInkXsCw==
it('Supports signing with GnuPG stripped-key extension', async function() {
const priv_key_gnupg_ext = await openpgp.readKey({ armoredKey: flowcrypt_stripped_key });
await priv_key_gnupg_ext.decrypt('FlowCrypt');
const sig = await openpgp.sign({ message: 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$/);
});
@ -1083,7 +1083,7 @@ hUhMKMuiM3pRwdIyDOItkUWQmjEEw7/XmhgInkXsCw==
it('Verify latin-1 signed message', async function() {
const latin1Binary = util.hexToUint8Array('48e46c6cf62057e86c74');
const message = await openpgp.Message.fromBinary(latin1Binary);
const message = await openpgp.createMessage({ binary: latin1Binary });
message.appendSignature(`-----BEGIN PGP SIGNATURE-----
@ -1212,10 +1212,10 @@ yYDnCgA=
async read() {
while (true) {
await new Promise(setTimeout);
if (!msg_armor.length) {
if (!armoredMessage.length) {
return this.push(null);
}
if (!this.push(msg_armor.shift())) {
if (!this.push(armoredMessage.shift())) {
break;
}
}
@ -1322,7 +1322,7 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
await privKey.decrypt('hello world');
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 });
return openpgp.verify({ publicKeys:[pubKey], message, config });
@ -1342,7 +1342,7 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
await privKey.decrypt('hello world');
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 });
return openpgp.verify({ publicKeys:[pubKey], message, config });
@ -1362,7 +1362,7 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
await privKey.decrypt('hello world');
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 });
return openpgp.verify({ publicKeys:[pubKey], message, config });
@ -1382,7 +1382,7 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
await privKey.decrypt('hello world');
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 });
return openpgp.verify({ publicKeys:[pubKey], message, format: 'binary', config });
@ -1402,7 +1402,7 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
await privKey.decrypt('hello world');
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 });
return openpgp.verify({ publicKeys:[pubKey], message, format: 'binary', config });
@ -1422,9 +1422,9 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
await privKey.decrypt('hello world');
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 });
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 }) {
expect(data).to.equal(plaintext);
expect(signatures).to.have.length(1);
@ -1441,9 +1441,9 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
await privKey.decrypt('hello world');
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 });
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 }) {
expect(data).to.equal(plaintext);
expect(signatures).to.have.length(1);
@ -1459,9 +1459,9 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
await privKey.decrypt('hello world');
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 });
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 => {
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 publicKey = await openpgp.readKey({ armoredKey: publicKeyArmored });
const message = await openpgp.Message.fromText(content);
const message = await openpgp.createMessage({ text: content });
await message.appendSignature(detachedSig);
const { data, signatures } = await openpgp.verify({ publicKeys:[publicKey], message, config: { minRSABits: 1024 } });
expect(data).to.equal(content);
@ -1589,7 +1589,7 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
});
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 privKey2 = await openpgp.readKey({ armoredKey: priv_key_arm2 });
await privKey2.decrypt('hello world');
@ -1608,7 +1608,7 @@ hkJiXopCSWKSlQInL1devkJJUWJmTmZeugJYlpdLAagQJM0JpsCqIQZwKgAA
const opt = { userIDs: { name:'test', email:'a@b.com' }, passphrase: null };
return openpgp.generateKey(opt).then(async function(gen) {
const key = gen.key;
const message = await openpgp.Message.fromText('hello world');
const message = await openpgp.createMessage({ text: 'hello world' });
return message.sign([key]);
});
});

66
test/general/streaming.js
View File

@ -196,7 +196,7 @@ function tests() {
}
});
const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromBinary(data),
message: await openpgp.createMessage({ binary: data }),
passwords: ['test']
});
const msgAsciiArmored = await openpgp.stream.readToEnd(encrypted);
@ -210,7 +210,7 @@ function tests() {
it('Encrypt larger message', async function() {
const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromBinary(data),
message: await openpgp.createMessage({ binary: data }),
passwords: ['test']
});
const reader = openpgp.stream.getReader(encrypted);
@ -229,7 +229,7 @@ function tests() {
it('Input stream should be canceled when canceling encrypted stream', async function() {
const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromBinary(data),
message: await openpgp.createMessage({ binary: data }),
passwords: ['test']
});
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() {
const signed = await openpgp.sign({
message: await openpgp.Message.fromBinary(data),
message: await openpgp.createMessage({ binary: data }),
privateKeys: privKey,
config: { minRSABits: 1024 }
});
@ -258,7 +258,7 @@ function tests() {
const aeadProtectValue = openpgp.config.aeadProtect;
openpgp.config.aeadProtect = false;
const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromBinary(data),
message: await openpgp.createMessage({ binary: data }),
passwords: ['test'],
armor: false
});
@ -286,7 +286,7 @@ function tests() {
openpgp.config.allowUnauthenticatedStream = true;
try {
const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromBinary(data),
message: await openpgp.createMessage({ binary: data }),
passwords: ['test'],
armor: false
});
@ -316,7 +316,7 @@ function tests() {
openpgp.config.allowUnauthenticatedStream = true;
try {
const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromBinary(data),
message: await openpgp.createMessage({ binary: data }),
publicKeys: pubKey,
privateKeys: privKey,
armor: false,
@ -349,7 +349,7 @@ function tests() {
await priv.decrypt(xPass);
try {
const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromBinary(data),
message: await openpgp.createMessage({ binary: data }),
publicKeys: pub,
privateKeys: priv,
armor: false
@ -381,7 +381,7 @@ function tests() {
await priv.decrypt(brainpoolPass);
try {
const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromBinary(data),
message: await openpgp.createMessage({ binary: data }),
publicKeys: pub,
privateKeys: priv,
armor: false
@ -412,7 +412,7 @@ function tests() {
openpgp.config.allowUnauthenticatedStream = true;
try {
const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromBinary(data, 'msg.bin'),
message: await openpgp.createMessage({ binary: data, filename: 'msg.bin' }),
passwords: ['test']
});
expect(openpgp.stream.isStream(encrypted)).to.equal(expectedType);
@ -449,7 +449,7 @@ function tests() {
openpgp.config.allowUnauthenticatedStream = true;
try {
const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromBinary(data),
message: await openpgp.createMessage({ binary: data }),
publicKeys: pubKey,
privateKeys: privKey,
config: { minRSABits: 1024 }
@ -487,7 +487,7 @@ function tests() {
openpgp.config.allowUnauthenticatedStream = true;
try {
const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromBinary(data),
message: await openpgp.createMessage({ binary: data }),
publicKeys: pubKey,
privateKeys: privKey,
config: { minRSABits: 1024 }
@ -522,7 +522,7 @@ function tests() {
it('Sign/verify: Detect armor checksum error', async function() {
const signed = await openpgp.sign({
message: await openpgp.Message.fromBinary(data),
message: await openpgp.createMessage({ binary: data }),
privateKeys: privKey,
config: { minRSABits: 1024 }
});
@ -578,7 +578,7 @@ function tests() {
it('Sign/verify: Input stream should be canceled when canceling verified stream', async function() {
const signed = await openpgp.sign({
message: await openpgp.Message.fromBinary(data),
message: await openpgp.createMessage({ binary: data }),
privateKeys: privKey,
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() {
const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromBinary(data),
message: await openpgp.createMessage({ binary: data }),
passwords: ['test']
});
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() {
const signed = await openpgp.sign({
message: await openpgp.Message.fromBinary(data),
message: await openpgp.createMessage({ binary: data }),
privateKeys: privKey,
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() {
const signed = await openpgp.sign({
message: await openpgp.Message.fromBinary(data),
message: await openpgp.createMessage({ binary: data }),
privateKeys: privKey,
config: { minRSABits: 1024 }
});
@ -668,7 +668,7 @@ function tests() {
}
});
const signed = await openpgp.sign({
message: await openpgp.Message.fromBinary(data),
message: await openpgp.createMessage({ binary: data }),
privateKeys: privKey,
detached: true,
streaming: expectedType,
@ -680,7 +680,7 @@ function tests() {
const verified = await openpgp.verify({
signature,
publicKeys: pubKey,
message: await openpgp.Message.fromText('hello world'),
message: await openpgp.createMessage({ text: 'hello world' }),
config: { minRSABits: 1024 }
});
expect(verified.data).to.equal('hello world');
@ -704,7 +704,7 @@ function tests() {
}
});
const signed = await openpgp.sign({
message: await openpgp.Message.fromBinary(data),
message: await openpgp.createMessage({ binary: data }),
privateKeys: privKey,
detached: true,
streaming: false,
@ -716,7 +716,7 @@ function tests() {
const verified = await openpgp.verify({
signature,
publicKeys: pubKey,
message: await openpgp.Message.fromText('hello world'),
message: await openpgp.createMessage({ text: 'hello world' }),
config: { minRSABits: 1024 }
});
expect(verified.data).to.equal('hello world');
@ -743,7 +743,7 @@ function tests() {
const pub = await openpgp.readKey({ armoredKey: brainpoolPub });
await priv.decrypt(brainpoolPass);
const signed = await openpgp.sign({
message: await openpgp.Message.fromBinary(data),
message: await openpgp.createMessage({ binary: data }),
privateKeys: priv,
detached: true,
streaming: expectedType
@ -754,7 +754,7 @@ function tests() {
const verified = await openpgp.verify({
signature,
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.signatures).to.exist.and.have.length(1);
@ -780,7 +780,7 @@ function tests() {
const pub = await openpgp.readKey({ armoredKey: xPub });
await priv.decrypt(xPass);
const signed = await openpgp.sign({
message: await openpgp.Message.fromBinary(data),
message: await openpgp.createMessage({ binary: data }),
privateKeys: priv,
detached: true,
streaming: expectedType
@ -791,7 +791,7 @@ function tests() {
const verified = await openpgp.verify({
signature,
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.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() {
const signed = await openpgp.sign({
message: await openpgp.Message.fromBinary(data),
message: await openpgp.createMessage({ binary: data }),
privateKeys: privKey,
detached: true,
config: { minRSABits: 1024 }
@ -815,7 +815,7 @@ function tests() {
it('Detached sign: Input stream should be canceled when canceling signed stream', async function() {
const signed = await openpgp.sign({
message: await openpgp.Message.fromBinary(data),
message: await openpgp.createMessage({ binary: data }),
privateKeys: privKey,
detached: true,
config: { minRSABits: 1024 }
@ -846,7 +846,7 @@ function tests() {
it('Encrypt and decrypt larger message roundtrip (AEAD)', async function() {
const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromBinary(data),
message: await openpgp.createMessage({ binary: data }),
passwords: ['test'],
armor: false
});
@ -897,7 +897,7 @@ function tests() {
}
});
const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromText(data),
message: await openpgp.createMessage({ text: data }),
streaming: expectedType,
passwords: ['test']
});
@ -927,7 +927,7 @@ function tests() {
}
try {
const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromBinary(data),
message: await openpgp.createMessage({ binary: data }),
passwords: ['test']
});
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() {
const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromBinary(data),
message: await openpgp.createMessage({ binary: data }),
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 data = fs.createReadStream(__filename.replace('streaming.js', 'openpgp.js'), { encoding: 'utf8' });
const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromText(data),
message: await openpgp.createMessage({ text: data }),
passwords: ['test']
});
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 data = fs.createReadStream(__filename.replace('streaming.js', 'openpgp.js'));
const encrypted = await openpgp.encrypt({
message: await openpgp.Message.fromBinary(data),
message: await openpgp.createMessage({ binary: data }),
passwords: ['test'],
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 randomData = input.createSomeMessage();
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 msg = await openpgp.readCleartextMessage({ cleartextMessage: signed });
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 lightPrivate = await load_priv_key('light');
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 lightPublic = await load_pub_key('light');
@ -447,7 +447,7 @@ function omnibus() {
}),
// Signing message
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 => {
const msg = await openpgp.readCleartextMessage({ cleartextMessage: signed });
// Verifying signed message
@ -457,7 +457,7 @@ function omnibus() {
).then(output => expect(output.signatures[0].valid).to.be.true),
// Verifying detached signature
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(),
signature: msg.signature
}).then(output => expect(output.signatures[0].valid).to.be.true)
@ -466,7 +466,7 @@ function omnibus() {
// Encrypting and signing
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()],
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 { readKey, Key, readCleartextMessage, CleartextMessage, enums, PacketList, SignaturePacket } = openpgp;
const { readKey, Key, readCleartextMessage, createCleartextMessage, enums, PacketList, SignaturePacket } = openpgp;
const chai = require('chai');
chai.use(require('chai-as-promised'));
@ -27,7 +27,7 @@ async function generateTestData() {
})).key;
attackerPrivKey.revocationSignatures = [];
const signed = await openpgp.sign({
message: await CleartextMessage.fromText('I am batman'),
message: await createCleartextMessage({ text: 'I am batman' }),
privateKeys: victimPrivKey,
streaming: false,
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 { readKey, Key, message, enums, PacketList, SignaturePacket } = openpgp;
const { readKey, Key, createMessage, enums, PacketList, SignaturePacket } = openpgp;
const chai = require('chai');
chai.use(require('chai-as-promised'));
@ -58,7 +58,7 @@ async function makeKeyValid() {
async function encryptFails(k) {
try {
await openpgp.encrypt({
message: await Message.fromText('Hello', 'hello.txt'),
message: await createMessage({ text: 'Hello', filename: 'hello.txt' }),
publicKeys: k
});
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.
*/
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';
@ -25,7 +25,7 @@ import { expect } from 'chai';
// Encrypt text message (armored)
const text = 'hello';
const textMessage = await Message.fromText('hello');
const textMessage = await createMessage({ text: 'hello' });
const encryptedArmor: string = await encrypt({ publicKeys, message: textMessage });
expect(encryptedArmor).to.include('-----BEGIN PGP MESSAGE-----');
@ -33,7 +33,7 @@ import { expect } from 'chai';
const binary = new Uint8Array(2);
binary[0] = 1;
binary[1] = 2;
const binaryMessage = await Message.fromBinary(binary);
const binaryMessage = await createMessage({ binary });
const encryptedBinary: Uint8Array = await encrypt({ publicKeys, message: binaryMessage, armor: false });
expect(encryptedBinary).to.be.instanceOf(Uint8Array);
@ -54,7 +54,7 @@ import { expect } from 'chai';
expect(encryptedMessage).to.be.instanceOf(Message);
// Sign cleartext message (armored)
const cleartextMessage = await CleartextMessage.fromText('hello');
const cleartextMessage = await createCleartextMessage({ text: 'hello' });
const clearSignedArmor = await sign({ privateKeys, message: cleartextMessage });
expect(clearSignedArmor).to.include('-----BEGIN PGP SIGNED MESSAGE-----');
@ -80,12 +80,12 @@ import { expect } from 'chai';
// // Detached - sign cleartext message (armored)
// 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 });
// console.log(signed); // String
// // 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 });
// console.log(signed); // Uint8Array
@ -99,7 +99,7 @@ import { expect } from 'chai';
// // Streaming - encrypt text message on Node.js (armored)
// 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 });
// encrypted.on('data', chunk => {
// console.log(chunk); // String
@ -107,7 +107,7 @@ import { expect } from 'chai';
// // Streaming - encrypt binary message on Node.js (unarmored)
// 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 });
// 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 });
await privateKey.decrypt('test');
const data = await openpgp.encrypt({
message: await openpgp.Message.fromText(message),
message: await openpgp.createMessage({ text: message }),
publicKeys: publicKey,
privateKeys: privateKey
});