gnache-cli 0.0.1-security → 6.12.2

package/node_modules/ethereum-cryptography/src/blake2b.ts

@@ -0,0 +1,9 @@
+const blake2bJs = require("blakejs");
+
+export function blake2b(input: Buffer, outputLength = 64): Buffer {
+  if (outputLength <= 0 || outputLength > 64) {
+    throw Error("Invalid outputLength");
+  }
+
+  return Buffer.from(blake2bJs.blake2b(input, undefined, outputLength));
+}

package/node_modules/ethereum-cryptography/src/hash-utils.ts

@@ -0,0 +1,11 @@
+import { Hash } from "crypto";
+
+export function createHashFunction(
+  hashConstructor: () => Hash
+): (msg: Buffer) => Buffer {
+  return msg => {
+    const hash = hashConstructor();
+    hash.update(msg);
+    return Buffer.from(hash.digest());
+  };
+}

package/node_modules/ethereum-cryptography/src/hdkey.ts

@@ -0,0 +1,5 @@
+import * as hdkeyPure from "./pure/hdkey";
+
+const hdkey: typeof hdkeyPure.HDKey = require("./vendor/hdkey-without-crypto");
+
+export const HDKey = hdkey;

package/node_modules/ethereum-cryptography/src/index.ts

@@ -0,0 +1,3 @@
+throw new Error(
+  "This package has no entry-point. Please consult the README.md to learn how to use it."
+);

package/node_modules/ethereum-cryptography/src/keccak.ts

@@ -0,0 +1,19 @@
+import { createHashFunction } from "./hash-utils";
+
+const createKeccakHash = require("keccak");
+
+export const keccak224 = createHashFunction(() =>
+  createKeccakHash("keccak224")
+);
+
+export const keccak256 = createHashFunction(() =>
+  createKeccakHash("keccak256")
+);
+
+export const keccak384 = createHashFunction(() =>
+  createKeccakHash("keccak384")
+);
+
+export const keccak512 = createHashFunction(() =>
+  createKeccakHash("keccak512")
+);

package/node_modules/ethereum-cryptography/src/pbkdf2.ts

@@ -0,0 +1,37 @@
+import * as pbkdf2Js from "pbkdf2";
+
+export function pbkdf2(
+  password: Buffer,
+  salt: Buffer,
+  iterations: number,
+  keylen: number,
+  digest: string
+): Promise<Buffer> {
+  return new Promise((resolve, reject) => {
+    pbkdf2Js.pbkdf2(
+      password,
+      salt,
+      iterations,
+      keylen,
+      digest,
+      (err, result) => {
+        if (err) {
+          reject(err);
+          return;
+        }
+
+        resolve(result);
+      }
+    );
+  });
+}
+
+export function pbkdf2Sync(
+  password: Buffer,
+  salt: Buffer,
+  iterations: number,
+  keylen: number,
+  digest: string
+): Buffer {
+  return pbkdf2Js.pbkdf2Sync(password, salt, iterations, keylen, digest);
+}

package/node_modules/ethereum-cryptography/src/pure/hdkey.ts

@@ -0,0 +1,36 @@
+export interface Versions {
+  private: number;
+  public: number;
+}
+
+export declare class HDKeyT {
+  public static HARDENED_OFFSET: number;
+  public static fromMasterSeed(seed: Buffer, versions?: Versions): HDKeyT;
+  public static fromExtendedKey(base58key: string, versions?: Versions): HDKeyT;
+  public static fromJSON(json: { xpriv: string }): HDKeyT;
+
+  public versions: Versions;
+  public depth: number;
+  public index: number;
+  public chainCode: Buffer | null;
+  public privateKey: Buffer | null;
+  public publicKey: Buffer | null;
+  public fingerprint: number;
+  public parentFingerprint: number;
+  public pubKeyHash: Buffer | undefined;
+  public identifier: Buffer | undefined;
+  public privateExtendedKey: string;
+  public publicExtendedKey: string;
+
+  private constructor(versios: Versions);
+  public derive(path: string): HDKeyT;
+  public deriveChild(index: number): HDKeyT;
+  public sign(hash: Buffer): Buffer;
+  public verify(hash: Buffer, signature: Buffer): boolean;
+  public wipePrivateData(): this;
+  public toJSON(): { xpriv: string; xpub: string };
+}
+
+const hdkey: typeof HDKeyT = require("./vendor/hdkey-without-crypto");
+
+export const HDKey = hdkey;

package/node_modules/ethereum-cryptography/src/pure/ripemd160.ts

@@ -0,0 +1,5 @@
+const { ripemd160: Ripemd160 } = require("hash.js/lib/hash/ripemd");
+
+import { createHashFunction } from "../hash-utils";
+
+export const ripemd160 = createHashFunction(() => new Ripemd160());

package/node_modules/ethereum-cryptography/src/pure/sha256.ts

@@ -0,0 +1,5 @@
+const Sha256Hash = require("hash.js/lib/hash/sha/256");
+
+import { createHashFunction } from "../hash-utils";
+
+export const sha256 = createHashFunction(() => new Sha256Hash());

package/node_modules/ethereum-cryptography/src/pure/shims/hdkey-crypto.ts

@@ -0,0 +1,42 @@
+import { ripemd160 } from "../ripemd160";
+import { sha256 } from "../sha256";
+
+export const createHmac = require("create-hmac");
+export const randomBytes = require("randombytes");
+
+class Hash {
+  private buffers: Buffer[] = [];
+
+  constructor(private readonly hashFunction: (msg: Buffer) => Buffer) {}
+
+  public update(buffer: Buffer): this {
+    if (!Buffer.isBuffer(buffer)) {
+      throw new Error("hdkey-crypto shim is outdated");
+    }
+
+    this.buffers.push(buffer);
+
+    return this;
+  }
+
+  public digest(param: any): Buffer {
+    if (param) {
+      throw new Error("hdkey-crypto shim is outdated");
+    }
+
+    return this.hashFunction(Buffer.concat(this.buffers));
+  }
+}
+
+// We don't use create-hash here, as it doesn't work well with Rollup
+export const createHash = (name: string) => {
+  if (name === "ripemd160") {
+    return new Hash(ripemd160);
+  }
+
+  if (name === "sha256") {
+    return new Hash(sha256);
+  }
+
+  throw new Error("hdkey-crypto shim is outdated");
+};

package/node_modules/ethereum-cryptography/src/pure/shims/hdkey-secp256k1v3.ts

@@ -0,0 +1 @@
+export * from "../../shims/hdkey-secp256k1v3";

package/node_modules/ethereum-cryptography/src/pure/vendor/hdkey-without-crypto.js

@@ -0,0 +1,255 @@
+'use strict';
+
+function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
+
+var assert = _interopDefault(require('assert'));
+var safeBuffer = _interopDefault(require('safe-buffer'));
+var bs58check = _interopDefault(require('bs58check'));
+
+var cryptoShim = require("../shims/hdkey-crypto");
+
+var secp256k1Shim = require("../shims/hdkey-secp256k1v3");
+
+var Buffer = safeBuffer.Buffer;
+
+
+
+
+var MASTER_SECRET = Buffer.from('Bitcoin seed', 'utf8');
+var HARDENED_OFFSET = 0x80000000;
+var LEN = 78;
+
+// Bitcoin hardcoded by default, can use package `coininfo` for others
+var BITCOIN_VERSIONS = {private: 0x0488ADE4, public: 0x0488B21E};
+
+function HDKey (versions) {
+  this.versions = versions || BITCOIN_VERSIONS;
+  this.depth = 0;
+  this.index = 0;
+  this._privateKey = null;
+  this._publicKey = null;
+  this.chainCode = null;
+  this._fingerprint = 0;
+  this.parentFingerprint = 0;
+}
+
+Object.defineProperty(HDKey.prototype, 'fingerprint', { get: function () { return this._fingerprint } });
+Object.defineProperty(HDKey.prototype, 'identifier', { get: function () { return this._identifier } });
+Object.defineProperty(HDKey.prototype, 'pubKeyHash', { get: function () { return this.identifier } });
+
+Object.defineProperty(HDKey.prototype, 'privateKey', {
+  get: function () {
+    return this._privateKey
+  },
+  set: function (value) {
+    assert.equal(value.length, 32, 'Private key must be 32 bytes.');
+    assert(secp256k1Shim.privateKeyVerify(value) === true, 'Invalid private key');
+
+    this._privateKey = value;
+    this._publicKey = secp256k1Shim.publicKeyCreate(value, true);
+    this._identifier = hash160(this.publicKey);
+    this._fingerprint = this._identifier.slice(0, 4).readUInt32BE(0);
+  }
+});
+
+Object.defineProperty(HDKey.prototype, 'publicKey', {
+  get: function () {
+    return this._publicKey
+  },
+  set: function (value) {
+    assert(value.length === 33 || value.length === 65, 'Public key must be 33 or 65 bytes.');
+    assert(secp256k1Shim.publicKeyVerify(value) === true, 'Invalid public key');
+
+    this._publicKey = secp256k1Shim.publicKeyConvert(value, true); // force compressed point
+    this._identifier = hash160(this.publicKey);
+    this._fingerprint = this._identifier.slice(0, 4).readUInt32BE(0);
+    this._privateKey = null;
+  }
+});
+
+Object.defineProperty(HDKey.prototype, 'privateExtendedKey', {
+  get: function () {
+    if (this._privateKey) return bs58check.encode(serialize(this, this.versions.private, Buffer.concat([Buffer.alloc(1, 0), this.privateKey])))
+    else return null
+  }
+});
+
+Object.defineProperty(HDKey.prototype, 'publicExtendedKey', {
+  get: function () {
+    return bs58check.encode(serialize(this, this.versions.public, this.publicKey))
+  }
+});
+
+HDKey.prototype.derive = function (path) {
+  if (path === 'm' || path === 'M' || path === "m'" || path === "M'") {
+    return this
+  }
+
+  var entries = path.split('/');
+  var hdkey = this;
+  entries.forEach(function (c, i) {
+    if (i === 0) {
+      assert(/^[mM]{1}/.test(c), 'Path must start with "m" or "M"');
+      return
+    }
+
+    var hardened = (c.length > 1) && (c[c.length - 1] === "'");
+    var childIndex = parseInt(c, 10); // & (HARDENED_OFFSET - 1)
+    assert(childIndex < HARDENED_OFFSET, 'Invalid index');
+    if (hardened) childIndex += HARDENED_OFFSET;
+
+    hdkey = hdkey.deriveChild(childIndex);
+  });
+
+  return hdkey
+};
+
+HDKey.prototype.deriveChild = function (index) {
+  var isHardened = index >= HARDENED_OFFSET;
+  var indexBuffer = Buffer.allocUnsafe(4);
+  indexBuffer.writeUInt32BE(index, 0);
+
+  var data;
+
+  if (isHardened) { // Hardened child
+    assert(this.privateKey, 'Could not derive hardened child key');
+
+    var pk = this.privateKey;
+    var zb = Buffer.alloc(1, 0);
+    pk = Buffer.concat([zb, pk]);
+
+    // data = 0x00 || ser256(kpar) || ser32(index)
+    data = Buffer.concat([pk, indexBuffer]);
+  } else { // Normal child
+    // data = serP(point(kpar)) || ser32(index)
+    //      = serP(Kpar) || ser32(index)
+    data = Buffer.concat([this.publicKey, indexBuffer]);
+  }
+
+  var I = cryptoShim.createHmac('sha512', this.chainCode).update(data).digest();
+  var IL = I.slice(0, 32);
+  var IR = I.slice(32);
+
+  var hd = new HDKey(this.versions);
+
+  // Private parent key -> private child key
+  if (this.privateKey) {
+    // ki = parse256(IL) + kpar (mod n)
+    try {
+      hd.privateKey = secp256k1Shim.privateKeyTweakAdd(this.privateKey, IL);
+      // throw if IL >= n || (privateKey + IL) === 0
+    } catch (err) {
+      // In case parse256(IL) >= n or ki == 0, one should proceed with the next value for i
+      return this.deriveChild(index + 1)
+    }
+  // Public parent key -> public child key
+  } else {
+    // Ki = point(parse256(IL)) + Kpar
+    //    = G*IL + Kpar
+    try {
+      hd.publicKey = secp256k1Shim.publicKeyTweakAdd(this.publicKey, IL, true);
+      // throw if IL >= n || (g**IL + publicKey) is infinity
+    } catch (err) {
+      // In case parse256(IL) >= n or Ki is the point at infinity, one should proceed with the next value for i
+      return this.deriveChild(index + 1)
+    }
+  }
+
+  hd.chainCode = IR;
+  hd.depth = this.depth + 1;
+  hd.parentFingerprint = this.fingerprint;// .readUInt32BE(0)
+  hd.index = index;
+
+  return hd
+};
+
+HDKey.prototype.sign = function (hash) {
+  return secp256k1Shim.sign(hash, this.privateKey).signature
+};
+
+HDKey.prototype.verify = function (hash, signature) {
+  return secp256k1Shim.verify(hash, signature, this.publicKey)
+};
+
+HDKey.prototype.wipePrivateData = function () {
+  if (this._privateKey) cryptoShim.randomBytes(this._privateKey.length).copy(this._privateKey);
+  this._privateKey = null;
+  return this
+};
+
+HDKey.prototype.toJSON = function () {
+  return {
+    xpriv: this.privateExtendedKey,
+    xpub: this.publicExtendedKey
+  }
+};
+
+HDKey.fromMasterSeed = function (seedBuffer, versions) {
+  var I = cryptoShim.createHmac('sha512', MASTER_SECRET).update(seedBuffer).digest();
+  var IL = I.slice(0, 32);
+  var IR = I.slice(32);
+
+  var hdkey = new HDKey(versions);
+  hdkey.chainCode = IR;
+  hdkey.privateKey = IL;
+
+  return hdkey
+};
+
+HDKey.fromExtendedKey = function (base58key, versions) {
+  // => version(4) || depth(1) || fingerprint(4) || index(4) || chain(32) || key(33)
+  versions = versions || BITCOIN_VERSIONS;
+  var hdkey = new HDKey(versions);
+
+  var keyBuffer = bs58check.decode(base58key);
+
+  var version = keyBuffer.readUInt32BE(0);
+  assert(version === versions.private || version === versions.public, 'Version mismatch: does not match private or public');
+
+  hdkey.depth = keyBuffer.readUInt8(4);
+  hdkey.parentFingerprint = keyBuffer.readUInt32BE(5);
+  hdkey.index = keyBuffer.readUInt32BE(9);
+  hdkey.chainCode = keyBuffer.slice(13, 45);
+
+  var key = keyBuffer.slice(45);
+  if (key.readUInt8(0) === 0) { // private
+    assert(version === versions.private, 'Version mismatch: version does not match private');
+    hdkey.privateKey = key.slice(1); // cut off first 0x0 byte
+  } else {
+    assert(version === versions.public, 'Version mismatch: version does not match public');
+    hdkey.publicKey = key;
+  }
+
+  return hdkey
+};
+
+HDKey.fromJSON = function (obj) {
+  return HDKey.fromExtendedKey(obj.xpriv)
+};
+
+function serialize (hdkey, version, key) {
+  // => version(4) || depth(1) || fingerprint(4) || index(4) || chain(32) || key(33)
+  var buffer = Buffer.allocUnsafe(LEN);
+
+  buffer.writeUInt32BE(version, 0);
+  buffer.writeUInt8(hdkey.depth, 4);
+
+  var fingerprint = hdkey.depth ? hdkey.parentFingerprint : 0x00000000;
+  buffer.writeUInt32BE(fingerprint, 5);
+  buffer.writeUInt32BE(hdkey.index, 9);
+
+  hdkey.chainCode.copy(buffer, 13);
+  key.copy(buffer, 45);
+
+  return buffer
+}
+
+function hash160 (buf) {
+  var sha = cryptoShim.createHash('sha256').update(buf).digest();
+  return cryptoShim.createHash('ripemd160').update(sha).digest()
+}
+
+HDKey.HARDENED_OFFSET = HARDENED_OFFSET;
+var hdkey = HDKey;
+
+module.exports = hdkey;

package/node_modules/ethereum-cryptography/src/random.ts

@@ -0,0 +1,18 @@
+const randombytes = require("randombytes");
+
+export function getRandomBytes(bytes: number): Promise<Buffer> {
+  return new Promise((resolve, reject) => {
+    randombytes(bytes, function(err: any, resp: Buffer) {
+      if (err) {
+        reject(err);
+        return;
+      }
+
+      resolve(resp);
+    });
+  });
+}
+
+export function getRandomBytesSync(bytes: number): Buffer {
+  return randombytes(bytes);
+}

package/node_modules/ethereum-cryptography/src/ripemd160.ts

@@ -0,0 +1,7 @@
+import crypto from "crypto";
+
+import { createHashFunction } from "./hash-utils";
+
+export const ripemd160 = createHashFunction(() =>
+  crypto.createHash("ripemd160")
+);

package/node_modules/ethereum-cryptography/src/scrypt.ts

@@ -0,0 +1,24 @@
+import "scrypt-js/thirdparty/setImmediate";
+const scryptJs = require("scrypt-js");
+
+export async function scrypt(
+  password: Buffer,
+  salt: Buffer,
+  n: number,
+  p: number,
+  r: number,
+  dklen: number
+): Promise<Buffer> {
+  return Buffer.from(await scryptJs.scrypt(password, salt, n, r, p, dklen));
+}
+
+export function scryptSync(
+  password: Buffer,
+  salt: Buffer,
+  n: number,
+  p: number,
+  r: number,
+  dklen: number
+): Buffer {
+  return Buffer.from(scryptJs.syncScrypt(password, salt, n, r, p, dklen));
+}

package/node_modules/ethereum-cryptography/src/secp256k1.ts

@@ -0,0 +1,24 @@
+import { privateKeyVerify } from "secp256k1";
+import { getRandomBytes, getRandomBytesSync } from "./random";
+
+const SECP256K1_PRIVATE_KEY_SIZE = 32;
+
+export async function createPrivateKey(): Promise<Uint8Array> {
+  while (true) {
+    const pk = await getRandomBytes(SECP256K1_PRIVATE_KEY_SIZE);
+    if (privateKeyVerify(pk)) {
+      return pk;
+    }
+  }
+}
+
+export function createPrivateKeySync(): Uint8Array {
+  while (true) {
+    const pk = getRandomBytesSync(SECP256K1_PRIVATE_KEY_SIZE);
+    if (privateKeyVerify(pk)) {
+      return pk;
+    }
+  }
+}
+
+export * from "secp256k1";

package/node_modules/ethereum-cryptography/src/sha256.ts

@@ -0,0 +1,5 @@
+import crypto from "crypto";
+
+import { createHashFunction } from "./hash-utils";
+
+export const sha256 = createHashFunction(() => crypto.createHash("sha256"));

package/node_modules/ethereum-cryptography/src/shims/hdkey-crypto.ts

@@ -0,0 +1 @@
+export { createHash, createHmac, randomBytes } from "crypto";

package/node_modules/ethereum-cryptography/src/shims/hdkey-secp256k1v3.ts

@@ -0,0 +1,49 @@
+import * as secp256k1 from "secp256k1";
+
+export function privateKeyVerify(privateKey: Buffer): boolean {
+  return secp256k1.privateKeyVerify(privateKey);
+}
+
+export function publicKeyCreate(privateKey: Buffer, compressed = true): Buffer {
+  return Buffer.from(secp256k1.publicKeyCreate(privateKey, compressed));
+}
+
+export function publicKeyVerify(publicKey: Buffer): boolean {
+  return secp256k1.publicKeyVerify(publicKey);
+}
+
+export function publicKeyConvert(publicKey: Buffer, compressed = true): Buffer {
+  return Buffer.from(secp256k1.publicKeyConvert(publicKey, compressed));
+}
+
+export function privateKeyTweakAdd(publicKey: Buffer, tweak: Buffer): Buffer {
+  return Buffer.from(
+    secp256k1.privateKeyTweakAdd(Buffer.from(publicKey), tweak)
+  );
+}
+
+export function publicKeyTweakAdd(
+  publicKey: Buffer,
+  tweak: Buffer,
+  compressed = true
+): Buffer {
+  return Buffer.from(
+    secp256k1.publicKeyTweakAdd(Buffer.from(publicKey), tweak, compressed)
+  );
+}
+
+export function sign(
+  message: Buffer,
+  privateKey: Buffer
+): { signature: Buffer; recovery: number } {
+  const ret = secp256k1.ecdsaSign(message, privateKey);
+  return { signature: Buffer.from(ret.signature), recovery: ret.recid };
+}
+
+export function verify(
+  message: Buffer,
+  signature: Buffer,
+  publicKey: Buffer
+): boolean {
+  return secp256k1.ecdsaVerify(signature, message, publicKey);
+}