mirror of
https://github.com/openpgpjs/openpgpjs.git
synced 2025-06-10 16:16:45 +00:00
232 lines
7.1 KiB
JavaScript
232 lines
7.1 KiB
JavaScript
// OpenPGP.js - An OpenPGP implementation in javascript
|
|
// Copyright (C) 2015-2016 Decentral
|
|
//
|
|
// This library is free software; you can redistribute it and/or
|
|
// modify it under the terms of the GNU Lesser General Public
|
|
// License as published by the Free Software Foundation; either
|
|
// version 3.0 of the License, or (at your option) any later version.
|
|
//
|
|
// This library is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
// Lesser General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Lesser General Public
|
|
// License along with this library; if not, write to the Free Software
|
|
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
|
|
// Wrapper for a KeyPair of an Elliptic Curve
|
|
|
|
/**
|
|
* @requires bn.js
|
|
* @requires crypto/public_key/elliptic/curves
|
|
* @requires crypto/hash
|
|
* @requires util
|
|
* @requires enums
|
|
* @requires encoding/base64
|
|
* @requires jwk-to-pem
|
|
* @requires asn1.js
|
|
* @module crypto/public_key/elliptic/key
|
|
*/
|
|
|
|
import BN from 'bn.js';
|
|
import { webCurves, nodeCurves } from './curves';
|
|
import hash from '../../hash';
|
|
import util from '../../../util';
|
|
import enums from '../../../enums';
|
|
import base64 from '../../../encoding/base64';
|
|
|
|
const webCrypto = util.getWebCrypto();
|
|
const nodeCrypto = util.getNodeCrypto();
|
|
|
|
const jwkToPem = nodeCrypto ? require('jwk-to-pem') : undefined;
|
|
const ECDSASignature = nodeCrypto ?
|
|
require('asn1.js').define('ECDSASignature', function() {
|
|
this.seq().obj(
|
|
this.key('r').int(),
|
|
this.key('s').int()
|
|
);
|
|
}) : undefined;
|
|
|
|
export default function KeyPair(curve, options) {
|
|
this.curve = curve;
|
|
this.keyType = curve.curve.type === 'edwards' ? enums.publicKey.eddsa : enums.publicKey.ecdsa;
|
|
this.keyPair = this.curve.keyPair(options);
|
|
}
|
|
|
|
KeyPair.prototype.sign = async function (message, hash_algo) {
|
|
if (webCrypto && this.curve.web) {
|
|
// If browser doesn't support a curve, we'll catch it
|
|
try {
|
|
return webSign(this.curve, hash_algo, message, this.keyPair);
|
|
} catch (err) {
|
|
util.print_debug("Browser did not support signing: " + err.message);
|
|
}
|
|
} else if (nodeCrypto && this.curve.node) {
|
|
return nodeSign(this.curve, hash_algo, message, this.keyPair);
|
|
}
|
|
const digest = (typeof hash_algo === 'undefined') ? message : hash.digest(hash_algo, message);
|
|
return this.keyPair.sign(digest);
|
|
};
|
|
|
|
KeyPair.prototype.verify = async function (message, signature, hash_algo) {
|
|
if (webCrypto && this.curve.web) {
|
|
// If browser doesn't support a curve, we'll catch it
|
|
try {
|
|
return webVerify(this.curve, hash_algo, signature, message, this.keyPair.getPublic());
|
|
} catch (err) {
|
|
util.print_debug("Browser did not support signing: " + err.message);
|
|
}
|
|
} else if (nodeCrypto && this.curve.node) {
|
|
return nodeVerify(this.curve, hash_algo, signature, message, this.keyPair.getPublic());
|
|
}
|
|
const digest = (typeof hash_algo === 'undefined') ? message : hash.digest(hash_algo, message);
|
|
return this.keyPair.verify(digest, signature);
|
|
};
|
|
|
|
KeyPair.prototype.derive = function (pub) {
|
|
if (this.keyType === enums.publicKey.eddsa) {
|
|
throw new Error('Key can only be used for EdDSA');
|
|
}
|
|
return this.keyPair.derive(pub.keyPair.getPublic());
|
|
};
|
|
|
|
KeyPair.prototype.getPublic = function () {
|
|
const compact = (this.curve.curve.type === 'edwards' || this.curve.curve.type === 'mont');
|
|
return this.keyPair.getPublic('array', compact);
|
|
};
|
|
|
|
KeyPair.prototype.getPrivate = function () {
|
|
if (this.keyType === enums.publicKey.eddsa) {
|
|
return this.keyPair.getSecret();
|
|
}
|
|
return this.keyPair.getPrivate().toArray();
|
|
};
|
|
|
|
|
|
//////////////////////////
|
|
// //
|
|
// Helper functions //
|
|
// //
|
|
//////////////////////////
|
|
|
|
|
|
async function webSign(curve, hash_algo, message, keyPair) {
|
|
const l = curve.payloadSize;
|
|
const key = await webCrypto.importKey(
|
|
"jwk",
|
|
{
|
|
"kty": "EC",
|
|
"crv": webCurves[curve.name],
|
|
"x": base64.encode(new Uint8Array(keyPair.getPublic().getX().toArray('be', l)), true),
|
|
"y": base64.encode(new Uint8Array(keyPair.getPublic().getY().toArray('be', l)), true),
|
|
"d": base64.encode(new Uint8Array(keyPair.getPrivate().toArray('be', l)), true),
|
|
"use": "sig",
|
|
"kid": "ECDSA Private Key"
|
|
},
|
|
{
|
|
"name": "ECDSA",
|
|
"namedCurve": webCurves[curve.name],
|
|
"hash": { name: enums.read(enums.webHash, curve.hash) }
|
|
},
|
|
false,
|
|
["sign"]
|
|
);
|
|
|
|
const signature = new Uint8Array(await webCrypto.sign(
|
|
{
|
|
"name": 'ECDSA',
|
|
"namedCurve": webCurves[curve.name],
|
|
"hash": { name: enums.read(enums.webHash, hash_algo) }
|
|
},
|
|
key,
|
|
message
|
|
));
|
|
return {
|
|
r: signature.slice(0, l),
|
|
s: signature.slice(l, 2 * l)
|
|
};
|
|
}
|
|
|
|
async function webVerify(curve, hash_algo, { r, s }, message, publicKey) {
|
|
const l = curve.payloadSize;
|
|
r = Array(l - r.length).fill(0).concat(r);
|
|
s = Array(l - s.length).fill(0).concat(s);
|
|
const signature = new Uint8Array(r.concat(s)).buffer;
|
|
const key = await webCrypto.importKey(
|
|
"jwk",
|
|
{
|
|
"kty": "EC",
|
|
"crv": webCurves[curve.name],
|
|
"x": base64.encode(new Uint8Array(publicKey.getX().toArray('be', l)), true),
|
|
"y": base64.encode(new Uint8Array(publicKey.getY().toArray('be', l)), true),
|
|
"use": "sig",
|
|
"kid": "ECDSA Public Key"
|
|
},
|
|
{
|
|
"name": "ECDSA",
|
|
"namedCurve": webCurves[curve.name],
|
|
"hash": { name: enums.read(enums.webHash, curve.hash) }
|
|
},
|
|
false,
|
|
["verify"]
|
|
);
|
|
|
|
return webCrypto.verify(
|
|
{
|
|
"name": 'ECDSA',
|
|
"namedCurve": webCurves[curve.name],
|
|
"hash": { name: enums.read(enums.webHash, hash_algo) }
|
|
},
|
|
key,
|
|
signature,
|
|
message
|
|
);
|
|
}
|
|
|
|
|
|
async function nodeSign(curve, hash_algo, message, keyPair) {
|
|
const key = jwkToPem(
|
|
{
|
|
"kty": "EC",
|
|
"crv": webCurves[curve.name],
|
|
"x": base64.encode(new Uint8Array(keyPair.getPublic().getX().toArray())),
|
|
"y": base64.encode(new Uint8Array(keyPair.getPublic().getY().toArray())),
|
|
"d": base64.encode(new Uint8Array(keyPair.getPrivate().toArray())),
|
|
"use": "sig",
|
|
"kid": "ECDSA Private Key"
|
|
},
|
|
{ private: true }
|
|
);
|
|
|
|
const sign = nodeCrypto.createSign(enums.read(enums.hash, hash_algo));
|
|
sign.write(message);
|
|
sign.end();
|
|
const signature = await ECDSASignature.decode(sign.sign(key), 'der');
|
|
return {
|
|
r: signature.r.toArray(),
|
|
s: signature.s.toArray()
|
|
};
|
|
}
|
|
|
|
async function nodeVerify(curve, hash_algo, { r, s }, message, publicKey) {
|
|
const signature = ECDSASignature.encode({ r: new BN(r), s: new BN(s) }, 'der');
|
|
const key = jwkToPem(
|
|
{
|
|
"kty": "EC",
|
|
"crv": webCurves[curve.name],
|
|
"x": base64.encode(new Uint8Array(publicKey.getX().toArray())),
|
|
"y": base64.encode(new Uint8Array(publicKey.getY().toArray())),
|
|
"use": "sig",
|
|
"kid": "ECDSA Public Key"
|
|
},
|
|
{ private: false }
|
|
);
|
|
|
|
const verify = nodeCrypto.createVerify(enums.read(enums.hash, hash_algo));
|
|
verify.write(message);
|
|
verify.end();
|
|
const result = await verify.verify(key, signature);
|
|
return result;
|
|
}
|