3box/lib/3id/keyring.js

Interact with user data

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");

var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));

var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));

var _require = require('@ethersproject/hdnode'),
    HDNode = _require.HDNode;

var nacl = require('tweetnacl');

nacl.util = require('tweetnacl-util');

var SimpleSigner = require('did-jwt').SimpleSigner;

var _require2 = require('../utils/index'),
    sha256 = _require2.sha256;

var EC = require('elliptic').ec;

var ec = new EC('secp256k1');

var _require3 = require('./utils'),
    randomNonce = _require3.randomNonce,
    symEncryptBase = _require3.symEncryptBase,
    symDecryptBase = _require3.symDecryptBase;

var BASE_PATH = "m/7696500'/0'/0'";
var MM_PATH = "m/44'/60'/0'/0";

var Keyring = /*#__PURE__*/function () {
  function Keyring(seed) {
    (0, _classCallCheck2["default"])(this, Keyring);
    this._seed = seed;
    var seedNode = HDNode.fromSeed(this._seed);
    var baseNode = seedNode.derivePath(BASE_PATH);
    this.signingKey = baseNode.derivePath("0");
    var tmpEncKey = Buffer.from(baseNode.derivePath("2").privateKey.slice(2), 'hex');
    this.asymEncryptionKey = nacl.box.keyPair.fromSecretKey(new Uint8Array(tmpEncKey));
    this.symEncryptionKey = new Uint8Array(Buffer.from(baseNode.derivePath("3").privateKey.slice(2), 'hex'));
    this.ethereumKey = seedNode.derivePath(MM_PATH).derivePath("0");
  }

  (0, _createClass2["default"])(Keyring, [{
    key: "asymEncrypt",
    value: function asymEncrypt(msg, toPublic, nonce) {
      nonce = nonce || randomNonce();
      toPublic = nacl.util.decodeBase64(toPublic);

      if (typeof msg === 'string') {
        msg = nacl.util.decodeUTF8(msg);
      }

      var ephemneralKeypair = nacl.box.keyPair();
      var ciphertext = nacl.box(msg, nonce, toPublic, ephemneralKeypair.secretKey);
      return {
        nonce: nacl.util.encodeBase64(nonce),
        ephemeralFrom: nacl.util.encodeBase64(ephemneralKeypair.publicKey),
        ciphertext: nacl.util.encodeBase64(ciphertext)
      };
    }
  }, {
    key: "asymDecrypt",
    value: function asymDecrypt(ciphertext, fromPublic, nonce, toBuffer) {
      fromPublic = nacl.util.decodeBase64(fromPublic);
      ciphertext = nacl.util.decodeBase64(ciphertext);
      nonce = nacl.util.decodeBase64(nonce);
      var cleartext = nacl.box.open(ciphertext, nonce, fromPublic, this.asymEncryptionKey.secretKey);

      if (toBuffer) {
        return cleartext ? Buffer.from(cleartext) : null;
      }

      return cleartext ? nacl.util.encodeUTF8(cleartext) : null;
    }
  }, {
    key: "symEncrypt",
    value: function symEncrypt(msg, nonce) {
      return symEncryptBase(msg, this.symEncryptionKey, nonce);
    }
  }, {
    key: "symDecrypt",
    value: function symDecrypt(ciphertext, nonce, toBuffer) {
      return symDecryptBase(ciphertext, this.symEncryptionKey, nonce, toBuffer);
    }
  }, {
    key: "getJWTSigner",
    value: function getJWTSigner() {
      return SimpleSigner(this.signingKey.privateKey.slice(2));
    }
  }, {
    key: "getDBSalt",
    value: function getDBSalt() {
      return sha256(this.signingKey.derivePath('0').privateKey.slice(2));
    }
  }, {
    key: "getPublicKeys",
    value: function getPublicKeys(uncompressed) {
      var signingKey = this.signingKey.publicKey.slice(2);
      var ethereumKey = this.ethereumKey.publicKey.slice(2);

      if (uncompressed) {
        signingKey = Keyring.uncompress(signingKey);
        ethereumKey = Keyring.uncompress(ethereumKey);
      }

      return {
        signingKey: signingKey,
        ethereumKey: ethereumKey,
        asymEncryptionKey: nacl.util.encodeBase64(this.asymEncryptionKey.publicKey)
      };
    }
  }, {
    key: "serialize",
    value: function serialize() {
      return this._seed;
    }
  }], [{
    key: "uncompress",
    value: function uncompress(key) {
      return ec.keyFromPublic(Buffer.from(key, 'hex')).getPublic(false, 'hex');
    }
  }]);
  return Keyring;
}();

module.exports = Keyring;