@li0ard/dstu 0.0.1 → 0.1.1

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 (49) hide show
  1. package/LICENSE +21 -0
  2. package/README.md +52 -45
  3. package/const.d.ts +14 -0
  4. package/const.js +1084 -0
  5. package/dstu4145/const.d.ts +59 -0
  6. package/dstu4145/const.js +197 -0
  7. package/dstu4145/ec/expand.d.ts +6 -0
  8. package/dstu4145/ec/expand.js +129 -0
  9. package/dstu4145/ec/index.d.ts +823 -0
  10. package/dstu4145/ec/index.js +301 -0
  11. package/dstu4145/ec/onb.d.ts +6 -0
  12. package/dstu4145/ec/onb.js +100 -0
  13. package/dstu4145/ec/wnaf.d.ts +4 -0
  14. package/dstu4145/ec/wnaf.js +63 -0
  15. package/dstu4145/index.d.ts +180 -0
  16. package/dstu4145/index.js +93 -0
  17. package/index.d.ts +6 -0
  18. package/index.js +6 -0
  19. package/kalyna/index.d.ts +51 -0
  20. package/kalyna/index.js +210 -0
  21. package/kupyna/index.d.ts +162 -0
  22. package/kupyna/index.js +233 -0
  23. package/kupyna/kmac.d.ts +46 -0
  24. package/kupyna/kmac.js +124 -0
  25. package/modes/cbc.d.ts +5 -0
  26. package/modes/cbc.js +34 -0
  27. package/modes/cfb.d.ts +5 -0
  28. package/modes/cfb.js +72 -0
  29. package/modes/ctr.d.ts +5 -0
  30. package/modes/ctr.js +24 -0
  31. package/modes/ecb.d.ts +4 -0
  32. package/modes/ecb.js +17 -0
  33. package/modes/gcm.d.ts +5 -0
  34. package/modes/gcm.js +20 -0
  35. package/modes/index.d.ts +7 -0
  36. package/modes/index.js +7 -0
  37. package/modes/mac.d.ts +6 -0
  38. package/modes/mac.js +65 -0
  39. package/modes/ofb.d.ts +5 -0
  40. package/modes/ofb.js +20 -0
  41. package/package.json +49 -7
  42. package/padding.d.ts +3 -0
  43. package/padding.js +22 -0
  44. package/strumok/index.d.ts +21 -0
  45. package/strumok/index.js +352 -0
  46. package/types.d.ts +41 -0
  47. package/types.js +1 -0
  48. package/utils.d.ts +14 -0
  49. package/utils.js +81 -0
@@ -0,0 +1,301 @@
1
+ import { concatBytes } from "@noble/hashes/utils.js";
2
+ import BN from "bn.js";
3
+ import { bitLength, getWindowSize, windowNaf } from "./wnaf.js";
4
+ import { init_onb_parameters } from "./onb.js";
5
+ export const computeMod = (m, ks) => {
6
+ const modulo = new BN(0);
7
+ modulo.setn(m, 1);
8
+ modulo.setn(0, 1);
9
+ for (const i of ks)
10
+ modulo.setn(i, 1);
11
+ return modulo;
12
+ };
13
+ export const binaryWeierstrass = (parameters) => {
14
+ // GF(2^m) operations
15
+ class Field {
16
+ value;
17
+ constructor(value = new BN(0)) {
18
+ this.value = value;
19
+ }
20
+ compare(v) { return this.value.cmp(v.value); }
21
+ clone() { return new Field(this.value.clone()); }
22
+ getLength() { return this.value.bitLength(); }
23
+ testBit(i) { return this.value.testn(i) ? 1 : 0; }
24
+ setBit(i, v) { this.value = this.value.setn(i, v == 1); }
25
+ add(v) { return new Field(this.value.xor(v.value)); }
26
+ is0() { return this.value.isZero(); }
27
+ shiftLeft(n) {
28
+ if (n < 0)
29
+ throw new Error("Shift amount cannot be negative.");
30
+ return new Field(this.value.ushln(n));
31
+ }
32
+ mod() {
33
+ const cmp = this.compare(modulo);
34
+ if (cmp === 0)
35
+ return Field.get0();
36
+ if (cmp < 0)
37
+ return this.clone();
38
+ let bag = this;
39
+ const vl = modulo.getLength();
40
+ while (true) {
41
+ bag = bag.add(modulo.shiftLeft(bag.getLength() - vl));
42
+ if (bag.getLength() < vl)
43
+ return bag;
44
+ }
45
+ }
46
+ mul(v) {
47
+ let bag = Field.get0();
48
+ let shift = this;
49
+ const vLen = v.getLength();
50
+ for (let i = 0; i < vLen; i++) {
51
+ if (v.testBit(i) == 1)
52
+ bag = bag.add(shift);
53
+ shift = shift.shiftLeft(1);
54
+ }
55
+ return bag.mod();
56
+ }
57
+ trace() {
58
+ let t = this;
59
+ for (let i = 1; i < parameters.m; i++)
60
+ t = t.mul(t).add(this);
61
+ return t.testBit(0);
62
+ }
63
+ traceOnb() {
64
+ let t = 0;
65
+ for (let i = 0; i < parameters.m; i++)
66
+ t ^= this.testBit(i);
67
+ return t;
68
+ }
69
+ invert() {
70
+ let r = this.mod(), s = modulo;
71
+ let u = Field.get1(), v = Field.get0();
72
+ while (r.getLength() > 1) {
73
+ let j = s.getLength() - r.getLength();
74
+ if (j < 0) {
75
+ [r, s] = [s, r];
76
+ [u, v] = [v, u];
77
+ j = -j;
78
+ }
79
+ s = s.add(r.shiftLeft(j));
80
+ v = v.add(u.shiftLeft(j));
81
+ }
82
+ return u;
83
+ }
84
+ fsquad() {
85
+ const range_to = Math.floor((parameters.m - 1) / 2);
86
+ const val_a = this.mod();
87
+ let val_z = val_a.clone();
88
+ for (let idx = 1; idx <= range_to; idx++) {
89
+ val_z = val_z.mul(val_z);
90
+ val_z = val_z.mul(val_z).add(val_a);
91
+ }
92
+ const val_w = val_z.mul(val_z).add(val_z);
93
+ if (val_w.compare(val_a) == 0)
94
+ return val_z.mod();
95
+ throw new Error("squad eq fail: no square root exists");
96
+ }
97
+ toBytes(length) { return new Uint8Array(this.value.toArray("be", length)); }
98
+ static fromString(str) { return new Field(new BN(str, 16)); }
99
+ static fromBytes(v) { return new Field(new BN(v, 16)); }
100
+ static get0() { return new Field(new BN(0)); }
101
+ static get1() { return new Field(new BN(1)); }
102
+ }
103
+ const onb = parameters.onb ? init_onb_parameters(parameters) : undefined;
104
+ // Convert ONB to PB (if needed)
105
+ const toInternal = (f) => onb ? new Field(onb.onbToPb(f.value)) : f.clone();
106
+ // Convert PB to ONB (if needed)
107
+ const toExternal = (f) => onb ? new Field(onb.pbToOnb(f.value)) : f.clone();
108
+ // Convert `n` and `b` to `Field`
109
+ const order = Field.fromString(parameters.order);
110
+ const b = toInternal(Field.fromString(parameters.b));
111
+ // Compute modulo from `m` and `ks` coefficients
112
+ const modulo = new Field(computeMod(parameters.m, parameters.ks));
113
+ // Compute values length
114
+ const fieldByteLength = Math.ceil(parameters.m / 8), scalarByteLength = Math.ceil(order.getLength() / 8), pointByteLength = fieldByteLength * 2, signatureByteLength = scalarByteLength * 2;
115
+ const lengths = Object.freeze({ fieldByteLength, pointByteLength, scalarByteLength, signatureByteLength });
116
+ // Point operations
117
+ class Point {
118
+ x;
119
+ y;
120
+ static BASE = new Point(toInternal(Field.fromString(parameters.Gx)), toInternal(Field.fromString(parameters.Gy)));
121
+ static ZERO = new Point(Field.get0(), Field.get0());
122
+ _precomp;
123
+ _double;
124
+ constructor(x, y) {
125
+ this.x = x;
126
+ this.y = y;
127
+ }
128
+ add(p) {
129
+ const pz = Point.ZERO.clone();
130
+ const x0 = this.x.clone(), y0 = this.y.clone();
131
+ const x1 = p.x.clone(), y1 = p.y.clone();
132
+ if (this.iszero())
133
+ return p;
134
+ if (p.iszero())
135
+ return this;
136
+ let lbd, x2;
137
+ if (x0.compare(x1) !== 0) {
138
+ const tmp = y0.add(y1), tmp2 = x0.add(x1);
139
+ lbd = tmp.mul(tmp2.invert());
140
+ x2 = lbd.mul(lbd);
141
+ if (parameters.a === 1)
142
+ x2.setBit(0, 1 ^ x2.testBit(0));
143
+ x2 = x2.add(lbd).add(x0).add(x1);
144
+ }
145
+ else {
146
+ if (y1.compare(y0) !== 0)
147
+ return pz;
148
+ if (x1.compare(Field.get0()) === 0)
149
+ return pz;
150
+ lbd = x1.add(p.y.mul(p.x.invert()));
151
+ x2 = lbd.mul(lbd);
152
+ if (parameters.a === 1)
153
+ x2.setBit(0, 1 ^ x2.testBit(0));
154
+ x2 = x2.add(lbd);
155
+ }
156
+ const y2 = lbd.mul(x1.add(x2)).add(x2).add(y1);
157
+ pz.x = x2;
158
+ pz.y = y2;
159
+ return pz;
160
+ }
161
+ mul(f) {
162
+ let pz = Point.ZERO.clone();
163
+ let p = this.clone();
164
+ for (let j = f.getLength() - 1; j >= 0; j--) {
165
+ if (f.testBit(j) === 1) {
166
+ pz = pz.add(p);
167
+ p = p.add(p);
168
+ }
169
+ else {
170
+ p = pz.add(p);
171
+ pz = pz.add(pz);
172
+ }
173
+ }
174
+ return pz;
175
+ }
176
+ negate() { return new Point(this.x, this.x.add(this.y)); }
177
+ clone() { return new Point(this.x, this.y); }
178
+ iszero() { return this.x.is0() && this.y.is0(); }
179
+ compress() {
180
+ const x_inv = this.x.invert();
181
+ const tmp = x_inv.mul(this.y);
182
+ const trace = tmp.trace();
183
+ const xExt = toExternal(this.x);
184
+ xExt.setBit(0, trace);
185
+ return xExt;
186
+ }
187
+ toBytes(isCompressed = false) {
188
+ if (isCompressed)
189
+ return this.compress().toBytes(fieldByteLength);
190
+ return concatBytes(toExternal(this.x).toBytes(fieldByteLength), toExternal(this.y).toBytes(fieldByteLength));
191
+ }
192
+ double() { return this.add(this); }
193
+ timesPow2(e) {
194
+ let r = this;
195
+ for (let i = 0; i < e; i++)
196
+ r = r.double();
197
+ return r;
198
+ }
199
+ precomp(width) {
200
+ if (!this._precomp)
201
+ this._precomp = { pos: [this], neg: [] };
202
+ const pos = this._precomp.pos, neg = this._precomp.neg;
203
+ if (!neg[0])
204
+ neg[0] = pos[0].negate();
205
+ const len = 1 << Math.max(0, width - 2);
206
+ if (len === 1)
207
+ return { pos, neg };
208
+ const twice = this._double ?? (this._double = this.double());
209
+ for (let i = pos.length; i < len; i++) {
210
+ pos[i] = twice.add(pos[i - 1]);
211
+ neg[i] = pos[i].negate();
212
+ }
213
+ return { pos, neg };
214
+ }
215
+ mulWnaf(f) {
216
+ let width = getWindowSize(f.value.bitLength());
217
+ width = Math.max(2, Math.min(16, width));
218
+ const { pos, neg } = this.precomp(width);
219
+ const wnaf = windowNaf(width, f.value);
220
+ let R = Point.ZERO;
221
+ let i = wnaf.length;
222
+ if (i > 1) {
223
+ const wi = wnaf[--i];
224
+ const digit = wi >> 16;
225
+ let zeroes = wi & 0xffff;
226
+ const n = Math.abs(digit);
227
+ const table = digit < 0 ? neg : pos;
228
+ if ((n << 2) < (1 << width)) {
229
+ const highest = bitLength(n);
230
+ const scale = width - highest;
231
+ const lowBits = n ^ (1 << (highest - 1));
232
+ const i1 = (1 << (width - 1)) - 1;
233
+ const i2 = (lowBits << scale) + 1;
234
+ R = table[i1 >>> 1].add(table[i2 >>> 1]);
235
+ zeroes -= scale;
236
+ }
237
+ else
238
+ R = table[n >>> 1];
239
+ R = R.timesPow2(zeroes);
240
+ }
241
+ while (i > 0) {
242
+ const wi = wnaf[--i];
243
+ const digit = wi >> 16;
244
+ const table = digit < 0 ? neg : pos;
245
+ R = R.double().add(table[Math.abs(digit) >>> 1]);
246
+ R = R.timesPow2(wi & 0xffff);
247
+ }
248
+ return R;
249
+ }
250
+ static expand(xExt) {
251
+ const bit = xExt.testBit(0);
252
+ const xCleanExt = xExt.clone();
253
+ xCleanExt.setBit(0, 0);
254
+ const a = parameters.a ?? 0;
255
+ const traceX = onb ? xCleanExt.traceOnb() : xCleanExt.trace();
256
+ if ((traceX === 1 && a === 0) || (traceX === 0 && a === 1))
257
+ xCleanExt.setBit(0, 1);
258
+ const xClean = toInternal(xCleanExt);
259
+ const x2 = xClean.mul(xClean);
260
+ let rhs = x2.mul(xClean);
261
+ if (a === 1)
262
+ rhs = rhs.add(x2);
263
+ if (b)
264
+ rhs = rhs.add(b);
265
+ const x2inv = x2.invert();
266
+ const c = rhs.mul(x2inv);
267
+ const z = c.fsquad();
268
+ const traceZ = z.trace();
269
+ if ((traceZ === 0 && bit === 1) || (traceZ === 1 && bit === 0)) {
270
+ const currentBit = z.testBit(0);
271
+ z.setBit(0, 1 ^ currentBit);
272
+ }
273
+ return new Point(xClean, z.mul(xClean));
274
+ }
275
+ static fromBytes(bytes) {
276
+ if (bytes.length == pointByteLength)
277
+ return new Point(toInternal(Field.fromBytes(bytes.subarray(0, fieldByteLength))), toInternal(Field.fromBytes(bytes.subarray(fieldByteLength))));
278
+ else if (bytes.length == fieldByteLength)
279
+ return Point.expand(Field.fromBytes(bytes));
280
+ else
281
+ throw new Error(`Invalid bytes length. Must be ${pointByteLength} for uncompressed and ${fieldByteLength} for compressed`);
282
+ }
283
+ }
284
+ // Utils
285
+ const hashToField = (hash) => {
286
+ const bn = new BN(hash);
287
+ const k = Math.min(parameters.m, bn.bitLength());
288
+ return new Field(bn.maskn(k));
289
+ };
290
+ // precompute
291
+ Point.BASE.mulWnaf(new Field(new BN(3)));
292
+ return Object.freeze({
293
+ Field, Point,
294
+ ORDER: order, MODULO: modulo,
295
+ parameters, lengths,
296
+ hashToField,
297
+ isOnb: !!onb,
298
+ toInternalField: toInternal,
299
+ toExternalField: toExternal
300
+ });
301
+ };
@@ -0,0 +1,6 @@
1
+ import BN from "bn.js";
2
+ import type { DSTUShortParameters } from "../const.js";
3
+ export declare const init_onb_parameters: (curve: DSTUShortParameters) => {
4
+ onbToPb: (x: BN) => BN;
5
+ pbToOnb: (x: BN) => BN;
6
+ };
@@ -0,0 +1,100 @@
1
+ import BN from "bn.js";
2
+ import { computeMod } from "./index.js";
3
+ import { hexToBytes } from "@noble/hashes/utils.js";
4
+ const decompress_matrix = (compress_mulp, mulp) => {
5
+ const bitLen = compress_mulp.bitLength();
6
+ const mlen = Math.ceil(bitLen / 9);
7
+ if (mlen === 0)
8
+ return;
9
+ let temp = compress_mulp;
10
+ const mask = new BN(0x1ff);
11
+ for (let j = mlen - 1; j >= 0; j--) {
12
+ mulp[j] = temp.and(mask).toNumber();
13
+ temp = temp.shrn(9);
14
+ }
15
+ };
16
+ export const init_onb_parameters = (curve) => {
17
+ if (!curve.onb)
18
+ throw new Error("Invalid curve: Curve doesn't support ONB");
19
+ const { m, ks } = curve;
20
+ const modulo = computeMod(m, ks);
21
+ const mulp = new Uint16Array(2 * m - 1);
22
+ const compress_mulp = new BN(hexToBytes(curve.onb.matrix), "le");
23
+ decompress_matrix(compress_mulp, mulp);
24
+ const root1 = new BN(hexToBytes(curve.onb.root1), "le"), root2 = new BN(hexToBytes(curve.onb.root2), "le");
25
+ const multiplyOnb = (x, y) => {
26
+ const r = new BN(0);
27
+ const xb = (pos) => (x.testn(pos % m) ? 1 : 0);
28
+ const yb = (pos) => (y.testn(pos % m) ? 1 : 0);
29
+ for (let j = 0; j < m; j++) {
30
+ let bit = 0;
31
+ for (let i = 0; i < m - 1; i++) {
32
+ const t1 = yb(mulp[2 * i] + j + 1);
33
+ const t2 = yb(mulp[2 * i + 1] + j + 1);
34
+ const t3 = xb(i + j + 1);
35
+ bit ^= (t1 ^ t2) & t3;
36
+ }
37
+ bit ^= yb(mulp[2 * m - 2] + j + 1) & xb(m - 1 + j + 1);
38
+ if (bit)
39
+ r.setn(j, 1);
40
+ }
41
+ return r;
42
+ };
43
+ const reverseBits = (x, m) => {
44
+ const r = new BN(0);
45
+ for (let i = 0; i < m; i++)
46
+ if (x.testn(i))
47
+ r.setn(m - 1 - i, 1);
48
+ return r;
49
+ };
50
+ const mod = (f) => {
51
+ const cmp = f.cmp(modulo);
52
+ if (cmp === 0)
53
+ return new BN(0);
54
+ if (cmp < 0)
55
+ return f.clone();
56
+ let bag = f;
57
+ const vl = modulo.bitLength();
58
+ while (true) {
59
+ bag = bag.xor(modulo.ushln(bag.bitLength() - vl));
60
+ if (bag.bitLength() < vl)
61
+ return bag;
62
+ }
63
+ };
64
+ const mul = (x, v) => {
65
+ let bag = new BN(0);
66
+ let shift = x;
67
+ const vLen = v.bitLength();
68
+ for (let i = 0; i < vLen; i++) {
69
+ if (v.testn(i))
70
+ bag = bag.xor(shift);
71
+ shift = shift.ushln(1);
72
+ }
73
+ return mod(bag);
74
+ };
75
+ const toPb = new Array(m);
76
+ toPb[0] = root1.clone();
77
+ for (let i = 1; i < m; i++)
78
+ toPb[i] = mul(toPb[i - 1], toPb[i - 1]);
79
+ const _toOnb = new Array(m);
80
+ _toOnb[0] = new BN(1).shln(m).subn(1);
81
+ for (let i = 1; i < m; i++)
82
+ _toOnb[i] = multiplyOnb(_toOnb[i - 1], root2);
83
+ const toOnb = _toOnb.map((v) => reverseBits(v, m));
84
+ return {
85
+ onbToPb: (x) => {
86
+ let r = new BN(0);
87
+ for (let p = 0; p < m; p++)
88
+ if (x.testn(p))
89
+ r = r.xor(toPb[m - 1 - p]);
90
+ return r;
91
+ },
92
+ pbToOnb: (x) => {
93
+ let r = new BN(0);
94
+ for (let j = 0; j < m; j++)
95
+ if (x.testn(j))
96
+ r = r.xor(toOnb[j]);
97
+ return r;
98
+ }
99
+ };
100
+ };
@@ -0,0 +1,4 @@
1
+ import BN from "bn.js";
2
+ export declare const bitLength: (n: number) => number;
3
+ export declare const windowNaf: (width: number, k: BN) => Int32Array;
4
+ export declare const getWindowSize: (bits: number) => number;
@@ -0,0 +1,63 @@
1
+ // Based on jkurwa
2
+ // github.com/dstucrypt/jkurwa
3
+ import BN from "bn.js";
4
+ const DEFAULT_CUTOFFS = [13, 41, 121, 337, 897, 2305];
5
+ export const bitLength = (n) => n === 0 ? 0 : 32 - Math.clz32(n);
6
+ const compactNaf = (k) => {
7
+ if (k.bitLength() >= 1 << 16)
8
+ throw new Error("'k' must have bitlength < 2^16");
9
+ if (k.isZero())
10
+ return new Int32Array(0);
11
+ const _3k = k.shln(1).add(k);
12
+ const bits = _3k.bitLength();
13
+ const naf = new Int32Array(bits >> 1);
14
+ const diff = _3k.xor(k);
15
+ const highBit = bits - 1;
16
+ let length = 0, zeroes = 0;
17
+ for (let i = 1; i < highBit; ++i) {
18
+ if (!diff.testn(i)) {
19
+ ++zeroes;
20
+ continue;
21
+ }
22
+ const digit = k.testn(i) ? -1 : 1;
23
+ naf[length++] = (digit << 16) | zeroes;
24
+ zeroes = 1;
25
+ ++i;
26
+ }
27
+ naf[length++] = (1 << 16) | zeroes;
28
+ return naf.length > length ? naf.subarray(0, length) : naf;
29
+ };
30
+ export const windowNaf = (width, k) => {
31
+ if (width === 2)
32
+ return compactNaf(k);
33
+ const bigint = k.clone();
34
+ const retLen = Math.floor(bigint.bitLength() / width) + 1;
35
+ const wnaf = new Int32Array(retLen);
36
+ const pow2 = 1 << width, mask = pow2 - 1, sign = pow2 >>> 1;
37
+ let carry = false;
38
+ let length = 0, pos = 0;
39
+ while (pos <= bigint.bitLength()) {
40
+ if (bigint.testn(pos) === carry) {
41
+ ++pos;
42
+ continue;
43
+ }
44
+ bigint.iushrn(pos);
45
+ let digit = bigint.andln(mask);
46
+ if (carry)
47
+ digit++;
48
+ carry = (digit & sign) !== 0;
49
+ if (carry)
50
+ digit -= pow2;
51
+ const zeroes = length > 0 ? pos - 1 : pos;
52
+ wnaf[length++] = (digit << 16) | zeroes;
53
+ pos = width;
54
+ }
55
+ return wnaf.length > length ? wnaf.subarray(0, length) : wnaf;
56
+ };
57
+ export const getWindowSize = (bits) => {
58
+ let i = 0;
59
+ for (; i < DEFAULT_CUTOFFS.length; ++i)
60
+ if (bits < DEFAULT_CUTOFFS[i])
61
+ break;
62
+ return i + 2;
63
+ };
@@ -0,0 +1,180 @@
1
+ import { type TArg, type TRet } from "@noble/hashes/utils.js";
2
+ import { type DSTUParameters } from "./const.js";
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
+ sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
7
+ verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
8
+ keygen: (isCompressed?: boolean) => {
9
+ secretKey: TRet<Uint8Array>;
10
+ publicKey: TRet<Uint8Array>;
11
+ };
12
+ lengths: Readonly<{
13
+ fieldByteLength: number;
14
+ pointByteLength: number;
15
+ scalarByteLength: number;
16
+ signatureByteLength: number;
17
+ }>;
18
+ }>;
19
+ export * from "./const.js";
20
+ export * from "./ec/expand.js";
21
+ /** DSTU 4145-2002 163 bit curve */
22
+ export declare const dstu163: Readonly<{
23
+ getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
24
+ sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
25
+ verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
26
+ keygen: (isCompressed?: boolean) => {
27
+ secretKey: TRet<Uint8Array>;
28
+ publicKey: TRet<Uint8Array>;
29
+ };
30
+ lengths: Readonly<{
31
+ fieldByteLength: number;
32
+ pointByteLength: number;
33
+ scalarByteLength: number;
34
+ signatureByteLength: number;
35
+ }>;
36
+ }>;
37
+ /** DSTU 4145-2002 167 bit curve */
38
+ export declare const dstu167: Readonly<{
39
+ getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
40
+ sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
41
+ verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
42
+ keygen: (isCompressed?: boolean) => {
43
+ secretKey: TRet<Uint8Array>;
44
+ publicKey: TRet<Uint8Array>;
45
+ };
46
+ lengths: Readonly<{
47
+ fieldByteLength: number;
48
+ pointByteLength: number;
49
+ scalarByteLength: number;
50
+ signatureByteLength: number;
51
+ }>;
52
+ }>;
53
+ /** DSTU 4145-2002 173 bit curve */
54
+ export declare const dstu173: Readonly<{
55
+ getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
56
+ sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
57
+ verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
58
+ keygen: (isCompressed?: boolean) => {
59
+ secretKey: TRet<Uint8Array>;
60
+ publicKey: TRet<Uint8Array>;
61
+ };
62
+ lengths: Readonly<{
63
+ fieldByteLength: number;
64
+ pointByteLength: number;
65
+ scalarByteLength: number;
66
+ signatureByteLength: number;
67
+ }>;
68
+ }>;
69
+ /** DSTU 4145-2002 179 bit curve */
70
+ export declare const dstu179: Readonly<{
71
+ getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
72
+ sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
73
+ verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
74
+ keygen: (isCompressed?: boolean) => {
75
+ secretKey: TRet<Uint8Array>;
76
+ publicKey: TRet<Uint8Array>;
77
+ };
78
+ lengths: Readonly<{
79
+ fieldByteLength: number;
80
+ pointByteLength: number;
81
+ scalarByteLength: number;
82
+ signatureByteLength: number;
83
+ }>;
84
+ }>;
85
+ /** DSTU 4145-2002 191 bit curve */
86
+ export declare const dstu191: Readonly<{
87
+ getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
88
+ sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
89
+ verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
90
+ keygen: (isCompressed?: boolean) => {
91
+ secretKey: TRet<Uint8Array>;
92
+ publicKey: TRet<Uint8Array>;
93
+ };
94
+ lengths: Readonly<{
95
+ fieldByteLength: number;
96
+ pointByteLength: number;
97
+ scalarByteLength: number;
98
+ signatureByteLength: number;
99
+ }>;
100
+ }>;
101
+ /** DSTU 4145-2002 233 bit curve */
102
+ export declare const dstu233: Readonly<{
103
+ getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
104
+ sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
105
+ verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
106
+ keygen: (isCompressed?: boolean) => {
107
+ secretKey: TRet<Uint8Array>;
108
+ publicKey: TRet<Uint8Array>;
109
+ };
110
+ lengths: Readonly<{
111
+ fieldByteLength: number;
112
+ pointByteLength: number;
113
+ scalarByteLength: number;
114
+ signatureByteLength: number;
115
+ }>;
116
+ }>;
117
+ /** DSTU 4145-2002 257 bit curve */
118
+ export declare const dstu257: Readonly<{
119
+ getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
120
+ sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
121
+ verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
122
+ keygen: (isCompressed?: boolean) => {
123
+ secretKey: TRet<Uint8Array>;
124
+ publicKey: TRet<Uint8Array>;
125
+ };
126
+ lengths: Readonly<{
127
+ fieldByteLength: number;
128
+ pointByteLength: number;
129
+ scalarByteLength: number;
130
+ signatureByteLength: number;
131
+ }>;
132
+ }>;
133
+ /** DSTU 4145-2002 307 bit curve */
134
+ export declare const dstu307: Readonly<{
135
+ getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
136
+ sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
137
+ verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
138
+ keygen: (isCompressed?: boolean) => {
139
+ secretKey: TRet<Uint8Array>;
140
+ publicKey: TRet<Uint8Array>;
141
+ };
142
+ lengths: Readonly<{
143
+ fieldByteLength: number;
144
+ pointByteLength: number;
145
+ scalarByteLength: number;
146
+ signatureByteLength: number;
147
+ }>;
148
+ }>;
149
+ /** DSTU 4145-2002 367 bit curve */
150
+ export declare const dstu367: Readonly<{
151
+ getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
152
+ sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
153
+ verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
154
+ keygen: (isCompressed?: boolean) => {
155
+ secretKey: TRet<Uint8Array>;
156
+ publicKey: TRet<Uint8Array>;
157
+ };
158
+ lengths: Readonly<{
159
+ fieldByteLength: number;
160
+ pointByteLength: number;
161
+ scalarByteLength: number;
162
+ signatureByteLength: number;
163
+ }>;
164
+ }>;
165
+ /** DSTU 4145-2002 431 bit curve */
166
+ export declare const dstu431: Readonly<{
167
+ getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
168
+ sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
169
+ verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
170
+ keygen: (isCompressed?: boolean) => {
171
+ secretKey: TRet<Uint8Array>;
172
+ publicKey: TRet<Uint8Array>;
173
+ };
174
+ lengths: Readonly<{
175
+ fieldByteLength: number;
176
+ pointByteLength: number;
177
+ scalarByteLength: number;
178
+ signatureByteLength: number;
179
+ }>;
180
+ }>;