@li0ard/gost 0.1.5 → 0.1.6

package/gost3410/index.d.ts

@@ -1,5 +1,5 @@
 import { type TArg, type TRet } from "@noble/curves/utils.js";
-import { type GostCurveParameters } from "./const.js";
+import type { GostCurveParameters } from "./const.js";
 /**
  * Generate public key from private.
  * @param parameters Curve parameters

package/gost3410/index.js

@@ -1,5 +1,4 @@
 import { bytesToNumberBE, concatBytes, numberToBytesBE, randomBytes } from "@noble/curves/utils.js";
-import { CURVES } from "./const.js";
 import { mod } from "@noble/curves/abstract/modular.js";
 import { weierstrass } from "@noble/curves/abstract/weierstrass.js";
 /**

package/gost341194/index.d.ts

@@ -3,7 +3,7 @@ import { type Hash, type TArg, type TRet } from "@noble/hashes/utils.js";
 export declare class Gost341194 implements Hash<Gost341194> {
     private data;
     private sbox;
-    readonly blockLen: number;
+    readonly blockLen = 32;
     readonly outputLen = 32;
     readonly canXOF = false;
     /** GOST R 34.11-94 hash function */

package/gost341194/index.js

@@ -3,146 +3,50 @@ import { Magma } from "../magma/index.js";
 import { DSSZZI_UA_DKE_1, ID_GOSTR_3411_94_CRYPTOPRO_PARAM_SET } from "../magma/const.js";
 import { bytesToNumberBE, numberToBytesBE } from "@noble/curves/utils.js";
 import { xorBytes } from "../utils.js";
-const BLOCKSIZE = 32;
 const r = (1n << 256n) - 1n;
-const C2 = new Uint8Array(32);
 const C3 = new Uint8Array([
     0xff, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0xff,
     0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00,
     0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff,
     0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00
 ]);
-const C4 = new Uint8Array(32);
-const A = (x) => {
-    const x2 = x.subarray(16, 24);
-    return concatBytes(xorBytes(x.subarray(24, 32), x2), x.subarray(0, 8), x.subarray(8, 16), x2);
-};
+const A = (x) => concatBytes(xorBytes(x.subarray(24, 32), x.subarray(16, 24)), x.subarray(0, 8), x.subarray(8, 16), x.subarray(16, 24));
 const P = (x) => new Uint8Array([
     x[0], x[8], x[16], x[24], x[1], x[9], x[17], x[25],
     x[2], x[10], x[18], x[26], x[3], x[11], x[19], x[27],
     x[4], x[12], x[20], x[28], x[5], x[13], x[21], x[29],
     x[6], x[14], x[22], x[30], x[7], x[15], x[23], x[31]
 ]);
-/*const chi = (Y: TArg<Uint8Array>): TRet<Uint8Array> => {
-    const byx = new Uint8Array(2);
-    byx[0] = Y[30] ^ Y[28] ^ Y[26] ^ Y[24] ^ Y[6] ^ Y[0];
-    byx[1] = Y[31] ^ Y[29] ^ Y[27] ^ Y[25] ^ Y[7] ^ Y[1];
-
-    const result = new Uint8Array(BLOCKSIZE);
-    result.set(byx, 0);
-    result.set(Y.slice(0,30), 2);
-
-    return result;
-}*/
 const chi = (Y) => new Uint8Array([
     Y[30] ^ Y[28] ^ Y[26] ^ Y[24] ^ Y[6] ^ Y[0],
     Y[31] ^ Y[29] ^ Y[27] ^ Y[25] ^ Y[7] ^ Y[1],
     ...Y.subarray(0, 30)
 ]);
+const _getMagma = (u, v, sbox) => new Magma(P(xorBytes(u, v)).reverse(), sbox, true);
 const _step = (hin, m, sbox) => {
-    let u = hin;
-    let v = m;
-    let w = xorBytes(hin, m);
-    const k1 = new Magma(P(w).reverse(), sbox, true);
-    u = xorBytes(A(u), C2);
-    v = A(A(v));
-    w = xorBytes(u, v);
-    const k2 = new Magma(P(w).reverse(), sbox, true);
+    const k1 = _getMagma(hin, m, sbox);
+    let u = A(hin);
+    let v = A(A(m));
+    const k2 = _getMagma(u, v, sbox);
     u = xorBytes(A(u), C3);
     v = A(A(v));
-    w = xorBytes(u, v);
-    const k3 = new Magma(P(w).reverse(), sbox, true);
-    u = xorBytes(A(u), C4);
+    const k3 = _getMagma(u, v, sbox);
+    u = A(u);
     v = A(A(v));
-    w = xorBytes(u, v);
-    const k4 = new Magma(P(w).reverse(), sbox, true);
-    const s = concatBytes(k4.encrypt(hin.slice(0, 8).reverse()).reverse(), k3.encrypt(hin.slice(8, 16).reverse()).reverse(), k2.encrypt(hin.slice(16, 24).reverse()).reverse(), k1.encrypt(hin.slice(24, 32).reverse()).reverse());
-    //let x = new Uint8Array(s);
-    //for(let i = 0; i < 12; i++) x = chi(x);
-    let x = chi(s);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = xorBytes(x, m);
-    x = chi(x);
-    x = xorBytes(hin, x);
-    //for(let i = 0; i < 61; i++) x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
-    x = chi(x);
+    const k4 = _getMagma(u, v, sbox);
+    const x = concatBytes(k4.encrypt(hin.slice(0, 8).reverse()).reverse(), k3.encrypt(hin.slice(8, 16).reverse()).reverse(), k2.encrypt(hin.slice(16, 24).reverse()).reverse(), k1.encrypt(hin.slice(24, 32).reverse()).reverse());
+    for (let i = 0; i < 12; i++)
+        x.set(chi(x));
+    x.set(xorBytes(hin, chi(xorBytes(x, m))));
+    for (let i = 0; i < 61; i++)
+        x.set(chi(x));
     return x;
 };
 /** GOST R 34.11-94 hash function */
 export class Gost341194 {
     data;
     sbox;
-    blockLen = BLOCKSIZE;
+    blockLen = 32;
     outputLen = 32;
     canXOF = false;
     /** GOST R 34.11-94 hash function */
@@ -167,17 +71,17 @@ export class Gost341194 {
     digestInto(buf) {
         let len = 0n;
         let checksum = 0n;
-        const h = new Uint8Array(BLOCKSIZE);
+        const h = new Uint8Array(this.blockLen);
         const m = new Uint8Array(this.data);
-        for (let i = 0; i < m.length; i += BLOCKSIZE) {
-            let part = m.slice(i, i + BLOCKSIZE).reverse();
+        for (let i = 0; i < m.length; i += this.blockLen) {
+            let part = m.slice(i, i + this.blockLen).reverse();
             len += BigInt(part.length) * 8n;
             checksum = (checksum + bytesToNumberBE(part)) & r;
-            if (part.length < BLOCKSIZE)
-                part = numberToBytesBE(bytesToNumberBE(part), BLOCKSIZE);
+            if (part.length < this.blockLen)
+                part = numberToBytesBE(bytesToNumberBE(part), this.blockLen);
             h.set(_step(h, part, this.sbox));
         }
-        h.set(_step(_step(h, numberToBytesBE(len, BLOCKSIZE), this.sbox), numberToBytesBE(checksum, BLOCKSIZE), this.sbox));
+        h.set(_step(_step(h, numberToBytesBE(len, this.blockLen), this.sbox), numberToBytesBE(checksum, this.blockLen), this.sbox));
         buf.set(h.reverse());
         this.destroy();
     }

package/kuznyechik/const.js

@@ -37,7 +37,7 @@ export const PI_REV = new Uint8Array([
 export const L = new Uint8Array([
     0x01, 0x94, 0x20, 0x85, 0x10, 0xc2, 0xc0, 0x01, 0xfb, 0x01, 0xc0, 0xc2, 0x10, 0x85, 0x20, 0x94,
 ]);
-/*const ITER: Uint8Array[] = Array(32).fill(null).map(() => new Uint8Array(16).fill(0));
+/*const ITER: Uint8Array[] = Array(32).fill(null).map(() => new Uint8Array(16));
 for(let i = 0; i < 32; i++) {
     ITER[i][15] = i + 1;
     ITER[i] = LL(ITER[i]);

package/kuznyechik/index.js

@@ -1,146 +1,64 @@
 import { copyBytes } from "@noble/curves/utils.js";
 import { ITER, L, PI, PI_REV } from "./const.js";
 import { xorBytes } from "../utils.js";
-const BLOCKSIZE = 16, KEYSIZE = 32;
-const S = (input, pi = PI) => {
-    const result = new Uint8Array(BLOCKSIZE);
-    //for(let i = 0; i < BLOCKSIZE; i++) result[i] = pi[input[i]];
-    result[0] = pi[input[0]];
-    result[1] = pi[input[1]];
-    result[2] = pi[input[2]];
-    result[3] = pi[input[3]];
-    result[4] = pi[input[4]];
-    result[5] = pi[input[5]];
-    result[6] = pi[input[6]];
-    result[7] = pi[input[7]];
-    result[8] = pi[input[8]];
-    result[9] = pi[input[9]];
-    result[10] = pi[input[10]];
-    result[11] = pi[input[11]];
-    result[12] = pi[input[12]];
-    result[13] = pi[input[13]];
-    result[14] = pi[input[14]];
-    result[15] = pi[input[15]];
-    return result;
-};
 const gfMultiply = (a, b) => {
-    let result = 0;
-    let high_bit;
-    for (let i = 0; i < 8; i++) {
-        if ((b & 0b00000001) === 0b00000001)
+    let result = 0, high_bit;
+    for (let _ = 0; _ < 8; _++) {
+        if ((b & 1) === 1)
             result ^= a;
-        high_bit = a & 0b10000000;
+        high_bit = a & 0x80;
         a <<= 1;
-        if (high_bit == 0b10000000)
-            a ^= 0b11000011;
+        if (high_bit == 0x80)
+            a ^= 0xC3;
         b >>= 1;
     }
     return result & 0xFF;
 };
-const R = (input) => {
-    const result = new Uint8Array(BLOCKSIZE);
-    result.set(input.slice(0, 15), 1);
-    result[0] = input[15];
-    //let temp = 0;
-    //for (let i = 0; i < BLOCKSIZE; i++) temp ^= gfMultiply(result[i], L[i]);
-    let temp = gfMultiply(result[0], L[0]);
-    temp ^= gfMultiply(result[1], L[1]);
-    temp ^= gfMultiply(result[2], L[2]);
-    temp ^= gfMultiply(result[3], L[3]);
-    temp ^= gfMultiply(result[4], L[4]);
-    temp ^= gfMultiply(result[5], L[5]);
-    temp ^= gfMultiply(result[6], L[6]);
-    temp ^= gfMultiply(result[7], L[7]);
-    temp ^= gfMultiply(result[8], L[8]);
-    temp ^= gfMultiply(result[9], L[9]);
-    temp ^= gfMultiply(result[10], L[10]);
-    temp ^= gfMultiply(result[11], L[11]);
-    temp ^= gfMultiply(result[12], L[12]);
-    temp ^= gfMultiply(result[13], L[13]);
-    temp ^= gfMultiply(result[14], L[14]);
-    temp ^= gfMultiply(result[15], L[15]);
-    result[0] = temp;
-    return result;
-};
-const Rr = (input) => {
-    const result = new Uint8Array(BLOCKSIZE);
-    //let temp = 0;
-    //for (let i = 0; i < BLOCKSIZE; i++) temp ^= gfMultiply(input[i], L[i]);
-    let temp = gfMultiply(input[0], L[0]);
-    temp ^= gfMultiply(input[1], L[1]);
-    temp ^= gfMultiply(input[2], L[2]);
-    temp ^= gfMultiply(input[3], L[3]);
-    temp ^= gfMultiply(input[4], L[4]);
-    temp ^= gfMultiply(input[5], L[5]);
-    temp ^= gfMultiply(input[6], L[6]);
-    temp ^= gfMultiply(input[7], L[7]);
-    temp ^= gfMultiply(input[8], L[8]);
-    temp ^= gfMultiply(input[9], L[9]);
-    temp ^= gfMultiply(input[10], L[10]);
-    temp ^= gfMultiply(input[11], L[11]);
-    temp ^= gfMultiply(input[12], L[12]);
-    temp ^= gfMultiply(input[13], L[13]);
-    temp ^= gfMultiply(input[14], L[14]);
-    temp ^= gfMultiply(input[15], L[15]);
-    result.set(input.slice(1));
-    result[15] = temp;
-    return result;
-};
-const LL = (input) => {
-    //let result = copyBytes(input);
-    //for(let i = 0; i < BLOCKSIZE; i++) result = R(result);
-    let result = R(copyBytes(input));
-    result = R(result);
-    result = R(result);
-    result = R(result);
-    result = R(result);
-    result = R(result);
-    result = R(result);
-    result = R(result);
-    result = R(result);
-    result = R(result);
-    result = R(result);
-    result = R(result);
-    result = R(result);
-    result = R(result);
-    result = R(result);
-    result = R(result);
-    return result;
-};
-const LLr = (input) => {
-    //let result = copyBytes(input);
-    //for(let i = 0; i < BLOCKSIZE; i++) result = Rr(result);
-    let result = Rr(copyBytes(input));
-    result = Rr(result);
-    result = Rr(result);
-    result = Rr(result);
-    result = Rr(result);
-    result = Rr(result);
-    result = Rr(result);
-    result = Rr(result);
-    result = Rr(result);
-    result = Rr(result);
-    result = Rr(result);
-    result = Rr(result);
-    result = Rr(result);
-    result = Rr(result);
-    result = Rr(result);
-    result = Rr(result);
-    return result;
-};
+const S = (input, pi = PI) => new Uint8Array([
+    pi[input[0]], pi[input[1]], pi[input[2]], pi[input[3]],
+    pi[input[4]], pi[input[5]], pi[input[6]], pi[input[7]],
+    pi[input[8]], pi[input[9]], pi[input[10]], pi[input[11]],
+    pi[input[12]], pi[input[13]], pi[input[14]], pi[input[15]]
+]);
+const R = (input) => new Uint8Array([
+    gfMultiply(input[15], L[0]) ^ gfMultiply(input[0], L[1]) ^
+        gfMultiply(input[1], L[2]) ^ gfMultiply(input[2], L[3]) ^
+        gfMultiply(input[3], L[4]) ^ gfMultiply(input[4], L[5]) ^
+        gfMultiply(input[5], L[6]) ^ gfMultiply(input[6], L[7]) ^
+        gfMultiply(input[7], L[8]) ^ gfMultiply(input[8], L[9]) ^
+        gfMultiply(input[9], L[10]) ^ gfMultiply(input[10], L[11]) ^
+        gfMultiply(input[11], L[12]) ^ gfMultiply(input[12], L[13]) ^
+        gfMultiply(input[13], L[14]) ^ gfMultiply(input[14], L[15]),
+    ...input.subarray(0, 15)
+]);
+const Rr = (input) => new Uint8Array([
+    ...input.subarray(1, 16),
+    gfMultiply(input[0], L[0]) ^ gfMultiply(input[1], L[1]) ^
+        gfMultiply(input[2], L[2]) ^ gfMultiply(input[3], L[3]) ^
+        gfMultiply(input[4], L[4]) ^ gfMultiply(input[5], L[5]) ^
+        gfMultiply(input[6], L[6]) ^ gfMultiply(input[7], L[7]) ^
+        gfMultiply(input[8], L[8]) ^ gfMultiply(input[9], L[9]) ^
+        gfMultiply(input[10], L[10]) ^ gfMultiply(input[11], L[11]) ^
+        gfMultiply(input[12], L[12]) ^ gfMultiply(input[13], L[13]) ^
+        gfMultiply(input[14], L[14]) ^ gfMultiply(input[15], L[15])
+]);
+// Call `R` 16x times
+const LL = (input) => R(R(R(R(R(R(R(R(R(R(R(R(R(R(R(R(input))))))))))))))));
+// Call `Rr` 16x times
+const LLr = (input) => Rr(Rr(Rr(Rr(Rr(Rr(Rr(Rr(Rr(Rr(Rr(Rr(Rr(Rr(Rr(Rr(input))))))))))))))));
 const LLS = (block) => LL(S(block));
 const SLLr = (block) => S(LLr(block), PI_REV);
-const F = (in_key1, in_key2, iter_constant) => xorBytes(LLS(xorBytes(in_key1, iter_constant)), in_key2);
+const F = (inKey, inKey2, iter) => xorBytes(LLS(xorBytes(inKey, iter)), inKey2);
 /** Kuznyechik (GOST R 34.12-2015) cipher */
 export class Kuznyechik {
-    keySize = KEYSIZE;
-    blockSize = BLOCKSIZE;
+    keySize = 32;
+    blockSize = 16;
     roundKeys;
     /** Kuznyechik (GOST R 34.12-2015) cipher */
     constructor(key) {
         if (key.length !== this.keySize)
             throw new Error("Invalid key length");
-        const roundKeys = Array(10).fill(null).map(() => new Uint8Array(this.blockSize));
+        const roundKeys = Array(10);
         roundKeys[0] = key.slice(0, this.blockSize);
         roundKeys[1] = key.slice(this.blockSize);
         let temp1 = copyBytes(roundKeys[0]);
@@ -184,8 +102,7 @@ export class Kuznyechik {
         currentBlock = LLS(xorBytes(this.roundKeys[6], currentBlock));
         currentBlock = LLS(xorBytes(this.roundKeys[7], currentBlock));
         currentBlock = LLS(xorBytes(this.roundKeys[8], currentBlock));
-        currentBlock = xorBytes(this.roundKeys[9], currentBlock);
-        return currentBlock;
+        return xorBytes(this.roundKeys[9], currentBlock);
     }
     decrypt(ciphertext) {
         if (ciphertext.length !== this.blockSize)
@@ -201,7 +118,6 @@ export class Kuznyechik {
         currentBlock = xorBytes(this.roundKeys[3], SLLr(currentBlock));
         currentBlock = xorBytes(this.roundKeys[2], SLLr(currentBlock));
         currentBlock = xorBytes(this.roundKeys[1], SLLr(currentBlock));
-        currentBlock = xorBytes(this.roundKeys[0], SLLr(currentBlock));
-        return currentBlock;
+        return xorBytes(this.roundKeys[0], SLLr(currentBlock));
     }
 }

package/magma/index.js

@@ -1,19 +1,14 @@
 import { bytesToNumberBE, concatBytes, copyBytes, numberToBytesBE } from "@noble/curves/utils.js";
 import { ID_TC26_GOST_28147_PARAM_Z, magmaKeySequences } from "./const.js";
 const BLOCKSIZE = 8, KEYSIZE = 32;
-const T = (value, sbox) => {
-    //let result = 0;
-    //for (let i = 0; i < 8; i++) result |= sbox[i][(value >> (4 * i)) & 0x0f] << (4 * i);
-    let result = sbox[0][(value >> 0) & 0x0f] << 0;
-    result |= sbox[1][(value >> 4) & 0x0f] << 4;
-    result |= sbox[2][(value >> 8) & 0x0f] << 8;
-    result |= sbox[3][(value >> 12) & 0x0f] << 12;
-    result |= sbox[4][(value >> 16) & 0x0f] << 16;
-    result |= sbox[5][(value >> 20) & 0x0f] << 20;
-    result |= sbox[6][(value >> 24) & 0x0f] << 24;
-    result |= sbox[7][(value >> 28) & 0x0f] << 28;
-    return result >>> 0;
-};
+const T = (value, sbox) => ((sbox[0][(value >> 0) & 0x0f] << 0) |
+    (sbox[1][(value >> 4) & 0x0f] << 4) |
+    (sbox[2][(value >> 8) & 0x0f] << 8) |
+    (sbox[3][(value >> 12) & 0x0f] << 12) |
+    (sbox[4][(value >> 16) & 0x0f] << 16) |
+    (sbox[5][(value >> 20) & 0x0f] << 20) |
+    (sbox[6][(value >> 24) & 0x0f] << 24) |
+    (sbox[7][(value >> 28) & 0x0f] << 28)) >>> 0;
 const G = (a, k, sbox) => {
     const substituted = T((a + k) >>> 0, sbox);
     return ((substituted << 11) | (substituted >>> 21)) >>> 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@li0ard/gost",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "main": "index.js",
   "types": "index.d.ts",
   "type": "module",

package/streebog/index.js

@@ -20,144 +20,32 @@ const add512 = (a, b) => {
     }
     return c;
 };
-const S = (input) => {
-    const result = new Uint8Array(BLOCKSIZE);
-    //for (let i = 0; i < BLOCKSIZE; i++) result[i] = PI[input[i]];
-    result[0] = PI[input[0]];
-    result[1] = PI[input[1]];
-    result[2] = PI[input[2]];
-    result[3] = PI[input[3]];
-    result[4] = PI[input[4]];
-    result[5] = PI[input[5]];
-    result[6] = PI[input[6]];
-    result[7] = PI[input[7]];
-    result[8] = PI[input[8]];
-    result[9] = PI[input[9]];
-    result[10] = PI[input[10]];
-    result[11] = PI[input[11]];
-    result[12] = PI[input[12]];
-    result[13] = PI[input[13]];
-    result[14] = PI[input[14]];
-    result[15] = PI[input[15]];
-    result[16] = PI[input[16]];
-    result[17] = PI[input[17]];
-    result[18] = PI[input[18]];
-    result[19] = PI[input[19]];
-    result[20] = PI[input[20]];
-    result[21] = PI[input[21]];
-    result[22] = PI[input[22]];
-    result[23] = PI[input[23]];
-    result[24] = PI[input[24]];
-    result[25] = PI[input[25]];
-    result[26] = PI[input[26]];
-    result[27] = PI[input[27]];
-    result[28] = PI[input[28]];
-    result[29] = PI[input[29]];
-    result[30] = PI[input[30]];
-    result[31] = PI[input[31]];
-    result[32] = PI[input[32]];
-    result[33] = PI[input[33]];
-    result[34] = PI[input[34]];
-    result[35] = PI[input[35]];
-    result[36] = PI[input[36]];
-    result[37] = PI[input[37]];
-    result[38] = PI[input[38]];
-    result[39] = PI[input[39]];
-    result[40] = PI[input[40]];
-    result[41] = PI[input[41]];
-    result[42] = PI[input[42]];
-    result[43] = PI[input[43]];
-    result[44] = PI[input[44]];
-    result[45] = PI[input[45]];
-    result[46] = PI[input[46]];
-    result[47] = PI[input[47]];
-    result[48] = PI[input[48]];
-    result[49] = PI[input[49]];
-    result[50] = PI[input[50]];
-    result[51] = PI[input[51]];
-    result[52] = PI[input[52]];
-    result[53] = PI[input[53]];
-    result[54] = PI[input[54]];
-    result[55] = PI[input[55]];
-    result[56] = PI[input[56]];
-    result[57] = PI[input[57]];
-    result[58] = PI[input[58]];
-    result[59] = PI[input[59]];
-    result[60] = PI[input[60]];
-    result[61] = PI[input[61]];
-    result[62] = PI[input[62]];
-    result[63] = PI[input[63]];
-    return result;
-};
-const P = (input) => {
-    const result = new Uint8Array(BLOCKSIZE);
-    //for (let i = 0; i < BLOCKSIZE; i++) result[i] = input[TAU[i]];
-    result[0] = input[TAU[0]];
-    result[1] = input[TAU[1]];
-    result[2] = input[TAU[2]];
-    result[3] = input[TAU[3]];
-    result[4] = input[TAU[4]];
-    result[5] = input[TAU[5]];
-    result[6] = input[TAU[6]];
-    result[7] = input[TAU[7]];
-    result[8] = input[TAU[8]];
-    result[9] = input[TAU[9]];
-    result[10] = input[TAU[10]];
-    result[11] = input[TAU[11]];
-    result[12] = input[TAU[12]];
-    result[13] = input[TAU[13]];
-    result[14] = input[TAU[14]];
-    result[15] = input[TAU[15]];
-    result[16] = input[TAU[16]];
-    result[17] = input[TAU[17]];
-    result[18] = input[TAU[18]];
-    result[19] = input[TAU[19]];
-    result[20] = input[TAU[20]];
-    result[21] = input[TAU[21]];
-    result[22] = input[TAU[22]];
-    result[23] = input[TAU[23]];
-    result[24] = input[TAU[24]];
-    result[25] = input[TAU[25]];
-    result[26] = input[TAU[26]];
-    result[27] = input[TAU[27]];
-    result[28] = input[TAU[28]];
-    result[29] = input[TAU[29]];
-    result[30] = input[TAU[30]];
-    result[31] = input[TAU[31]];
-    result[32] = input[TAU[32]];
-    result[33] = input[TAU[33]];
-    result[34] = input[TAU[34]];
-    result[35] = input[TAU[35]];
-    result[36] = input[TAU[36]];
-    result[37] = input[TAU[37]];
-    result[38] = input[TAU[38]];
-    result[39] = input[TAU[39]];
-    result[40] = input[TAU[40]];
-    result[41] = input[TAU[41]];
-    result[42] = input[TAU[42]];
-    result[43] = input[TAU[43]];
-    result[44] = input[TAU[44]];
-    result[45] = input[TAU[45]];
-    result[46] = input[TAU[46]];
-    result[47] = input[TAU[47]];
-    result[48] = input[TAU[48]];
-    result[49] = input[TAU[49]];
-    result[50] = input[TAU[50]];
-    result[51] = input[TAU[51]];
-    result[52] = input[TAU[52]];
-    result[53] = input[TAU[53]];
-    result[54] = input[TAU[54]];
-    result[55] = input[TAU[55]];
-    result[56] = input[TAU[56]];
-    result[57] = input[TAU[57]];
-    result[58] = input[TAU[58]];
-    result[59] = input[TAU[59]];
-    result[60] = input[TAU[60]];
-    result[61] = input[TAU[61]];
-    result[62] = input[TAU[62]];
-    result[63] = input[TAU[63]];
-    return result;
-};
+const S = (input) => new Uint8Array([
+    PI[input[0]], PI[input[1]], PI[input[2]], PI[input[3]], PI[input[4]], PI[input[5]],
+    PI[input[6]], PI[input[7]], PI[input[8]], PI[input[9]], PI[input[10]], PI[input[11]],
+    PI[input[12]], PI[input[13]], PI[input[14]], PI[input[15]], PI[input[16]], PI[input[17]],
+    PI[input[18]], PI[input[19]], PI[input[20]], PI[input[21]], PI[input[22]], PI[input[23]],
+    PI[input[24]], PI[input[25]], PI[input[26]], PI[input[27]], PI[input[28]], PI[input[29]],
+    PI[input[30]], PI[input[31]], PI[input[32]], PI[input[33]], PI[input[34]], PI[input[35]],
+    PI[input[36]], PI[input[37]], PI[input[38]], PI[input[39]], PI[input[40]], PI[input[41]],
+    PI[input[42]], PI[input[43]], PI[input[44]], PI[input[45]], PI[input[46]], PI[input[47]],
+    PI[input[48]], PI[input[49]], PI[input[50]], PI[input[51]], PI[input[52]], PI[input[53]],
+    PI[input[54]], PI[input[55]], PI[input[56]], PI[input[57]], PI[input[58]], PI[input[59]],
+    PI[input[60]], PI[input[61]], PI[input[62]], PI[input[63]]
+]);
+const P = (input) => new Uint8Array([
+    input[TAU[0]], input[TAU[1]], input[TAU[2]], input[TAU[3]], input[TAU[4]], input[TAU[5]],
+    input[TAU[6]], input[TAU[7]], input[TAU[8]], input[TAU[9]], input[TAU[10]], input[TAU[11]],
+    input[TAU[12]], input[TAU[13]], input[TAU[14]], input[TAU[15]], input[TAU[16]], input[TAU[17]],
+    input[TAU[18]], input[TAU[19]], input[TAU[20]], input[TAU[21]], input[TAU[22]], input[TAU[23]],
+    input[TAU[24]], input[TAU[25]], input[TAU[26]], input[TAU[27]], input[TAU[28]], input[TAU[29]],
+    input[TAU[30]], input[TAU[31]], input[TAU[32]], input[TAU[33]], input[TAU[34]], input[TAU[35]],
+    input[TAU[36]], input[TAU[37]], input[TAU[38]], input[TAU[39]], input[TAU[40]], input[TAU[41]],
+    input[TAU[42]], input[TAU[43]], input[TAU[44]], input[TAU[45]], input[TAU[46]], input[TAU[47]],
+    input[TAU[48]], input[TAU[49]], input[TAU[50]], input[TAU[51]], input[TAU[52]], input[TAU[53]],
+    input[TAU[54]], input[TAU[55]], input[TAU[56]], input[TAU[57]], input[TAU[58]], input[TAU[59]],
+    input[TAU[60]], input[TAU[61]], input[TAU[62]], input[TAU[63]]
+]);
 const L = (input) => {
     const result = new Uint8Array(BLOCKSIZE);
     for (let i = 0; i < 8; i++) {
@@ -181,8 +69,7 @@ const E = (block, keys) => {
     // block will be mutated
     let c = xorBytes(block, keys);
     /*for (let i = 0; i < 12; i++) {
-        block = LPS(xorBytes(block, C[i]));
-        c = xorBytes(LPS(c), block);
+        block = LPS(xorBytes(block, C[i])); c = xorBytes(LPS(c), block);
     }*/
     block = LPS(xorBytes(block, C[0]));
     c = xorBytes(LPS(c), block);
@@ -236,24 +123,24 @@ class Streebog {
     }
     digestInto(buf) {
         const message = this.buffer.slice().reverse();
-        let n = new Uint8Array(BLOCKSIZE);
-        let sigma = new Uint8Array(BLOCKSIZE);
-        let hash = new Uint8Array(BLOCKSIZE).fill(this.is512 ? 0 : 1);
+        let n = new Uint8Array(this.blockLen);
+        let sigma = new Uint8Array(this.blockLen);
+        let hash = new Uint8Array(this.blockLen).fill(this.is512 ? 0 : 1);
         let blocks = 1;
-        for (let i = message.length; i >= BLOCKSIZE; i -= BLOCKSIZE) {
-            const pos = message.length - blocks * BLOCKSIZE;
-            hash = G(n, hash, message.subarray(pos, pos + BLOCKSIZE));
+        for (let i = message.length; i >= this.blockLen; i -= this.blockLen) {
+            const pos = message.length - blocks * this.blockLen;
+            hash = G(n, hash, message.subarray(pos, pos + this.blockLen));
             n = add512(n, _0020);
-            sigma = add512(sigma, message.subarray(pos, pos + BLOCKSIZE));
+            sigma = add512(sigma, message.subarray(pos, pos + this.blockLen));
             blocks++;
         }
-        let paddedMsg = new Uint8Array(BLOCKSIZE);
+        let paddedMsg = new Uint8Array(this.blockLen);
         const msg = message.subarray(0, message.length - (blocks - 1) * 64);
-        if (msg.length < BLOCKSIZE) {
-            paddedMsg = pad1(paddedMsg, BLOCKSIZE);
-            paddedMsg[BLOCKSIZE - msg.length - 1] = 0x01;
+        if (msg.length < this.blockLen) {
+            paddedMsg = pad1(paddedMsg, this.blockLen);
+            paddedMsg[this.blockLen - msg.length - 1] = 0x01;
             for (let i = 0; i < msg.length; i++)
-                paddedMsg[BLOCKSIZE - msg.length + i] = msg[i];
+                paddedMsg[this.blockLen - msg.length + i] = msg[i];
         }
         hash = G(_0, G(_0, G(n, hash, paddedMsg), add512(n, numberToBytesBE(msg.length * 8, 4))), add512(sigma, paddedMsg));
         if (this.is512)