@li0ard/gost 0.1.5 → 0.1.7

package/gf/gf128.d.ts

@@ -0,0 +1,2 @@
+import { type TArg, type TRet } from "@noble/curves/utils.js";
+export declare const gf128Multiply: (a: TArg<Uint8Array>, b: TArg<Uint8Array>) => TRet<Uint8Array>;

package/gf/gf128.js

@@ -0,0 +1,15 @@
+import { bytesToNumberBE, numberToBytesBE } from "@noble/curves/utils.js";
+export const gf128Multiply = (a, b) => {
+    let x = bytesToNumberBE(a), y = bytesToNumberBE(b), z = 0n;
+    const max_bit = 1n << 127n;
+    while (y > 0n) {
+        if ((y & 1n) == 1n)
+            z ^= x;
+        if ((x & max_bit) > 0n)
+            x = ((x ^ max_bit) << 1n) ^ 0x87n;
+        else
+            x <<= 1n;
+        y >>= 1n;
+    }
+    return numberToBytesBE(z, 16);
+};

package/gf/gf256.d.ts

@@ -0,0 +1 @@
+export declare const gf256Multiply: (a: number, b: number) => number;

package/gf/gf256.js

@@ -0,0 +1,62 @@
+/*// Precompute GF(256) multiply table
+const gf256Multiply_slow = (a: number, b: number): number => {
+    let result = 0, high_bit: number;
+    for(let _ = 0; _ < 8; _++) {
+        if((b & 1) === 1) result ^= a;
+        high_bit = a & 0x80;
+        a <<= 1;
+        if(high_bit == 0x80) a ^= 0xC3;
+        b >>= 1;
+    }
+
+    return result & 0xFF;
+}
+
+const gen_mul_tables = () => {
+    let c = 1;
+
+    for (let i = 0; i < 256; i++) {
+        gf_multtable_log[c] = i;
+        gf_multtable_exp[i] = c;
+        c = gfMultiply_slow(c, 3);
+    }
+}*/
+const gf_multtable_exp = new Uint8Array([
+    0x01, 0x03, 0x05, 0x0F, 0x11, 0x33, 0x55, 0xFF, 0xC2, 0x85, 0x4C, 0xD4, 0xBF, 0x02, 0x06, 0x0A,
+    0x1E, 0x22, 0x66, 0xAA, 0x3D, 0x47, 0xC9, 0x98, 0x6B, 0xBD, 0x04, 0x0C, 0x14, 0x3C, 0x44, 0xCC,
+    0x97, 0x7A, 0x8E, 0x51, 0xF3, 0xD6, 0xB9, 0x08, 0x18, 0x28, 0x78, 0x88, 0x5B, 0xED, 0xF4, 0xDF,
+    0xA2, 0x25, 0x6F, 0xB1, 0x10, 0x30, 0x50, 0xF0, 0xD3, 0xB6, 0x19, 0x2B, 0x7D, 0x87, 0x4A, 0xDE,
+    0xA1, 0x20, 0x60, 0xA0, 0x23, 0x65, 0xAF, 0x32, 0x56, 0xFA, 0xCD, 0x94, 0x7F, 0x81, 0x40, 0xC0,
+    0x83, 0x46, 0xCA, 0x9D, 0x64, 0xAC, 0x37, 0x59, 0xEB, 0xFE, 0xC1, 0x80, 0x43, 0xC5, 0x8C, 0x57,
+    0xF9, 0xC8, 0x9B, 0x6E, 0xB2, 0x15, 0x3F, 0x41, 0xC3, 0x86, 0x49, 0xDB, 0xAE, 0x31, 0x53, 0xF5,
+    0xDC, 0xA7, 0x2A, 0x7E, 0x82, 0x45, 0xCF, 0x92, 0x75, 0x9F, 0x62, 0xA6, 0x29, 0x7B, 0x8D, 0x54,
+    0xFC, 0xC7, 0x8A, 0x5D, 0xE7, 0xEA, 0xFD, 0xC4, 0x8F, 0x52, 0xF6, 0xD9, 0xA8, 0x3B, 0x4D, 0xD7,
+    0xBA, 0x0D, 0x17, 0x39, 0x4B, 0xDD, 0xA4, 0x2F, 0x71, 0x93, 0x76, 0x9A, 0x6D, 0xB7, 0x1A, 0x2E,
+    0x72, 0x96, 0x79, 0x8B, 0x5E, 0xE2, 0xE5, 0xEC, 0xF7, 0xDA, 0xAD, 0x34, 0x5C, 0xE4, 0xEF, 0xF2,
+    0xD5, 0xBC, 0x07, 0x09, 0x1B, 0x2D, 0x77, 0x99, 0x68, 0xB8, 0x0B, 0x1D, 0x27, 0x69, 0xBB, 0x0E,
+    0x12, 0x36, 0x5A, 0xEE, 0xF1, 0xD0, 0xB3, 0x16, 0x3A, 0x4E, 0xD2, 0xB5, 0x1C, 0x24, 0x6C, 0xB4,
+    0x1F, 0x21, 0x63, 0xA5, 0x2C, 0x74, 0x9C, 0x67, 0xA9, 0x38, 0x48, 0xD8, 0xAB, 0x3E, 0x42, 0xC6,
+    0x89, 0x58, 0xE8, 0xFB, 0xCE, 0x91, 0x70, 0x90, 0x73, 0x95, 0x7C, 0x84, 0x4F, 0xD1, 0xB0, 0x13,
+    0x35, 0x5F, 0xE1, 0xE0, 0xE3, 0xE6, 0xE9, 0xF8, 0xCB, 0x9E, 0x61, 0xA3, 0x26, 0x6A, 0xBE, 0x01
+]);
+const gf_multtable_log = new Uint8Array([
+    0x00, 0xFF, 0x0D, 0x01, 0x1A, 0x02, 0x0E, 0xB2, 0x27, 0xB3, 0x0F, 0xBA, 0x1B, 0x91, 0xBF, 0x03,
+    0x34, 0x04, 0xC0, 0xEF, 0x1C, 0x65, 0xC7, 0x92, 0x28, 0x3A, 0x9E, 0xB4, 0xCC, 0xBB, 0x10, 0xD0,
+    0x41, 0xD1, 0x11, 0x44, 0xCD, 0x31, 0xFC, 0xBC, 0x29, 0x7C, 0x72, 0x3B, 0xD4, 0xB5, 0x9F, 0x97,
+    0x35, 0x6D, 0x47, 0x05, 0xAB, 0xF0, 0xC1, 0x56, 0xD9, 0x93, 0xC8, 0x8D, 0x1D, 0x14, 0xDD, 0x66,
+    0x4E, 0x67, 0xDE, 0x5C, 0x1E, 0x75, 0x51, 0x15, 0xDA, 0x6A, 0x3E, 0x94, 0x0A, 0x8E, 0xC9, 0xEC,
+    0x36, 0x23, 0x89, 0x6E, 0x7F, 0x06, 0x48, 0x5F, 0xE1, 0x57, 0xC2, 0x2C, 0xAC, 0x83, 0xA4, 0xF1,
+    0x42, 0xFA, 0x7A, 0xD2, 0x54, 0x45, 0x12, 0xD7, 0xB8, 0xBD, 0xFD, 0x18, 0xCE, 0x9C, 0x63, 0x32,
+    0xE6, 0x98, 0xA0, 0xE8, 0xD5, 0x78, 0x9A, 0xB6, 0x2A, 0xA2, 0x21, 0x7D, 0xEA, 0x3C, 0x73, 0x4C,
+    0x5B, 0x4D, 0x74, 0x50, 0xEB, 0x09, 0x69, 0x3D, 0x2B, 0xE0, 0x82, 0xA3, 0x5E, 0x7E, 0x22, 0x88,
+    0xE7, 0xE5, 0x77, 0x99, 0x4B, 0xE9, 0xA1, 0x20, 0x17, 0xB7, 0x9B, 0x62, 0xD6, 0x53, 0xF9, 0x79,
+    0x43, 0x40, 0x30, 0xFB, 0x96, 0xD3, 0x7B, 0x71, 0x8C, 0xD8, 0x13, 0xDC, 0x55, 0xAA, 0x6C, 0x46,
+    0xEE, 0x33, 0x64, 0xC6, 0xCF, 0xCB, 0x39, 0x9D, 0xB9, 0x26, 0x90, 0xBE, 0xB1, 0x19, 0xFE, 0x0C,
+    0x4F, 0x5A, 0x08, 0x68, 0x87, 0x5D, 0xDF, 0x81, 0x61, 0x16, 0x52, 0xF8, 0x1F, 0x4A, 0xE4, 0x76,
+    0xC5, 0xED, 0xCA, 0x38, 0x0B, 0xB0, 0x25, 0x8F, 0xDB, 0x8B, 0xA9, 0x6B, 0x70, 0x95, 0x3F, 0x2F,
+    0xF3, 0xF2, 0xA5, 0xF4, 0xAD, 0xA6, 0xF5, 0x84, 0xE2, 0xF6, 0x85, 0x58, 0xA7, 0x2D, 0xC3, 0xAE,
+    0x37, 0xC4, 0xAF, 0x24, 0x2E, 0x6F, 0x8A, 0xA8, 0xF7, 0x60, 0x49, 0xE3, 0x80, 0x86, 0x59, 0x07
+]);
+export const gf256Multiply = (a, b) => (a == 0 || b == 0)
+    ? 0
+    : gf_multtable_exp[(gf_multtable_log[a] + gf_multtable_log[b]) % 255];

package/gf/gf64.d.ts

@@ -0,0 +1,2 @@
+import { type TArg, type TRet } from "@noble/curves/utils.js";
+export declare const gf64Multiply: (a: TArg<Uint8Array>, b: TArg<Uint8Array>) => TRet<Uint8Array>;

package/gf/gf64.js

@@ -0,0 +1,15 @@
+import { bytesToNumberBE, numberToBytesBE } from "@noble/curves/utils.js";
+export const gf64Multiply = (a, b) => {
+    let x = bytesToNumberBE(a), y = bytesToNumberBE(b), z = 0n;
+    const max_bit = 1n << 63n;
+    while (y > 0n) {
+        if ((y & 1n) == 1n)
+            z ^= x;
+        if ((x & max_bit) > 0n)
+            x = ((x ^ max_bit) << 1n) ^ 0x1bn;
+        else
+            x <<= 1n;
+        y >>= 1n;
+    }
+    return numberToBytesBE(z, 8);
+};

package/gf/index.d.ts

@@ -0,0 +1,3 @@
+export { gf64Multiply } from "./gf64.js";
+export { gf128Multiply } from "./gf128.js";
+export { gf256Multiply } from "./gf256.js";

package/gf/index.js

@@ -0,0 +1,3 @@
+export { gf64Multiply } from "./gf64.js";
+export { gf128Multiply } from "./gf128.js";
+export { gf256Multiply } from "./gf256.js";

package/gost3410/const.js

@@ -1,5 +1,5 @@
 /** GOST R 34.10-2001 CryptoCom param set */
-export const ID_GOSTR3410_2001_PARAM_SET_CC = ({
+export const ID_GOSTR3410_2001_PARAM_SET_CC = {
     p: 0xc0000000000000000000000000000000000000000000000000000000000003c7n,
     n: 0x5fffffffffffffffffffffffffffffff606117a2f4bde428b7458a54b6e87b85n,
     a: 0xc0000000000000000000000000000000000000000000000000000000000003c4n,
@@ -9,9 +9,9 @@ export const ID_GOSTR3410_2001_PARAM_SET_CC = ({
     h: 1n,
     length: 32,
     oids: ["1.2.643.2.9.1.8.1"]
-});
+};
 /** GOST R 34.10-2001 test param set */
-export const ID_GOSTR3410_2001_TEST_PARAM_SET = ({
+export const ID_GOSTR3410_2001_TEST_PARAM_SET = {
     p: 0x8000000000000000000000000000000000000000000000000000000000000431n,
     n: 0x8000000000000000000000000000000150fe8a1892976154c59cfc193accf5b3n,
     a: 7n,
@@ -21,9 +21,9 @@ export const ID_GOSTR3410_2001_TEST_PARAM_SET = ({
     h: 1n,
     length: 32,
     oids: ["1.2.643.2.2.35.0"]
-});
+};
 /** GOST R 34.10-2012 256 bit `A` param set */
-export const ID_GOSTR3410_2012_256_PARAM_SET_A = ({
+export const ID_GOSTR3410_2012_256_PARAM_SET_A = {
     p: 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd97n,
     n: 0x400000000000000000000000000000000fd8cddfc87b6635c115af556c360c67n,
     a: 0xc2173f1513981673af4892c23035a27ce25e2013bf95aa33b22c656f277e7335n,
@@ -36,9 +36,9 @@ export const ID_GOSTR3410_2012_256_PARAM_SET_A = ({
     length: 32,
     st: [0x7e7e82520f9f015faa1d0f18c14ab9fb35188275da3fd94206b74f34a48e0ecdn, 0x0100fe73f595ff158e974b44d478d9588744fe5c192ac47ea63075dce7a14aaan],
     oids: ["1.2.643.7.1.2.1.1.1"]
-});
+};
 /** GOST R 34.10-2012 256 bit `B` param set (aka CryptoPro `A` (`XchA`) param set) */
-export const ID_GOSTR3410_2012_256_PARAM_SET_B = ({
+export const ID_GOSTR3410_2012_256_PARAM_SET_B = {
     p: 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd97n,
     n: 0xffffffffffffffffffffffffffffffff6c611070995ad10045841b09b761b893n,
     a: 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffd94n,
@@ -48,9 +48,9 @@ export const ID_GOSTR3410_2012_256_PARAM_SET_B = ({
     h: 1n,
     length: 32,
     oids: ["1.2.643.7.1.2.1.1.2", "1.2.643.2.2.35.1", "1.2.643.2.2.36.0"]
-});
+};
 /** GOST R 34.10-2012 256 bit `C` param set (aka CryptoPro `B` param set) */
-export const ID_GOSTR3410_2012_256_PARAM_SET_C = ({
+export const ID_GOSTR3410_2012_256_PARAM_SET_C = {
     p: 0x8000000000000000000000000000000000000000000000000000000000000c99n,
     n: 0x800000000000000000000000000000015f700cfff1a624e5e497161bcc8a198fn,
     a: 0x8000000000000000000000000000000000000000000000000000000000000c96n,
@@ -60,9 +60,9 @@ export const ID_GOSTR3410_2012_256_PARAM_SET_C = ({
     h: 1n,
     length: 32,
     oids: ["1.2.643.7.1.2.1.1.3", "1.2.643.2.2.35.2"]
-});
+};
 /** GOST R 34.10-2012 256 bit `D` param set (aka CryptoPro `C` (`XchB`) param set) */
-export const ID_GOSTR3410_2012_256_PARAM_SET_D = ({
+export const ID_GOSTR3410_2012_256_PARAM_SET_D = {
     p: 0x9b9f605f5a858107ab1ec85e6b41c8aacf846e86789051d37998f7b9022d759bn,
     n: 0x9b9f605f5a858107ab1ec85e6b41c8aa582ca3511eddfb74f02f3a6598980bb9n,
     a: 0x9b9f605f5a858107ab1ec85e6b41c8aacf846e86789051d37998f7b9022d7598n,
@@ -72,9 +72,9 @@ export const ID_GOSTR3410_2012_256_PARAM_SET_D = ({
     h: 1n,
     length: 32,
     oids: ["1.2.643.7.1.2.1.1.4", "1.2.643.2.2.35.3", "1.2.643.2.2.36.1"]
-});
+};
 /** GOST R 34.10-2012 512 bit test param set */
-export const ID_GOSTR3410_2012_512_TEST_PARAM_SET = ({
+export const ID_GOSTR3410_2012_512_TEST_PARAM_SET = {
     p: 0x4531acd1fe0023c7550d267b6b2fee80922b14b2ffb90f04d4eb7c09b5d2d15df1d852741af4704a0458047e80e4546d35b8336fac224dd81664bbf528be6373n,
     n: 0x4531acd1fe0023c7550d267b6b2fee80922b14b2ffb90f04d4eb7c09b5d2d15da82f2d7ecb1dbac719905c5eecc423f1d86e25edbe23c595d644aaf187e6e6dfn,
     a: 7n,
@@ -84,9 +84,9 @@ export const ID_GOSTR3410_2012_512_TEST_PARAM_SET = ({
     h: 1n,
     length: 64,
     oids: ["1.2.643.7.1.2.1.2.0"]
-});
+};
 /** GOST R 34.10-2012 512 bit `A` param set */
-export const ID_GOSTR3410_2012_512_PARAM_SET_A = ({
+export const ID_GOSTR3410_2012_512_PARAM_SET_A = {
     p: 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdc7n,
     n: 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff27e69532f48d89116ff22b8d4e0560609b4b38abfad2b85dcacdb1411f10b275n,
     a: 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdc4n,
@@ -96,9 +96,9 @@ export const ID_GOSTR3410_2012_512_PARAM_SET_A = ({
     h: 1n,
     length: 64,
     oids: ["1.2.643.7.1.2.1.2.1"]
-});
+};
 /** GOST R 34.10-2012 512 bit `B` param set */
-export const ID_GOSTR3410_2012_512_PARAM_SET_B = ({
+export const ID_GOSTR3410_2012_512_PARAM_SET_B = {
     p: 0x8000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006fn,
     n: 0x800000000000000000000000000000000000000000000000000000000000000149a1ec142565a545acfdb77bd9d40cfa8b996712101bea0ec6346c54374f25bdn,
     a: 0x8000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006cn,
@@ -108,9 +108,9 @@ export const ID_GOSTR3410_2012_512_PARAM_SET_B = ({
     h: 1n,
     length: 64,
     oids: ["1.2.643.7.1.2.1.2.2"]
-});
+};
 /** GOST R 34.10-2012 512 bit `C` param set */
-export const ID_GOSTR3410_2012_512_PARAM_SET_C = ({
+export const ID_GOSTR3410_2012_512_PARAM_SET_C = {
     p: 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffdc7n,
     n: 0x3fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc98cdba46506ab004c33a9ff5147502cc8eda9e7a769a12694623cef47f023edn,
     a: 0xdc9203e514a721875485a529d2c722fb187bc8980eb866644de41c68e143064546e861c0e2c9edd92ade71f46fcf50ff2ad97f951fda9f2a2eb6546f39689bd3n,
@@ -123,7 +123,7 @@ export const ID_GOSTR3410_2012_512_PARAM_SET_C = ({
     length: 64,
     st: [0x186c289cffa09c983b168c30c829006c952ff4aaf99c73850875d7e77bebef18d653187d6ba8fe533ec74c6f061872585b97cc0f50f57752cd73f4913304621en, 0x9a628f975594ecefd89ba28a2539ffb79c8ab238aeed0851fa5c1abb02b80b44c6734501b83a011dd625cd0b5145091a6d9acd4b1f5c5b1e21b2b249ddfd1271n],
     oids: ["1.2.643.7.1.2.1.2.3"]
-});
+};
 export const CURVES = {
     ID_GOSTR3410_2001_PARAM_SET_CC,
     ID_GOSTR3410_2001_TEST_PARAM_SET,

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/gost3410/vko.js

@@ -1,6 +1,6 @@
 import { Field } from "@noble/curves/abstract/modular.js";
 import { weierstrass } from "@noble/curves/abstract/weierstrass.js";
-import { gost341194 } from "../gost341194";
+import { gost341194 } from "../gost341194/index.js";
 import { streebog256, streebog512 } from "../streebog/index.js";
 import { bytesToNumberBE, concatBytes, numberToBytesLE } from "@noble/curves/utils.js";
 /**

package/gost341194/index.d.ts

@@ -3,11 +3,11 @@ 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 */
-    constructor(data?: TArg<Uint8Array>, sbox?: TArg<Uint8Array>[]);
+    constructor(data?: TArg<Uint8Array>, sbox?: TArg<Uint8Array>);
     /** Create hash instance */
     static create(): Gost341194;
     destroy(): void;
@@ -18,6 +18,6 @@ export declare class Gost341194 implements Hash<Gost341194> {
     digest(): TRet<Uint8Array>;
 }
 /** GOST R 34.11-94 hash function */
-export declare const gost341194: (msg: TArg<Uint8Array>, sbox?: TArg<Uint8Array>[]) => TRet<Uint8Array>;
+export declare const gost341194: (msg: TArg<Uint8Array>, sbox?: TArg<Uint8Array>) => TRet<Uint8Array>;
 /** DSTU GOST 34.311-95 */
 export declare const gost3431195: (msg: TArg<Uint8Array>) => TRet<Uint8Array>;

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/kdf.js

@@ -1,4 +1,4 @@
-import { concatBytes, createHasher } from "@noble/hashes/utils.js";
+import { concatBytes, copyBytes, createHasher } from "@noble/hashes/utils.js";
 import { streebog256hmac } from "./hmac.js";
 import { numberToBytesBE } from "@noble/curves/utils.js";
 import { pbkdf2 } from "@noble/hashes/pbkdf2.js";
@@ -35,7 +35,7 @@ export const cpkdf = (password, salt) => {
     if (password.length != 0)
         hasher.update(pin);
     const hash = hasher.digest();
-    const c = new Uint8Array(CPKDF_CONST);
+    const c = copyBytes(CPKDF_CONST);
     const m0 = new Uint8Array(bs);
     const m1 = new Uint8Array(bs);
     for (let j = 0; j < (password.length != 0 ? 2000 : 2); j++) {

package/kuznyechik/const.js

@@ -37,11 +37,6 @@ 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));
-for(let i = 0; i < 32; i++) {
-    ITER[i][15] = i + 1;
-    ITER[i] = LL(ITER[i]);
-}*/
 export const ITER = [
     new Uint8Array([0x6E, 0xA2, 0x76, 0x72, 0x6C, 0x48, 0x7A, 0xB8, 0x5D, 0x27, 0xBD, 0x10, 0xDD, 0x84, 0x94, 0x01]),
     new Uint8Array([0xDC, 0x87, 0xEC, 0xE4, 0xD8, 0x90, 0xF4, 0xB3, 0xBA, 0x4E, 0xB9, 0x20, 0x79, 0xCB, 0xEB, 0x02]),