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

Internal: rename Curves to CurvesWithOID

Browse Source 
Following the addition of the new format for Montgomery curves,
which do not rely on OIDs.
This commit is contained in:
larabr 2023-03-28 18:14:50 +02:00
parent ef953ce81e
commit b164190f6a
9 changed files with 36 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/crypto/crypto.js
View File

@ -33,7 +33,7 @@ import KDFParams from '../type/kdf_params';
import enums from '../enums'; import enums from '../enums';
import util from '../util'; import util from '../util';
import OID from '../type/oid'; import OID from '../type/oid';
import { Curve } from './public_key/elliptic/curves'; import { CurveWithOID } from './public_key/elliptic/oid_curves';
import { UnsupportedError } from '../packet/packet'; import { UnsupportedError } from '../packet/packet';
import ECDHXSymmetricKey from '../type/ecdh_x_symkey'; import ECDHXSymmetricKey from '../type/ecdh_x_symkey';
@ -219,14 +219,14 @@ export function parsePrivateKeyParams(algo, bytes, publicParams) {
} }
case enums.publicKey.ecdsa: case enums.publicKey.ecdsa:
case enums.publicKey.ecdh: { case enums.publicKey.ecdh: {
const curve = new Curve(publicParams.oid); const curve = new CurveWithOID(publicParams.oid);
let d = util.readMPI(bytes.subarray(read)); read += d.length + 2; let d = util.readMPI(bytes.subarray(read)); read += d.length + 2;
d = util.leftPad(d, curve.payloadSize); d = util.leftPad(d, curve.payloadSize);
return { read, privateParams: { d } }; return { read, privateParams: { d } };
} }
case enums.publicKey.eddsa: case enums.publicKey.eddsa:
case enums.publicKey.ed25519Legacy: { case enums.publicKey.ed25519Legacy: {
const curve = new Curve(publicParams.oid); const curve = new CurveWithOID(publicParams.oid);
let seed = util.readMPI(bytes.subarray(read)); read += seed.length + 2; let seed = util.readMPI(bytes.subarray(read)); read += seed.length + 2;
seed = util.leftPad(seed, curve.payloadSize); seed = util.leftPad(seed, curve.payloadSize);
return { read, privateParams: { seed } }; return { read, privateParams: { seed } };

22
src/crypto/public_key/elliptic/ecdh.js
View File

@ -22,7 +22,7 @@
*/ */
import nacl from '@openpgp/tweetnacl/nacl-fast-light'; import nacl from '@openpgp/tweetnacl/nacl-fast-light';
import { Curve, jwkToRawPublic, rawPublicToJWK, privateToJWK, validateStandardParams } from './curves'; import { CurveWithOID, jwkToRawPublic, rawPublicToJWK, privateToJWK, validateStandardParams } from './oid_curves';
import * as aesKW from '../../aes_kw'; import * as aesKW from '../../aes_kw';
import { getRandomBytes } from '../../random'; import { getRandomBytes } from '../../random';
import hash from '../../hash'; import hash from '../../hash';
@ -86,7 +86,7 @@ async function kdf(hashAlgo, X, length, param, stripLeading = false, stripTraili
/** /**
* Generate ECDHE ephemeral key and secret from public key * Generate ECDHE ephemeral key and secret from public key
* *
* @param {Curve} curve - Elliptic curve object * @param {CurveWithOID} curve - Elliptic curve object
* @param {Uint8Array} Q - Recipient public key * @param {Uint8Array} Q - Recipient public key
* @returns {Promise<{publicKey: Uint8Array, sharedKey: Uint8Array}>} * @returns {Promise<{publicKey: Uint8Array, sharedKey: Uint8Array}>}
* @async * @async
@ -129,7 +129,7 @@ async function genPublicEphemeralKey(curve, Q) {
export async function encrypt(oid, kdfParams, data, Q, fingerprint) { export async function encrypt(oid, kdfParams, data, Q, fingerprint) {
const m = pkcs5.encode(data); const m = pkcs5.encode(data);
const curve = new Curve(oid); const curve = new CurveWithOID(oid);
const { publicKey, sharedKey } = await genPublicEphemeralKey(curve, Q); const { publicKey, sharedKey } = await genPublicEphemeralKey(curve, Q);
const param = buildEcdhParam(enums.publicKey.ecdh, oid, kdfParams, fingerprint); const param = buildEcdhParam(enums.publicKey.ecdh, oid, kdfParams, fingerprint);
const { keySize } = getCipher(kdfParams.cipher); const { keySize } = getCipher(kdfParams.cipher);
@ -141,7 +141,7 @@ export async function encrypt(oid, kdfParams, data, Q, fingerprint) {
/** /**
* Generate ECDHE secret from private key and public part of ephemeral key * Generate ECDHE secret from private key and public part of ephemeral key
* *
* @param {Curve} curve - Elliptic curve object * @param {CurveWithOID} curve - Elliptic curve object
* @param {Uint8Array} V - Public part of ephemeral key * @param {Uint8Array} V - Public part of ephemeral key
* @param {Uint8Array} Q - Recipient public key * @param {Uint8Array} Q - Recipient public key
* @param {Uint8Array} d - Recipient private key * @param {Uint8Array} d - Recipient private key
@ -189,7 +189,7 @@ async function genPrivateEphemeralKey(curve, V, Q, d) {
* @async * @async
*/ */
export async function decrypt(oid, kdfParams, V, C, Q, d, fingerprint) { export async function decrypt(oid, kdfParams, V, C, Q, d, fingerprint) {
const curve = new Curve(oid); const curve = new CurveWithOID(oid);
const { sharedKey } = await genPrivateEphemeralKey(curve, V, Q, d); const { sharedKey } = await genPrivateEphemeralKey(curve, V, Q, d);
const param = buildEcdhParam(enums.publicKey.ecdh, oid, kdfParams, fingerprint); const param = buildEcdhParam(enums.publicKey.ecdh, oid, kdfParams, fingerprint);
const { keySize } = getCipher(kdfParams.cipher); const { keySize } = getCipher(kdfParams.cipher);
@ -209,7 +209,7 @@ export async function decrypt(oid, kdfParams, V, C, Q, d, fingerprint) {
/** /**
* Generate ECDHE secret from private key and public part of ephemeral key using webCrypto * Generate ECDHE secret from private key and public part of ephemeral key using webCrypto
* *
* @param {Curve} curve - Elliptic curve object * @param {CurveWithOID} curve - Elliptic curve object
* @param {Uint8Array} V - Public part of ephemeral key * @param {Uint8Array} V - Public part of ephemeral key
* @param {Uint8Array} Q - Recipient public key * @param {Uint8Array} Q - Recipient public key
* @param {Uint8Array} d - Recipient private key * @param {Uint8Array} d - Recipient private key
@ -262,7 +262,7 @@ async function webPrivateEphemeralKey(curve, V, Q, d) {
/** /**
* Generate ECDHE ephemeral key and secret from public key using webCrypto * Generate ECDHE ephemeral key and secret from public key using webCrypto
* *
* @param {Curve} curve - Elliptic curve object * @param {CurveWithOID} curve - Elliptic curve object
* @param {Uint8Array} Q - Recipient public key * @param {Uint8Array} Q - Recipient public key
* @returns {Promise<{publicKey: Uint8Array, sharedKey: Uint8Array}>} * @returns {Promise<{publicKey: Uint8Array, sharedKey: Uint8Array}>}
* @async * @async
@ -310,7 +310,7 @@ async function webPublicEphemeralKey(curve, Q) {
/** /**
* Generate ECDHE secret from private key and public part of ephemeral key using indutny/elliptic * Generate ECDHE secret from private key and public part of ephemeral key using indutny/elliptic
* *
* @param {Curve} curve - Elliptic curve object * @param {CurveWithOID} curve - Elliptic curve object
* @param {Uint8Array} V - Public part of ephemeral key * @param {Uint8Array} V - Public part of ephemeral key
* @param {Uint8Array} d - Recipient private key * @param {Uint8Array} d - Recipient private key
* @returns {Promise<{secretKey: Uint8Array, sharedKey: Uint8Array}>} * @returns {Promise<{secretKey: Uint8Array, sharedKey: Uint8Array}>}
@ -330,7 +330,7 @@ async function ellipticPrivateEphemeralKey(curve, V, d) {
/** /**
* Generate ECDHE ephemeral key and secret from public key using indutny/elliptic * Generate ECDHE ephemeral key and secret from public key using indutny/elliptic
* *
* @param {Curve} curve - Elliptic curve object * @param {CurveWithOID} curve - Elliptic curve object
* @param {Uint8Array} Q - Recipient public key * @param {Uint8Array} Q - Recipient public key
* @returns {Promise<{publicKey: Uint8Array, sharedKey: Uint8Array}>} * @returns {Promise<{publicKey: Uint8Array, sharedKey: Uint8Array}>}
* @async * @async
@ -350,7 +350,7 @@ async function ellipticPublicEphemeralKey(curve, Q) {
/** /**
* Generate ECDHE secret from private key and public part of ephemeral key using nodeCrypto * Generate ECDHE secret from private key and public part of ephemeral key using nodeCrypto
* *
* @param {Curve} curve - Elliptic curve object * @param {CurveWithOID} curve - Elliptic curve object
* @param {Uint8Array} V - Public part of ephemeral key * @param {Uint8Array} V - Public part of ephemeral key
* @param {Uint8Array} d - Recipient private key * @param {Uint8Array} d - Recipient private key
* @returns {Promise<{secretKey: Uint8Array, sharedKey: Uint8Array}>} * @returns {Promise<{secretKey: Uint8Array, sharedKey: Uint8Array}>}
@ -367,7 +367,7 @@ async function nodePrivateEphemeralKey(curve, V, d) {
/** /**
* Generate ECDHE ephemeral key and secret from public key using nodeCrypto * Generate ECDHE ephemeral key and secret from public key using nodeCrypto
* *
* @param {Curve} curve - Elliptic curve object * @param {CurveWithOID} curve - Elliptic curve object
* @param {Uint8Array} Q - Recipient public key * @param {Uint8Array} Q - Recipient public key
* @returns {Promise<{publicKey: Uint8Array, sharedKey: Uint8Array}>} * @returns {Promise<{publicKey: Uint8Array, sharedKey: Uint8Array}>}
* @async * @async

8
src/crypto/public_key/elliptic/ecdsa.js
View File

@ -25,7 +25,7 @@ import enums from '../../../enums';
import util from '../../../util'; import util from '../../../util';
import { getRandomBytes } from '../../random'; import { getRandomBytes } from '../../random';
import hash from '../../hash'; import hash from '../../hash';
import { Curve, webCurves, privateToJWK, rawPublicToJWK, validateStandardParams } from './curves'; import { CurveWithOID, webCurves, privateToJWK, rawPublicToJWK, validateStandardParams } from './oid_curves';
import { getIndutnyCurve, keyFromPrivate, keyFromPublic } from './indutnyKey'; import { getIndutnyCurve, keyFromPrivate, keyFromPublic } from './indutnyKey';
const webCrypto = util.getWebCrypto(); const webCrypto = util.getWebCrypto();
@ -46,7 +46,7 @@ const nodeCrypto = util.getNodeCrypto();
* @async * @async
*/ */
export async function sign(oid, hashAlgo, message, publicKey, privateKey, hashed) { export async function sign(oid, hashAlgo, message, publicKey, privateKey, hashed) {
const curve = new Curve(oid); const curve = new CurveWithOID(oid);
if (message && !util.isStream(message)) { if (message && !util.isStream(message)) {
const keyPair = { publicKey, privateKey }; const keyPair = { publicKey, privateKey };
switch (curve.type) { switch (curve.type) {
@ -91,7 +91,7 @@ export async function sign(oid, hashAlgo, message, publicKey, privateKey, hashed
* @async * @async
*/ */
export async function verify(oid, hashAlgo, signature, message, publicKey, hashed) { export async function verify(oid, hashAlgo, signature, message, publicKey, hashed) {
const curve = new Curve(oid); const curve = new CurveWithOID(oid);
if (message && !util.isStream(message)) { if (message && !util.isStream(message)) {
switch (curve.type) { switch (curve.type) {
case 'web': case 'web':
@ -125,7 +125,7 @@ export async function verify(oid, hashAlgo, signature, message, publicKey, hashe
* @async * @async
*/ */
export async function validateParams(oid, Q, d) { export async function validateParams(oid, Q, d) {
const curve = new Curve(oid); const curve = new CurveWithOID(oid);
// Reject curves x25519 and ed25519 // Reject curves x25519 and ed25519
if (curve.keyType !== enums.publicKey.ecdsa) { if (curve.keyType !== enums.publicKey.ecdsa) {
return false; return false;

4
src/crypto/public_key/elliptic/index.js
View File

@ -25,7 +25,7 @@
* @private * @private
*/ */
import { Curve, generate, getPreferredHashAlgo } from './curves'; import { CurveWithOID, generate, getPreferredHashAlgo } from './oid_curves';
import * as ecdsa from './ecdsa'; import * as ecdsa from './ecdsa';
import * as eddsaLegacy from './eddsa_legacy'; import * as eddsaLegacy from './eddsa_legacy';
import * as eddsa from './eddsa'; import * as eddsa from './eddsa';
@ -33,5 +33,5 @@ import * as ecdh from './ecdh';
import * as ecdhX from './ecdh_x'; import * as ecdhX from './ecdh_x';
export { export {
Curve, ecdh, ecdhX, ecdsa, eddsaLegacy, eddsa, generate, getPreferredHashAlgo CurveWithOID, ecdh, ecdhX, ecdsa, eddsaLegacy, eddsa, generate, getPreferredHashAlgo
}; };

6
src/crypto/public_key/elliptic/curves.js → src/crypto/public_key/elliptic/oid_curves.js
View File

@ -131,7 +131,7 @@ const curves = {
} }
}; };
class Curve { class CurveWithOID {
constructor(oidOrName, params) { constructor(oidOrName, params) {
try { try {
if (util.isArray(oidOrName) || if (util.isArray(oidOrName) ||
@ -208,7 +208,7 @@ class Curve {
async function generate(curve) { async function generate(curve) {
const BigInteger = await util.getBigInteger(); const BigInteger = await util.getBigInteger();
curve = new Curve(curve); curve = new CurveWithOID(curve);
const keyPair = await curve.genKeyPair(); const keyPair = await curve.genKeyPair();
const Q = new BigInteger(keyPair.publicKey).toUint8Array(); const Q = new BigInteger(keyPair.publicKey).toUint8Array();
const secret = new BigInteger(keyPair.privateKey).toUint8Array('be', curve.payloadSize); const secret = new BigInteger(keyPair.privateKey).toUint8Array('be', curve.payloadSize);
@ -293,7 +293,7 @@ async function validateStandardParams(algo, oid, Q, d) {
} }
export { export {
Curve, curves, webCurves, nodeCurves, generate, getPreferredHashAlgo, jwkToRawPublic, rawPublicToJWK, privateToJWK, validateStandardParams CurveWithOID, curves, webCurves, nodeCurves, generate, getPreferredHashAlgo, jwkToRawPublic, rawPublicToJWK, privateToJWK, validateStandardParams
}; };
////////////////////////// //////////////////////////

2
src/crypto/signature.js
View File

@ -97,7 +97,7 @@ export async function verify(algo, hashAlgo, signature, publicParams, data, hash
} }
case enums.publicKey.ecdsa: { case enums.publicKey.ecdsa: {
const { oid, Q } = publicParams; const { oid, Q } = publicParams;
const curveSize = new publicKey.elliptic.Curve(oid).payloadSize; const curveSize = new publicKey.elliptic.CurveWithOID(oid).payloadSize;
// padding needed for webcrypto // padding needed for webcrypto
const r = util.leftPad(signature.r, curveSize); const r = util.leftPad(signature.r, curveSize);
const s = util.leftPad(signature.s, curveSize); const s = util.leftPad(signature.s, curveSize);

14
test/crypto/ecdh.js
View File

@ -20,7 +20,7 @@ module.exports = () => describe('ECDH key exchange @lightweight', function () {
data = new Uint8Array(data); data = new Uint8Array(data);
} }
return Promise.resolve().then(() => { return Promise.resolve().then(() => {
const curve = new elliptic_curves.Curve(oid); const curve = new elliptic_curves.CurveWithOID(oid);
return elliptic_curves.ecdh.decrypt( return elliptic_curves.ecdh.decrypt(
new OID(curve.oid), new OID(curve.oid),
new KDFParams({ cipher, hash }), new KDFParams({ cipher, hash }),
@ -138,7 +138,7 @@ module.exports = () => describe('ECDH key exchange @lightweight', function () {
if (!openpgp.config.useIndutnyElliptic && !util.getNodeCrypto()) { if (!openpgp.config.useIndutnyElliptic && !util.getNodeCrypto()) {
this.skip(); this.skip();
} }
const curve = new elliptic_curves.Curve('secp256k1'); const curve = new elliptic_curves.CurveWithOID('secp256k1');
const oid = new OID(curve.oid); const oid = new OID(curve.oid);
const kdfParams = new KDFParams({ hash: curve.hash, cipher: curve.cipher }); const kdfParams = new KDFParams({ hash: curve.hash, cipher: curve.cipher });
const data = util.stringToUint8Array('test'); const data = util.stringToUint8Array('test');
@ -148,7 +148,7 @@ module.exports = () => describe('ECDH key exchange @lightweight', function () {
}); });
it('Different keys', async function () { it('Different keys', async function () {
const curve = new elliptic_curves.Curve('curve25519'); const curve = new elliptic_curves.CurveWithOID('curve25519');
const oid = new OID(curve.oid); const oid = new OID(curve.oid);
const kdfParams = new KDFParams({ hash: curve.hash, cipher: curve.cipher }); const kdfParams = new KDFParams({ hash: curve.hash, cipher: curve.cipher });
const data = util.stringToUint8Array('test'); const data = util.stringToUint8Array('test');
@ -159,7 +159,7 @@ module.exports = () => describe('ECDH key exchange @lightweight', function () {
}); });
it('Invalid fingerprint', async function () { it('Invalid fingerprint', async function () {
const curve = new elliptic_curves.Curve('curve25519'); const curve = new elliptic_curves.CurveWithOID('curve25519');
const oid = new OID(curve.oid); const oid = new OID(curve.oid);
const kdfParams = new KDFParams({ hash: curve.hash, cipher: curve.cipher }); const kdfParams = new KDFParams({ hash: curve.hash, cipher: curve.cipher });
const data = util.stringToUint8Array('test'); const data = util.stringToUint8Array('test');
@ -170,7 +170,7 @@ module.exports = () => describe('ECDH key exchange @lightweight', function () {
}); });
it('Successful exchange x25519 (legacy)', async function () { it('Successful exchange x25519 (legacy)', async function () {
const curve = new elliptic_curves.Curve('curve25519'); const curve = new elliptic_curves.CurveWithOID('curve25519');
const oid = new OID(curve.oid); const oid = new OID(curve.oid);
const kdfParams = new KDFParams({ hash: curve.hash, cipher: curve.cipher }); const kdfParams = new KDFParams({ hash: curve.hash, cipher: curve.cipher });
const data = util.stringToUint8Array('test'); const data = util.stringToUint8Array('test');
@ -190,7 +190,7 @@ module.exports = () => describe('ECDH key exchange @lightweight', function () {
['p256', 'p384', 'p521'].forEach(curveName => { ['p256', 'p384', 'p521'].forEach(curveName => {
it(`NIST ${curveName} - Successful exchange`, async function () { it(`NIST ${curveName} - Successful exchange`, async function () {
const curve = new elliptic_curves.Curve(curveName); const curve = new elliptic_curves.CurveWithOID(curveName);
const oid = new OID(curve.oid); const oid = new OID(curve.oid);
const kdfParams = new KDFParams({ hash: curve.hash, cipher: curve.cipher }); const kdfParams = new KDFParams({ hash: curve.hash, cipher: curve.cipher });
const data = util.stringToUint8Array('test'); const data = util.stringToUint8Array('test');
@ -233,7 +233,7 @@ module.exports = () => describe('ECDH key exchange @lightweight', function () {
this.skip(); this.skip();
} }
const curve = new elliptic_curves.Curve(curveName); const curve = new elliptic_curves.CurveWithOID(curveName);
const oid = new OID(curve.oid); const oid = new OID(curve.oid);
const kdfParams = new KDFParams({ hash: curve.hash, cipher: curve.cipher }); const kdfParams = new KDFParams({ hash: curve.hash, cipher: curve.cipher });
const data = util.stringToUint8Array('test'); const data = util.stringToUint8Array('test');

8
test/crypto/elliptic.js
View File

@ -59,10 +59,10 @@ module.exports = () => describe('Elliptic Curve Cryptography @lightweight', func
describe('Basic Operations', function () { describe('Basic Operations', function () {
it('Creating curve from name or oid', function (done) { it('Creating curve from name or oid', function (done) {
Object.keys(openpgp.enums.curve).forEach(function(name_or_oid) { Object.keys(openpgp.enums.curve).forEach(function(name_or_oid) {
expect(new elliptic_curves.Curve(name_or_oid)).to.exist; expect(new elliptic_curves.CurveWithOID(name_or_oid)).to.exist;
}); });
Object.values(openpgp.enums.curve).forEach(function(name_or_oid) { Object.values(openpgp.enums.curve).forEach(function(name_or_oid) {
expect(new elliptic_curves.Curve(name_or_oid)).to.exist; expect(new elliptic_curves.CurveWithOID(name_or_oid)).to.exist;
}); });
done(); done();
}); });
@ -73,7 +73,7 @@ module.exports = () => describe('Elliptic Curve Cryptography @lightweight', func
const names = config.useIndutnyElliptic ? ['p256', 'p384', 'p521', 'secp256k1', 'curve25519', 'brainpoolP256r1', 'brainpoolP384r1', 'brainpoolP512r1'] : const names = config.useIndutnyElliptic ? ['p256', 'p384', 'p521', 'secp256k1', 'curve25519', 'brainpoolP256r1', 'brainpoolP384r1', 'brainpoolP512r1'] :
['p256', 'p384', 'p521', 'curve25519']; ['p256', 'p384', 'p521', 'curve25519'];
return Promise.all(names.map(function (name) { return Promise.all(names.map(function (name) {
const curve = new elliptic_curves.Curve(name); const curve = new elliptic_curves.CurveWithOID(name);
return curve.genKeyPair().then(keyPair => { return curve.genKeyPair().then(keyPair => {
expect(keyPair).to.exist; expect(keyPair).to.exist;
}); });
@ -243,7 +243,7 @@ module.exports = () => describe('Elliptic Curve Cryptography @lightweight', func
.to.eventually.be.true.notify(done); .to.eventually.be.true.notify(done);
}); });
it('Sign and verify message', function () { it('Sign and verify message', function () {
const curve = new elliptic_curves.Curve('p521'); const curve = new elliptic_curves.CurveWithOID('p521');
return curve.genKeyPair().then(async keyPair => { return curve.genKeyPair().then(async keyPair => {
const keyPublic = new Uint8Array(keyPair.publicKey); const keyPublic = new Uint8Array(keyPair.publicKey);
const keyPrivate = new Uint8Array(keyPair.privateKey); const keyPrivate = new Uint8Array(keyPair.privateKey);

2
test/general/x25519.js
View File

@ -218,7 +218,7 @@ module.exports = () => (openpgp.config.ci ? describe.skip : describe)('X25519 Cr
describe('Ed25519 Test Vectors from RFC8032', function () { describe('Ed25519 Test Vectors from RFC8032', function () {
// https://tools.ietf.org/html/rfc8032#section-7.1 // https://tools.ietf.org/html/rfc8032#section-7.1
function testVector(vector) { function testVector(vector) {
const curve = new elliptic.Curve('ed25519'); const curve = new elliptic.CurveWithOID('ed25519');
const { publicKey } = nacl.sign.keyPair.fromSeed(util.hexToUint8Array(vector.SECRET_KEY)); const { publicKey } = nacl.sign.keyPair.fromSeed(util.hexToUint8Array(vector.SECRET_KEY));
expect(publicKey).to.deep.equal(util.hexToUint8Array(vector.PUBLIC_KEY)); expect(publicKey).to.deep.equal(util.hexToUint8Array(vector.PUBLIC_KEY));
const data = vector.MESSAGE; const data = vector.MESSAGE;