@li0ard/gost 0.1.7 → 0.1.8

package/README.md

@@ -28,6 +28,7 @@ npm i @li0ard/gost
 - Kuznyechik cipher (GOST R 34.12-2015)
 - Magma cipher (GOST R 34.12-2015)
     - Supports legacy version from GOST 28147-89
+    - Various S-Box'es included (CryptoPro, DSSZZI, tests etc.)
 - Streebog hash function (GOST R 34.11-2012)
     - Supports HMAC, PBKDF2 (512 bit), `kdf_gostr3411_2012_256`, `kdf_tree_gostr3411_2012_256` and CPKDF
 

package/gf/index.d.ts

@@ -1,3 +1,4 @@
-export { gf64Multiply } from "./gf64.js";
-export { gf128Multiply } from "./gf128.js";
+import { type TArg, type TRet } from "@noble/curves/utils.js";
+export declare const gf64Multiply: (a: TArg<Uint8Array>, b: TArg<Uint8Array>) => TRet<Uint8Array>;
+export declare const gf128Multiply: (a: TArg<Uint8Array>, b: TArg<Uint8Array>) => TRet<Uint8Array>;
 export { gf256Multiply } from "./gf256.js";

package/gf/index.js

@@ -1,3 +1,18 @@
-export { gf64Multiply } from "./gf64.js";
-export { gf128Multiply } from "./gf128.js";
+import { bytesToNumberBE, numberToBytesBE } from "@noble/curves/utils.js";
+const gf2m_multiply = (degree, poly, a, b) => {
+    let x = bytesToNumberBE(a), y = bytesToNumberBE(b), z = 0n;
+    const max_bit = 1n << (degree - 1n);
+    while (y > 0n) {
+        if ((y & 1n) == 1n)
+            z ^= x;
+        if ((x & max_bit) > 0n)
+            x = ((x ^ max_bit) << 1n) ^ poly;
+        else
+            x <<= 1n;
+        y >>= 1n;
+    }
+    return numberToBytesBE(z, Number(degree / 8n));
+};
+export const gf64Multiply = (a, b) => gf2m_multiply(64n, 0x1bn, a, b);
+export const gf128Multiply = (a, b) => gf2m_multiply(128n, 0x87n, a, b);
 export { gf256Multiply } from "./gf256.js";

package/gost341194/index.d.ts

@@ -1,13 +1,13 @@
 import { type Hash, type TArg, type TRet } from "@noble/hashes/utils.js";
 /** GOST R 34.11-94 hash function */
 export declare class Gost341194 implements Hash<Gost341194> {
-    private data;
+    private buffer;
     private sbox;
     readonly blockLen = 32;
     readonly outputLen = 32;
     readonly canXOF = false;
     /** GOST R 34.11-94 hash function */
-    constructor(data?: TArg<Uint8Array>, sbox?: TArg<Uint8Array>);
+    constructor(buffer?: TArg<Uint8Array>, sbox?: TArg<Uint8Array>);
     /** Create hash instance */
     static create(): Gost341194;
     destroy(): void;

package/gost341194/index.js

@@ -1,4 +1,4 @@
-import { concatBytes } from "@noble/hashes/utils.js";
+import { concatBytes, copyBytes } from "@noble/hashes/utils.js";
 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";
@@ -10,7 +10,7 @@ const C3 = new Uint8Array([
     0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff,
     0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00
 ]);
-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 A = (x) => concatBytes(xorBytes(x.subarray(24, 32), x.subarray(16, 24)), x.subarray(0, 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],
@@ -44,35 +44,35 @@ const _step = (hin, m, sbox) => {
 };
 /** GOST R 34.11-94 hash function */
 export class Gost341194 {
-    data;
+    buffer;
     sbox;
     blockLen = 32;
     outputLen = 32;
     canXOF = false;
     /** GOST R 34.11-94 hash function */
-    constructor(data = new Uint8Array(), sbox = ID_GOSTR_3411_94_CRYPTOPRO_PARAM_SET) {
-        this.data = data;
+    constructor(buffer = new Uint8Array(), sbox = ID_GOSTR_3411_94_CRYPTOPRO_PARAM_SET) {
+        this.buffer = buffer;
         this.sbox = sbox;
     }
     /** Create hash instance */
     static create() { return new Gost341194(); }
-    destroy() { this.data = new Uint8Array(); }
+    destroy() { this.buffer = new Uint8Array(); }
     clone() { return this._cloneInto(); }
     _cloneInto(to) {
         to ||= new Gost341194();
-        to.data = new Uint8Array(this.data);
+        to.buffer = new Uint8Array(this.buffer);
         to.sbox = this.sbox;
         return to;
     }
     update(data) {
-        this.data = concatBytes(this.data, data);
+        this.buffer = concatBytes(this.buffer, data);
         return this;
     }
     digestInto(buf) {
         let len = 0n;
         let checksum = 0n;
         const h = new Uint8Array(this.blockLen);
-        const m = new Uint8Array(this.data);
+        const m = copyBytes(this.buffer);
         for (let i = 0; i < m.length; i += this.blockLen) {
             let part = m.slice(i, i + this.blockLen).reverse();
             len += BigInt(part.length) * 8n;

package/kdf.js

@@ -8,8 +8,6 @@ import { pad1, xorBytes } from "./utils.js";
 const _0 = new Uint8Array([0]);
 const _1 = new Uint8Array([1]);
 const _0100 = new Uint8Array([1, 0]);
-const CPKDF_CONST = new Uint8Array(64);
-CPKDF_CONST.set(new TextEncoder().encode("DENEFH028.760246785.IUEFHWUIO.EF"));
 const _36 = new Uint8Array(64).fill(0x36);
 const _5C = new Uint8Array(64).fill(0x5C);
 export const kdf_gostr3411_2012_256 = (key, label, seed) => streebog256hmac(key, concatBytes(_1, label, _0, seed, _0100));
@@ -35,9 +33,9 @@ export const cpkdf = (password, salt) => {
     if (password.length != 0)
         hasher.update(pin);
     const hash = hasher.digest();
-    const c = copyBytes(CPKDF_CONST);
-    const m0 = new Uint8Array(bs);
-    const m1 = new Uint8Array(bs);
+    const c = new Uint8Array(64);
+    c.set(new TextEncoder().encode("DENEFH028.760246785.IUEFHWUIO.EF"));
+    const m0 = new Uint8Array(bs), m1 = new Uint8Array(bs);
     for (let j = 0; j < (password.length != 0 ? 2000 : 2); j++) {
         m0.set(xorBytes(c, _36));
         m1.set(xorBytes(c, _5C));

package/kuznyechik/index.d.ts

@@ -1,11 +1,18 @@
 import { type TArg, type TRet } from "@noble/curves/utils.js";
 import type { Cipher } from "../types.js";
-/** Kuznyechik (GOST R 34.12-2015) cipher */
+/**
+ * **Kuznyechik cipher**
+ *
+ * Described by GOST R 34.12-2015 ([RFC 7801](https://datatracker.ietf.org/doc/html/rfc7801.html))
+ */
 export declare class Kuznyechik implements Cipher {
     readonly keySize = 32;
     readonly blockSize = 16;
     private roundKeys;
-    /** Kuznyechik (GOST R 34.12-2015) cipher */
+    /**
+     * Kuznyechik (GOST R 34.12-2015) cipher
+     * @param key Encryption key
+     */
     constructor(key: TArg<Uint8Array>);
     encrypt(plaintext: TArg<Uint8Array>): TRet<Uint8Array>;
     decrypt(ciphertext: TArg<Uint8Array>): TRet<Uint8Array>;

package/kuznyechik/index.js

@@ -37,12 +37,19 @@ 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 = (inKey, inKey2, iter) => xorBytes(LLS(xorBytes(inKey, iter)), inKey2);
-/** Kuznyechik (GOST R 34.12-2015) cipher */
+/**
+ * **Kuznyechik cipher**
+ *
+ * Described by GOST R 34.12-2015 ([RFC 7801](https://datatracker.ietf.org/doc/html/rfc7801.html))
+ */
 export class Kuznyechik {
     keySize = 32;
     blockSize = 16;
     roundKeys;
-    /** Kuznyechik (GOST R 34.12-2015) cipher */
+    /**
+     * Kuznyechik (GOST R 34.12-2015) cipher
+     * @param key Encryption key
+     */
     constructor(key) {
         if (key.length !== this.keySize)
             throw new Error("Invalid key length");

package/magma/const.d.ts

@@ -1,4 +1,4 @@
-/** S-Box from RFC 7836 */
+/** S-Box from RFC 8891 */
 export declare const ID_TC26_GOST_28147_PARAM_Z: Uint8Array<ArrayBuffer>;
 /** S-Box from RFC 4357 aka `CryptoPro Paramset A` */
 export declare const ID_GOST_28147_89_CRYPTO_PRO_A_PARAM_SET: Uint8Array<ArrayBuffer>;

package/magma/const.js

@@ -1,4 +1,4 @@
-/** S-Box from RFC 7836 */
+/** S-Box from RFC 8891 */
 export const ID_TC26_GOST_28147_PARAM_Z = new Uint8Array([
     0x0c, 0x04, 0x06, 0x02, 0x0a, 0x05, 0x0b, 0x09, 0x0e, 0x08, 0x0d, 0x07, 0x00, 0x03, 0x0f, 0x01,
     0x06, 0x08, 0x02, 0x03, 0x09, 0x0a, 0x05, 0x0c, 0x01, 0x0e, 0x04, 0x07, 0x0b, 0x0d, 0x00, 0x0f,
@@ -64,7 +64,6 @@ export const DSSZZI_UA_DKE_1 = new Uint8Array([
     0x03, 0x08, 0x0b, 0x05, 0x06, 0x04, 0x0e, 0x0a, 0x02, 0x0c, 0x01, 0x07, 0x09, 0x0f, 0x0d, 0x00,
     0x01, 0x02, 0x03, 0x0e, 0x06, 0x0d, 0x0b, 0x08, 0x0f, 0x0a, 0x0c, 0x05, 0x07, 0x09, 0x00, 0x04,
 ]);
-// Converted from tables by script, accuracy not guaranteed
 /** S-Box from Instruction no. 114 by State Special Communications Service of Ukraine */
 export const DSSZZI_UA_DKE_2 = new Uint8Array([
     0x0e, 0x09, 0x03, 0x07, 0x0f, 0x04, 0x0c, 0x0b, 0x06, 0x0a, 0x0d, 0x01, 0x00, 0x05, 0x08, 0x02,

package/magma/index.d.ts

@@ -1,12 +1,18 @@
 import { type TArg, type TRet } from "@noble/curves/utils.js";
 import type { Cipher } from "../types.js";
-/** Magma (GOST R 34.12-2015 and GOST 28147-89) cipher */
+/**
+ * **Magma cipher**
+ *
+ * Described by GOST 28147-89 ([RFC 5830](https://datatracker.ietf.org/doc/html/rfc5830.html)) in 1989 (Uses LE byte order, no S-Box'es defined)
+ *
+ * Revised by GOST R 34.12-2015 ([RFC 8891](https://datatracker.ietf.org/doc/html/rfc8891.html)) in 2015 (Uses BE byte order and fixed {@link ID_TC26_GOST_28147_PARAM_Z S-Box})
+ */
 export declare class Magma implements Cipher {
+    private key;
     private sbox;
     isLegacy: boolean;
     readonly keySize = 32;
     readonly blockSize = 8;
-    private key;
     /**
      * Magma (GOST R 34.12-2015 and GOST 28147-89) cipher
      * @param key Encryption key
@@ -17,7 +23,5 @@ export declare class Magma implements Cipher {
     proceedBlock(block: TArg<Uint8Array>, sequence: number[]): TRet<Uint8Array>;
     encrypt(plaintext: TArg<Uint8Array>): TRet<Uint8Array>;
     decrypt(ciphertext: TArg<Uint8Array>): TRet<Uint8Array>;
-    static reverseKey(key: TArg<Uint8Array>): TRet<Uint8Array>;
-    static reverseChunks(data: TArg<Uint8Array>): TRet<Uint8Array>;
 }
 export { magmaSboxes, magmaKeySequences } from "./const.js";

package/magma/index.js

@@ -1,32 +1,38 @@
-import { bytesToNumberBE, concatBytes, copyBytes, numberToBytesBE } from "@noble/curves/utils.js";
+import { bytesToNumberBE, bytesToNumberLE, concatBytes, numberToBytesBE, numberToBytesLE } 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) => ((sbox[((value >> 0) & 0x0f)] << 0) |
-    (sbox[16 + ((value >> 4) & 0x0f)] << 4) |
-    (sbox[32 + ((value >> 8) & 0x0f)] << 8) |
-    (sbox[48 + ((value >> 12) & 0x0f)] << 12) |
-    (sbox[64 + ((value >> 16) & 0x0f)] << 16) |
-    (sbox[80 + ((value >> 20) & 0x0f)] << 20) |
-    (sbox[96 + ((value >> 24) & 0x0f)] << 24) |
-    (sbox[112 + ((value >> 28) & 0x0f)] << 28)) >>> 0;
-const G = (a, k, sbox) => {
-    const substituted = T((a + k) >>> 0, sbox);
-    return ((substituted << 11) | (substituted >>> 21)) >>> 0;
+import { createView } from "@noble/hashes/utils.js";
+const BLOCKSIZE = 8;
+const G = (v, sbox) => {
+    const t = (sbox[(v & 0x0f)] << 0) |
+        (sbox[16 + ((v >> 4) & 0x0f)] << 4) |
+        (sbox[32 + ((v >> 8) & 0x0f)] << 8) |
+        (sbox[48 + ((v >> 12) & 0x0f)] << 12) |
+        (sbox[64 + ((v >> 16) & 0x0f)] << 16) |
+        (sbox[80 + ((v >> 20) & 0x0f)] << 20) |
+        (sbox[96 + ((v >> 24) & 0x0f)] << 24) |
+        (sbox[112 + ((v >> 28) & 0x0f)] << 28);
+    return ((t << 11) | (t >>> 21)) >>> 0;
 };
-const extendKey = (key, sequence) => {
-    const view = new DataView(key.buffer, key.byteOffset, key.byteLength);
+const extendKey = (key, sequence, isLegacy) => {
+    const view = createView(key);
     const chunks = new Uint32Array(BLOCKSIZE);
     for (let i = 0; i < BLOCKSIZE; i++)
-        chunks[i] = view.getUint32(i * 4);
+        chunks[i] = view.getUint32(i * 4, isLegacy);
     return new Uint32Array(sequence.map(i => chunks[i]));
 };
-/** Magma (GOST R 34.12-2015 and GOST 28147-89) cipher */
+/**
+ * **Magma cipher**
+ *
+ * Described by GOST 28147-89 ([RFC 5830](https://datatracker.ietf.org/doc/html/rfc5830.html)) in 1989 (Uses LE byte order, no S-Box'es defined)
+ *
+ * Revised by GOST R 34.12-2015 ([RFC 8891](https://datatracker.ietf.org/doc/html/rfc8891.html)) in 2015 (Uses BE byte order and fixed {@link ID_TC26_GOST_28147_PARAM_Z S-Box})
+ */
 export class Magma {
+    key;
     sbox;
     isLegacy;
-    keySize = KEYSIZE;
+    keySize = 32;
     blockSize = BLOCKSIZE;
-    key;
     /**
      * Magma (GOST R 34.12-2015 and GOST 28147-89) cipher
      * @param key Encryption key
@@ -34,46 +40,34 @@ export class Magma {
      * @param isLegacy Use GOST 28147-89 instead of GOST R 34.12-2015?
      */
     constructor(key, sbox = ID_TC26_GOST_28147_PARAM_Z, isLegacy = false) {
+        this.key = key;
         this.sbox = sbox;
         this.isLegacy = isLegacy;
         if (key.length !== this.keySize)
             throw new Error("Invalid key length");
-        this.key = isLegacy ? Magma.reverseKey(key) : key;
     }
     proceedBlock(block, sequence) {
         if (block.length !== this.blockSize)
             throw new Error("Invalid block size");
-        const roundKeys = extendKey(this.key, sequence);
-        let a0 = Number(bytesToNumberBE(block.subarray(0, 4)));
-        let a1 = Number(bytesToNumberBE(block.subarray(4, 8)));
+        const roundKeys = extendKey(this.key, sequence, this.isLegacy);
+        const F = block.subarray(0, 4), S = block.subarray(4, 8);
+        const bytesToNumber = this.isLegacy ? bytesToNumberLE : bytesToNumberBE;
+        let a0 = Number(bytesToNumber(this.isLegacy ? S : F)), a1 = Number(bytesToNumber(this.isLegacy ? F : S));
         for (let i = 0; i < roundKeys.length; i++) {
             const temp = a1;
-            a1 = (a0 ^ G(a1, roundKeys[i], this.sbox)) >>> 0;
+            a1 = (a0 ^ G((a1 + roundKeys[i]) >>> 0, this.sbox)) >>> 0;
             a0 = temp;
         }
-        return concatBytes(numberToBytesBE(a1, 4), numberToBytesBE(a0, 4));
+        if (this.isLegacy)
+            return concatBytes(numberToBytesLE(a0, 4), numberToBytesLE(a1, 4));
+        else
+            return concatBytes(numberToBytesBE(a1, 4), numberToBytesBE(a0, 4));
     }
     encrypt(plaintext) {
-        if (this.isLegacy)
-            return Magma.reverseChunks(this.proceedBlock(Magma.reverseChunks(plaintext), magmaKeySequences.ENCRYPT));
         return this.proceedBlock(plaintext, magmaKeySequences.ENCRYPT);
     }
     decrypt(ciphertext) {
-        if (this.isLegacy)
-            return Magma.reverseChunks(this.proceedBlock(Magma.reverseChunks(ciphertext), magmaKeySequences.DECRYPT));
         return this.proceedBlock(ciphertext, magmaKeySequences.DECRYPT);
     }
-    static reverseKey(key) {
-        const result = new Uint8Array(KEYSIZE);
-        for (let i = 0; i < BLOCKSIZE; i++)
-            result.set(copyBytes(key.subarray(i * 4, i * 4 + 4)).reverse(), i * 4);
-        return result;
-    }
-    static reverseChunks(data) {
-        const chunks = [];
-        for (let i = 0; i < data.length; i += BLOCKSIZE)
-            chunks.push(copyBytes(data.subarray(i, i + BLOCKSIZE)).reverse());
-        return concatBytes(...chunks);
-    }
 }
 export { magmaSboxes, magmaKeySequences } from "./const.js";

package/modes/ctr.js

@@ -1,6 +1,6 @@
 import { concatBytes } from "@noble/hashes/utils.js";
 import { getPadLength, xorBytes } from "../utils.js";
-import { bytesToNumberBE, numberToBytesBE } from "@noble/curves/utils.js";
+import { bytesToNumberLE, numberToBytesBE, numberToBytesLE } from "@noble/curves/utils.js";
 import { acpkm } from "./_keytransform.js";
 /**
  * **EN:** Counter (CTR) mode
@@ -42,19 +42,17 @@ export const ctr = (cipher, iv, isAcpkm, _isAcpkmOmac) => {
 export const cnt = (cipher, iv) => {
     if (iv.length !== cipher.blockSize)
         throw new Error("Invalid IV size");
-    const C1 = 0x01010104n;
-    const C2 = 0x01010101n;
+    const C1 = 0x01010104n, C2 = 0x01010101n;
     const encrypter = cipher.encrypt.bind(cipher);
     return {
         crypt: (msg) => {
-            const encryptedIv = encrypter(iv).reverse();
-            let n2 = (bytesToNumberBE(encryptedIv.subarray(0, 4)));
-            let n1 = (bytesToNumberBE(encryptedIv.subarray(4)));
+            const encryptedIv = encrypter(iv);
+            let n1 = bytesToNumberLE(encryptedIv.subarray(0, 4)), n2 = bytesToNumberLE(encryptedIv.subarray(4));
             const gamma = [];
             for (let i = 0; i < (msg.length + getPadLength(msg.length, cipher.blockSize)); i += cipher.blockSize) {
                 n1 = (n1 + C2) % 0x100000000n;
                 n2 = (n2 + C1) % 0xffffffffn;
-                gamma.push(encrypter(concatBytes(numberToBytesBE(n2, 4), numberToBytesBE(n1, 4)).reverse()));
+                gamma.push(encrypter(concatBytes(numberToBytesLE(n1, 4), numberToBytesLE(n2, 4))));
             }
             return xorBytes(concatBytes(...gamma), msg);
         }

package/modes/mac.js

@@ -1,6 +1,6 @@
-import {} from "@noble/hashes/utils.js";
+import { concatBytes } from "@noble/hashes/utils.js";
 import { pad1, pad3, xorBytes } from "../utils.js";
-import { bytesToNumberBE, numberToVarBytesBE } from "@noble/curves/utils.js";
+import { bytesToNumberBE, bytesToNumberLE, numberToBytesLE, numberToVarBytesBE } from "@noble/curves/utils.js";
 import { magmaKeySequences, Magma } from "../magma/index.js";
 import { acpkm_master } from "./_keytransform.js";
 const Rb64 = 0b11011;
@@ -61,19 +61,16 @@ export const mac = (cipher) => {
  */
 export const mac_legacy = (cipher, iv = new Uint8Array(cipher.blockSize)) => {
     const split = (data) => [
-        (data[0] | data[1] << 8 | data[2] << 16 | data[3] << 24) >>> 0,
-        (data[4] | data[5] << 8 | data[6] << 16 | data[7] << 24) >>> 0
+        Number(bytesToNumberLE(data.subarray(0, 4))),
+        Number(bytesToNumberLE(data.subarray(4, 8)))
     ];
-    const join = (ns) => new Uint8Array([
-        (ns[1] >> 0) & 0xFF, (ns[1] >> 8) & 0xFF, (ns[1] >> 16) & 0xFF, (ns[1] >> 24) & 0xFF,
-        (ns[0] >> 0) & 0xFF, (ns[0] >> 8) & 0xFF, (ns[0] >> 16) & 0xFF, (ns[0] >> 24) & 0xFF
-    ]);
+    const join = (ns) => concatBytes(numberToBytesLE(ns[1], 4), numberToBytesLE(ns[0], 4));
     return {
         compute: (msg) => {
             const paddedData = pad1(msg, cipher.blockSize);
             let prev = split(iv).reverse();
             for (let i = 0; i < paddedData.length; i += cipher.blockSize)
-                prev = split(Magma.reverseChunks(cipher.proceedBlock(Magma.reverseChunks(xorBytes(paddedData.subarray(i, i + cipher.blockSize), join(prev))), magmaKeySequences.MAC)));
+                prev = split(cipher.proceedBlock(xorBytes(paddedData.subarray(i, i + cipher.blockSize), join(prev)), magmaKeySequences.MAC));
             return join(prev);
         }
     };

package/package.json

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

package/streebog/index.d.ts

@@ -15,7 +15,11 @@ declare abstract class Streebog<T extends Streebog<T>> implements Hash<Streebog<
     digest(): TRet<Uint8Array>;
     digestInto(buf: TArg<Uint8Array>): void;
 }
-/** Streebog-256 (GOST R 34.11-2012) hash function */
+/**
+ * **Streebog-256 hash function**
+ *
+ * Described by GOST R 34.11-2012 ([RFC 6986](https://datatracker.ietf.org/doc/html/rfc6986.html))
+ */
 export declare class Streebog256 extends Streebog<Streebog256> {
     /** Streebog-256 (GOST R 34.11-2012) hash function */
     constructor();
@@ -24,7 +28,11 @@ export declare class Streebog256 extends Streebog<Streebog256> {
     clone(): Streebog256;
     _cloneInto(to?: Streebog256): Streebog256;
 }
-/** Streebog-512 (GOST R 34.11-2012) hash function */
+/**
+ * **Streebog-512 hash function**
+ *
+ * Described by GOST R 34.11-2012 ([RFC 6986](https://datatracker.ietf.org/doc/html/rfc6986.html))
+ */
 export declare class Streebog512 extends Streebog<Streebog512> {
     /** Streebog-512 (GOST R 34.11-2012) hash function */
     constructor();
@@ -33,8 +41,11 @@ export declare class Streebog512 extends Streebog<Streebog512> {
     clone(): Streebog512;
     _cloneInto(to?: Streebog512): Streebog512;
 }
-/** Streebog-256 (GOST R 34.11-2012) hash function */
-export declare const streebog256: {
+/**
+ * **Streebog-256 hash function**
+ *
+ * Described by GOST R 34.11-2012 ([RFC 6986](https://datatracker.ietf.org/doc/html/rfc6986.html))
+ */ export declare const streebog256: {
     outputLen: number;
     blockLen: number;
     canXOF: boolean;
@@ -48,8 +59,11 @@ export declare const streebog256: {
     oid?: TRet<Uint8Array> | undefined;
     create: () => Streebog256;
 };
-/** Streebog-512 (GOST R 34.11-2012) hash function */
-export declare const streebog512: {
+/**
+ * **Streebog-512 hash function**
+ *
+ * Described by GOST R 34.11-2012 ([RFC 6986](https://datatracker.ietf.org/doc/html/rfc6986.html))
+ */ export declare const streebog512: {
     outputLen: number;
     blockLen: number;
     canXOF: boolean;

package/streebog/index.js

@@ -8,8 +8,7 @@ const _0020 = new Uint8Array([0, 0, 2, 0]);
 const _0 = new Uint8Array(64);
 const add512 = (a, b) => {
     const c = new Uint8Array(64);
-    const tmpA = new Uint8Array(64);
-    const tmpB = new Uint8Array(64);
+    const tmpA = new Uint8Array(64), tmpB = new Uint8Array(64);
     for (let i = 0; i < a.length; i++)
         tmpA[63 - i] = a[a.length - i - 1];
     for (let i = 0; i < b.length; i++)
@@ -150,7 +149,11 @@ class Streebog {
         this.destroy();
     }
 }
-/** Streebog-256 (GOST R 34.11-2012) hash function */
+/**
+ * **Streebog-256 hash function**
+ *
+ * Described by GOST R 34.11-2012 ([RFC 6986](https://datatracker.ietf.org/doc/html/rfc6986.html))
+ */
 export class Streebog256 extends Streebog {
     /** Streebog-256 (GOST R 34.11-2012) hash function */
     constructor() { super(false); }
@@ -163,7 +166,11 @@ export class Streebog256 extends Streebog {
         return to;
     }
 }
-/** Streebog-512 (GOST R 34.11-2012) hash function */
+/**
+ * **Streebog-512 hash function**
+ *
+ * Described by GOST R 34.11-2012 ([RFC 6986](https://datatracker.ietf.org/doc/html/rfc6986.html))
+ */
 export class Streebog512 extends Streebog {
     /** Streebog-512 (GOST R 34.11-2012) hash function */
     constructor() { super(true); }
@@ -176,7 +183,13 @@ export class Streebog512 extends Streebog {
         return to;
     }
 }
-/** Streebog-256 (GOST R 34.11-2012) hash function */
-export const streebog256 = createHasher(Streebog256.create);
-/** Streebog-512 (GOST R 34.11-2012) hash function */
-export const streebog512 = createHasher(Streebog512.create);
+/**
+ * **Streebog-256 hash function**
+ *
+ * Described by GOST R 34.11-2012 ([RFC 6986](https://datatracker.ietf.org/doc/html/rfc6986.html))
+ */ export const streebog256 = createHasher(Streebog256.create);
+/**
+ * **Streebog-512 hash function**
+ *
+ * Described by GOST R 34.11-2012 ([RFC 6986](https://datatracker.ietf.org/doc/html/rfc6986.html))
+ */ export const streebog512 = createHasher(Streebog512.create);

package/gf/gf128.d.ts

@@ -1,2 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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/gf64.d.ts

@@ -1,2 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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);
-};