40542fd08a
- `openpgp.generateKey`, `reformatKey` and `revokeKey` take a new `format`
option, whose possible values are: `'armor', 'binary', 'object'` (default is
`'armor'`).
- `generateKey` and `reformatKey` now return an object of the form `{
publicKey, privateKey, revocationCertificate }`, where the type of `publicKey`
and `privateKey` depends on `options.format`:
* if `format: 'armor'` then `privateKey, publicKey` are armored strings;
* if `format: 'binary'` then `privateKey, publicKey` are `Uint8Array`;
* if `format: 'object'` then `privateKey, publicKey` are `PrivateKey` and
`PublicKey` objects respectively;
- `revokeKey` now returns `{ publicKey, privateKey }`, where:
* if a `PrivateKey` is passed as `key` input, `privateKey, publicKey` are of the
requested format;
* if a `PublicKey` is passed as `key` input, `publicKey` is of the requested format,
while `privateKey` is `null` (previously, in this case the `privateKey` field
was not defined).
Breaking changes:
- In `revokeKey`, if no `format` option is specified, the returned `publicKey,
privateKey` are armored strings (they used to be objects).
- In `generateKey` and `reformatKey`, the `key` value is no longer returned.
- For all three functions, the `publicKeyArmored` and `privateKeyArmored`
values are no longer returned.
79 lines
3.7 KiB
JavaScript
79 lines
3.7 KiB
JavaScript
const openpgp = typeof window !== 'undefined' && window.openpgp ? window.openpgp : require('../..');
|
|
|
|
const chai = require('chai');
|
|
chai.use(require('chai-as-promised'));
|
|
const input = require('./testInputs.js');
|
|
const util = require('../../src/util');
|
|
|
|
const expect = chai.expect;
|
|
|
|
module.exports = () => describe('Elliptic Curve Cryptography for NIST P-256,P-384,P-521 curves @lightweight', function () {
|
|
function omnibus() {
|
|
it('Omnibus NIST P-256 Test', async function () {
|
|
const testData = input.createSomeMessage();
|
|
const testData2 = input.createSomeMessage();
|
|
|
|
const { privateKey: hi, publicKey: pubHi } = await openpgp.generateKey({ userIDs: { name: "Hi", email: "hi@hel.lo" }, curve: "p256", format: 'object' });
|
|
const { privateKey: bye, publicKey: pubBye } = await openpgp.generateKey({ userIDs: { name: "Bye", email: "bye@good.bye" }, curve: "p256", format: 'object' });
|
|
|
|
const cleartextMessage = await openpgp.sign({ message: await openpgp.createCleartextMessage({ text: testData }), signingKeys: hi });
|
|
await openpgp.verify({
|
|
message: await openpgp.readCleartextMessage({ cleartextMessage }),
|
|
verificationKeys: pubHi
|
|
}).then(output => expect(output.signatures[0].valid).to.be.true);
|
|
// Verifying detached signature
|
|
await openpgp.verify({
|
|
message: await openpgp.createMessage({ text: util.removeTrailingSpaces(testData) }),
|
|
verificationKeys: 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.createMessage({ text: testData2 }),
|
|
encryptionKeys: [pubBye],
|
|
signingKeys: [hi]
|
|
});
|
|
// Decrypting and verifying
|
|
return openpgp.decrypt({
|
|
message: await openpgp.readMessage({ armoredMessage: encrypted }),
|
|
decryptionKeys: bye,
|
|
verificationKeys: [pubHi]
|
|
}).then(output => {
|
|
expect(output.data).to.equal(testData2);
|
|
expect(output.signatures[0].valid).to.be.true;
|
|
});
|
|
});
|
|
}
|
|
|
|
omnibus();
|
|
|
|
it('Sign message', async function () {
|
|
const testData = input.createSomeMessage();
|
|
const options = { userIDs: { name: "Hi", email: "hi@hel.lo" }, curve: "p256", format: 'object' };
|
|
const { privateKey, publicKey } = await openpgp.generateKey(options);
|
|
const signature = await openpgp.sign({ message: await openpgp.createCleartextMessage({ text: testData }), signingKeys: privateKey });
|
|
const msg = await openpgp.readCleartextMessage({ cleartextMessage: signature });
|
|
const result = await openpgp.verify({ message: msg, verificationKeys: publicKey });
|
|
expect(result.signatures[0].valid).to.be.true;
|
|
});
|
|
|
|
it('Encrypt and sign message', async function () {
|
|
const testData = input.createSomeMessage();
|
|
let options = { userIDs: { name: "Hi", email: "hi@hel.lo" }, curve: "p256", format: 'object' };
|
|
const firstKey = await openpgp.generateKey(options);
|
|
options = { userIDs: { name: "Bye", email: "bye@good.bye" }, curve: "p256", format: 'object' };
|
|
const secondKey = await openpgp.generateKey(options);
|
|
const encrypted = await openpgp.encrypt({
|
|
message: await openpgp.createMessage({ text: testData }),
|
|
encryptionKeys: secondKey.publicKey,
|
|
signingKeys: firstKey.privateKey
|
|
});
|
|
const message = await openpgp.readMessage({ armoredMessage: encrypted });
|
|
const result = await openpgp.decrypt({ message, decryptionKeys: secondKey.privateKey, verificationKeys: firstKey.publicKey });
|
|
expect(result.signatures[0].valid).to.be.true;
|
|
});
|
|
|
|
// TODO find test vectors
|
|
});
|