PHP WebShell
Текущая директория: /opt/BitGoJS/node_modules/@cosmjs/crypto/build
Просмотр файла: secp256k1.js
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Secp256k1 = void 0;
const encoding_1 = require("@cosmjs/encoding");
const bn_js_1 = __importDefault(require("bn.js"));
const elliptic_1 = __importDefault(require("elliptic"));
const secp256k1signature_1 = require("./secp256k1signature");
const secp256k1 = new elliptic_1.default.ec("secp256k1");
const secp256k1N = new bn_js_1.default("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141", "hex");
class Secp256k1 {
/**
* Takes a 32 byte private key and returns a privkey/pubkey pair.
*
* The resulting pubkey is uncompressed. For the use in Cosmos it should
* be compressed first using `Secp256k1.compressPubkey`.
*/
static async makeKeypair(privkey) {
if (privkey.length !== 32) {
// is this check missing in secp256k1.validatePrivateKey?
// https://github.com/bitjson/bitcoin-ts/issues/4
throw new Error("input data is not a valid secp256k1 private key");
}
const keypair = secp256k1.keyFromPrivate(privkey);
if (keypair.validate().result !== true) {
throw new Error("input data is not a valid secp256k1 private key");
}
// range test that is not part of the elliptic implementation
const privkeyAsBigInteger = new bn_js_1.default(privkey);
if (privkeyAsBigInteger.gte(secp256k1N)) {
// not strictly smaller than N
throw new Error("input data is not a valid secp256k1 private key");
}
const out = {
privkey: (0, encoding_1.fromHex)(keypair.getPrivate("hex")),
// encodes uncompressed as
// - 1-byte prefix "04"
// - 32-byte x coordinate
// - 32-byte y coordinate
pubkey: Uint8Array.from(keypair.getPublic("array")),
};
return out;
}
/**
* Creates a signature that is
* - deterministic (RFC 6979)
* - lowS signature
* - DER encoded
*/
static async createSignature(messageHash, privkey) {
if (messageHash.length === 0) {
throw new Error("Message hash must not be empty");
}
if (messageHash.length > 32) {
throw new Error("Message hash length must not exceed 32 bytes");
}
const keypair = secp256k1.keyFromPrivate(privkey);
// the `canonical` option ensures creation of lowS signature representations
const { r, s, recoveryParam } = keypair.sign(messageHash, { canonical: true });
if (typeof recoveryParam !== "number")
throw new Error("Recovery param missing");
return new secp256k1signature_1.ExtendedSecp256k1Signature(Uint8Array.from(r.toArray()), Uint8Array.from(s.toArray()), recoveryParam);
}
static async verifySignature(signature, messageHash, pubkey) {
if (messageHash.length === 0) {
throw new Error("Message hash must not be empty");
}
if (messageHash.length > 32) {
throw new Error("Message hash length must not exceed 32 bytes");
}
const keypair = secp256k1.keyFromPublic(pubkey);
// From https://github.com/indutny/elliptic:
//
// Sign the message's hash (input must be an array, or a hex-string)
//
// Signature MUST be either:
// 1) DER-encoded signature as hex-string; or
// 2) DER-encoded signature as buffer; or
// 3) object with two hex-string properties (r and s); or
// 4) object with two buffer properties (r and s)
//
// Uint8Array is not a Buffer, but elliptic seems to be happy with the interface
// common to both types. Uint8Array is not an array of ints but the interface is
// similar
try {
return keypair.verify(messageHash, signature.toDer());
}
catch (error) {
return false;
}
}
static recoverPubkey(signature, messageHash) {
const signatureForElliptic = { r: (0, encoding_1.toHex)(signature.r()), s: (0, encoding_1.toHex)(signature.s()) };
const point = secp256k1.recoverPubKey(messageHash, signatureForElliptic, signature.recovery);
const keypair = secp256k1.keyFromPublic(point);
return (0, encoding_1.fromHex)(keypair.getPublic(false, "hex"));
}
/**
* Takes a compressed or uncompressed pubkey and return a compressed one.
*
* This function is idempotent.
*/
static compressPubkey(pubkey) {
switch (pubkey.length) {
case 33:
return pubkey;
case 65:
return Uint8Array.from(secp256k1.keyFromPublic(pubkey).getPublic(true, "array"));
default:
throw new Error("Invalid pubkey length");
}
}
/**
* Takes a compressed or uncompressed pubkey and returns an uncompressed one.
*
* This function is idempotent.
*/
static uncompressPubkey(pubkey) {
switch (pubkey.length) {
case 33:
return Uint8Array.from(secp256k1.keyFromPublic(pubkey).getPublic(false, "array"));
case 65:
return pubkey;
default:
throw new Error("Invalid pubkey length");
}
}
static trimRecoveryByte(signature) {
switch (signature.length) {
case 64:
return signature;
case 65:
return signature.slice(0, 64);
default:
throw new Error("Invalid signature length");
}
}
}
exports.Secp256k1 = Secp256k1;
//# sourceMappingURL=secp256k1.js.mapВыполнить команду
Для локальной разработки. Не используйте в интернете!