@li0ard/dstu 0.1.7 → 0.1.9

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 (45) hide show
  1. package/README.md +6 -2
  2. package/dstu4145/const.d.ts +2 -0
  3. package/dstu4145/const.js +42 -15
  4. package/dstu4145/ec/expand.d.ts +4 -3
  5. package/dstu4145/ec/expand.js +1 -2
  6. package/dstu4145/ec/index.js +1 -2
  7. package/dstu4145/ec/wnaf.d.ts +2 -1
  8. package/dstu4145/ecies.d.ts +82 -0
  9. package/dstu4145/ecies.js +62 -0
  10. package/dstu4145/{ec/math.d.ts → gf2m/index.d.ts} +1 -0
  11. package/dstu4145/gf2m/index.js +78 -0
  12. package/dstu4145/{ec → gf2m}/onb.js +31 -17
  13. package/dstu4145/gf2m/utils.d.ts +10 -0
  14. package/dstu4145/gf2m/utils.js +262 -0
  15. package/dstu4145/index.d.ts +23 -177
  16. package/dstu4145/index.js +37 -20
  17. package/dstu9041/curve.d.ts +4 -12
  18. package/dstu9041/curve.js +4 -3
  19. package/dstu9041/index.d.ts +2 -8
  20. package/dstu9041/index.js +2 -3
  21. package/dstu9311/hash.d.ts +10 -3
  22. package/dstu9311/hash.js +10 -3
  23. package/iso15946.d.ts +3 -0
  24. package/iso15946.js +49 -0
  25. package/kalyna/index.d.ts +2 -1
  26. package/kalyna/index.js +23 -28
  27. package/keywrap.d.ts +3 -3
  28. package/keywrap.js +21 -16
  29. package/modes/ccm.d.ts +4 -0
  30. package/modes/ccm.js +47 -0
  31. package/modes/gcm.d.ts +1 -1
  32. package/modes/gcm.js +1 -2
  33. package/modes/gmac.js +1 -2
  34. package/modes/index.d.ts +1 -0
  35. package/modes/index.js +1 -0
  36. package/modes/kw.d.ts +2 -6
  37. package/modes/xts.d.ts +2 -6
  38. package/modes/xts.js +2 -2
  39. package/package.json +6 -6
  40. package/strumok/index.d.ts +2 -1
  41. package/types.d.ts +77 -0
  42. package/utils.d.ts +1 -0
  43. package/utils.js +2 -2
  44. package/dstu4145/ec/math.js +0 -206
  45. /package/dstu4145/{ec → gf2m}/onb.d.ts +0 -0
@@ -0,0 +1,262 @@
1
+ import BN from "bn.js";
2
+ export const SQR_PRECOMP = new Uint16Array([
3
+ 0x0000, 0x0001, 0x0004, 0x0005, 0x0010, 0x0011, 0x0014, 0x0015,
4
+ 0x0040, 0x0041, 0x0044, 0x0045, 0x0050, 0x0051, 0x0054, 0x0055,
5
+ 0x0100, 0x0101, 0x0104, 0x0105, 0x0110, 0x0111, 0x0114, 0x0115,
6
+ 0x0140, 0x0141, 0x0144, 0x0145, 0x0150, 0x0151, 0x0154, 0x0155,
7
+ 0x0400, 0x0401, 0x0404, 0x0405, 0x0410, 0x0411, 0x0414, 0x0415,
8
+ 0x0440, 0x0441, 0x0444, 0x0445, 0x0450, 0x0451, 0x0454, 0x0455,
9
+ 0x0500, 0x0501, 0x0504, 0x0505, 0x0510, 0x0511, 0x0514, 0x0515,
10
+ 0x0540, 0x0541, 0x0544, 0x0545, 0x0550, 0x0551, 0x0554, 0x0555,
11
+ 0x1000, 0x1001, 0x1004, 0x1005, 0x1010, 0x1011, 0x1014, 0x1015,
12
+ 0x1040, 0x1041, 0x1044, 0x1045, 0x1050, 0x1051, 0x1054, 0x1055,
13
+ 0x1100, 0x1101, 0x1104, 0x1105, 0x1110, 0x1111, 0x1114, 0x1115,
14
+ 0x1140, 0x1141, 0x1144, 0x1145, 0x1150, 0x1151, 0x1154, 0x1155,
15
+ 0x1400, 0x1401, 0x1404, 0x1405, 0x1410, 0x1411, 0x1414, 0x1415,
16
+ 0x1440, 0x1441, 0x1444, 0x1445, 0x1450, 0x1451, 0x1454, 0x1455,
17
+ 0x1500, 0x1501, 0x1504, 0x1505, 0x1510, 0x1511, 0x1514, 0x1515,
18
+ 0x1540, 0x1541, 0x1544, 0x1545, 0x1550, 0x1551, 0x1554, 0x1555,
19
+ 0x4000, 0x4001, 0x4004, 0x4005, 0x4010, 0x4011, 0x4014, 0x4015,
20
+ 0x4040, 0x4041, 0x4044, 0x4045, 0x4050, 0x4051, 0x4054, 0x4055,
21
+ 0x4100, 0x4101, 0x4104, 0x4105, 0x4110, 0x4111, 0x4114, 0x4115,
22
+ 0x4140, 0x4141, 0x4144, 0x4145, 0x4150, 0x4151, 0x4154, 0x4155,
23
+ 0x4400, 0x4401, 0x4404, 0x4405, 0x4410, 0x4411, 0x4414, 0x4415,
24
+ 0x4440, 0x4441, 0x4444, 0x4445, 0x4450, 0x4451, 0x4454, 0x4455,
25
+ 0x4500, 0x4501, 0x4504, 0x4505, 0x4510, 0x4511, 0x4514, 0x4515,
26
+ 0x4540, 0x4541, 0x4544, 0x4545, 0x4550, 0x4551, 0x4554, 0x4555,
27
+ 0x5000, 0x5001, 0x5004, 0x5005, 0x5010, 0x5011, 0x5014, 0x5015,
28
+ 0x5040, 0x5041, 0x5044, 0x5045, 0x5050, 0x5051, 0x5054, 0x5055,
29
+ 0x5100, 0x5101, 0x5104, 0x5105, 0x5110, 0x5111, 0x5114, 0x5115,
30
+ 0x5140, 0x5141, 0x5144, 0x5145, 0x5150, 0x5151, 0x5154, 0x5155,
31
+ 0x5400, 0x5401, 0x5404, 0x5405, 0x5410, 0x5411, 0x5414, 0x5415,
32
+ 0x5440, 0x5441, 0x5444, 0x5445, 0x5450, 0x5451, 0x5454, 0x5455,
33
+ 0x5500, 0x5501, 0x5504, 0x5505, 0x5510, 0x5511, 0x5514, 0x5515,
34
+ 0x5540, 0x5541, 0x5544, 0x5545, 0x5550, 0x5551, 0x5554, 0x5555
35
+ ]);
36
+ export const WORD_BITS = 32;
37
+ const numWordsFor = (x) => Math.max(1, Math.ceil(Math.max(x.bitLength(), 1) / WORD_BITS));
38
+ export const bn2LE = (x, numWords = numWordsFor(x)) => {
39
+ const arr = new Uint32Array(numWords);
40
+ const bytes = x.toArray("le");
41
+ for (let i = 0; i < bytes.length; i++)
42
+ arr[i >> 2] |= bytes[i] << ((i & 3) * 8);
43
+ return arr;
44
+ };
45
+ export const le2BN = (arr) => {
46
+ const bytes = new Uint8Array(arr.length * 4);
47
+ for (let i = 0; i < arr.length; i++) {
48
+ const w = arr[i];
49
+ bytes[i * 4] = w & 0xff;
50
+ bytes[i * 4 + 1] = (w >>> 8) & 0xff;
51
+ bytes[i * 4 + 2] = (w >>> 16) & 0xff;
52
+ bytes[i * 4 + 3] = (w >>> 24) & 0xff;
53
+ }
54
+ return new BN(bytes, "le");
55
+ };
56
+ const wBitLen = (words) => {
57
+ let nz = words.length - 1;
58
+ while (nz >= 0 && words[nz] === 0)
59
+ nz--;
60
+ if (nz < 0)
61
+ return 0;
62
+ let x = words[nz], r = 1, t;
63
+ if ((t = x >>> 16) !== 0) {
64
+ x = t;
65
+ r += 16;
66
+ }
67
+ if ((t = x >> 8) !== 0) {
68
+ x = t;
69
+ r += 8;
70
+ }
71
+ if ((t = x >> 4) !== 0) {
72
+ x = t;
73
+ r += 4;
74
+ }
75
+ if ((t = x >> 2) !== 0) {
76
+ x = t;
77
+ r += 2;
78
+ }
79
+ if ((t = x >> 1) !== 0) {
80
+ x = t;
81
+ r += 1;
82
+ }
83
+ return r + nz * WORD_BITS;
84
+ };
85
+ const mul_1x1 = (offset, a, b, dst) => {
86
+ const a1 = a & 0x3fffffff, a2 = a1 << 1, a4 = a2 << 1, tab = [0, a1, a2, a1 ^ a2, a4, a1 ^ a4, a2 ^ a4, a1 ^ a2 ^ a4];
87
+ let s = tab[b & 0x7], l = s;
88
+ s = tab[(b >>> 3) & 0x7];
89
+ l ^= s << 3;
90
+ let h = s >>> 29;
91
+ s = tab[(b >>> 6) & 0x7];
92
+ l ^= s << 6;
93
+ h ^= s >>> 26;
94
+ s = tab[(b >>> 9) & 0x7];
95
+ l ^= s << 9;
96
+ h ^= s >>> 23;
97
+ s = tab[(b >>> 12) & 0x7];
98
+ l ^= s << 12;
99
+ h ^= s >>> 20;
100
+ s = tab[(b >>> 15) & 0x7];
101
+ l ^= s << 15;
102
+ h ^= s >>> 17;
103
+ s = tab[(b >>> 18) & 0x7];
104
+ l ^= s << 18;
105
+ h ^= s >>> 14;
106
+ s = tab[(b >>> 21) & 0x7];
107
+ l ^= s << 21;
108
+ h ^= s >>> 11;
109
+ s = tab[(b >>> 24) & 0x7];
110
+ l ^= s << 24;
111
+ h ^= s >>> 8;
112
+ s = tab[(b >>> 27) & 0x7];
113
+ l ^= s << 27;
114
+ h ^= s >>> 5;
115
+ s = tab[b >>> 30];
116
+ l ^= s << 30;
117
+ h ^= s >>> 2;
118
+ const t2b = a >>> 30;
119
+ if (t2b & 1) {
120
+ l ^= b << 30;
121
+ h ^= b >>> 2;
122
+ }
123
+ if (t2b & 2) {
124
+ l ^= b << 31;
125
+ h ^= b >>> 1;
126
+ }
127
+ dst[offset + 1] = h;
128
+ dst[offset] = l;
129
+ };
130
+ const mul_2x2 = (a1, a0, b1, b0, dst) => {
131
+ mul_1x1(2, a1, b1, dst);
132
+ mul_1x1(0, a0, b0, dst);
133
+ mul_1x1(4, a0 ^ a1, b0 ^ b1, dst);
134
+ dst[2] ^= dst[5] ^ dst[1] ^ dst[3];
135
+ dst[1] = dst[3] ^ dst[2] ^ dst[0] ^ dst[4] ^ dst[5];
136
+ dst[4] = 0;
137
+ dst[5] = 0;
138
+ };
139
+ export const mulWords = (a, b) => {
140
+ const out = new Uint32Array(a.length + b.length), x22 = new Uint32Array(6);
141
+ for (let j = 0; j < b.length; j += 2) {
142
+ const y0 = b[j], y1 = j + 1 === b.length ? 0 : b[j + 1];
143
+ if (y0 === 0 && y1 === 0)
144
+ continue;
145
+ for (let i = 0; i < a.length; i += 2) {
146
+ const x0 = a[i], x1 = i + 1 === a.length ? 0 : a[i + 1];
147
+ if (x0 === 0 && x1 === 0)
148
+ continue;
149
+ mul_2x2(x1, x0, y1, y0, x22);
150
+ out[j + i] ^= x22[0];
151
+ out[j + i + 1] ^= x22[1];
152
+ out[j + i + 2] ^= x22[2];
153
+ out[j + i + 3] ^= x22[3];
154
+ }
155
+ }
156
+ return out;
157
+ };
158
+ export const sqrWords = (xw) => {
159
+ const out = new Uint32Array(xw.length * 2);
160
+ for (let j = 0; j < xw.length; j++) {
161
+ const w = xw[j];
162
+ if (w === 0)
163
+ continue;
164
+ const b0 = w & 0xff, b1 = (w >>> 8) & 0xff, b2 = (w >>> 16) & 0xff, b3 = (w >>> 24) & 0xff;
165
+ out[2 * j] = SQR_PRECOMP[b0] | (SQR_PRECOMP[b1] << 16);
166
+ out[2 * j + 1] = SQR_PRECOMP[b2] | (SQR_PRECOMP[b3] << 16);
167
+ }
168
+ return out;
169
+ };
170
+ export const modWords = (a, poly) => {
171
+ const dN = Math.floor(poly[0] / WORD_BITS), len = Math.max(a.length, dN + 1), res = new Uint32Array(len);
172
+ res.set(a);
173
+ let j = len - 1;
174
+ while (j > dN) {
175
+ const zz = res[j];
176
+ if (zz === 0) {
177
+ j--;
178
+ continue;
179
+ }
180
+ res[j] = 0;
181
+ for (let k = 1; poly[k]; k++) {
182
+ let n = poly[0] - poly[k];
183
+ const d0 = n % WORD_BITS;
184
+ n = Math.floor(n / WORD_BITS);
185
+ res[j - n] ^= zz >>> d0;
186
+ if (d0)
187
+ res[j - n - 1] ^= zz << (WORD_BITS - d0);
188
+ }
189
+ const d0m = poly[0] % WORD_BITS;
190
+ res[j - dN] ^= zz >>> d0m;
191
+ if (d0m)
192
+ res[j - dN - 1] ^= zz << (WORD_BITS - d0m);
193
+ }
194
+ while (j === dN) {
195
+ const d0 = poly[0] % WORD_BITS, zz = res[dN] >>> d0;
196
+ if (zz === 0)
197
+ break;
198
+ const d1 = WORD_BITS - d0;
199
+ res[dN] = d0 ? (res[dN] << d1) >>> d1 : 0;
200
+ res[0] ^= zz;
201
+ for (let k = 1; poly[k]; k++) {
202
+ const n = Math.floor(poly[k] / WORD_BITS), dd0 = poly[k] % WORD_BITS, dd1 = WORD_BITS - dd0;
203
+ res[n] ^= zz << dd0;
204
+ const carry = zz >>> dd1;
205
+ if (dd0 && carry)
206
+ res[n + 1] ^= carry;
207
+ }
208
+ }
209
+ return res;
210
+ };
211
+ export const invWords = (a, poly) => {
212
+ const len = a.length;
213
+ let uu = new Uint32Array(len), vv = new Uint32Array(len), bb = new Uint32Array(len), cc = new Uint32Array(len);
214
+ bb[0] = 1;
215
+ uu.set(a);
216
+ vv.set(poly);
217
+ let ubits = wBitLen(uu), vbits = wBitLen(vv);
218
+ if (ubits === 0)
219
+ throw new Error("Element is 0, there's no inverse");
220
+ let iter = 100000;
221
+ while (true) {
222
+ if (--iter <= 0)
223
+ throw new Error("Failed to converge");
224
+ while (ubits && !(uu[0] & 1)) {
225
+ let u0 = uu[0], b0 = bb[0];
226
+ const mask = (b0 & 1) ? 0xffffffff : 0;
227
+ b0 ^= poly[0] & mask;
228
+ let idx = 0;
229
+ for (; idx < len - 1; idx++) {
230
+ const u1 = uu[idx + 1];
231
+ uu[idx] = (u0 >>> 1) | (u1 << 31);
232
+ u0 = u1;
233
+ const b1 = bb[idx + 1] ^ (poly[idx + 1] & mask);
234
+ bb[idx] = (b0 >>> 1) | (b1 << 31);
235
+ b0 = b1;
236
+ }
237
+ uu[idx] = u0 >>> 1;
238
+ bb[idx] = b0 >>> 1;
239
+ ubits--;
240
+ }
241
+ if (ubits <= 32 && uu[0] === 1)
242
+ break;
243
+ if (ubits < vbits) {
244
+ let t = ubits;
245
+ ubits = vbits;
246
+ vbits = t;
247
+ let tw = uu;
248
+ uu = vv;
249
+ vv = tw;
250
+ tw = bb;
251
+ bb = cc;
252
+ cc = tw;
253
+ }
254
+ for (let idx = 0; idx < len; idx++) {
255
+ uu[idx] ^= vv[idx];
256
+ bb[idx] ^= cc[idx];
257
+ }
258
+ if (ubits === vbits)
259
+ ubits = wBitLen(uu);
260
+ }
261
+ return bb;
262
+ };
@@ -1,191 +1,37 @@
1
- import { type TArg, type TRet } from "@noble/hashes/utils.js";
2
1
  import { type DSTUParameters } from "./const.js";
2
+ import type { ECDSA } from "../types.js";
3
3
  /** Create DSTU 4145-2002 signer (Big-Endian) */
4
- export declare const dstu4145: (parameters: DSTUParameters) => Readonly<{
5
- getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
6
- getSharedSecret: (secretKeyA: TArg<Uint8Array>, publicKeyB: TArg<Uint8Array>, withCofactor?: boolean) => TRet<Uint8Array>;
7
- sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
8
- verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
9
- keygen: (isCompressed?: boolean) => {
10
- secretKey: TRet<Uint8Array>;
11
- publicKey: TRet<Uint8Array>;
12
- };
13
- lengths: Readonly<{
14
- fieldByteLength: number;
15
- pointByteLength: number;
16
- scalarByteLength: number;
17
- signatureByteLength: number;
18
- }>;
19
- }>;
4
+ export declare const dstu4145: (parameters: DSTUParameters) => ECDSA;
5
+ /**
6
+ * Create DSTU 4145-2002 signer (Little-Endian)
7
+ *
8
+ * **NOTE:** Parameters MUST be in Big-Endian
9
+ */
10
+ export declare const dstu4145_le: (parameters: DSTUParameters) => ECDSA;
20
11
  export * from "./const.js";
21
12
  export * from "./ec/expand.js";
13
+ export * from "./ecies.js";
22
14
  /** DSTU 4145-2002 163 bit curve */
23
- export declare const dstu163: Readonly<{
24
- getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
25
- getSharedSecret: (secretKeyA: TArg<Uint8Array>, publicKeyB: TArg<Uint8Array>, withCofactor?: boolean) => TRet<Uint8Array>;
26
- sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
27
- verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
28
- keygen: (isCompressed?: boolean) => {
29
- secretKey: TRet<Uint8Array>;
30
- publicKey: TRet<Uint8Array>;
31
- };
32
- lengths: Readonly<{
33
- fieldByteLength: number;
34
- pointByteLength: number;
35
- scalarByteLength: number;
36
- signatureByteLength: number;
37
- }>;
38
- }>;
15
+ export declare const dstu163: ECDSA;
39
16
  /** DSTU 4145-2002 167 bit curve */
40
- export declare const dstu167: Readonly<{
41
- getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
42
- getSharedSecret: (secretKeyA: TArg<Uint8Array>, publicKeyB: TArg<Uint8Array>, withCofactor?: boolean) => TRet<Uint8Array>;
43
- sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
44
- verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
45
- keygen: (isCompressed?: boolean) => {
46
- secretKey: TRet<Uint8Array>;
47
- publicKey: TRet<Uint8Array>;
48
- };
49
- lengths: Readonly<{
50
- fieldByteLength: number;
51
- pointByteLength: number;
52
- scalarByteLength: number;
53
- signatureByteLength: number;
54
- }>;
55
- }>;
17
+ export declare const dstu167: ECDSA;
56
18
  /** DSTU 4145-2002 173 bit curve */
57
- export declare const dstu173: Readonly<{
58
- getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
59
- getSharedSecret: (secretKeyA: TArg<Uint8Array>, publicKeyB: TArg<Uint8Array>, withCofactor?: boolean) => TRet<Uint8Array>;
60
- sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
61
- verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
62
- keygen: (isCompressed?: boolean) => {
63
- secretKey: TRet<Uint8Array>;
64
- publicKey: TRet<Uint8Array>;
65
- };
66
- lengths: Readonly<{
67
- fieldByteLength: number;
68
- pointByteLength: number;
69
- scalarByteLength: number;
70
- signatureByteLength: number;
71
- }>;
72
- }>;
19
+ export declare const dstu173: ECDSA;
73
20
  /** DSTU 4145-2002 179 bit curve */
74
- export declare const dstu179: Readonly<{
75
- getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
76
- getSharedSecret: (secretKeyA: TArg<Uint8Array>, publicKeyB: TArg<Uint8Array>, withCofactor?: boolean) => TRet<Uint8Array>;
77
- sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
78
- verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
79
- keygen: (isCompressed?: boolean) => {
80
- secretKey: TRet<Uint8Array>;
81
- publicKey: TRet<Uint8Array>;
82
- };
83
- lengths: Readonly<{
84
- fieldByteLength: number;
85
- pointByteLength: number;
86
- scalarByteLength: number;
87
- signatureByteLength: number;
88
- }>;
89
- }>;
21
+ export declare const dstu179: ECDSA;
90
22
  /** DSTU 4145-2002 191 bit curve */
91
- export declare const dstu191: Readonly<{
92
- getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
93
- getSharedSecret: (secretKeyA: TArg<Uint8Array>, publicKeyB: TArg<Uint8Array>, withCofactor?: boolean) => TRet<Uint8Array>;
94
- sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
95
- verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
96
- keygen: (isCompressed?: boolean) => {
97
- secretKey: TRet<Uint8Array>;
98
- publicKey: TRet<Uint8Array>;
99
- };
100
- lengths: Readonly<{
101
- fieldByteLength: number;
102
- pointByteLength: number;
103
- scalarByteLength: number;
104
- signatureByteLength: number;
105
- }>;
106
- }>;
23
+ export declare const dstu191: ECDSA;
107
24
  /** DSTU 4145-2002 233 bit curve */
108
- export declare const dstu233: Readonly<{
109
- getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
110
- getSharedSecret: (secretKeyA: TArg<Uint8Array>, publicKeyB: TArg<Uint8Array>, withCofactor?: boolean) => TRet<Uint8Array>;
111
- sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
112
- verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
113
- keygen: (isCompressed?: boolean) => {
114
- secretKey: TRet<Uint8Array>;
115
- publicKey: TRet<Uint8Array>;
116
- };
117
- lengths: Readonly<{
118
- fieldByteLength: number;
119
- pointByteLength: number;
120
- scalarByteLength: number;
121
- signatureByteLength: number;
122
- }>;
123
- }>;
25
+ export declare const dstu233: ECDSA;
124
26
  /** DSTU 4145-2002 257 bit curve */
125
- export declare const dstu257: Readonly<{
126
- getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
127
- getSharedSecret: (secretKeyA: TArg<Uint8Array>, publicKeyB: TArg<Uint8Array>, withCofactor?: boolean) => TRet<Uint8Array>;
128
- sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
129
- verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
130
- keygen: (isCompressed?: boolean) => {
131
- secretKey: TRet<Uint8Array>;
132
- publicKey: TRet<Uint8Array>;
133
- };
134
- lengths: Readonly<{
135
- fieldByteLength: number;
136
- pointByteLength: number;
137
- scalarByteLength: number;
138
- signatureByteLength: number;
139
- }>;
140
- }>;
27
+ export declare const dstu257: ECDSA;
28
+ /** DSTU 4145-2002 257 bit curve (LE) */
29
+ export declare const dstu257_le: ECDSA;
141
30
  /** DSTU 4145-2002 307 bit curve */
142
- export declare const dstu307: Readonly<{
143
- getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
144
- getSharedSecret: (secretKeyA: TArg<Uint8Array>, publicKeyB: TArg<Uint8Array>, withCofactor?: boolean) => TRet<Uint8Array>;
145
- sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
146
- verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
147
- keygen: (isCompressed?: boolean) => {
148
- secretKey: TRet<Uint8Array>;
149
- publicKey: TRet<Uint8Array>;
150
- };
151
- lengths: Readonly<{
152
- fieldByteLength: number;
153
- pointByteLength: number;
154
- scalarByteLength: number;
155
- signatureByteLength: number;
156
- }>;
157
- }>;
31
+ export declare const dstu307: ECDSA;
158
32
  /** DSTU 4145-2002 367 bit curve */
159
- export declare const dstu367: Readonly<{
160
- getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
161
- getSharedSecret: (secretKeyA: TArg<Uint8Array>, publicKeyB: TArg<Uint8Array>, withCofactor?: boolean) => TRet<Uint8Array>;
162
- sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
163
- verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
164
- keygen: (isCompressed?: boolean) => {
165
- secretKey: TRet<Uint8Array>;
166
- publicKey: TRet<Uint8Array>;
167
- };
168
- lengths: Readonly<{
169
- fieldByteLength: number;
170
- pointByteLength: number;
171
- scalarByteLength: number;
172
- signatureByteLength: number;
173
- }>;
174
- }>;
33
+ export declare const dstu367: ECDSA;
175
34
  /** DSTU 4145-2002 431 bit curve */
176
- export declare const dstu431: Readonly<{
177
- getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
178
- getSharedSecret: (secretKeyA: TArg<Uint8Array>, publicKeyB: TArg<Uint8Array>, withCofactor?: boolean) => TRet<Uint8Array>;
179
- sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
180
- verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
181
- keygen: (isCompressed?: boolean) => {
182
- secretKey: TRet<Uint8Array>;
183
- publicKey: TRet<Uint8Array>;
184
- };
185
- lengths: Readonly<{
186
- fieldByteLength: number;
187
- pointByteLength: number;
188
- scalarByteLength: number;
189
- signatureByteLength: number;
190
- }>;
191
- }>;
35
+ export declare const dstu431: ECDSA;
36
+ /** DSTU 4145-2002 431 bit curve (LE) */
37
+ export declare const dstu431_le: ECDSA;
package/dstu4145/index.js CHANGED
@@ -2,22 +2,13 @@ import { concatBytes, randomBytes } from "@noble/hashes/utils.js";
2
2
  import { DSTU_163, DSTU_167, DSTU_173, DSTU_179, DSTU_191, DSTU_233, DSTU_257, DSTU_307, DSTU_367, DSTU_431 } from "./const.js";
3
3
  import { binaryWeierstrass } from "./ec/index.js";
4
4
  import BN from "bn.js";
5
+ import { reverseBytes } from "../utils.js";
5
6
  /** Create DSTU 4145-2002 signer (Big-Endian) */
6
7
  export const dstu4145 = (parameters) => {
7
8
  const curve = binaryWeierstrass(parameters);
8
9
  const { Field, Point, MASK, lengths } = curve;
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);
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
- */
10
+ const getPublicKey = (secretKey, isCompressed = true) => Point.BASE.mul(Field.fromHexStringOrBytes(secretKey)).negate().toBytes(isCompressed);
11
+ /** Computes presign (ephermeral keypair) */
21
12
  const computePresign = (rand) => {
22
13
  const e = new BN(rand ?? randomBytes(lengths.scalarByteLength)).imaskn(MASK);
23
14
  if (rand && e.isZero())
@@ -36,7 +27,6 @@ export const dstu4145 = (parameters) => {
36
27
  h = new BN(1);
37
28
  return h;
38
29
  };
39
- /** Signs a message hash with a secret key. */
40
30
  const sign = (secretKey, digest, rand) => {
41
31
  const d = new BN(secretKey), h = prepareHash(digest), { Fe, e } = computePresign(rand);
42
32
  if (d.isZero() || d.gte(curve.ORDER))
@@ -49,7 +39,6 @@ export const dstu4145 = (parameters) => {
49
39
  return sign(secretKey, digest, rand);
50
40
  return concatBytes(Field.toBytes(s, lengths.scalarByteLength), Field.toBytes(r, lengths.scalarByteLength));
51
41
  };
52
- /** Verifies a signature against message hash and public key. */
53
42
  const verify = (publicKey, digest, signature) => {
54
43
  if (signature.length != lengths.signatureByteLength)
55
44
  throw new Error("Invalid signature length");
@@ -62,10 +51,6 @@ export const dstu4145 = (parameters) => {
62
51
  const y = curve.toExternalField(Field.mul(h, R.x)).imaskn(MASK);
63
52
  return y.eq(r);
64
53
  };
65
- /**
66
- * Computes shared secret key
67
- * @param withCofactor Multiply result by curve cofactor? (default - `true`)
68
- */
69
54
  const getSharedSecret = (secretKeyA, publicKeyB, withCofactor = true) => {
70
55
  const d = new BN(secretKeyA), Q = Point.fromBytes(publicKeyB);
71
56
  if (d.isZero() || d.gte(curve.ORDER))
@@ -77,8 +62,8 @@ export const dstu4145 = (parameters) => {
77
62
  throw new Error(`Invalid parameters, shared secret is point at infinity`);
78
63
  return Field.toBytes(curve.toExternalField(R.x), lengths.fieldByteLength);
79
64
  };
80
- const keygen = (isCompressed = false) => {
81
- const secretKey = randomPrivateKey();
65
+ const keygen = (isCompressed = true) => {
66
+ const secretKey = Field.toBytes(new BN(randomBytes(lengths.scalarByteLength)).imaskn(MASK), lengths.scalarByteLength);
82
67
  const publicKey = getPublicKey(secretKey, isCompressed);
83
68
  return { secretKey, publicKey };
84
69
  };
@@ -91,8 +76,36 @@ export const dstu4145 = (parameters) => {
91
76
  lengths
92
77
  });
93
78
  };
79
+ /**
80
+ * Create DSTU 4145-2002 signer (Little-Endian)
81
+ *
82
+ * **NOTE:** Parameters MUST be in Big-Endian
83
+ */
84
+ export const dstu4145_le = (parameters) => {
85
+ const signer = dstu4145(parameters);
86
+ const getPublicKey = (secretKey, isCompressed = true) => reverseBytes(signer.getPublicKey(reverseBytes(secretKey), isCompressed));
87
+ const sign = (secretKey, digest, rand) => reverseBytes(signer.sign(reverseBytes(secretKey), reverseBytes(digest), rand ? reverseBytes(rand) : undefined));
88
+ const verify = (publicKey, digest, signature) => signer.verify(reverseBytes(publicKey), reverseBytes(digest), reverseBytes(signature));
89
+ const getSharedSecret = (secretKeyA, publicKeyB, withCofactor = true) => reverseBytes(signer.getSharedSecret(reverseBytes(secretKeyA), reverseBytes(publicKeyB), withCofactor));
90
+ const keygen = (isCompressed = true) => {
91
+ const { secretKey, publicKey } = signer.keygen(isCompressed);
92
+ return {
93
+ secretKey: reverseBytes(secretKey),
94
+ publicKey: reverseBytes(publicKey)
95
+ };
96
+ };
97
+ return Object.freeze({
98
+ getPublicKey,
99
+ getSharedSecret,
100
+ sign,
101
+ verify,
102
+ keygen,
103
+ lengths: signer.lengths
104
+ });
105
+ };
94
106
  export * from "./const.js";
95
107
  export * from "./ec/expand.js";
108
+ export * from "./ecies.js";
96
109
  // ONB curves don't preinitialized because `multiplyOnb` is slow O(m^3) function
97
110
  // You need to initialize them manually via `dstu4145`
98
111
  /** DSTU 4145-2002 163 bit curve */
@@ -109,9 +122,13 @@ export const dstu191 = dstu4145(DSTU_191);
109
122
  export const dstu233 = dstu4145(DSTU_233);
110
123
  /** DSTU 4145-2002 257 bit curve */
111
124
  export const dstu257 = dstu4145(DSTU_257);
125
+ /** DSTU 4145-2002 257 bit curve (LE) */
126
+ export const dstu257_le = dstu4145_le(DSTU_257);
112
127
  /** DSTU 4145-2002 307 bit curve */
113
128
  export const dstu307 = dstu4145(DSTU_307);
114
129
  /** DSTU 4145-2002 367 bit curve */
115
130
  export const dstu367 = dstu4145(DSTU_367);
116
131
  /** DSTU 4145-2002 431 bit curve */
117
132
  export const dstu431 = dstu4145(DSTU_431);
133
+ /** DSTU 4145-2002 431 bit curve (LE) */
134
+ export const dstu431_le = dstu4145_le(DSTU_431);
@@ -1,5 +1,6 @@
1
1
  import type { EdwardsOpts } from "@noble/curves/abstract/edwards.js";
2
2
  import { type TArg, type TRet } from "@noble/curves/utils.js";
3
+ import type { KeyPair } from "../types";
3
4
  export declare const dstu9041Curve: (parameters: EdwardsOpts) => Readonly<{
4
5
  Point: {
5
6
  new (X: bigint, Y: bigint, Z: bigint): {
@@ -138,10 +139,7 @@ export declare const dstu9041Curve: (parameters: EdwardsOpts) => Readonly<{
138
139
  };
139
140
  };
140
141
  getPublicKey: (secretKey: TArg<Uint8Array>) => TRet<Uint8Array>;
141
- keygen: () => {
142
- secretKey: TRet<Uint8Array>;
143
- publicKey: TRet<Uint8Array>;
144
- };
142
+ keygen: () => KeyPair;
145
143
  }>;
146
144
  export declare const curve256: Readonly<{
147
145
  Point: {
@@ -281,10 +279,7 @@ export declare const curve256: Readonly<{
281
279
  };
282
280
  };
283
281
  getPublicKey: (secretKey: TArg<Uint8Array>) => TRet<Uint8Array>;
284
- keygen: () => {
285
- secretKey: TRet<Uint8Array>;
286
- publicKey: TRet<Uint8Array>;
287
- };
282
+ keygen: () => KeyPair;
288
283
  }>;
289
284
  export declare const curve512: Readonly<{
290
285
  Point: {
@@ -424,8 +419,5 @@ export declare const curve512: Readonly<{
424
419
  };
425
420
  };
426
421
  getPublicKey: (secretKey: TArg<Uint8Array>) => TRet<Uint8Array>;
427
- keygen: () => {
428
- secretKey: TRet<Uint8Array>;
429
- publicKey: TRet<Uint8Array>;
430
- };
422
+ keygen: () => KeyPair;
431
423
  }>;
package/dstu9041/curve.js CHANGED
@@ -1,6 +1,5 @@
1
1
  import { Field, mod } from "@noble/curves/abstract/modular.js";
2
- import { bitGet, bitLen, bytesToNumberBE, randomBytes } from "@noble/curves/utils.js";
3
- import { concatBytes } from "@noble/hashes/utils.js";
2
+ import { concatBytes, bitGet, bitLen, bytesToNumberBE, randomBytes } from "@noble/curves/utils.js";
4
3
  export const dstu9041Curve = (parameters) => {
5
4
  if (parameters.a != 2n)
6
5
  throw new Error("Unsuppored `a` parameter, must be 2");
@@ -85,7 +84,9 @@ export const dstu9041Curve = (parameters) => {
85
84
  const y = Fp.fromBytes(bytes.subarray(Fp.BYTES, 2 * Fp.BYTES));
86
85
  return Point.fromAffine(x, y);
87
86
  }
88
- static fromAffine(x, y) { return new Point(x, y, Fp.ONE).assertValidity(); }
87
+ static fromAffine(x, y) {
88
+ return new Point(x, y, Fp.ONE).assertValidity();
89
+ }
89
90
  static fromX(x) {
90
91
  const x2 = Fp.sqr(x);
91
92
  if (Fp.eql(x, Fp.ZERO) ||
@@ -2,20 +2,14 @@ import { type TArg, type TRet } from "@noble/curves/utils.js";
2
2
  /** DSTU 9041:2020 (256 bit) */
3
3
  export declare const dstu9041_256: Readonly<{
4
4
  getPublicKey: (secretKey: TArg<Uint8Array>) => TRet<Uint8Array>;
5
- keygen: () => {
6
- secretKey: TRet<Uint8Array>;
7
- publicKey: TRet<Uint8Array>;
8
- };
5
+ keygen: () => import("../types.js").KeyPair;
9
6
  encrypt: (plaintext: TArg<Uint8Array>, publicKey: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
10
7
  decrypt: (ciphertext: TArg<Uint8Array>, privateKey: TArg<Uint8Array>) => TRet<Uint8Array>;
11
8
  }>;
12
9
  /** DSTU 9041:2020 (512 bit) */
13
10
  export declare const dstu9041_512: Readonly<{
14
11
  getPublicKey: (secretKey: TArg<Uint8Array>) => TRet<Uint8Array>;
15
- keygen: () => {
16
- secretKey: TRet<Uint8Array>;
17
- publicKey: TRet<Uint8Array>;
18
- };
12
+ keygen: () => import("../types.js").KeyPair;
19
13
  encrypt: (plaintext: TArg<Uint8Array>, publicKey: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
20
14
  decrypt: (ciphertext: TArg<Uint8Array>, privateKey: TArg<Uint8Array>) => TRet<Uint8Array>;
21
15
  }>;