Source: script/sigcache.js

  1. /*!
  2.  * sigcache.js - signature cache for bcoin
  3.  * Copyright (c) 2014-2017, Christopher Jeffrey (MIT License).
  4.  * https://github.com/bcoin-org/bcoin
  5.  */
  7. 'use strict';
  9. const assert = require('bsert');
  10. const {BufferMap} = require('buffer-map');
  11. const secp256k1 = require('bcrypto/lib/secp256k1');
  13. /**
  14.  * Signature cache.
  15.  * @alias module:script.SigCache
  16.  * @property {Number} size
  17.  * @property {Hash[]} keys
  18.  * @property {Object} valid
  19.  */
  21. class SigCache {
  22.   /**
  23.    * Create a signature cache.
  24.    * @constructor
  25.    * @param {Number} [size=10000]
  26.    */
  28.   constructor(size) {
  29.     if (size == null)
  30.       size = 10000;
  32.     assert((size >>> 0) === size);
  34.     this.size = size;
  35.     this.keys = [];
  36.     this.valid = new BufferMap();
  37.   }
  39.   /**
  40.    * Resize the sigcache.
  41.    * @param {Number} size
  42.    */
  44.   resize(size) {
  45.     assert((size >>> 0) === size);
  47.     this.size = size;
  48.     this.keys.length = 0;
  49.     this.valid.clear();
  50.   }
  52.   /**
  53.    * Add item to the sigcache.
  54.    * Potentially evict a random member.
  55.    * @param {Hash} msg - Sig hash.
  56.    * @param {Buffer} sig
  57.    * @param {Buffer} key
  58.    */
  60.   add(msg, sig, key) {
  61.     if (this.size === 0)
  62.       return;
  64.     this.valid.set(msg, new SigCacheEntry(sig, key));
  66.     if (this.keys.length >= this.size) {
  67.       const i = Math.floor(Math.random() * this.keys.length);
  68.       const k = this.keys[i];
  69.       this.valid.delete(k);
  70.       this.keys[i] = msg;
  71.     } else {
  72.       this.keys.push(msg);
  73.     }
  74.   }
  76.   /**
  77.    * Test whether the sig exists.
  78.    * @param {Hash} msg - Sig hash.
  79.    * @param {Buffer} sig
  80.    * @param {Buffer} key
  81.    * @returns {Boolean}
  82.    */
  84.   has(msg, sig, key) {
  85.     const entry = this.valid.get(msg);
  87.     if (!entry)
  88.       return false;
  90.     return entry.equals(sig, key);
  91.   }
  93.   /**
  94.    * Verify a signature, testing
  95.    * it against the cache first.
  96.    * @param {Buffer} msg
  97.    * @param {Buffer} sig
  98.    * @param {Buffer} key
  99.    * @returns {Boolean}
  100.    */
  102.   verify(msg, sig, key) {
  103.     if (this.size === 0)
  104.       return secp256k1.verifyDER(msg, sig, key);
  106.     if (this.has(msg, sig, key))
  107.       return true;
  109.     const result = secp256k1.verifyDER(msg, sig, key);
  111.     if (!result)
  112.       return false;
  114.     this.add(msg, sig, key);
  116.     return true;
  117.   }
  118. }
  120. /**
  121.  * Signature Cache Entry
  122.  * @ignore
  123.  * @property {Buffer} sig
  124.  * @property {Buffer} key
  125.  */
  127. class SigCacheEntry {
  128.   /**
  129.    * Create a cache entry.
  130.    * @constructor
  131.    * @param {Buffer} sig
  132.    * @param {Buffer} key
  133.    */
  135.   constructor(sig, key) {
  136.     this.sig = Buffer.from(sig);
  137.     this.key = Buffer.from(key);
  138.   }
  140.   /**
  141.    * Compare an entry to a sig and key.
  142.    * @param {Buffer} sig
  143.    * @param {Buffer} key
  144.    * @returns {Boolean}
  145.    */
  147.   equals(sig, key) {
  148.     return this.sig.equals(sig) && this.key.equals(key);
  149.   }
  150. }
  152. /*
  153.  * Expose
  154.  */
  156. module.exports = SigCache;