@li0ard/gost 0.0.1 → 0.1.3

package/magma/const.d.ts

@@ -0,0 +1,62 @@
+/** S-Box from RFC 7836 */
+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>[];
+/** S-Box from RFC 4357 aka `CryptoPro Paramset B` */
+export declare const ID_GOST_28147_89_CRYPTO_PRO_B_PARAM_SET: Uint8Array<ArrayBuffer>[];
+/** S-Box from RFC 4357 aka `CryptoPro Paramset C` */
+export declare const ID_GOST_28147_89_CRYPTO_PRO_C_PARAM_SET: Uint8Array<ArrayBuffer>[];
+/** S-Box from RFC 4357 aka `CryptoPro Paramset D` */
+export declare const ID_GOST_28147_89_CRYPTO_PRO_D_PARAM_SET: Uint8Array<ArrayBuffer>[];
+/** S-Box from Instruction no. 114 by State Special Communications Service of Ukraine */
+export declare const DSSZZI_UA_DKE_1: Uint8Array<ArrayBuffer>[];
+/** S-Box from Instruction no. 114 by State Special Communications Service of Ukraine */
+export declare const DSSZZI_UA_DKE_2: Uint8Array<ArrayBuffer>[];
+/** S-Box from Instruction no. 114 by State Special Communications Service of Ukraine */
+export declare const DSSZZI_UA_DKE_3: Uint8Array<ArrayBuffer>[];
+/** S-Box from Instruction no. 114 by State Special Communications Service of Ukraine */
+export declare const DSSZZI_UA_DKE_4: Uint8Array<ArrayBuffer>[];
+/** S-Box from Instruction no. 114 by State Special Communications Service of Ukraine */
+export declare const DSSZZI_UA_DKE_5: Uint8Array<ArrayBuffer>[];
+/** S-Box from Instruction no. 114 by State Special Communications Service of Ukraine */
+export declare const DSSZZI_UA_DKE_6: Uint8Array<ArrayBuffer>[];
+/** S-Box from Instruction no. 114 by State Special Communications Service of Ukraine */
+export declare const DSSZZI_UA_DKE_7: Uint8Array<ArrayBuffer>[];
+/** S-Box from Instruction no. 114 by State Special Communications Service of Ukraine */
+export declare const DSSZZI_UA_DKE_8: Uint8Array<ArrayBuffer>[];
+/** S-Box from Instruction no. 114 by State Special Communications Service of Ukraine */
+export declare const DSSZZI_UA_DKE_9: Uint8Array<ArrayBuffer>[];
+/** S-Box from Instruction no. 114 by State Special Communications Service of Ukraine */
+export declare const DSSZZI_UA_DKE_10: Uint8Array<ArrayBuffer>[];
+export declare const ID_GOST_28147_89_TEST_PARAM_SET: Uint8Array<ArrayBuffer>[];
+export declare const ID_GOSTR_3411_94_TEST_PARAM_SET: Uint8Array<ArrayBuffer>[];
+export declare const ID_GOSTR_3411_94_CRYPTOPRO_PARAM_SET: Uint8Array<ArrayBuffer>[];
+export declare const EAC_PARAM_SET: Uint8Array<ArrayBuffer>[];
+/** Implemented S-Boxes */
+export declare const magmaSboxes: {
+    ID_TC26_GOST_28147_PARAM_Z: Uint8Array<ArrayBuffer>[];
+    ID_GOST_28147_89_CRYPTO_PRO_A_PARAM_SET: Uint8Array<ArrayBuffer>[];
+    ID_GOST_28147_89_CRYPTO_PRO_B_PARAM_SET: Uint8Array<ArrayBuffer>[];
+    ID_GOST_28147_89_CRYPTO_PRO_C_PARAM_SET: Uint8Array<ArrayBuffer>[];
+    ID_GOST_28147_89_CRYPTO_PRO_D_PARAM_SET: Uint8Array<ArrayBuffer>[];
+    ID_GOST_28147_89_TEST_PARAM_SET: Uint8Array<ArrayBuffer>[];
+    ID_GOSTR_3411_94_TEST_PARAM_SET: Uint8Array<ArrayBuffer>[];
+    ID_GOSTR_3411_94_CRYPTOPRO_PARAM_SET: Uint8Array<ArrayBuffer>[];
+    EAC_PARAM_SET: Uint8Array<ArrayBuffer>[];
+    DSSZZI_UA_DKE_1: Uint8Array<ArrayBuffer>[];
+    DSSZZI_UA_DKE_2: Uint8Array<ArrayBuffer>[];
+    DSSZZI_UA_DKE_3: Uint8Array<ArrayBuffer>[];
+    DSSZZI_UA_DKE_4: Uint8Array<ArrayBuffer>[];
+    DSSZZI_UA_DKE_5: Uint8Array<ArrayBuffer>[];
+    DSSZZI_UA_DKE_6: Uint8Array<ArrayBuffer>[];
+    DSSZZI_UA_DKE_7: Uint8Array<ArrayBuffer>[];
+    DSSZZI_UA_DKE_8: Uint8Array<ArrayBuffer>[];
+    DSSZZI_UA_DKE_9: Uint8Array<ArrayBuffer>[];
+    DSSZZI_UA_DKE_10: Uint8Array<ArrayBuffer>[];
+};
+/** Sequences of `K_i` S-Box applying */
+export declare const magmaKeySequences: {
+    ENCRYPT: number[];
+    DECRYPT: number[];
+    MAC: number[];
+};

package/magma/const.js

@@ -0,0 +1,244 @@
+/** S-Box from RFC 7836 */
+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]),
+    new Uint8Array([0x06, 0x08, 0x02, 0x03, 0x09, 0x0a, 0x05, 0x0c, 0x01, 0x0e, 0x04, 0x07, 0x0b, 0x0d, 0x00, 0x0f]),
+    new Uint8Array([0x0b, 0x03, 0x05, 0x08, 0x02, 0x0f, 0x0a, 0x0d, 0x0e, 0x01, 0x07, 0x04, 0x0c, 0x09, 0x06, 0x00]),
+    new Uint8Array([0x0c, 0x08, 0x02, 0x01, 0x0d, 0x04, 0x0f, 0x06, 0x07, 0x00, 0x0a, 0x05, 0x03, 0x0e, 0x09, 0x0b]),
+    new Uint8Array([0x07, 0x0f, 0x05, 0x0a, 0x08, 0x01, 0x06, 0x0d, 0x00, 0x09, 0x03, 0x0e, 0x0b, 0x04, 0x02, 0x0c]),
+    new Uint8Array([0x05, 0x0d, 0x0f, 0x06, 0x09, 0x02, 0x0c, 0x0a, 0x0b, 0x07, 0x08, 0x01, 0x04, 0x03, 0x0e, 0x00]),
+    new Uint8Array([0x08, 0x0e, 0x02, 0x05, 0x06, 0x09, 0x01, 0x0c, 0x0f, 0x04, 0x0b, 0x00, 0x0d, 0x0a, 0x03, 0x07]),
+    new Uint8Array([0x01, 0x07, 0x0e, 0x0d, 0x00, 0x05, 0x08, 0x03, 0x04, 0x0f, 0x0a, 0x06, 0x09, 0x0c, 0x0b, 0x02]),
+];
+/** S-Box from RFC 4357 aka `CryptoPro Paramset A` */
+export const ID_GOST_28147_89_CRYPTO_PRO_A_PARAM_SET = [
+    new Uint8Array([0x09, 0x06, 0x03, 0x02, 0x08, 0x0b, 0x01, 0x07, 0x0a, 0x04, 0x0e, 0x0f, 0x0c, 0x00, 0x0d, 0x05]),
+    new Uint8Array([0x03, 0x07, 0x0e, 0x09, 0x08, 0x0a, 0x0f, 0x00, 0x05, 0x02, 0x06, 0x0c, 0x0b, 0x04, 0x0d, 0x01]),
+    new Uint8Array([0x0e, 0x04, 0x06, 0x02, 0x0b, 0x03, 0x0d, 0x08, 0x0c, 0x0f, 0x05, 0x0a, 0x00, 0x07, 0x01, 0x09]),
+    new Uint8Array([0x0e, 0x07, 0x0a, 0x0c, 0x0d, 0x01, 0x03, 0x09, 0x00, 0x02, 0x0b, 0x04, 0x0f, 0x08, 0x05, 0x06]),
+    new Uint8Array([0x0b, 0x05, 0x01, 0x09, 0x08, 0x0d, 0x0f, 0x00, 0x0e, 0x04, 0x02, 0x03, 0x0c, 0x07, 0x0a, 0x06]),
+    new Uint8Array([0x03, 0x0a, 0x0d, 0x0c, 0x01, 0x02, 0x00, 0x0b, 0x07, 0x05, 0x09, 0x04, 0x08, 0x0f, 0x0e, 0x06]),
+    new Uint8Array([0x01, 0x0d, 0x02, 0x09, 0x07, 0x0a, 0x06, 0x00, 0x08, 0x0c, 0x04, 0x05, 0x0f, 0x03, 0x0b, 0x0e]),
+    new Uint8Array([0x0b, 0x0a, 0x0f, 0x05, 0x00, 0x0c, 0x0e, 0x08, 0x06, 0x02, 0x03, 0x09, 0x01, 0x07, 0x0d, 0x04]),
+];
+/** S-Box from RFC 4357 aka `CryptoPro Paramset B` */
+export const ID_GOST_28147_89_CRYPTO_PRO_B_PARAM_SET = [
+    new Uint8Array([0x08, 0x04, 0x0b, 0x01, 0x03, 0x05, 0x00, 0x09, 0x02, 0x0e, 0x0a, 0x0c, 0x0d, 0x06, 0x07, 0x0f]),
+    new Uint8Array([0x00, 0x01, 0x02, 0x0a, 0x04, 0x0d, 0x05, 0x0c, 0x09, 0x07, 0x03, 0x0f, 0x0b, 0x08, 0x06, 0x0e]),
+    new Uint8Array([0x0e, 0x0c, 0x00, 0x0a, 0x09, 0x02, 0x0d, 0x0b, 0x07, 0x05, 0x08, 0x0f, 0x03, 0x06, 0x01, 0x04]),
+    new Uint8Array([0x07, 0x05, 0x00, 0x0d, 0x0b, 0x06, 0x01, 0x02, 0x03, 0x0a, 0x0c, 0x0f, 0x04, 0x0e, 0x09, 0x08]),
+    new Uint8Array([0x02, 0x07, 0x0c, 0x0f, 0x09, 0x05, 0x0a, 0x0b, 0x01, 0x04, 0x00, 0x0d, 0x06, 0x08, 0x0e, 0x03]),
+    new Uint8Array([0x08, 0x03, 0x02, 0x06, 0x04, 0x0d, 0x0e, 0x0b, 0x0c, 0x01, 0x07, 0x0f, 0x0a, 0x00, 0x09, 0x05]),
+    new Uint8Array([0x05, 0x02, 0x0a, 0x0b, 0x09, 0x01, 0x0c, 0x03, 0x07, 0x04, 0x0d, 0x00, 0x06, 0x0f, 0x08, 0x0e]),
+    new Uint8Array([0x00, 0x04, 0x0b, 0x0e, 0x08, 0x03, 0x07, 0x01, 0x0a, 0x02, 0x09, 0x06, 0x0f, 0x0d, 0x05, 0x0c]),
+];
+/** S-Box from RFC 4357 aka `CryptoPro Paramset C` */
+export const ID_GOST_28147_89_CRYPTO_PRO_C_PARAM_SET = [
+    new Uint8Array([0x01, 0x0b, 0x0c, 0x02, 0x09, 0x0d, 0x00, 0x0f, 0x04, 0x05, 0x08, 0x0e, 0x0a, 0x07, 0x06, 0x03]),
+    new Uint8Array([0x00, 0x01, 0x07, 0x0d, 0x0b, 0x04, 0x05, 0x02, 0x08, 0x0e, 0x0f, 0x0c, 0x09, 0x0a, 0x06, 0x03]),
+    new Uint8Array([0x08, 0x02, 0x05, 0x00, 0x04, 0x09, 0x0f, 0x0a, 0x03, 0x07, 0x0c, 0x0d, 0x06, 0x0e, 0x01, 0x0b]),
+    new Uint8Array([0x03, 0x06, 0x00, 0x01, 0x05, 0x0d, 0x0a, 0x08, 0x0b, 0x02, 0x09, 0x07, 0x0e, 0x0f, 0x0c, 0x04]),
+    new Uint8Array([0x08, 0x0d, 0x0b, 0x00, 0x04, 0x05, 0x01, 0x02, 0x09, 0x03, 0x0c, 0x0e, 0x06, 0x0f, 0x0a, 0x07]),
+    new Uint8Array([0x0c, 0x09, 0x0b, 0x01, 0x08, 0x0e, 0x02, 0x04, 0x07, 0x03, 0x06, 0x05, 0x0a, 0x00, 0x0f, 0x0d]),
+    new Uint8Array([0x0a, 0x09, 0x06, 0x08, 0x0d, 0x0e, 0x02, 0x00, 0x0f, 0x03, 0x05, 0x0b, 0x04, 0x01, 0x0c, 0x07]),
+    new Uint8Array([0x07, 0x04, 0x00, 0x05, 0x0a, 0x02, 0x0f, 0x0e, 0x0c, 0x06, 0x01, 0x0b, 0x0d, 0x09, 0x03, 0x08]),
+];
+/** S-Box from RFC 4357 aka `CryptoPro Paramset D` */
+export const ID_GOST_28147_89_CRYPTO_PRO_D_PARAM_SET = [
+    new Uint8Array([0x0f, 0x0c, 0x02, 0x0a, 0x06, 0x04, 0x05, 0x00, 0x07, 0x09, 0x0e, 0x0d, 0x01, 0x0b, 0x08, 0x03]),
+    new Uint8Array([0x0b, 0x06, 0x03, 0x04, 0x0c, 0x0f, 0x0e, 0x02, 0x07, 0x0d, 0x08, 0x00, 0x05, 0x0a, 0x09, 0x01]),
+    new Uint8Array([0x01, 0x0c, 0x0b, 0x00, 0x0f, 0x0e, 0x06, 0x05, 0x0a, 0x0d, 0x04, 0x08, 0x09, 0x03, 0x07, 0x02]),
+    new Uint8Array([0x01, 0x05, 0x0e, 0x0c, 0x0a, 0x07, 0x00, 0x0d, 0x06, 0x02, 0x0b, 0x04, 0x09, 0x03, 0x0f, 0x08]),
+    new Uint8Array([0x00, 0x0c, 0x08, 0x09, 0x0d, 0x02, 0x0a, 0x0b, 0x07, 0x03, 0x06, 0x05, 0x04, 0x0e, 0x0f, 0x01]),
+    new Uint8Array([0x08, 0x00, 0x0f, 0x03, 0x02, 0x05, 0x0e, 0x0b, 0x01, 0x0a, 0x04, 0x07, 0x0c, 0x09, 0x0d, 0x06]),
+    new Uint8Array([0x03, 0x00, 0x06, 0x0f, 0x01, 0x0e, 0x09, 0x02, 0x0d, 0x08, 0x0c, 0x04, 0x0b, 0x0a, 0x05, 0x07]),
+    new Uint8Array([0x01, 0x0a, 0x06, 0x08, 0x0f, 0x0b, 0x00, 0x04, 0x0c, 0x03, 0x05, 0x09, 0x07, 0x0d, 0x02, 0x0e]),
+];
+/** S-Box from Instruction no. 114 by State Special Communications Service of Ukraine */
+export const DSSZZI_UA_DKE_1 = [
+    new Uint8Array([0x0a, 0x09, 0x0d, 0x06, 0x0e, 0x0b, 0x04, 0x05, 0x0f, 0x01, 0x03, 0x0c, 0x07, 0x00, 0x08, 0x02]),
+    new Uint8Array([0x08, 0x00, 0x0c, 0x04, 0x09, 0x06, 0x07, 0x0b, 0x02, 0x03, 0x01, 0x0f, 0x05, 0x0e, 0x0a, 0x0d]),
+    new Uint8Array([0x0f, 0x06, 0x05, 0x08, 0x0e, 0x0b, 0x0a, 0x04, 0x0c, 0x00, 0x03, 0x07, 0x02, 0x09, 0x01, 0x0d]),
+    new Uint8Array([0x03, 0x08, 0x0d, 0x09, 0x06, 0x0b, 0x0f, 0x00, 0x02, 0x05, 0x0c, 0x0a, 0x04, 0x0e, 0x01, 0x07]),
+    new Uint8Array([0x0f, 0x08, 0x0e, 0x09, 0x07, 0x02, 0x00, 0x0d, 0x0c, 0x06, 0x01, 0x05, 0x0b, 0x04, 0x03, 0x0a]),
+    new Uint8Array([0x02, 0x08, 0x09, 0x07, 0x05, 0x0f, 0x00, 0x0b, 0x0c, 0x01, 0x0d, 0x0e, 0x0a, 0x03, 0x06, 0x04]),
+    new Uint8Array([0x03, 0x08, 0x0b, 0x05, 0x06, 0x04, 0x0e, 0x0a, 0x02, 0x0c, 0x01, 0x07, 0x09, 0x0f, 0x0d, 0x00]),
+    new Uint8Array([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]),
+    new Uint8Array([0x0a, 0x0d, 0x0c, 0x07, 0x06, 0x0e, 0x08, 0x01, 0x0f, 0x03, 0x0b, 0x04, 0x00, 0x09, 0x05, 0x02]),
+    new Uint8Array([0x04, 0x0b, 0x01, 0x0f, 0x09, 0x02, 0x0e, 0x0c, 0x06, 0x0a, 0x08, 0x07, 0x03, 0x05, 0x00, 0x0d]),
+    new Uint8Array([0x04, 0x05, 0x01, 0x0c, 0x07, 0x0e, 0x09, 0x02, 0x0a, 0x0f, 0x0b, 0x0d, 0x00, 0x08, 0x06, 0x03]),
+    new Uint8Array([0x0c, 0x0b, 0x03, 0x09, 0x0f, 0x00, 0x04, 0x05, 0x07, 0x02, 0x0e, 0x0d, 0x01, 0x0a, 0x08, 0x06]),
+    new Uint8Array([0x08, 0x07, 0x03, 0x0a, 0x09, 0x06, 0x0e, 0x05, 0x0d, 0x00, 0x04, 0x0c, 0x01, 0x02, 0x0f, 0x0b]),
+    new Uint8Array([0x0f, 0x00, 0x0e, 0x06, 0x08, 0x0d, 0x05, 0x09, 0x0a, 0x03, 0x01, 0x0c, 0x04, 0x0b, 0x07, 0x02]),
+    new Uint8Array([0x04, 0x03, 0x0e, 0x0d, 0x05, 0x00, 0x02, 0x0b, 0x01, 0x0a, 0x07, 0x06, 0x09, 0x0f, 0x08, 0x0c]),
+];
+/** S-Box from Instruction no. 114 by State Special Communications Service of Ukraine */
+export const DSSZZI_UA_DKE_3 = [
+    new Uint8Array([0x0d, 0x09, 0x01, 0x0e, 0x07, 0x02, 0x0c, 0x05, 0x04, 0x0b, 0x06, 0x0f, 0x03, 0x08, 0x0a, 0x00]),
+    new Uint8Array([0x07, 0x08, 0x06, 0x0b, 0x00, 0x03, 0x04, 0x0d, 0x09, 0x05, 0x0f, 0x0e, 0x0a, 0x0c, 0x02, 0x01]),
+    new Uint8Array([0x0a, 0x05, 0x03, 0x0c, 0x09, 0x08, 0x0d, 0x06, 0x04, 0x0f, 0x0e, 0x00, 0x02, 0x0b, 0x01, 0x07]),
+    new Uint8Array([0x0b, 0x0a, 0x0c, 0x01, 0x05, 0x06, 0x09, 0x0e, 0x02, 0x0d, 0x0f, 0x07, 0x00, 0x04, 0x03, 0x08]),
+    new Uint8Array([0x05, 0x0b, 0x03, 0x00, 0x0f, 0x09, 0x0e, 0x04, 0x01, 0x0c, 0x08, 0x06, 0x02, 0x0a, 0x07, 0x0d]),
+    new Uint8Array([0x04, 0x03, 0x0b, 0x0d, 0x01, 0x0f, 0x08, 0x02, 0x07, 0x0e, 0x0c, 0x09, 0x0a, 0x00, 0x06, 0x05]),
+    new Uint8Array([0x03, 0x07, 0x08, 0x0b, 0x01, 0x0e, 0x05, 0x00, 0x0d, 0x04, 0x0c, 0x0a, 0x02, 0x09, 0x0f, 0x06]),
+    new Uint8Array([0x06, 0x0d, 0x0c, 0x0a, 0x0b, 0x07, 0x09, 0x03, 0x0f, 0x0e, 0x01, 0x02, 0x00, 0x08, 0x04, 0x05]),
+];
+/** S-Box from Instruction no. 114 by State Special Communications Service of Ukraine */
+export const DSSZZI_UA_DKE_4 = [
+    new Uint8Array([0x09, 0x0c, 0x03, 0x0d, 0x07, 0x06, 0x0e, 0x01, 0x0a, 0x02, 0x00, 0x04, 0x08, 0x0f, 0x05, 0x0b]),
+    new Uint8Array([0x0a, 0x05, 0x0b, 0x0e, 0x07, 0x06, 0x00, 0x0c, 0x02, 0x08, 0x0f, 0x04, 0x0d, 0x03, 0x09, 0x01]),
+    new Uint8Array([0x04, 0x0c, 0x03, 0x00, 0x0d, 0x02, 0x0e, 0x0b, 0x07, 0x0f, 0x05, 0x09, 0x01, 0x08, 0x0a, 0x06]),
+    new Uint8Array([0x03, 0x09, 0x04, 0x05, 0x0e, 0x07, 0x08, 0x06, 0x0d, 0x00, 0x02, 0x0f, 0x0b, 0x0c, 0x0a, 0x01]),
+    new Uint8Array([0x02, 0x09, 0x0c, 0x0f, 0x0d, 0x0b, 0x04, 0x01, 0x07, 0x05, 0x03, 0x0e, 0x06, 0x08, 0x0a, 0x00]),
+    new Uint8Array([0x0e, 0x05, 0x0d, 0x0b, 0x01, 0x09, 0x04, 0x02, 0x0f, 0x08, 0x07, 0x00, 0x03, 0x0c, 0x0a, 0x06]),
+    new Uint8Array([0x0e, 0x06, 0x05, 0x0a, 0x09, 0x0d, 0x04, 0x08, 0x0b, 0x0c, 0x00, 0x03, 0x07, 0x01, 0x0f, 0x02]),
+    new Uint8Array([0x01, 0x09, 0x0c, 0x0b, 0x07, 0x06, 0x08, 0x03, 0x02, 0x0f, 0x0e, 0x00, 0x05, 0x0a, 0x04, 0x0d]),
+];
+/** S-Box from Instruction no. 114 by State Special Communications Service of Ukraine */
+export const DSSZZI_UA_DKE_5 = [
+    new Uint8Array([0x03, 0x04, 0x0d, 0x08, 0x0c, 0x07, 0x0a, 0x02, 0x00, 0x0e, 0x09, 0x0f, 0x0b, 0x01, 0x05, 0x06]),
+    new Uint8Array([0x0c, 0x07, 0x06, 0x09, 0x03, 0x08, 0x0b, 0x05, 0x0f, 0x0a, 0x00, 0x0d, 0x04, 0x02, 0x01, 0x0e]),
+    new Uint8Array([0x0e, 0x04, 0x08, 0x07, 0x0b, 0x03, 0x0a, 0x0c, 0x01, 0x02, 0x06, 0x09, 0x0d, 0x0f, 0x00, 0x05]),
+    new Uint8Array([0x03, 0x09, 0x06, 0x0d, 0x08, 0x0f, 0x0a, 0x02, 0x07, 0x0e, 0x0c, 0x00, 0x0b, 0x04, 0x01, 0x05]),
+    new Uint8Array([0x05, 0x0c, 0x0a, 0x07, 0x02, 0x01, 0x0f, 0x0d, 0x0e, 0x03, 0x0b, 0x04, 0x00, 0x08, 0x09, 0x06]),
+    new Uint8Array([0x01, 0x08, 0x0b, 0x0e, 0x07, 0x04, 0x0a, 0x00, 0x0c, 0x03, 0x05, 0x0d, 0x09, 0x0f, 0x06, 0x02]),
+    new Uint8Array([0x09, 0x0b, 0x0a, 0x0d, 0x05, 0x0e, 0x02, 0x03, 0x00, 0x06, 0x04, 0x0c, 0x0f, 0x01, 0x07, 0x08]),
+    new Uint8Array([0x0e, 0x09, 0x01, 0x08, 0x05, 0x0f, 0x0b, 0x00, 0x06, 0x02, 0x0c, 0x07, 0x0a, 0x04, 0x0d, 0x03]),
+];
+/** S-Box from Instruction no. 114 by State Special Communications Service of Ukraine */
+export const DSSZZI_UA_DKE_6 = [
+    new Uint8Array([0x0f, 0x0c, 0x09, 0x06, 0x0e, 0x02, 0x01, 0x0b, 0x00, 0x0d, 0x04, 0x0a, 0x07, 0x08, 0x03, 0x05]),
+    new Uint8Array([0x0e, 0x0c, 0x05, 0x00, 0x07, 0x04, 0x0a, 0x03, 0x02, 0x06, 0x01, 0x0d, 0x09, 0x0b, 0x0f, 0x08]),
+    new Uint8Array([0x05, 0x06, 0x0d, 0x09, 0x0b, 0x0e, 0x0a, 0x03, 0x0f, 0x02, 0x08, 0x01, 0x04, 0x00, 0x07, 0x0c]),
+    new Uint8Array([0x01, 0x0f, 0x07, 0x04, 0x02, 0x0e, 0x0c, 0x03, 0x06, 0x0b, 0x09, 0x08, 0x00, 0x05, 0x0a, 0x0d]),
+    new Uint8Array([0x0f, 0x09, 0x0e, 0x06, 0x0d, 0x01, 0x05, 0x08, 0x04, 0x02, 0x03, 0x0c, 0x0a, 0x0b, 0x00, 0x07]),
+    new Uint8Array([0x0b, 0x00, 0x0d, 0x07, 0x0c, 0x0e, 0x01, 0x04, 0x02, 0x03, 0x06, 0x08, 0x0a, 0x05, 0x0f, 0x09]),
+    new Uint8Array([0x07, 0x0e, 0x0f, 0x08, 0x0d, 0x00, 0x0b, 0x03, 0x0a, 0x01, 0x04, 0x02, 0x09, 0x0c, 0x06, 0x05]),
+    new Uint8Array([0x01, 0x05, 0x0e, 0x0b, 0x02, 0x0c, 0x03, 0x08, 0x0a, 0x00, 0x09, 0x07, 0x0f, 0x06, 0x04, 0x0d]),
+];
+/** S-Box from Instruction no. 114 by State Special Communications Service of Ukraine */
+export const DSSZZI_UA_DKE_7 = [
+    new Uint8Array([0x0f, 0x0d, 0x0a, 0x05, 0x0c, 0x00, 0x01, 0x06, 0x09, 0x02, 0x0e, 0x07, 0x03, 0x0b, 0x04, 0x08]),
+    new Uint8Array([0x02, 0x05, 0x0a, 0x00, 0x06, 0x09, 0x01, 0x0f, 0x0d, 0x04, 0x07, 0x0e, 0x0b, 0x03, 0x08, 0x0c]),
+    new Uint8Array([0x03, 0x0e, 0x04, 0x0b, 0x05, 0x09, 0x01, 0x02, 0x0f, 0x06, 0x08, 0x0d, 0x07, 0x00, 0x0a, 0x0c]),
+    new Uint8Array([0x04, 0x0a, 0x0b, 0x09, 0x0f, 0x02, 0x0e, 0x05, 0x0d, 0x01, 0x03, 0x06, 0x00, 0x07, 0x0c, 0x08]),
+    new Uint8Array([0x0f, 0x06, 0x05, 0x08, 0x09, 0x07, 0x0c, 0x0b, 0x00, 0x0a, 0x03, 0x01, 0x02, 0x04, 0x0d, 0x0e]),
+    new Uint8Array([0x0c, 0x0b, 0x0f, 0x04, 0x05, 0x01, 0x0e, 0x09, 0x00, 0x08, 0x0d, 0x02, 0x0a, 0x07, 0x03, 0x06]),
+    new Uint8Array([0x0d, 0x02, 0x04, 0x08, 0x0b, 0x0c, 0x01, 0x03, 0x0a, 0x05, 0x09, 0x0e, 0x07, 0x0f, 0x00, 0x06]),
+    new Uint8Array([0x01, 0x05, 0x00, 0x0f, 0x06, 0x0a, 0x03, 0x0e, 0x07, 0x02, 0x0c, 0x0d, 0x0b, 0x08, 0x09, 0x04]),
+];
+/** S-Box from Instruction no. 114 by State Special Communications Service of Ukraine */
+export const DSSZZI_UA_DKE_8 = [
+    new Uint8Array([0x0e, 0x04, 0x0b, 0x02, 0x08, 0x07, 0x05, 0x0c, 0x09, 0x0d, 0x00, 0x03, 0x01, 0x0f, 0x06, 0x0a]),
+    new Uint8Array([0x03, 0x0e, 0x0c, 0x0a, 0x06, 0x02, 0x0d, 0x01, 0x09, 0x08, 0x07, 0x04, 0x00, 0x0f, 0x05, 0x0b]),
+    new Uint8Array([0x05, 0x02, 0x08, 0x07, 0x01, 0x0f, 0x0e, 0x06, 0x04, 0x0d, 0x0b, 0x00, 0x0a, 0x03, 0x0c, 0x09]),
+    new Uint8Array([0x0c, 0x0a, 0x07, 0x0d, 0x0e, 0x03, 0x00, 0x02, 0x09, 0x05, 0x01, 0x06, 0x0b, 0x04, 0x0f, 0x08]),
+    new Uint8Array([0x06, 0x03, 0x0f, 0x07, 0x00, 0x09, 0x0a, 0x08, 0x0b, 0x0c, 0x04, 0x01, 0x05, 0x02, 0x0d, 0x0e]),
+    new Uint8Array([0x06, 0x0d, 0x0f, 0x01, 0x05, 0x03, 0x08, 0x00, 0x0b, 0x0a, 0x0e, 0x04, 0x09, 0x0c, 0x02, 0x07]),
+    new Uint8Array([0x02, 0x0f, 0x0c, 0x05, 0x0b, 0x01, 0x03, 0x0e, 0x00, 0x06, 0x0d, 0x0a, 0x07, 0x09, 0x04, 0x08]),
+    new Uint8Array([0x03, 0x00, 0x05, 0x0c, 0x08, 0x0f, 0x0d, 0x0e, 0x0b, 0x06, 0x02, 0x09, 0x07, 0x01, 0x04, 0x0a]),
+];
+/** S-Box from Instruction no. 114 by State Special Communications Service of Ukraine */
+export const DSSZZI_UA_DKE_9 = [
+    new Uint8Array([0x09, 0x00, 0x0b, 0x0c, 0x02, 0x04, 0x03, 0x0f, 0x0d, 0x06, 0x0e, 0x01, 0x0a, 0x07, 0x05, 0x08]),
+    new Uint8Array([0x03, 0x05, 0x00, 0x0f, 0x08, 0x07, 0x0e, 0x0c, 0x0d, 0x0a, 0x01, 0x06, 0x0b, 0x02, 0x04, 0x09]),
+    new Uint8Array([0x08, 0x04, 0x05, 0x0a, 0x0e, 0x0b, 0x0d, 0x06, 0x0c, 0x0f, 0x07, 0x09, 0x03, 0x01, 0x02, 0x00]),
+    new Uint8Array([0x05, 0x04, 0x0f, 0x00, 0x0c, 0x0b, 0x0a, 0x09, 0x01, 0x0e, 0x08, 0x06, 0x03, 0x02, 0x0d, 0x07]),
+    new Uint8Array([0x07, 0x0c, 0x03, 0x00, 0x06, 0x08, 0x0e, 0x0b, 0x01, 0x0f, 0x0d, 0x0a, 0x09, 0x05, 0x02, 0x04]),
+    new Uint8Array([0x07, 0x04, 0x03, 0x0b, 0x06, 0x0a, 0x08, 0x01, 0x09, 0x0c, 0x0e, 0x0d, 0x00, 0x0f, 0x02, 0x05]),
+    new Uint8Array([0x07, 0x0e, 0x09, 0x0f, 0x01, 0x04, 0x08, 0x03, 0x0b, 0x0d, 0x00, 0x02, 0x06, 0x0a, 0x05, 0x0c]),
+    new Uint8Array([0x0e, 0x02, 0x08, 0x0f, 0x03, 0x00, 0x07, 0x0c, 0x0b, 0x0d, 0x01, 0x05, 0x06, 0x04, 0x09, 0x0a]),
+];
+/** S-Box from Instruction no. 114 by State Special Communications Service of Ukraine */
+export const DSSZZI_UA_DKE_10 = [
+    new Uint8Array([0x08, 0x04, 0x06, 0x09, 0x0b, 0x0c, 0x01, 0x02, 0x03, 0x07, 0x0e, 0x00, 0x0d, 0x0a, 0x0f, 0x05]),
+    new Uint8Array([0x07, 0x0d, 0x01, 0x08, 0x0a, 0x0e, 0x04, 0x0f, 0x09, 0x00, 0x06, 0x03, 0x02, 0x0c, 0x0b, 0x05]),
+    new Uint8Array([0x0c, 0x08, 0x0d, 0x01, 0x0a, 0x02, 0x09, 0x06, 0x03, 0x04, 0x0e, 0x07, 0x05, 0x0f, 0x00, 0x0b]),
+    new Uint8Array([0x02, 0x0b, 0x03, 0x04, 0x0c, 0x07, 0x09, 0x0d, 0x0f, 0x08, 0x05, 0x00, 0x01, 0x0e, 0x0a, 0x06]),
+    new Uint8Array([0x08, 0x03, 0x0d, 0x0a, 0x0e, 0x0f, 0x05, 0x01, 0x04, 0x07, 0x0b, 0x0c, 0x02, 0x00, 0x06, 0x09]),
+    new Uint8Array([0x04, 0x0c, 0x09, 0x0b, 0x0e, 0x0a, 0x07, 0x06, 0x03, 0x05, 0x00, 0x0f, 0x01, 0x02, 0x08, 0x0d]),
+    new Uint8Array([0x05, 0x08, 0x0e, 0x07, 0x03, 0x00, 0x01, 0x0d, 0x0a, 0x06, 0x09, 0x02, 0x0f, 0x0b, 0x0c, 0x04]),
+    new Uint8Array([0x0a, 0x03, 0x05, 0x09, 0x00, 0x0d, 0x07, 0x08, 0x0c, 0x04, 0x01, 0x06, 0x0b, 0x0f, 0x02, 0x0e]),
+];
+export const ID_GOST_28147_89_TEST_PARAM_SET = [
+    new Uint8Array([4, 2, 15, 5, 9, 1, 0, 8, 14, 3, 11, 12, 13, 7, 10, 6]),
+    new Uint8Array([12, 9, 15, 14, 8, 1, 3, 10, 2, 7, 4, 13, 6, 0, 11, 5]),
+    new Uint8Array([13, 8, 14, 12, 7, 3, 9, 10, 1, 5, 2, 4, 6, 15, 0, 11]),
+    new Uint8Array([14, 9, 11, 2, 5, 15, 7, 1, 0, 13, 12, 6, 10, 4, 3, 8]),
+    new Uint8Array([3, 14, 5, 9, 6, 8, 0, 13, 10, 11, 7, 12, 2, 1, 15, 4]),
+    new Uint8Array([8, 15, 6, 11, 1, 9, 12, 5, 13, 3, 7, 10, 0, 14, 2, 4]),
+    new Uint8Array([9, 11, 12, 0, 3, 6, 7, 5, 4, 8, 14, 15, 1, 10, 2, 13]),
+    new Uint8Array([12, 6, 5, 2, 11, 0, 9, 13, 3, 14, 7, 10, 15, 4, 1, 8]),
+];
+export const ID_GOSTR_3411_94_TEST_PARAM_SET = [
+    new Uint8Array([4, 10, 9, 2, 13, 8, 0, 14, 6, 11, 1, 12, 7, 15, 5, 3]),
+    new Uint8Array([14, 11, 4, 12, 6, 13, 15, 10, 2, 3, 8, 1, 0, 7, 5, 9]),
+    new Uint8Array([5, 8, 1, 13, 10, 3, 4, 2, 14, 15, 12, 7, 6, 0, 9, 11]),
+    new Uint8Array([7, 13, 10, 1, 0, 8, 9, 15, 14, 4, 6, 12, 11, 2, 5, 3]),
+    new Uint8Array([6, 12, 7, 1, 5, 15, 13, 8, 4, 10, 9, 14, 0, 3, 11, 2]),
+    new Uint8Array([4, 11, 10, 0, 7, 2, 1, 13, 3, 6, 8, 5, 9, 12, 15, 14]),
+    new Uint8Array([13, 11, 4, 1, 3, 15, 5, 9, 0, 10, 14, 7, 6, 8, 2, 12]),
+    new Uint8Array([1, 15, 13, 0, 5, 7, 10, 4, 9, 2, 3, 14, 6, 11, 8, 12]),
+];
+export const ID_GOSTR_3411_94_CRYPTOPRO_PARAM_SET = [
+    new Uint8Array([10, 4, 5, 6, 8, 1, 3, 7, 13, 12, 14, 0, 9, 2, 11, 15]),
+    new Uint8Array([5, 15, 4, 0, 2, 13, 11, 9, 1, 7, 6, 3, 12, 14, 10, 8]),
+    new Uint8Array([7, 15, 12, 14, 9, 4, 1, 0, 3, 11, 5, 2, 6, 10, 8, 13]),
+    new Uint8Array([4, 10, 7, 12, 0, 15, 2, 8, 14, 1, 6, 5, 13, 11, 9, 3]),
+    new Uint8Array([7, 6, 4, 11, 9, 12, 2, 10, 1, 8, 0, 14, 15, 13, 3, 5]),
+    new Uint8Array([7, 6, 2, 4, 13, 9, 15, 0, 10, 1, 5, 11, 8, 14, 12, 3]),
+    new Uint8Array([13, 14, 4, 1, 7, 0, 5, 10, 3, 12, 8, 15, 6, 2, 9, 11]),
+    new Uint8Array([1, 3, 10, 9, 5, 11, 4, 15, 8, 6, 7, 14, 13, 0, 2, 12]),
+];
+export const EAC_PARAM_SET = [
+    new Uint8Array([11, 4, 8, 10, 9, 7, 0, 3, 1, 6, 2, 15, 14, 5, 12, 13]),
+    new Uint8Array([1, 7, 14, 9, 11, 3, 15, 12, 0, 5, 4, 6, 13, 10, 8, 2]),
+    new Uint8Array([7, 3, 1, 9, 2, 4, 13, 15, 8, 10, 12, 6, 5, 0, 11, 14]),
+    new Uint8Array([10, 5, 15, 7, 14, 11, 3, 9, 2, 8, 1, 12, 0, 4, 6, 13]),
+    new Uint8Array([0, 14, 6, 11, 9, 3, 8, 4, 12, 15, 10, 5, 13, 7, 1, 2]),
+    new Uint8Array([9, 2, 11, 12, 0, 4, 5, 6, 3, 15, 13, 8, 1, 7, 14, 10]),
+    new Uint8Array([4, 0, 14, 1, 5, 11, 8, 3, 12, 2, 9, 7, 6, 10, 13, 15]),
+    new Uint8Array([7, 14, 12, 13, 9, 4, 8, 15, 10, 2, 6, 0, 3, 11, 5, 1]),
+];
+/** Implemented S-Boxes */
+export const magmaSboxes = {
+    ID_TC26_GOST_28147_PARAM_Z,
+    ID_GOST_28147_89_CRYPTO_PRO_A_PARAM_SET,
+    ID_GOST_28147_89_CRYPTO_PRO_B_PARAM_SET,
+    ID_GOST_28147_89_CRYPTO_PRO_C_PARAM_SET,
+    ID_GOST_28147_89_CRYPTO_PRO_D_PARAM_SET,
+    ID_GOST_28147_89_TEST_PARAM_SET,
+    ID_GOSTR_3411_94_TEST_PARAM_SET,
+    ID_GOSTR_3411_94_CRYPTOPRO_PARAM_SET,
+    EAC_PARAM_SET,
+    DSSZZI_UA_DKE_1,
+    DSSZZI_UA_DKE_2,
+    DSSZZI_UA_DKE_3,
+    DSSZZI_UA_DKE_4,
+    DSSZZI_UA_DKE_5,
+    DSSZZI_UA_DKE_6,
+    DSSZZI_UA_DKE_7,
+    DSSZZI_UA_DKE_8,
+    DSSZZI_UA_DKE_9,
+    DSSZZI_UA_DKE_10
+};
+/** Sequences of `K_i` S-Box applying */
+export const magmaKeySequences = {
+    ENCRYPT: [
+        0, 1, 2, 3, 4, 5, 6, 7,
+        0, 1, 2, 3, 4, 5, 6, 7,
+        0, 1, 2, 3, 4, 5, 6, 7,
+        7, 6, 5, 4, 3, 2, 1, 0
+    ],
+    DECRYPT: [
+        0, 1, 2, 3, 4, 5, 6, 7,
+        7, 6, 5, 4, 3, 2, 1, 0,
+        7, 6, 5, 4, 3, 2, 1, 0,
+        7, 6, 5, 4, 3, 2, 1, 0
+    ],
+    MAC: [0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7]
+};

package/magma/index.d.ts

@@ -0,0 +1,24 @@
+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 */
+export declare class Magma implements Cipher {
+    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
+     * @param sbox S-Box
+     * @param isLegacy Use GOST 28147-89 instead of GOST R 34.12-2015?
+     */
+    constructor(key: TArg<Uint8Array>, sbox?: TArg<Uint8Array>[], isLegacy?: boolean);
+    private regenerateRoundKeys;
+    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

@@ -0,0 +1,86 @@
+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 G = (a, k, sbox) => {
+    const substituted = T((a + k) >>> 0, sbox);
+    return ((substituted << 11) | (substituted >>> 21)) >>> 0;
+};
+/** Magma (GOST R 34.12-2015 and GOST 28147-89) cipher */
+export class Magma {
+    sbox;
+    isLegacy;
+    keySize = KEYSIZE;
+    blockSize = BLOCKSIZE;
+    key;
+    /**
+     * Magma (GOST R 34.12-2015 and GOST 28147-89) cipher
+     * @param key Encryption key
+     * @param sbox S-Box
+     * @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.sbox = sbox;
+        this.isLegacy = isLegacy;
+        if (key.length !== this.keySize)
+            throw new Error("Invalid key length");
+        this.key = isLegacy ? Magma.reverseKey(key) : key;
+    }
+    regenerateRoundKeys(sequence) {
+        const keyChunks = [];
+        for (let j = 0; j < 8; j++)
+            keyChunks.push(Number(bytesToNumberBE(this.key.subarray(j * 4, j * 4 + 4))));
+        const roundKeys = new Array(sequence.length);
+        for (let i = 0; i < sequence.length; i++)
+            roundKeys[i] = keyChunks[sequence[i]];
+        return roundKeys;
+    }
+    proceedBlock(block, sequence) {
+        if (block.length !== this.blockSize)
+            throw new Error("Invalid block size");
+        const roundKeys = this.regenerateRoundKeys(sequence);
+        let a0 = Number(bytesToNumberBE(block.subarray(0, 4)));
+        let a1 = Number(bytesToNumberBE(block.subarray(4, 8)));
+        for (let i = 0; i < roundKeys.length; i++) {
+            const temp = a1;
+            a1 = (a0 ^ G(a1, roundKeys[i], this.sbox)) >>> 0;
+            a0 = temp;
+        }
+        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/_keytransform.d.ts

@@ -0,0 +1,5 @@
+import { type TArg, type TRet } from "@noble/curves/utils.js";
+import type { Cipher } from "../types.js";
+export declare const cp_kek_diversify: (kek: TArg<Uint8Array>, ukm: TArg<Uint8Array>, sbox?: TArg<Uint8Array>[]) => TRet<Uint8Array>;
+export declare const acpkm: (encrypter: (msg: TArg<Uint8Array>) => TRet<Uint8Array>, bs: number) => TRet<Uint8Array>;
+export declare const acpkm_master: (cipher: Cipher, length: number) => TRet<Uint8Array>;

package/modes/_keytransform.js

@@ -0,0 +1,35 @@
+import { bytesToNumberLE, concatBytes, copyBytes, numberToBytesLE } from "@noble/curves/utils.js";
+import { Magma } from "../magma/index.js";
+import { ID_GOST_28147_89_CRYPTO_PRO_A_PARAM_SET } from "../magma/const.js";
+import { cfb } from "./cfb.js";
+import { ctr } from "./ctr.js";
+import { hexToBytes } from "@noble/hashes/utils.js";
+import { ecb } from "./ecb.js";
+export const cp_kek_diversify = (kek, ukm, sbox = ID_GOST_28147_89_CRYPTO_PRO_A_PARAM_SET) => {
+    let out = copyBytes(kek);
+    for (let i = 0; i < 8; i++) {
+        let s1 = 0, s2 = 0;
+        for (let j = 0; j < 8; j++) {
+            const k = Number(bytesToNumberLE(out.subarray(j * 4, j * 4 + 4))); //((out[j * 4]) | (out[j * 4 + 1] << 8) | (out[j * 4 + 2] << 16) | (out[j * 4 + 3] << 24)) >>> 0;
+            if ((ukm[i] >> j) & 1)
+                s1 += k;
+            else
+                s2 += k;
+        }
+        const iv = concatBytes(numberToBytesLE(s1 >>> 0, 4), numberToBytesLE(s2 >>> 0, 4));
+        const cipher = new Magma(out, sbox, true);
+        out = cfb(cipher, iv).encrypt(out);
+    }
+    return out;
+};
+export const acpkm = (encrypter, bs) => {
+    const result = [];
+    for (let d = 0x80; d < (0x80 + bs * (32 / bs)); d += bs) {
+        const block = new Uint8Array(bs);
+        for (let i = 0; i < bs; i++)
+            block[i] = d + i;
+        result.push(encrypter(block));
+    }
+    return concatBytes(...result);
+};
+export const acpkm_master = (cipher, length) => ctr(cipher, new Uint8Array(cipher.blockSize / 2).fill(0xFF), true, true).crypt(new Uint8Array(length));

package/modes/cbc.d.ts

@@ -0,0 +1,8 @@
+import { type TArg } from "@noble/hashes/utils.js";
+import type { BlockMode, Cipher } from "../types.js";
+/**
+ * **EN:** Cipher Block Chaining (CBC) mode
+ *
+ * **RU:** Режим простой замены с зацеплением
+ */
+export declare const cbc: (cipher: Cipher, iv: TArg<Uint8Array>) => BlockMode;

package/modes/cbc.js

@@ -0,0 +1,42 @@
+import { concatBytes } from "@noble/hashes/utils.js";
+import { xorBytes } from "../utils.js";
+/**
+ * **EN:** Cipher Block Chaining (CBC) mode
+ *
+ * **RU:** Режим простой замены с зацеплением
+ */
+export const cbc = (cipher, iv) => {
+    if (iv.length == 0 || iv.length % cipher.blockSize !== 0)
+        throw new Error("Invalid IV size");
+    const encrypter = cipher.encrypt.bind(cipher);
+    const decrypter = cipher.decrypt.bind(cipher);
+    return {
+        encrypt: (plaintext) => {
+            if (plaintext.length == 0 || plaintext.length % cipher.blockSize !== 0)
+                throw new Error("Data not aligned");
+            let r = [];
+            for (let i = 0; i < iv.length; i += cipher.blockSize)
+                r.push(iv.slice(i, i + cipher.blockSize));
+            const result = [];
+            for (let i = 0; i < plaintext.length; i += cipher.blockSize) {
+                result.push(encrypter(xorBytes(r[0], plaintext.subarray(i, i + cipher.blockSize))));
+                r = r.slice(1).concat(result[result.length - 1]);
+            }
+            return concatBytes(...result);
+        },
+        decrypt: (ciphertext) => {
+            if (ciphertext.length == 0 || ciphertext.length % cipher.blockSize !== 0)
+                throw new Error("Data not aligned");
+            let r = [];
+            for (let i = 0; i < iv.length; i += cipher.blockSize)
+                r.push(iv.slice(i, i + cipher.blockSize));
+            const result = [];
+            for (let i = 0; i < ciphertext.length; i += cipher.blockSize) {
+                const blk = ciphertext.slice(i, i + cipher.blockSize);
+                result.push(xorBytes(r[0], decrypter(blk)));
+                r = r.slice(1).concat(blk);
+            }
+            return concatBytes(...result);
+        }
+    };
+};

package/modes/cfb.d.ts

@@ -0,0 +1,8 @@
+import { type TArg } from "@noble/hashes/utils.js";
+import type { BlockMode, Cipher } from "../types.js";
+/**
+ * **EN:** Cipher Feedback (CFB) mode
+ *
+ * **RU:** Режим гаммирования с обратной связью по шифртексту
+ */
+export declare const cfb: (cipher: Cipher, iv: TArg<Uint8Array>) => BlockMode;

package/modes/cfb.js

@@ -0,0 +1,37 @@
+import { concatBytes } from "@noble/hashes/utils.js";
+import { getPadLength, xorBytes } from "../utils.js";
+/**
+ * **EN:** Cipher Feedback (CFB) mode
+ *
+ * **RU:** Режим гаммирования с обратной связью по шифртексту
+ */
+export const cfb = (cipher, iv) => {
+    if (iv.length == 0 || iv.length % cipher.blockSize !== 0)
+        throw new Error("Invalid IV size");
+    const encrypter = cipher.encrypt.bind(cipher);
+    return {
+        encrypt: (plaintext) => {
+            let r = [];
+            for (let i = 0; i < iv.length; i += cipher.blockSize)
+                r.push(iv.slice(i, i + cipher.blockSize));
+            const result = [];
+            for (let i = 0; i < (plaintext.length + getPadLength(plaintext.length, cipher.blockSize)); i += cipher.blockSize) {
+                result.push(xorBytes(encrypter(r[0]), plaintext.subarray(i, i + cipher.blockSize)));
+                r = r.slice(1).concat(result[result.length - 1]);
+            }
+            return concatBytes(...result);
+        },
+        decrypt: (ciphertext) => {
+            let r = [];
+            for (let i = 0; i < iv.length; i += cipher.blockSize)
+                r.push(iv.slice(i, i + cipher.blockSize));
+            const result = [];
+            for (let i = 0; i < (ciphertext.length + getPadLength(ciphertext.length, cipher.blockSize)); i += cipher.blockSize) {
+                const blk = ciphertext.slice(i, i + cipher.blockSize);
+                result.push(xorBytes(encrypter(r[0]), blk));
+                r = r.slice(1).concat(blk);
+            }
+            return concatBytes(...result);
+        }
+    };
+};

package/modes/ctr.d.ts

@@ -0,0 +1,15 @@
+import { type TArg } from "@noble/hashes/utils.js";
+import type { Cipher, StreamMode } from "../types.js";
+import type { Magma } from "../magma/index.js";
+/**
+ * **EN:** Counter (CTR) mode
+ *
+ * **RU:** Режим гаммирования
+ */
+export declare const ctr: (cipher: Cipher, iv: TArg<Uint8Array>, isAcpkm?: boolean, _isAcpkmOmac?: boolean) => StreamMode;
+/**
+ * **EN:** Counter (CTR) mode (GOST 28147-89)
+ *
+ * **RU:** Режим гаммирования (ГОСТ 28147-89)
+ */
+export declare const cnt: (cipher: Magma, iv: TArg<Uint8Array>) => StreamMode;

package/modes/ctr.js

@@ -0,0 +1,62 @@
+import { concatBytes } from "@noble/hashes/utils.js";
+import { getPadLength, xorBytes } from "../utils.js";
+import { bytesToNumberBE, numberToBytesBE } from "@noble/curves/utils.js";
+import { acpkm } from "./_keytransform.js";
+/**
+ * **EN:** Counter (CTR) mode
+ *
+ * **RU:** Режим гаммирования
+ */
+export const ctr = (cipher, iv, isAcpkm, _isAcpkmOmac) => {
+    const halfBlockSize = cipher.blockSize / 2;
+    if (iv.length !== halfBlockSize)
+        throw new Error("Invalid IV size");
+    return {
+        crypt: (msg) => {
+            let encrypter = cipher.encrypt.bind(cipher);
+            const ctrMax = 1n << (8n * BigInt(halfBlockSize));
+            const maxSize = ctrMax * BigInt(cipher.blockSize);
+            if (BigInt(msg.length) > maxSize)
+                throw new Error("Too big data");
+            let acpkmSectionSize = 0;
+            if (isAcpkm)
+                acpkmSectionSize = _isAcpkmOmac ? (cipher.blockSize == 16 ? 6 : 10) : 2;
+            const keystreamBlocks = [];
+            for (let ctr = 0; ctr < Math.ceil(msg.length / cipher.blockSize); ctr++) {
+                if (isAcpkm && ctr != 0 && (ctr % acpkmSectionSize) == 0) {
+                    // @ts-ignore
+                    const cipher2 = new cipher.constructor(acpkm(encrypter, cipher.blockSize));
+                    encrypter = cipher2.encrypt.bind(cipher2);
+                }
+                keystreamBlocks.push(encrypter(concatBytes(iv, numberToBytesBE(ctr, halfBlockSize))));
+            }
+            return xorBytes(concatBytes(...keystreamBlocks), msg);
+        }
+    };
+};
+/**
+ * **EN:** Counter (CTR) mode (GOST 28147-89)
+ *
+ * **RU:** Режим гаммирования (ГОСТ 28147-89)
+ */
+export const cnt = (cipher, iv) => {
+    if (iv.length !== cipher.blockSize)
+        throw new Error("Invalid IV size");
+    const C1 = 0x01010104n;
+    const 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 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()));
+            }
+            return xorBytes(concatBytes(...gamma), msg);
+        }
+    };
+};

package/modes/ecb.d.ts

@@ -0,0 +1,7 @@
+import type { BlockMode, Cipher } from "../types.js";
+/**
+ * **EN:** Electronic Codebook (ECB) mode
+ *
+ * **RU:** Режим простой замены
+ */
+export declare const ecb: (cipher: Cipher) => BlockMode;