Heap & asm instance pooling

src/aes/aes.asm.js

@@ -767,6 +767,38 @@ export var AES_asm = function () {
         return 16;
       }
 
+      /**
+       * Store the internal nonce vector into the heap.
+       * @instance
+       * @memberof AES_asm
+       * @param {number} pos - offset where to put the data
+       * @return {number} The number of bytes have been written into the heap, always 16.
+       */
+      function get_nonce(pos) {
+        pos = pos | 0;
+
+        if (pos & 15) return -1;
+
+        DATA[pos | 0] = N0 >>> 24,
+          DATA[pos | 1] = N0 >>> 16 & 255,
+          DATA[pos | 2] = N0 >>> 8 & 255,
+          DATA[pos | 3] = N0 & 255,
+          DATA[pos | 4] = N1 >>> 24,
+          DATA[pos | 5] = N1 >>> 16 & 255,
+          DATA[pos | 6] = N1 >>> 8 & 255,
+          DATA[pos | 7] = N1 & 255,
+          DATA[pos | 8] = N2 >>> 24,
+          DATA[pos | 9] = N2 >>> 16 & 255,
+          DATA[pos | 10] = N2 >>> 8 & 255,
+          DATA[pos | 11] = N2 & 255,
+          DATA[pos | 12] = N3 >>> 24,
+          DATA[pos | 13] = N3 >>> 16 & 255,
+          DATA[pos | 14] = N3 >>> 8 & 255,
+          DATA[pos | 15] = N3 & 255;
+
+        return 16;
+      }
+
       /**
        * GCM initialization.
        * @instance
@@ -887,6 +919,7 @@ export var AES_asm = function () {
         set_counter: set_counter,
         get_state: get_state,
         get_iv: get_iv,
+        get_nonce: get_nonce,
         gcm_init: gcm_init,
         cipher: cipher,
         mac: mac,

src/aes/aes.ts

@@ -2,6 +2,9 @@ import { AES_asm, AES_mode } from './aes.asm';
 import { _heap_init, _heap_write, is_bytes } from '../other/utils';
 import { IllegalArgumentError, SecurityError } from '../other/errors';
 
+const heap_pool = [];
+const asm_pool = [];
+
 export abstract class AES {
   protected readonly heap: Uint8Array;
   protected readonly asm: AES_asm;
@@ -13,14 +16,36 @@ export abstract class AES {
   protected constructor(key: Uint8Array, iv: Uint8Array | undefined, padding = true, mode: AES_mode) {
     this.mode = mode;
 
-    // The AES "worker"
-    this.heap = _heap_init().subarray(AES_asm.HEAP_DATA);
-    this.asm = new AES_asm(null, this.heap.buffer);
-
     // The AES object state
     this.pos = 0;
     this.len = 0;
 
+    this.key = key;
+    this.iv = iv;
+    this.padding = padding;
+
+    // The AES "worker"
+    this.acquire_asm();
+  }
+
+  protected acquire_asm() {
+    if (this.heap === undefined && this.asm === undefined) {
+      this.heap = heap_pool.pop() || _heap_init().subarray(AES_asm.HEAP_DATA);
+      this.asm = asm_pool.pop() || AES_asm(null, this.heap.buffer);
+      this.reset(this.key, this.iv);
+    }
+  }
+
+  protected release_asm() {
+    this.iv = this.heap.slice(0, this.asm[this.mode === 'CTR' ? 'get_nonce' : 'get_iv'](AES_asm.HEAP_DATA));
+
+    heap_pool.push(this.heap);
+    asm_pool.push(this.asm);
+    this.heap = undefined;
+    this.asm = undefined;
+  }
+
+  protected reset(key, iv) {
     // Key
     const keylen = key.length;
     if (keylen !== 16 && keylen !== 24 && keylen !== 32) throw new IllegalArgumentError('illegal key size');
@@ -48,13 +73,13 @@ export abstract class AES {
     } else {
       this.asm.set_iv(0, 0, 0, 0);
     }
-
-    this.padding = padding;
   }
 
   AES_Encrypt_process(data: Uint8Array): Uint8Array {
     if (!is_bytes(data)) throw new TypeError("data isn't of expected type");
 
+    this.acquire_asm();
+
     let asm = this.asm;
     let heap = this.heap;
     let amode = AES_asm.ENC[this.mode];
@@ -96,6 +121,8 @@ export abstract class AES {
   }
 
   AES_Encrypt_finish(): Uint8Array {
+    this.acquire_asm();
+
     let asm = this.asm;
     let heap = this.heap;
     let amode = AES_asm.ENC[this.mode];
@@ -128,12 +155,16 @@ export abstract class AES {
     this.pos = 0;
     this.len = 0;
 
+    this.release_asm();
+
     return result;
   }
 
   AES_Decrypt_process(data: Uint8Array): Uint8Array {
     if (!is_bytes(data)) throw new TypeError("data isn't of expected type");
 
+    this.acquire_asm();
+
     let asm = this.asm;
     let heap = this.heap;
     let amode = AES_asm.DEC[this.mode];
@@ -181,6 +212,8 @@ export abstract class AES {
   }
 
   AES_Decrypt_finish(): Uint8Array {
+    this.acquire_asm();
+
     let asm = this.asm;
     let heap = this.heap;
     let amode = AES_asm.DEC[this.mode];
@@ -221,6 +254,8 @@ export abstract class AES {
     this.pos = 0;
     this.len = 0;
 
+    this.release_asm();
+
     return result;
   }
 }

src/aes/ctr.ts

@@ -12,9 +12,12 @@ export class AES_CTR extends AES {
   }
 
   constructor(key: Uint8Array, nonce: Uint8Array) {
-    super(key, undefined, false, 'CTR');
+    super(key, nonce, false, 'CTR');
     delete this.padding;
+  }
 
+  protected reset(key: Uint8Array, nonce: Uint8Array) {
+    super.reset(key, undefined);
     this.AES_CTR_set_options(nonce);
   }
 

src/hash/hash.ts

@@ -1,4 +1,4 @@
-import { _heap_write } from '../other/utils';
+import { _heap_init, _heap_write } from '../other/utils';
 import { IllegalStateError } from '../other/errors';
 import { sha1result } from './sha1/sha1.asm';
 import { sha256result } from './sha256/sha256.asm';
@@ -13,7 +13,32 @@ export abstract class Hash<T extends sha1result | sha256result | sha512result> {
   public BLOCK_SIZE!: number;
   public HASH_SIZE!: number;
 
+  protected static heap_pool !: Array;
+  protected static asm_pool !: Array;
+  protected static asm_function!: Function;
+
+  constructor() {
+    this.acquire_asm();
+  }
+
+  protected acquire_asm() {
+    if (this.heap === undefined && this.asm === undefined) {
+      this.heap = this.constructor.heap_pool.pop() || _heap_init();
+      this.asm = this.constructor.asm_pool.pop() || this.constructor.asm_function({ Uint8Array: Uint8Array }, null, this.heap.buffer);
+      this.reset();
+    }
+  }
+
+  protected release_asm() {
+    this.constructor.heap_pool.push(this.heap));
+    this.constructor.asm_pool.push(this.asm);
+    this.heap = undefined;
+    this.asm = undefined;
+  }
+
   reset() {
+    this.acquire_asm();
+
     this.result = null;
     this.pos = 0;
     this.len = 0;
@@ -26,6 +51,8 @@ export abstract class Hash<T extends sha1result | sha256result | sha512result> {
   process(data: Uint8Array) {
     if (this.result !== null) throw new IllegalStateError('state must be reset before processing new data');
 
+    this.acquire_asm();
+
     let asm = this.asm;
     let heap = this.heap;
     let hpos = this.pos;
@@ -57,6 +84,8 @@ export abstract class Hash<T extends sha1result | sha256result | sha512result> {
   finish() {
     if (this.result !== null) throw new IllegalStateError('state must be reset before processing new data');
 
+    this.acquire_asm();
+
     this.asm.finish(this.pos, this.len, 0);
 
     this.result = new Uint8Array(this.HASH_SIZE);
@@ -65,6 +94,8 @@ export abstract class Hash<T extends sha1result | sha256result | sha512result> {
     this.pos = 0;
     this.len = 0;
 
+    this.release_asm();
+
     return this;
   }
 }

src/hash/sha1/sha1.ts

@@ -1,6 +1,5 @@
 import { sha1_asm, sha1result } from './sha1.asm';
 import { Hash } from '../hash';
-import { _heap_init } from '../../other/utils';
 
 export const _sha1_block_size = 64;
 export const _sha1_hash_size = 20;
@@ -11,12 +10,11 @@ export class Sha1 extends Hash<sha1result> {
   public BLOCK_SIZE = _sha1_block_size;
   public HASH_SIZE = _sha1_hash_size;
 
-  constructor() {
-    super();
+  protected static heap_pool = [];
+  protected static asm_pool = [];
+  protected static asm_function = sha1_asm;
 
-    this.heap = _heap_init();
-    this.asm = sha1_asm({ Uint8Array: Uint8Array }, null, this.heap.buffer);
-
-    this.reset();
+  static bytes(data: Uint8Array): Uint8Array {
+    return new Sha1().process(data).finish().result;
   }
 }

src/hash/sha256/sha256.ts

@@ -1,6 +1,5 @@
 import { sha256_asm, sha256result } from './sha256.asm';
 import { Hash } from '../hash';
-import { _heap_init } from '../../other/utils';
 
 export const _sha256_block_size = 64;
 export const _sha256_hash_size = 32;
@@ -11,12 +10,11 @@ export class Sha256 extends Hash<sha256result> {
   public BLOCK_SIZE = _sha256_block_size;
   public HASH_SIZE = _sha256_hash_size;
 
-  constructor() {
-    super();
+  protected static heap_pool = [];
+  protected static asm_pool = [];
+  protected static asm_function = sha256_asm;
 
-    this.heap = _heap_init();
-    this.asm = sha256_asm({ Uint8Array: Uint8Array }, null, this.heap.buffer);
-
-    this.reset();
+  static bytes(data: Uint8Array): Uint8Array {
+    return new Sha256().process(data).finish().result;
   }
 }

src/hash/sha512/sha512.ts

@@ -1,6 +1,5 @@
 import { sha512_asm, sha512result } from './sha512.asm';
 import { Hash } from '../hash';
-import { _heap_init } from '../../other/utils';
 
 export const _sha512_block_size = 128;
 export const _sha512_hash_size = 64;
@@ -11,12 +10,11 @@ export class Sha512 extends Hash<sha512result> {
   public BLOCK_SIZE = _sha512_block_size;
   public HASH_SIZE = _sha512_hash_size;
 
-  constructor() {
-    super();
+  protected static heap_pool = [];
+  protected static asm_pool = [];
+  protected static asm_function = sha512_asm;
 
-    this.heap = _heap_init();
-    this.asm = sha512_asm({ Uint8Array: Uint8Array }, null, this.heap.buffer);
-
-    this.reset();
+  static bytes(data: Uint8Array): Uint8Array {
+    return new Sha512().process(data).finish().result;
   }
 }