@li0ard/dstu 0.1.5 → 0.1.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (50) hide show
  1. package/README.md +5 -0
  2. package/dstu4145/const.d.ts +2 -0
  3. package/dstu4145/const.js +17 -0
  4. package/dstu4145/ec/index.d.ts +8 -4
  5. package/dstu4145/ec/index.js +24 -6
  6. package/dstu4145/ec/math.js +2 -0
  7. package/dstu4145/index.d.ts +11 -0
  8. package/dstu4145/index.js +35 -6
  9. package/dstu9041/curve.js +13 -10
  10. package/dstu9041/index.d.ts +2 -2
  11. package/dstu9041/index.js +48 -44
  12. package/dstu9311/const.d.ts +29 -0
  13. package/dstu9311/const.js +150 -0
  14. package/dstu9311/hash.d.ts +34 -0
  15. package/dstu9311/hash.js +91 -0
  16. package/dstu9311/index.d.ts +16 -0
  17. package/dstu9311/index.js +59 -0
  18. package/index.d.ts +2 -0
  19. package/index.js +2 -0
  20. package/keywrap.d.ts +6 -0
  21. package/keywrap.js +34 -0
  22. package/modes/cbc.d.ts +2 -3
  23. package/modes/cbc.js +6 -5
  24. package/modes/cfb.d.ts +3 -4
  25. package/modes/cfb.js +88 -56
  26. package/modes/cmac.d.ts +2 -0
  27. package/modes/cmac.js +45 -0
  28. package/modes/ctr.d.ts +2 -3
  29. package/modes/ctr.js +25 -14
  30. package/modes/ecb.d.ts +2 -3
  31. package/modes/gcm.d.ts +2 -3
  32. package/modes/gcm.js +18 -14
  33. package/modes/gmac.d.ts +3 -0
  34. package/modes/gmac.js +40 -0
  35. package/modes/index.d.ts +3 -1
  36. package/modes/index.js +3 -1
  37. package/modes/kw.d.ts +5 -4
  38. package/modes/kw.js +63 -56
  39. package/modes/ofb.d.ts +2 -3
  40. package/modes/ofb.js +3 -2
  41. package/modes/xts.d.ts +7 -0
  42. package/modes/xts.js +93 -0
  43. package/package.json +3 -2
  44. package/strumok/index.d.ts +4 -3
  45. package/strumok/index.js +42 -277
  46. package/types.d.ts +5 -3
  47. package/utils.d.ts +5 -0
  48. package/utils.js +14 -2
  49. package/modes/mac.d.ts +0 -6
  50. package/modes/mac.js +0 -61
package/README.md CHANGED
@@ -26,6 +26,8 @@ npm i @li0ard/dstu
26
26
  - Supports KMAC
27
27
  - Strumok stream cipher (DSTU 8845:2019)
28
28
  - ECIES encryption schema over Twisted Edwards curves (DSTU 9041:2020)
29
+ - DSTU 9311:2024 cipher (republished DSTU GOST 28147:2009)
30
+ - GOST 34.311-95 hash function over DSTU 9311:2024
29
31
 
30
32
  ## Supported cipher modes
31
33
 
@@ -36,6 +38,9 @@ npm i @li0ard/dstu
36
38
  - Galois Counter mode (GCM)
37
39
  - Message Authentication Code mode (MAC and GMAC)
38
40
  - Output Feedback mode (OFB)
41
+ - Key wrapping (KW)
42
+ - Supports [`Dstu7624Wrap`](https://zakon.rada.gov.ua/laws/show/z0108-13)
43
+ - XEX Tweakable Block Ciphertext Stealing (XTS)
39
44
 
40
45
  ## Supported curves
41
46
 
@@ -22,6 +22,8 @@ export interface DSTUShortParameters {
22
22
  export interface DSTUParameters extends DSTUShortParameters {
23
23
  /** Curve order */
24
24
  order: string;
25
+ /** Curve cofactor */
26
+ cofactor: 2 | 4;
25
27
  /** Base point `X` coordinate */
26
28
  Gx: string;
27
29
  /** Base point `Y` coordinate */
package/dstu4145/const.js CHANGED
@@ -3,6 +3,7 @@ export const DSTU_163 = {
3
3
  a: 1,
4
4
  b: "05FF6108462A2DC8210AB403925E638A19C1455D21",
5
5
  order: "0400000000000000000002BEC12BE2262D39BCF14D",
6
+ cofactor: 2,
6
7
  Gx: "02E2F85F5DD74CE983A5C4237229DAF8A3F35823BE",
7
8
  Gy: "03826F008A8C51D7B95284D9D03FF0E00CE2CD723A",
8
9
  m: 163,
@@ -13,6 +14,7 @@ export const DSTU_163_TEST = {
13
14
  a: 1,
14
15
  b: "05FF6108462A2DC8210AB403925E638A19C1455D21",
15
16
  order: "0400000000000000000002BEC12BE2262D39BCF14D",
17
+ cofactor: 2,
16
18
  Gx: "072D867F93A93AC27DF9FF01AFFE74885C8C540420",
17
19
  Gy: "00224A9C3947852B97C5599D5F4AB81122ADC3FD9B",
18
20
  m: 163,
@@ -23,6 +25,7 @@ export const DSTU_167 = {
23
25
  a: 1,
24
26
  b: "6EE3CEEB230811759F20518A0930F1A4315A827DAC",
25
27
  order: "3FFFFFFFFFFFFFFFFFFFFFB12EBCC7D7F29FF7701F",
28
+ cofactor: 2,
26
29
  Gx: "7A1F6653786A68192803910A3D30B2A2018B21CD54",
27
30
  Gy: "5F49EB26781C0EC6B8909156D98ED435E45FD59918",
28
31
  m: 167,
@@ -33,6 +36,7 @@ export const DSTU_173 = {
33
36
  a: 0,
34
37
  b: "108576C80499DB2FC16EDDF6853BBB278F6B6FB437D9",
35
38
  order: "0800000000000000000000189B4E67606E3825BB2831",
39
+ cofactor: 4,
36
40
  Gx: "04D41A619BCC6EADF0448FA22FAD567A9181D37389CA",
37
41
  Gy: "10B51CC12849B234C75E6DD2028BF7FF5C1CE0D991A1",
38
42
  m: 173,
@@ -48,6 +52,7 @@ export const DSTU_173_ONB = {
48
52
  a: 0,
49
53
  b: "043D7E139319F43BA00944915740E1E6651B06E278C7",
50
54
  order: "800000000000000000000189B4E67606E3825BB2831",
55
+ cofactor: 4,
51
56
  Gx: "0A3B8B8D704089B24318CAA51917CB6E424B4E6DEA56",
52
57
  Gy: "005A43D5EE1F400349CF35150C74F119A39145F0CB08",
53
58
  m: 173,
@@ -59,6 +64,7 @@ export const DSTU_173_ONB_TEST = {
59
64
  a: 0,
60
65
  b: "043D7E139319F43BA00944915740E1E6651B06E278C7",
61
66
  order: "800000000000000000000189B4E67606E3825BB2831",
67
+ cofactor: 4,
62
68
  Gx: "1D26E5282C2647E1B0327CB4F6087932A0A1F006A89F",
63
69
  Gy: "0322218E4551CF8F6E3345644A10B2408F5DF19EC2C7",
64
70
  m: 173,
@@ -70,6 +76,7 @@ export const DSTU_179 = {
70
76
  a: 1,
71
77
  b: "04A6E0856526436F2F88DD07A341E32D04184572BEB710",
72
78
  order: "03FFFFFFFFFFFFFFFFFFFFFFB981960435FE5AB64236EF",
79
+ cofactor: 2,
73
80
  Gx: "06BA06FE51464B2BD26DC57F48819BA9954667022C7D03",
74
81
  Gy: "025FBC363582DCEC065080CA8287AAFF09788A66DC3A9E",
75
82
  m: 179,
@@ -80,6 +87,7 @@ export const DSTU_179_ONB = {
80
87
  a: 1,
81
88
  b: "019C9EBC4FD8308193D3A61762C547C82F2E6B2182CBCB",
82
89
  order: "03FFFFFFFFFFFFFFFFFFFFFFB981960435FE5AB64236EF",
90
+ cofactor: 2,
83
91
  Gx: "011F4112265410477159E0D3E39BC4AC4ADE43B21B66B9",
84
92
  Gy: "02CA5F0B34C61A86216F13766591CB266E2819EE582B3C",
85
93
  m: 179,
@@ -95,6 +103,7 @@ export const DSTU_191 = {
95
103
  a: 1,
96
104
  b: "7BC86E2102902EC4D5890E8B6B4981FF27E0482750FEFC03",
97
105
  order: "40000000000000000000000069A779CAC1DABC6788F7474F",
106
+ cofactor: 2,
98
107
  Gx: "714114B762F2FF4A7912A6D2AC58B9B5C2FCFE76DAEB7129",
99
108
  Gy: "29C41E568B77C617EFE5902F11DB96FA9613CD8D03DB08DA",
100
109
  m: 191,
@@ -105,6 +114,7 @@ export const DSTU_191_ONB = {
105
114
  a: 1,
106
115
  b: "13871C9D29D6CEEA740FD57444F72FDBAE559C13A1E31EF8",
107
116
  order: "40000000000000000000000069A779CAC1DABC6788F7474F",
117
+ cofactor: 2,
108
118
  Gx: "7159E0D3E39BC4AC4ADE43B21B66B94F2AF25ABEEB1D85D3",
109
119
  Gy: "57E45D546BE6201E9705E029535D009D31F51D81E18226BE",
110
120
  m: 191,
@@ -120,6 +130,7 @@ export const DSTU_233 = {
120
130
  a: 1,
121
131
  b: "6973B15095675534C7CF7E64A21BD54EF5DD3B8A0326AA936ECE454D2C",
122
132
  order: "01000000000000000000000000000013E974E72F8A6922031D2603CFE0D7",
133
+ cofactor: 2,
123
134
  Gx: "3FCDA526B6CDF83BA1118DF35B3C31761D3545F32728D003EEB25EFE96",
124
135
  Gy: "9CA8B57A934C54DEEDA9E54A7BBAD95E3B2E91C54D32BE0B9DF96D8D35",
125
136
  m: 233,
@@ -130,6 +141,7 @@ export const DSTU_233_ONB = {
130
141
  a: 1,
131
142
  b: "80F920952A702C75B704A424C018EEA55AA44664F3A003E0962D4F9A8E",
132
143
  order: "01000000000000000000000000000013E974E72F8A6922031D2603CFE0D7",
144
+ cofactor: 2,
133
145
  Gx: "A0823B8ACF069F1CDE256256F21D90DB35CA795792D5F758EC2E9992FB",
134
146
  Gy: "019DAE222AF326D33AFB7761953F624A23D3EB1CA7A1C300F0AA9953CA85",
135
147
  m: 233,
@@ -145,6 +157,7 @@ export const DSTU_257 = {
145
157
  a: 0,
146
158
  b: "01CEF494720115657E18F938D7A7942394FF9425C1458C57861F9EEA6ADBE3BE10",
147
159
  order: "00800000000000000000000000000000006759213AF182E987D3E17714907D470D",
160
+ cofactor: 4,
148
161
  Gx: "002A29EF207D0E9B6C55CD260B306C7E007AC491CA1B10C62334A9E8DCD8D20FB7",
149
162
  Gy: "010686D41FF744D4449FCCF6D8EEA03102E6812C93A9D60B978B702CF156D814EF",
150
163
  m: 257,
@@ -155,6 +168,7 @@ export const DSTU_307 = {
155
168
  a: 1,
156
169
  b: "0393C7F7D53666B5054B5E6C6D3DE94F4296C0C599E2E2E241050DF18B6090BDC90186904968BB",
157
170
  order: "03FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC079C2F3825DA70D390FBBA588D4604022B7B7",
171
+ cofactor: 2,
158
172
  Gx: "0216EE8B189D291A0224984C1E92F1D16BF75CCD825A087A239B276D3167743C52C02D6E7232AA",
159
173
  Gy: "05D9306BACD22B7FAEB09D2E049C6E2866C5D1677762A8F2F2DC9A11C7F7BE8340AB2237C7F2A0",
160
174
  m: 307,
@@ -165,6 +179,7 @@ export const DSTU_367 = {
165
179
  a: 1,
166
180
  b: "43FC8AD242B0B7A6F3D1627AD5654447556B47BF6AA4A64B0C2AFE42CADAB8F93D92394C79A79755437B56995136",
167
181
  order: "40000000000000000000000000000000000000000000009C300B75A3FA824F22428FD28CE8812245EF44049B2D49",
182
+ cofactor: 2,
168
183
  Gx: "324A6EDDD512F08C49A99AE0D3F961197A76413E7BE81A400CA681E09639B5FE12E59A109F78BF4A373541B3B9A1",
169
184
  Gy: "01AB597A5B4477F59E39539007C7F977D1A567B92B043A49C6B61984C3FE3481AAF454CD41BA1F051626442B3C10",
170
185
  m: 367,
@@ -175,6 +190,7 @@ export const DSTU_431 = {
175
190
  a: 1,
176
191
  b: "03CE10490F6A708FC26DFE8C3D27C4F94E690134D5BFF988D8D28AAEAEDE975936C66BAC536B18AE2DC312CA493117DAA469C640CAF3",
177
192
  order: "3FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFBA3175458009A8C0A724F02F81AA8A1FCBAF80D90C7A95110504CF",
193
+ cofactor: 2,
178
194
  Gx: "1A62BA79D98133A16BBAE7ED9A8E03C32E0824D57AEF72F88986874E5AAE49C27BED49A2A95058068426C2171E99FD3B43C5947C857D",
179
195
  Gy: "70B5E1E14031C1F70BBEFE96BDDE66F451754B4CA5F48DA241F331AA396B8D1839A855C1769B1EA14BA53308B5E2723724E090E02DB9",
180
196
  m: 431,
@@ -185,6 +201,7 @@ export const DSTU_431_ONB = {
185
201
  a: 1,
186
202
  b: "53FB7AF7B4407000A6F226AD6BAD28378646BD83F1F940810A4C19536EE65E53F40F973F2F06C5E80EFE3B43651BD5FF8B06BA5F9299",
187
203
  order: "3FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFBA3175458009A8C0A724F02F81AA8A1FCBAF80D90C7A95110504CF",
204
+ cofactor: 2,
188
205
  Gx: "2020182CFCD7C724157B363D4ABFD4C16251773C595D4E5C88572FA9D5EBB58142326448C08D3EE3E17E40B835D3090DCFBA7C5ADEA6",
189
206
  Gy: "18E1B6EFB28EEF8A1F9C1859ED57C74CA747E4E1A60294C005D1920E80903A432929855828DD7F21714F837E119A044987F00110ADAD",
190
207
  m: 431,
@@ -28,8 +28,9 @@ export declare const binaryWeierstrass: (parameters: DSTUParameters) => Readonly
28
28
  _double?: /*elided*/ any;
29
29
  x: BN;
30
30
  y: BN;
31
+ assertValidity(): /*elided*/ any;
31
32
  add(p: /*elided*/ any): /*elided*/ any;
32
- mul(f: BN): /*elided*/ any;
33
+ mul(f: BN | number): /*elided*/ any;
33
34
  negate(): /*elided*/ any;
34
35
  clone(): /*elided*/ any;
35
36
  isZero(): boolean;
@@ -51,8 +52,9 @@ export declare const binaryWeierstrass: (parameters: DSTUParameters) => Readonly
51
52
  _double?: /*elided*/ any;
52
53
  x: BN;
53
54
  y: BN;
55
+ assertValidity(): /*elided*/ any;
54
56
  add(p: /*elided*/ any): /*elided*/ any;
55
- mul(f: BN): /*elided*/ any;
57
+ mul(f: BN | number): /*elided*/ any;
56
58
  negate(): /*elided*/ any;
57
59
  clone(): /*elided*/ any;
58
60
  isZero(): boolean;
@@ -74,8 +76,9 @@ export declare const binaryWeierstrass: (parameters: DSTUParameters) => Readonly
74
76
  _double?: /*elided*/ any;
75
77
  x: BN;
76
78
  y: BN;
79
+ assertValidity(): /*elided*/ any;
77
80
  add(p: /*elided*/ any): /*elided*/ any;
78
- mul(f: BN): /*elided*/ any;
81
+ mul(f: BN | number): /*elided*/ any;
79
82
  negate(): /*elided*/ any;
80
83
  clone(): /*elided*/ any;
81
84
  isZero(): boolean;
@@ -98,8 +101,9 @@ export declare const binaryWeierstrass: (parameters: DSTUParameters) => Readonly
98
101
  _double?: /*elided*/ any;
99
102
  x: BN;
100
103
  y: BN;
104
+ assertValidity(): /*elided*/ any;
101
105
  add(p: /*elided*/ any): /*elided*/ any;
102
- mul(f: BN): /*elided*/ any;
106
+ mul(f: BN | number): /*elided*/ any;
103
107
  negate(): /*elided*/ any;
104
108
  clone(): /*elided*/ any;
105
109
  isZero(): boolean;
@@ -11,6 +11,15 @@ export const binaryWeierstrass = (parameters) => {
11
11
  const order = field.fromHexStringOrBytes(parameters.order);
12
12
  const b = toInternal(field.fromHexStringOrBytes(parameters.b));
13
13
  const c = field.sqrt(b);
14
+ const isValidXY = (x, y) => {
15
+ const x2 = field.sqr(x);
16
+ const lhs = field.sqr(y).ixor(field.mul(x, y));
17
+ const rhs = field.mul(x2, x).ixor(b);
18
+ // `a` must be 0 or 1, so if a = 1, just add x^2
19
+ if (parameters.a === 1)
20
+ rhs.ixor(x2);
21
+ return lhs.eq(rhs);
22
+ };
14
23
  const scalarByteLength = Math.ceil(order.bitLength() / 8), pointByteLength = field.LENGTH * 2;
15
24
  const lengths = Object.freeze({
16
25
  fieldByteLength: field.LENGTH,
@@ -45,6 +54,13 @@ export const binaryWeierstrass = (parameters) => {
45
54
  constructor(x, y) {
46
55
  this.x = x;
47
56
  this.y = y;
57
+ this.assertValidity();
58
+ }
59
+ assertValidity() {
60
+ // Skip if point is infinity
61
+ if (!isValidXY(this.x, this.y) && !this.x.isZero() && !this.y.isZero())
62
+ throw new Error("Assertation failed: point isn't on curve");
63
+ return this;
48
64
  }
49
65
  add(p) {
50
66
  const pz = Point.ZERO.clone();
@@ -79,6 +95,8 @@ export const binaryWeierstrass = (parameters) => {
79
95
  return pz;
80
96
  }
81
97
  mul(f) {
98
+ if (typeof f == "number")
99
+ f = new BN(f);
82
100
  if (f.isZero() || this.x.isZero())
83
101
  return Point.ZERO.clone();
84
102
  let X1 = this.x.clone(), Z1 = new BN(1);
@@ -101,12 +119,12 @@ export const binaryWeierstrass = (parameters) => {
101
119
  return this.negate();
102
120
  const A = field.mul(this.x, Z1).ixor(X1);
103
121
  const B = field.mul(this.x, Z2).ixor(X2);
104
- const Z1Z2 = field.mul(Z1, Z2);
105
- const Z1Z2x = field.mul(Z1Z2, this.x);
106
- const D = field.invert(field.mul(Z1Z2x, Z1));
107
- const N = field.mul(A, B).ixor(field.mul(Z1Z2, xSqr.ixor(this.y)));
108
- const Xk = field.mul(X1, field.mul(Z1Z2x, D));
109
- const Yk = field.mul(field.mul(A, N), D).ixor(this.y);
122
+ const C = field.mul(Z1, Z2);
123
+ const D = field.mul(C, this.x);
124
+ const E = field.invert(field.mul(D, Z1));
125
+ const F = field.mul(A, B).ixor(field.mul(C, xSqr.ixor(this.y)));
126
+ const Xk = field.mul(X1, field.mul(D, E));
127
+ const Yk = field.mul(field.mul(A, F), E).ixor(this.y);
110
128
  return new Point(Xk, Yk);
111
129
  }
112
130
  negate() { return new Point(this.x.clone(), this.x.xor(this.y)); }
@@ -107,6 +107,8 @@ export const createField = (m, ks) => {
107
107
  return bMod(le2BN(words));
108
108
  };
109
109
  const mul = (x, v) => {
110
+ if (x.eq(v))
111
+ return sqr(x);
110
112
  const table = new Array(MUL_TABLE_SIZE);
111
113
  table[0] = new BN(0);
112
114
  for (let i = 1; i < MUL_TABLE_SIZE; i++) {
@@ -3,6 +3,7 @@ import { type DSTUParameters } from "./const.js";
3
3
  /** Create DSTU 4145-2002 signer (Big-Endian) */
4
4
  export declare const dstu4145: (parameters: DSTUParameters) => Readonly<{
5
5
  getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
6
+ getSharedSecret: (secretKeyA: TArg<Uint8Array>, publicKeyB: TArg<Uint8Array>, withCofactor?: boolean) => TRet<Uint8Array>;
6
7
  sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
7
8
  verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
8
9
  keygen: (isCompressed?: boolean) => {
@@ -21,6 +22,7 @@ export * from "./ec/expand.js";
21
22
  /** DSTU 4145-2002 163 bit curve */
22
23
  export declare const dstu163: Readonly<{
23
24
  getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
25
+ getSharedSecret: (secretKeyA: TArg<Uint8Array>, publicKeyB: TArg<Uint8Array>, withCofactor?: boolean) => TRet<Uint8Array>;
24
26
  sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
25
27
  verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
26
28
  keygen: (isCompressed?: boolean) => {
@@ -37,6 +39,7 @@ export declare const dstu163: Readonly<{
37
39
  /** DSTU 4145-2002 167 bit curve */
38
40
  export declare const dstu167: Readonly<{
39
41
  getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
42
+ getSharedSecret: (secretKeyA: TArg<Uint8Array>, publicKeyB: TArg<Uint8Array>, withCofactor?: boolean) => TRet<Uint8Array>;
40
43
  sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
41
44
  verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
42
45
  keygen: (isCompressed?: boolean) => {
@@ -53,6 +56,7 @@ export declare const dstu167: Readonly<{
53
56
  /** DSTU 4145-2002 173 bit curve */
54
57
  export declare const dstu173: Readonly<{
55
58
  getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
59
+ getSharedSecret: (secretKeyA: TArg<Uint8Array>, publicKeyB: TArg<Uint8Array>, withCofactor?: boolean) => TRet<Uint8Array>;
56
60
  sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
57
61
  verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
58
62
  keygen: (isCompressed?: boolean) => {
@@ -69,6 +73,7 @@ export declare const dstu173: Readonly<{
69
73
  /** DSTU 4145-2002 179 bit curve */
70
74
  export declare const dstu179: Readonly<{
71
75
  getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
76
+ getSharedSecret: (secretKeyA: TArg<Uint8Array>, publicKeyB: TArg<Uint8Array>, withCofactor?: boolean) => TRet<Uint8Array>;
72
77
  sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
73
78
  verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
74
79
  keygen: (isCompressed?: boolean) => {
@@ -85,6 +90,7 @@ export declare const dstu179: Readonly<{
85
90
  /** DSTU 4145-2002 191 bit curve */
86
91
  export declare const dstu191: Readonly<{
87
92
  getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
93
+ getSharedSecret: (secretKeyA: TArg<Uint8Array>, publicKeyB: TArg<Uint8Array>, withCofactor?: boolean) => TRet<Uint8Array>;
88
94
  sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
89
95
  verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
90
96
  keygen: (isCompressed?: boolean) => {
@@ -101,6 +107,7 @@ export declare const dstu191: Readonly<{
101
107
  /** DSTU 4145-2002 233 bit curve */
102
108
  export declare const dstu233: Readonly<{
103
109
  getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
110
+ getSharedSecret: (secretKeyA: TArg<Uint8Array>, publicKeyB: TArg<Uint8Array>, withCofactor?: boolean) => TRet<Uint8Array>;
104
111
  sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
105
112
  verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
106
113
  keygen: (isCompressed?: boolean) => {
@@ -117,6 +124,7 @@ export declare const dstu233: Readonly<{
117
124
  /** DSTU 4145-2002 257 bit curve */
118
125
  export declare const dstu257: Readonly<{
119
126
  getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
127
+ getSharedSecret: (secretKeyA: TArg<Uint8Array>, publicKeyB: TArg<Uint8Array>, withCofactor?: boolean) => TRet<Uint8Array>;
120
128
  sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
121
129
  verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
122
130
  keygen: (isCompressed?: boolean) => {
@@ -133,6 +141,7 @@ export declare const dstu257: Readonly<{
133
141
  /** DSTU 4145-2002 307 bit curve */
134
142
  export declare const dstu307: Readonly<{
135
143
  getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
144
+ getSharedSecret: (secretKeyA: TArg<Uint8Array>, publicKeyB: TArg<Uint8Array>, withCofactor?: boolean) => TRet<Uint8Array>;
136
145
  sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
137
146
  verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
138
147
  keygen: (isCompressed?: boolean) => {
@@ -149,6 +158,7 @@ export declare const dstu307: Readonly<{
149
158
  /** DSTU 4145-2002 367 bit curve */
150
159
  export declare const dstu367: Readonly<{
151
160
  getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
161
+ getSharedSecret: (secretKeyA: TArg<Uint8Array>, publicKeyB: TArg<Uint8Array>, withCofactor?: boolean) => TRet<Uint8Array>;
152
162
  sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
153
163
  verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
154
164
  keygen: (isCompressed?: boolean) => {
@@ -165,6 +175,7 @@ export declare const dstu367: Readonly<{
165
175
  /** DSTU 4145-2002 431 bit curve */
166
176
  export declare const dstu431: Readonly<{
167
177
  getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
178
+ getSharedSecret: (secretKeyA: TArg<Uint8Array>, publicKeyB: TArg<Uint8Array>, withCofactor?: boolean) => TRet<Uint8Array>;
168
179
  sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
169
180
  verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
170
181
  keygen: (isCompressed?: boolean) => {
package/dstu4145/index.js CHANGED
@@ -6,29 +6,41 @@ import BN from "bn.js";
6
6
  export const dstu4145 = (parameters) => {
7
7
  const curve = binaryWeierstrass(parameters);
8
8
  const { Field, Point, MASK, lengths } = curve;
9
- const getPublicKey = (secretKey, isCompressed = false) => Point.BASE.mulWnaf(Field.fromHexStringOrBytes(secretKey)).negate().toBytes(isCompressed);
9
+ /**
10
+ * Computes public key for a secret key
11
+ * @param isCompressed - whether to return compact (default), or full key
12
+ * @returns Public key, full when `isCompressed=false`; short when `isCompressed=true`
13
+ */
14
+ const getPublicKey = (secretKey, isCompressed = false) => Point.BASE.mul(Field.fromHexStringOrBytes(secretKey)).negate().toBytes(isCompressed);
10
15
  const randomPrivateKey = () => Field.toBytes(new BN(randomBytes(lengths.scalarByteLength)).imaskn(MASK), lengths.scalarByteLength);
16
+ /**
17
+ * Computes presign (ephermeral keypair)
18
+ * @param rand Predefined secret ephermeral key
19
+ * @returns Ephemeral public key (`Fe`) and secret key (`e`)
20
+ */
11
21
  const computePresign = (rand) => {
12
- const e = (rand
13
- ? new BN(rand)
14
- : new BN(randomBytes(lengths.scalarByteLength))).imaskn(MASK);
22
+ const e = new BN(rand ?? randomBytes(lengths.scalarByteLength)).imaskn(MASK);
15
23
  if (rand && e.isZero())
16
24
  throw new Error("Invalid custom rand for presign (rand = 0)");
17
- if (e.isZero())
25
+ else if (e.isZero())
18
26
  return computePresign(rand);
19
- const Fe = Point.BASE.mulWnaf(e).x;
27
+ const Fe = Point.BASE.mul(e).x;
20
28
  if (Fe.isZero())
21
29
  return computePresign(rand);
22
30
  return { Fe, e };
23
31
  };
32
+ /** Converts hash into field element */
24
33
  const prepareHash = (digest) => {
25
34
  let h = curve.toInternalField(Field.hashToField(digest));
26
35
  if (h.isZero())
27
36
  h = new BN(1);
28
37
  return h;
29
38
  };
39
+ /** Signs a message hash with a secret key. */
30
40
  const sign = (secretKey, digest, rand) => {
31
41
  const d = new BN(secretKey), h = prepareHash(digest), { Fe, e } = computePresign(rand);
42
+ if (d.isZero() || d.gte(curve.ORDER))
43
+ throw new Error("Invalid private key, must be in range 1 < key < order");
32
44
  const r = curve.toExternalField(Field.mul(h, Fe)).imaskn(MASK);
33
45
  if (r.isZero())
34
46
  return sign(secretKey, digest, rand);
@@ -37,6 +49,7 @@ export const dstu4145 = (parameters) => {
37
49
  return sign(secretKey, digest, rand);
38
50
  return concatBytes(Field.toBytes(s, lengths.scalarByteLength), Field.toBytes(r, lengths.scalarByteLength));
39
51
  };
52
+ /** Verifies a signature against message hash and public key. */
40
53
  const verify = (publicKey, digest, signature) => {
41
54
  if (signature.length != lengths.signatureByteLength)
42
55
  throw new Error("Invalid signature length");
@@ -49,6 +62,21 @@ export const dstu4145 = (parameters) => {
49
62
  const y = curve.toExternalField(Field.mul(h, R.x)).imaskn(MASK);
50
63
  return y.eq(r);
51
64
  };
65
+ /**
66
+ * Computes shared secret key
67
+ * @param withCofactor Multiply result by curve cofactor? (default - `true`)
68
+ */
69
+ const getSharedSecret = (secretKeyA, publicKeyB, withCofactor = true) => {
70
+ const d = new BN(secretKeyA), Q = Point.fromBytes(publicKeyB);
71
+ if (d.isZero() || d.gte(curve.ORDER))
72
+ throw new Error("Invalid private key, must be in range 1 < key < order");
73
+ let R = Q.mul(d);
74
+ if (withCofactor)
75
+ R = R.mul(curve.parameters.cofactor);
76
+ if (R.isZero())
77
+ throw new Error(`Invalid parameters, shared secret is point at infinity`);
78
+ return Field.toBytes(curve.toExternalField(R.x), lengths.fieldByteLength);
79
+ };
52
80
  const keygen = (isCompressed = false) => {
53
81
  const secretKey = randomPrivateKey();
54
82
  const publicKey = getPublicKey(secretKey, isCompressed);
@@ -56,6 +84,7 @@ export const dstu4145 = (parameters) => {
56
84
  };
57
85
  return Object.freeze({
58
86
  getPublicKey,
87
+ getSharedSecret,
59
88
  sign,
60
89
  verify,
61
90
  keygen,
package/dstu9041/curve.js CHANGED
@@ -2,27 +2,30 @@ import { Field, mod } from "@noble/curves/abstract/modular.js";
2
2
  import { bitGet, bitLen, bytesToNumberBE, randomBytes } from "@noble/curves/utils.js";
3
3
  import { concatBytes } from "@noble/hashes/utils.js";
4
4
  export const dstu9041Curve = (parameters) => {
5
+ if (parameters.a != 2n)
6
+ throw new Error("Unsuppored `a` parameter, must be 2");
5
7
  if (mod(parameters.p, 8n) != 5n)
6
8
  throw new Error("Unsupported `p` prime");
7
9
  const Fp = Field(parameters.p), Fn = Field(parameters.n);
10
+ const { a, d, Gx, Gy } = parameters;
8
11
  const isValidXY = (x, y) => {
9
12
  const x2 = Fp.sqr(x);
10
13
  const y2 = Fp.sqr(y);
11
- const left = Fp.add(x2, Fp.mul(parameters.a, y2));
12
- const right = Fp.add(Fp.ONE, Fp.mul(parameters.d, Fp.mul(x2, y2)));
14
+ const left = Fp.add(x2, Fp.mul(a, y2));
15
+ const right = Fp.add(Fp.ONE, Fp.mul(d, Fp.mul(x2, y2)));
13
16
  return Fp.eql(left, right);
14
17
  };
15
- if (!isValidXY(parameters.Gx, parameters.Gy))
18
+ if (!isValidXY(Gx, Gy))
16
19
  throw new Error("Invalid base point");
17
20
  const p_minus_1 = Fp.sub(Fp.ZERO, Fp.ONE);
18
21
  const p_minus_1_over_2 = Fp.div(Fp.sub(Fp.ORDER, Fp.ONE), 2n);
19
- const a_over_d = Fp.div(parameters.a, parameters.d);
22
+ const a_over_d = Fp.div(a, d);
20
23
  class Point {
21
24
  X;
22
25
  Y;
23
26
  Z;
24
- static BASE = Point.fromAffine(parameters.Gx, parameters.Gy);
25
- static ZERO = Point.fromAffine(1n, 0n);
27
+ static BASE = new Point(Gx, Gy, Fp.ONE);
28
+ static ZERO = new Point(Fp.ONE, Fp.ZERO, Fp.ONE);
26
29
  static Fp = Fp;
27
30
  static Fn = Fn;
28
31
  constructor(X, Y, Z) {
@@ -42,13 +45,13 @@ export const dstu9041Curve = (parameters) => {
42
45
  const B = Fp.sqr(A);
43
46
  const C = Fp.mul(this.X, other.X);
44
47
  const D = Fp.mul(this.Y, other.Y);
45
- const E = Fp.mul(parameters.d, Fp.mul(C, D));
48
+ const E = Fp.mul(d, Fp.mul(C, D));
46
49
  const F = Fp.sub(B, E);
47
50
  const G = Fp.add(B, E);
48
51
  const self_sum = Fp.add(this.X, this.Y);
49
52
  const other_sum = Fp.add(other.X, other.Y);
50
53
  const cross = Fp.mul(self_sum, other_sum);
51
- const xr = Fp.mul(Fp.mul(A, G), Fp.sub(C, Fp.mul(parameters.a, D)));
54
+ const xr = Fp.mul(Fp.mul(A, G), Fp.sub(C, Fp.mul(a, D)));
52
55
  const yr = Fp.mul(Fp.mul(A, F), Fp.sub(Fp.sub(cross, C), D));
53
56
  const zr = Fp.mul(F, G);
54
57
  return new Point(xr, yr, zr);
@@ -59,7 +62,7 @@ export const dstu9041Curve = (parameters) => {
59
62
  let S = new Point(this.X, this.Y, this.Z);
60
63
  for (let i = bitLen(scalar) - 2; i >= 0; i--) {
61
64
  S = S.add(S);
62
- if (bitGet(scalar, i) == 1n)
65
+ if (bitGet(scalar, i) == Fp.ONE)
63
66
  S = S.add(this);
64
67
  }
65
68
  return S;
@@ -91,7 +94,7 @@ export const dstu9041Curve = (parameters) => {
91
94
  Fp.eql(x2, a_over_d))
92
95
  throw new Error("Invalid x-coordinate, can't recover y");
93
96
  const num = Fp.sub(Fp.ONE, x2);
94
- const denom = Fp.sub(parameters.a, Fp.mul(parameters.d, x2));
97
+ const denom = Fp.sub(a, Fp.mul(d, x2));
95
98
  const v = Fp.div(num, denom);
96
99
  if (Fp.pow(v, p_minus_1_over_2) != Fp.ONE)
97
100
  throw new Error("Invalid x-coordinate, non-complience with euler criterion");
@@ -6,7 +6,7 @@ export declare const dstu9041_256: Readonly<{
6
6
  secretKey: TRet<Uint8Array>;
7
7
  publicKey: TRet<Uint8Array>;
8
8
  };
9
- encrypt: (message: TArg<Uint8Array>, publicKey: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
9
+ encrypt: (plaintext: TArg<Uint8Array>, publicKey: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
10
10
  decrypt: (ciphertext: TArg<Uint8Array>, privateKey: TArg<Uint8Array>) => TRet<Uint8Array>;
11
11
  }>;
12
12
  /** DSTU 9041:2020 (512 bit) */
@@ -16,6 +16,6 @@ export declare const dstu9041_512: Readonly<{
16
16
  secretKey: TRet<Uint8Array>;
17
17
  publicKey: TRet<Uint8Array>;
18
18
  };
19
- encrypt: (message: TArg<Uint8Array>, publicKey: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
19
+ encrypt: (plaintext: TArg<Uint8Array>, publicKey: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
20
20
  decrypt: (ciphertext: TArg<Uint8Array>, privateKey: TArg<Uint8Array>) => TRet<Uint8Array>;
21
21
  }>;