Source: primitives/airdropkey.js

  1. /* eslint camelcase: 'off' */
  3. 'use strict';
  5. const assert = require('bsert');
  6. const bio = require('bufio');
  7. const base16 = require('bcrypto/lib/encoding/base16');
  8. const bech32 = require('bcrypto/lib/encoding/bech32');
  9. const BLAKE2b = require('bcrypto/lib/blake2b');
  10. const SHA256 = require('bcrypto/lib/sha256');
  11. const rsa = require('bcrypto/lib/rsa');
  12. const p256 = require('bcrypto/lib/p256');
  13. const ed25519 = require('bcrypto/lib/ed25519');
  14. const {countLeft} = require('bcrypto/lib/encoding/util');
  15. const Goo = require('goosig');
  17. /** @typedef {import('../types').Hash} Hash */
  18. /** @typedef {import('../types').Amount} AmountValue */
  19. /** @typedef {import('../types').BufioWriter} BufioWriter */
  21. /*
  22.  * Goo
  23.  */
  25. const goo = new Goo(Goo.RSA2048, 2, 3);
  27. /*
  28.  * Constants
  29.  */
  31. const keyTypes = {
  32.   RSA: 0,
  33.   GOO: 1,
  34.   P256: 2,
  35.   ED25519: 3,
  36.   ADDRESS: 4
  37. };
  39. const keyTypesByVal = {
  40.   [keyTypes.RSA]: 'RSA',
  41.   [keyTypes.GOO]: 'GOO',
  42.   [keyTypes.P256]: 'P256',
  43.   [keyTypes.ED25519]: 'ED25519',
  44.   [keyTypes.ADDRESS]: 'ADDRESS'
  45. };
  47. const EMPTY = Buffer.alloc(0);
  49. /**
  50.  * AirdropKey
  51.  */
  53. class AirdropKey extends bio.Struct {
  54.   constructor() {
  55.     super();
  56.     this.type = keyTypes.RSA;
  57.     this.n = EMPTY;
  58.     this.e = EMPTY;
  59.     this.C1 = EMPTY;
  60.     this.point = EMPTY;
  61.     this.version = 0;
  62.     this.address = EMPTY;
  63.     this.value = 0;
  64.     this.sponsor = false;
  65.     this.nonce = SHA256.zero;
  66.     this.tweak = null;
  67.   }
  69.   /**
  70.    * @param {AirdropKey} key
  71.    * @returns {this}
  72.    */
  74.   inject(key) {
  75.     assert(key instanceof AirdropKey);
  77.     this.type = key.type;
  78.     this.n = key.n;
  79.     this.e = key.e;
  80.     this.C1 = key.C1;
  81.     this.point = key.point;
  82.     this.version = key.version;
  83.     this.address = key.address;
  84.     this.value = key.value;
  85.     this.sponsor = key.sponsor;
  86.     this.nonce = key.nonce;
  87.     this.tweak = key.tweak;
  89.     return this;
  90.   }
  92.   isRSA() {
  93.     return this.type === keyTypes.RSA;
  94.   }
  96.   isGoo() {
  97.     return this.type === keyTypes.GOO;
  98.   }
  100.   isP256() {
  101.     return this.type === keyTypes.P256;
  102.   }
  104.   isED25519() {
  105.     return this.type === keyTypes.ED25519;
  106.   }
  108.   isAddress() {
  109.     return this.type === keyTypes.ADDRESS;
  110.   }
  112.   isWeak() {
  113.     if (!this.isRSA())
  114.       return false;
  116.     return countLeft(this.n) < 2048 - 7;
  117.   }
  119.   /**
  120.    * @returns {Boolean}
  121.    */
  123.   validate() {
  124.     switch (this.type) {
  125.       case keyTypes.RSA: {
  126.         let key;
  128.         try {
  129.           key = rsa.publicKeyImport({ n: this.n, e: this.e });
  130.         } catch (e) {
  131.           return false;
  132.         }
  134.         const bits = rsa.publicKeyBits(key);
  136.         // Allow 1024 bit RSA for now.
  137.         // We can softfork out later.
  138.         return bits >= 1024 && bits <= 4096;
  139.       }
  141.       case keyTypes.GOO: {
  142.         return this.C1.length === goo.size;
  143.       }
  145.       case keyTypes.P256: {
  146.         return p256.publicKeyVerify(this.point);
  147.       }
  149.       case keyTypes.ED25519: {
  150.         return ed25519.publicKeyVerify(this.point);
  151.       }
  153.       case keyTypes.ADDRESS: {
  154.         return true;
  155.       }
  157.       default: {
  158.         throw new assert.AssertionError('Invalid key type.');
  159.       }
  160.     }
  161.   }
  163.   /**
  164.    * @param {Buffer} msg
  165.    * @param {Buffer} sig
  166.    * @returns {Boolean}
  167.    */
  169.   verify(msg, sig) {
  170.     assert(Buffer.isBuffer(msg));
  171.     assert(Buffer.isBuffer(sig));
  173.     switch (this.type) {
  174.       case keyTypes.RSA: {
  175.         let key;
  177.         try {
  178.           key = rsa.publicKeyImport({ n: this.n, e: this.e });
  179.         } catch (e) {
  180.           return false;
  181.         }
  183.         return rsa.verify(SHA256, msg, sig, key);
  184.       }
  186.       case keyTypes.GOO: {
  187.         return goo.verify(msg, sig, this.C1);
  188.       }
  190.       case keyTypes.P256: {
  191.         return p256.verify(msg, sig, this.point);
  192.       }
  194.       case keyTypes.ED25519: {
  195.         return ed25519.verify(msg, sig, this.point);
  196.       }
  198.       case keyTypes.ADDRESS: {
  199.         return true;
  200.       }
  202.       default: {
  203.         throw new assert.AssertionError('Invalid key type.');
  204.       }
  205.     }
  206.   }
  208.   /**
  209.    * @returns {Hash}
  210.    */
  212.   hash() {
  213.     const bw = bio.pool(this.getSize());
  214.     this.write(bw);
  215.     return BLAKE2b.digest(bw.render());
  216.   }
  218.   getSize() {
  219.     let size = 0;
  221.     size += 1;
  223.     switch (this.type) {
  224.       case keyTypes.RSA:
  225.         assert(this.n.length <= 0xffff);
  226.         assert(this.e.length <= 0xff);
  227.         size += 2;
  228.         size += this.n.length;
  229.         size += 1;
  230.         size += this.e.length;
  231.         size += 32;
  232.         break;
  233.       case keyTypes.GOO:
  234.         size += goo.size;
  235.         break;
  236.       case keyTypes.P256:
  237.         size += 33;
  238.         size += 32;
  239.         break;
  240.       case keyTypes.ED25519:
  241.         size += 32;
  242.         size += 32;
  243.         break;
  244.       case keyTypes.ADDRESS:
  245.         size += 1;
  246.         size += 1;
  247.         size += this.address.length;
  248.         size += 8;
  249.         size += 1;
  250.         break;
  251.       default:
  252.         throw new assert.AssertionError('Invalid key type.');
  253.     }
  255.     return size;
  256.   }
  258.   /**
  259.    * @param {BufioWriter} bw
  260.    * @returns {BufioWriter}
  261.    */
  263.   write(bw) {
  264.     bw.writeU8(this.type);
  266.     switch (this.type) {
  267.       case keyTypes.RSA:
  268.         bw.writeU16(this.n.length);
  269.         bw.writeBytes(this.n);
  270.         bw.writeU8(this.e.length);
  271.         bw.writeBytes(this.e);
  272.         bw.writeBytes(this.nonce);
  273.         break;
  274.       case keyTypes.GOO:
  275.         bw.writeBytes(this.C1);
  276.         break;
  277.       case keyTypes.P256:
  278.       case keyTypes.ED25519:
  279.         bw.writeBytes(this.point);
  280.         bw.writeBytes(this.nonce);
  281.         break;
  282.       case keyTypes.ADDRESS:
  283.         bw.writeU8(this.version);
  284.         bw.writeU8(this.address.length);
  285.         bw.writeBytes(this.address);
  286.         bw.writeU64(this.value);
  287.         bw.writeU8(this.sponsor ? 1 : 0);
  288.         break;
  289.       default:
  290.         throw new assert.AssertionError('Invalid key type.');
  291.     }
  293.     return bw;
  294.   }
  296.   /**
  297.    * @param {bio.BufferReader} br
  298.    * @returns {this}
  299.    */
  301.   read(br) {
  302.     this.type = br.readU8();
  304.     switch (this.type) {
  305.       case keyTypes.RSA: {
  306.         this.n = br.readBytes(br.readU16());
  307.         this.e = br.readBytes(br.readU8());
  308.         this.nonce = br.readBytes(32);
  309.         break;
  310.       }
  312.       case keyTypes.GOO: {
  313.         this.C1 = br.readBytes(goo.size);
  314.         break;
  315.       }
  317.       case keyTypes.P256: {
  318.         this.point = br.readBytes(33);
  319.         this.nonce = br.readBytes(32);
  320.         break;
  321.       }
  323.       case keyTypes.ED25519: {
  324.         this.point = br.readBytes(32);
  325.         this.nonce = br.readBytes(32);
  326.         break;
  327.       }
  329.       case keyTypes.ADDRESS: {
  330.         this.version = br.readU8();
  331.         this.address = br.readBytes(br.readU8());
  332.         this.value = br.readU64();
  333.         this.sponsor = br.readU8() === 1;
  334.         break;
  335.       }
  337.       default: {
  338.         throw new Error('Unknown key type.');
  339.       }
  340.     }
  342.     return this;
  343.   }
  345.   /**
  346.    * @param {String} addr
  347.    * @param {AmountValue} value
  348.    * @param {Boolean} sponsor
  349.    * @returns {this}
  350.    */
  352.   fromAddress(addr, value, sponsor = false) {
  353.     assert(typeof addr === 'string');
  354.     assert(Number.isSafeInteger(value) && value >= 0);
  355.     assert(typeof sponsor === 'boolean');
  357.     const [hrp, version, hash] = bech32.decode(addr);
  359.     assert(hrp === 'hs' || hrp === 'ts' || hrp === 'rs');
  360.     assert(version === 0);
  361.     assert(hash.length === 20 || hash.length === 32);
  363.     this.type = keyTypes.ADDRESS;
  364.     this.version = version;
  365.     this.address = hash;
  366.     this.value = value;
  367.     this.sponsor = sponsor;
  369.     return this;
  370.   }
  372.   getJSON() {
  373.     return {
  374.       type: keyTypesByVal[this.type] || 'UNKNOWN',
  375.       n: this.n.length > 0
  376.         ? this.n.toString('hex')
  377.         : undefined,
  378.       e: this.e.length > 0
  379.         ? this.e.toString('hex')
  380.         : undefined,
  381.       C1: this.C1.length > 0
  382.         ? this.C1.toString('hex')
  383.         : undefined,
  384.       point: this.point.length > 0
  385.         ? this.point.toString('hex')
  386.         : undefined,
  387.       version: this.address.length > 0
  388.         ? this.version
  389.         : undefined,
  390.       address: this.address.length > 0
  391.         ? this.address.toString('hex')
  392.         : undefined,
  393.       value: this.value || undefined,
  394.       sponsor: this.value
  395.         ? this.sponsor
  396.         : undefined,
  397.       nonce: !this.isGoo() && !this.isAddress()
  398.         ? this.nonce.toString('hex')
  399.         : undefined
  400.     };
  401.   }
  403.   /**
  404.    * @param {Object} json
  405.    * @returns {this}
  406.    */
  408.   fromJSON(json) {
  409.     assert(json && typeof json === 'object');
  410.     assert(typeof json.type === 'string');
  411.     assert(Object.prototype.hasOwnProperty.call(keyTypes, json.type));
  413.     this.type = keyTypes[json.type];
  415.     console.log(base16.decode.toString());
  416.     switch (this.type) {
  417.       case keyTypes.RSA: {
  418.         this.n = base16.decode(json.n);
  419.         this.e = base16.decode(json.e);
  420.         this.nonce = base16.decode(json.nonce);
  421.         break;
  422.       }
  424.       case keyTypes.GOO: {
  425.         this.C1 = base16.decode(json.C1);
  426.         break;
  427.       }
  429.       case keyTypes.P256: {
  430.         this.point = base16.decode(json.point);
  431.         this.nonce = base16.decode(json.nonce);
  432.         break;
  433.       }
  435.       case keyTypes.ED25519: {
  436.         this.point = base16.decode(json.point);
  437.         this.nonce = base16.decode(json.nonce);
  438.         break;
  439.       }
  441.       case keyTypes.ADDRESS: {
  442.         assert((json.version & 0xff) === json.version);
  443.         assert(Number.isSafeInteger(json.value) && json.value >= 0);
  444.         assert(typeof json.sponsor === 'boolean');
  445.         this.version = json.version;
  446.         this.address = base16.decode(json.address);
  447.         this.value = json.value;
  448.         this.sponsor = json.sponsor;
  449.         break;
  450.       }
  452.       default: {
  453.         throw new Error('Unknown key type.');
  454.       }
  455.     }
  457.     return this;
  458.   }
  460.   /**
  461.    * @param {String} addr
  462.    * @param {AmountValue} value
  463.    * @param {Boolean} sponsor
  464.    * @returns {AirdropKey}
  465.    */
  467.   static fromAddress(addr, value, sponsor) {
  468.     return new this().fromAddress(addr, value, sponsor);
  469.   }
  470. }
  472. /*
  473.  * Static
  474.  */
  476. AirdropKey.keyTypes = keyTypes;
  477. AirdropKey.keyTypesByVal = keyTypesByVal;
  479. /*
  480.  * Expose
  481.  */
  483. module.exports = AirdropKey;