@li0ard/dstu 0.1.0 → 0.1.2

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.
@@ -1,3 +1,194 @@
1
- export * from "./curve.js";
2
- export * from "./field.js";
3
- export * from "./point.js";
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
+ import { createField } from "./math.js";
6
+ export const binaryWeierstrass = (parameters) => {
7
+ const field = createField(parameters.m, parameters.ks);
8
+ const onb = parameters.onb ? init_onb_parameters(parameters) : undefined;
9
+ const toInternal = (f) => onb ? onb.onbToPb(f) : f.clone();
10
+ const toExternal = (f) => onb ? onb.pbToOnb(f) : f.clone();
11
+ const order = field.fromHexStringOrBytes(parameters.order);
12
+ const b = toInternal(field.fromHexStringOrBytes(parameters.b));
13
+ const scalarByteLength = Math.ceil(order.bitLength() / 8), pointByteLength = field.LENGTH * 2;
14
+ const lengths = Object.freeze({
15
+ fieldByteLength: field.LENGTH,
16
+ pointByteLength,
17
+ scalarByteLength,
18
+ signatureByteLength: scalarByteLength * 2
19
+ });
20
+ // Point operations
21
+ class Point {
22
+ x;
23
+ y;
24
+ static BASE = new Point(toInternal(field.fromHexStringOrBytes(parameters.Gx)), toInternal(field.fromHexStringOrBytes(parameters.Gy)));
25
+ static ZERO = new Point(new BN(0), new BN(0));
26
+ _precomp;
27
+ _double;
28
+ constructor(x, y) {
29
+ this.x = x;
30
+ this.y = y;
31
+ }
32
+ add(p) {
33
+ const pz = Point.ZERO.clone();
34
+ const x0 = this.x.clone(), y0 = this.y.clone();
35
+ const x1 = p.x.clone(), y1 = p.y.clone();
36
+ if (this.isZero())
37
+ return p;
38
+ if (p.isZero())
39
+ return this;
40
+ let lbd, x2;
41
+ if (x0.cmp(x1) !== 0) {
42
+ const tmp = y0.xor(y1), tmp2 = x0.xor(x1);
43
+ lbd = field.mul(tmp, field.invert(tmp2));
44
+ x2 = field.sqr(lbd);
45
+ if (parameters.a === 1)
46
+ x2 = field.setBit(x2, 0, 1 ^ field.testBit(x2, 0));
47
+ x2 = x2.xor(lbd).xor(x0).xor(x1);
48
+ }
49
+ else {
50
+ if (y1.cmp(y0) !== 0)
51
+ return pz;
52
+ if (x1.isZero())
53
+ return pz;
54
+ lbd = x1.xor(field.mul(p.y, field.invert(p.x)));
55
+ x2 = field.sqr(lbd);
56
+ if (parameters.a === 1)
57
+ x2 = field.setBit(x2, 0, 1 ^ field.testBit(x2, 0));
58
+ x2 = x2.xor(lbd);
59
+ }
60
+ const y2 = field.mul(lbd, x1.xor(x2)).xor(x2).xor(y1);
61
+ pz.x = x2;
62
+ pz.y = y2;
63
+ return pz;
64
+ }
65
+ mul(f) {
66
+ let pz = Point.ZERO.clone(), p = this.clone();
67
+ for (let j = f.bitLength() - 1; j >= 0; j--) {
68
+ if (f.testn(j)) {
69
+ pz = pz.add(p);
70
+ p = p.add(p);
71
+ }
72
+ else {
73
+ p = pz.add(p);
74
+ pz = pz.add(pz);
75
+ }
76
+ }
77
+ return pz;
78
+ }
79
+ negate() { return new Point(this.x, this.x.xor(this.y)); }
80
+ clone() { return new Point(this.x, this.y); }
81
+ isZero() { return this.x.isZero() && this.y.isZero(); }
82
+ compress() {
83
+ const tmp = field.mul(field.invert(this.x), this.y);
84
+ return field.setBit(toExternal(this.x), 0, field.trace(tmp));
85
+ }
86
+ toBytes(isCompressed = false) {
87
+ if (isCompressed)
88
+ return field.toBytes(this.compress(), field.LENGTH);
89
+ return concatBytes(field.toBytes(toExternal(this.x), field.LENGTH), field.toBytes(toExternal(this.y), field.LENGTH));
90
+ }
91
+ double() { return this.add(this); }
92
+ timesPow2(e) {
93
+ let r = this;
94
+ for (let i = 0; i < e; i++)
95
+ r = r.double();
96
+ return r;
97
+ }
98
+ precomp(width) {
99
+ if (!this._precomp)
100
+ this._precomp = { pos: [this], neg: [] };
101
+ const pos = this._precomp.pos, neg = this._precomp.neg;
102
+ if (!neg[0])
103
+ neg[0] = pos[0].negate();
104
+ const len = 1 << Math.max(0, width - 2);
105
+ if (len === 1)
106
+ return { pos, neg };
107
+ const twice = this._double ?? (this._double = this.double());
108
+ for (let i = pos.length; i < len; i++) {
109
+ pos[i] = twice.add(pos[i - 1]);
110
+ neg[i] = pos[i].negate();
111
+ }
112
+ return { pos, neg };
113
+ }
114
+ mulWnaf(f) {
115
+ let width = getWindowSize(f.bitLength());
116
+ width = Math.max(2, Math.min(16, width));
117
+ const { pos, neg } = this.precomp(width);
118
+ const wnaf = windowNaf(width, f);
119
+ let R = Point.ZERO;
120
+ let i = wnaf.length;
121
+ if (i > 1) {
122
+ const wi = wnaf[--i];
123
+ const digit = wi >> 16;
124
+ let zeroes = wi & 0xffff;
125
+ const n = Math.abs(digit);
126
+ const table = digit < 0 ? neg : pos;
127
+ if ((n << 2) < (1 << width)) {
128
+ const highest = bitLength(n);
129
+ const scale = width - highest;
130
+ const lowBits = n ^ (1 << (highest - 1));
131
+ const i1 = (1 << (width - 1)) - 1;
132
+ const i2 = (lowBits << scale) + 1;
133
+ R = table[i1 >>> 1].add(table[i2 >>> 1]);
134
+ zeroes -= scale;
135
+ }
136
+ else
137
+ R = table[n >>> 1];
138
+ R = R.timesPow2(zeroes);
139
+ }
140
+ while (i > 0) {
141
+ const wi = wnaf[--i];
142
+ const digit = wi >> 16;
143
+ const table = digit < 0 ? neg : pos;
144
+ R = R.double().add(table[Math.abs(digit) >>> 1]);
145
+ R = R.timesPow2(wi & 0xffff);
146
+ }
147
+ return R;
148
+ }
149
+ static expand(xExt) {
150
+ const bit = field.testBit(xExt, 0);
151
+ let xCleanExt = xExt.clone();
152
+ xCleanExt = field.setBit(xCleanExt, 0, 0);
153
+ const a = parameters.a ?? 0;
154
+ const traceX = onb ? field.traceOnb(xCleanExt) : field.trace(xCleanExt);
155
+ if ((traceX === 1 && a === 0) || (traceX === 0 && a === 1))
156
+ xCleanExt = field.setBit(xCleanExt, 0, 1);
157
+ const xClean = toInternal(xCleanExt);
158
+ const x2 = field.sqr(xClean);
159
+ let rhs = field.mul(x2, xClean);
160
+ if (a === 1)
161
+ rhs = rhs.xor(x2);
162
+ if (b)
163
+ rhs = rhs.xor(b);
164
+ let z = field.sqrt(field.mul(rhs, field.invert(x2)));
165
+ const traceZ = field.trace(z);
166
+ if ((traceZ === 0 && bit === 1) || (traceZ === 1 && bit === 0)) {
167
+ const currentBit = field.testBit(z, 0);
168
+ z = field.setBit(z, 0, 1 ^ currentBit);
169
+ }
170
+ return new Point(xClean, field.mul(z, xClean));
171
+ }
172
+ static fromBytes(bytes) {
173
+ if (bytes.length == pointByteLength)
174
+ return new Point(toInternal(field.fromHexStringOrBytes(bytes.subarray(0, field.LENGTH))), toInternal(field.fromHexStringOrBytes(bytes.subarray(field.LENGTH))));
175
+ else if (bytes.length == field.LENGTH)
176
+ return Point.expand(field.fromHexStringOrBytes(bytes));
177
+ else
178
+ throw new Error(`Invalid bytes length. Must be ${pointByteLength} for uncompressed and ${field.LENGTH} for compressed`);
179
+ }
180
+ }
181
+ const k = order.bitLength() - 1;
182
+ const truncate = (x) => x.maskn(k);
183
+ // Precompute
184
+ Point.BASE.mulWnaf(new BN(3));
185
+ return Object.freeze({
186
+ Field: field, Point,
187
+ ORDER: order,
188
+ parameters, lengths,
189
+ isOnb: !!onb,
190
+ truncate,
191
+ toInternalField: toInternal,
192
+ toExternalField: toExternal
193
+ });
194
+ };
@@ -0,0 +1,22 @@
1
+ import type { TArg, TRet } from "@noble/hashes/utils.js";
2
+ import BN from "bn.js";
3
+ /** Compute curve modulo */
4
+ export declare const computeMod: (m: number, ks: number[]) => BN;
5
+ /** Create GF(2^m) fields */
6
+ export declare const createField: (m: number, ks: number[]) => Readonly<{
7
+ MODULO: BN;
8
+ LENGTH: number;
9
+ mod: (f: BN) => BN;
10
+ mul: (x: BN, v: BN) => BN;
11
+ sqr: (x: BN) => BN;
12
+ testBit: (x: BN, i: number) => 0 | 1;
13
+ setBit: (x: BN, i: number, v: number) => BN;
14
+ shiftLeft: (x: BN, n: number) => BN;
15
+ trace: (x: BN) => 0 | 1;
16
+ traceOnb: (x: BN) => 0 | 1;
17
+ invert: (f: BN) => BN;
18
+ sqrt: (v: BN) => BN;
19
+ fromHexStringOrBytes: (v: string | Uint8Array) => BN;
20
+ toBytes: (x: BN, length?: number) => TRet<Uint8Array>;
21
+ hashToField: (hash: TArg<Uint8Array>) => BN;
22
+ }>;
@@ -0,0 +1,100 @@
1
+ import BN from "bn.js";
2
+ /** Compute curve modulo */
3
+ export const computeMod = (m, ks) => {
4
+ const modulo = new BN(0);
5
+ modulo.setn(m, 1);
6
+ modulo.setn(0, 1);
7
+ for (const i of ks)
8
+ modulo.setn(i, 1);
9
+ return modulo;
10
+ };
11
+ /** Create GF(2^m) fields */
12
+ export const createField = (m, ks) => {
13
+ const modulo = computeMod(m, ks);
14
+ const mod = (f) => {
15
+ const cmp = f.cmp(modulo);
16
+ if (cmp === 0)
17
+ return new BN(0);
18
+ if (cmp < 0)
19
+ return f.clone();
20
+ let bag = f;
21
+ const vl = modulo.bitLength();
22
+ while (true) {
23
+ bag = bag.xor(modulo.ushln(bag.bitLength() - vl));
24
+ if (bag.bitLength() < vl)
25
+ return bag;
26
+ }
27
+ };
28
+ const mul = (x, v) => {
29
+ let bag = new BN(0);
30
+ let shift = x;
31
+ const vLen = v.bitLength();
32
+ for (let i = 0; i < vLen; i++) {
33
+ if (v.testn(i))
34
+ bag = bag.xor(shift);
35
+ shift = shift.ushln(1);
36
+ }
37
+ return mod(bag);
38
+ };
39
+ // Might be optimized in future
40
+ const sqr = (x) => mul(x, x);
41
+ const testBit = (x, i) => x.testn(i) ? 1 : 0;
42
+ const setBit = (x, i, v) => x.setn(i, v == 1);
43
+ const shiftLeft = (x, n) => {
44
+ if (n < 0)
45
+ throw new Error("Shift amount cannot be negative.");
46
+ return x.ushln(n);
47
+ };
48
+ const trace = (x) => {
49
+ let t = x;
50
+ for (let i = 1; i < m; i++)
51
+ t = sqr(t).xor(x);
52
+ return testBit(t, 0);
53
+ };
54
+ const traceOnb = (x) => {
55
+ let t = 0;
56
+ for (let i = 0; i < m; i++)
57
+ t ^= testBit(x, i);
58
+ return t;
59
+ };
60
+ const invert = (f) => {
61
+ let r = mod(f), s = modulo;
62
+ let u = new BN(1), v = new BN(0);
63
+ while (r.bitLength() > 1) {
64
+ let j = s.bitLength() - r.bitLength();
65
+ if (j < 0) {
66
+ [r, s] = [s, r];
67
+ [u, v] = [v, u];
68
+ j = -j;
69
+ }
70
+ s = s.xor(shiftLeft(r, j));
71
+ v = v.xor(shiftLeft(u, j));
72
+ }
73
+ return u;
74
+ };
75
+ const sqrt = (v) => {
76
+ const range_to = Math.floor((m - 1) / 2);
77
+ const a = mod(v);
78
+ let z = a.clone();
79
+ for (let idx = 1; idx <= range_to; idx++) {
80
+ z = sqr(sqr(z)).xor(a);
81
+ }
82
+ const w = sqr(z).xor(z);
83
+ if (w.cmp(a) == 0)
84
+ return mod(z);
85
+ throw new Error("squad eq fail: no square root exists");
86
+ };
87
+ const hashToField = (hash) => {
88
+ const bn = new BN(hash);
89
+ const k = Math.min(m, bn.bitLength());
90
+ return bn.maskn(k);
91
+ };
92
+ const fromHexStringOrBytes = (v) => new BN(v, 16);
93
+ const toBytes = (x, length) => new Uint8Array(x.toArray("be", length));
94
+ return Object.freeze({
95
+ MODULO: modulo,
96
+ LENGTH: Math.ceil(m / 8),
97
+ mod, mul, sqr, testBit, setBit, shiftLeft, trace, traceOnb, invert, sqrt,
98
+ fromHexStringOrBytes, toBytes, hashToField
99
+ });
100
+ };
@@ -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,75 @@
1
+ import BN from "bn.js";
2
+ import { hexToBytes } from "@noble/hashes/utils.js";
3
+ import { createField } from "./math.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 } = curve;
20
+ const mulp = new Uint16Array(2 * m - 1);
21
+ const compress_mulp = new BN(hexToBytes(curve.onb.matrix), "le");
22
+ decompress_matrix(compress_mulp, mulp);
23
+ const root1 = new BN(hexToBytes(curve.onb.root1), "le"), root2 = new BN(hexToBytes(curve.onb.root2), "le");
24
+ const multiplyOnb = (x, y) => {
25
+ const r = new BN(0);
26
+ const xb = (pos) => (x.testn(pos % m) ? 1 : 0);
27
+ const yb = (pos) => (y.testn(pos % m) ? 1 : 0);
28
+ for (let j = 0; j < m; j++) {
29
+ let bit = 0;
30
+ for (let i = 0; i < m - 1; i++) {
31
+ const t1 = yb(mulp[2 * i] + j + 1);
32
+ const t2 = yb(mulp[2 * i + 1] + j + 1);
33
+ const t3 = xb(i + j + 1);
34
+ bit ^= (t1 ^ t2) & t3;
35
+ }
36
+ bit ^= yb(mulp[2 * m - 2] + j + 1) & xb(m - 1 + j + 1);
37
+ if (bit)
38
+ r.setn(j, 1);
39
+ }
40
+ return r;
41
+ };
42
+ const reverseBits = (x, m) => {
43
+ const r = new BN(0);
44
+ for (let i = 0; i < m; i++)
45
+ if (x.testn(i))
46
+ r.setn(m - 1 - i, 1);
47
+ return r;
48
+ };
49
+ const toPb = new Array(m);
50
+ toPb[0] = root1.clone();
51
+ const { mul } = createField(m, curve.ks);
52
+ for (let i = 1; i < m; i++)
53
+ toPb[i] = mul(toPb[i - 1], toPb[i - 1]);
54
+ const _toOnb = new Array(m);
55
+ _toOnb[0] = new BN(1).shln(m).subn(1);
56
+ for (let i = 1; i < m; i++)
57
+ _toOnb[i] = multiplyOnb(_toOnb[i - 1], root2);
58
+ const toOnb = _toOnb.map((v) => reverseBits(v, m));
59
+ return {
60
+ onbToPb: (x) => {
61
+ let r = new BN(0);
62
+ for (let p = 0; p < m; p++)
63
+ if (x.testn(p))
64
+ r = r.xor(toPb[m - 1 - p]);
65
+ return r;
66
+ },
67
+ pbToOnb: (x) => {
68
+ let r = new BN(0);
69
+ for (let j = 0; j < m; j++)
70
+ if (x.testn(j))
71
+ r = r.xor(toOnb[j]);
72
+ return r;
73
+ }
74
+ };
75
+ };
@@ -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
+ };
@@ -1,28 +1,180 @@
1
- import { type TArg } from "@noble/hashes/utils.js";
2
- import type { DSTUParameters, PublicKey, Signature } from "./const.js";
3
- import { Point } from "./ec/index.js";
4
- /**
5
- * Generate public key from private
6
- * @param parameters Curve parameters
7
- * @param privateKey Private key
8
- */
9
- export declare const getPublicKey: (parameters: DSTUParameters, privateKey: TArg<Uint8Array>) => PublicKey;
10
- /**
11
- * Generate signature of provided digest
12
- * @param parameters Curve parameters
13
- * @param privateKey Private key
14
- * @param digest Digest to sign
15
- * @param rand Optional. Predefined random data
16
- */
17
- export declare const sign: (parameters: DSTUParameters, privateKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => Signature;
18
- /**
19
- * Verify signature of provided digest
20
- * @param parameters Curve parameters
21
- * @param publicKey Public key
22
- * @param digest Digest to verify
23
- * @param signature Signature
24
- */
25
- export declare const verify: (parameters: DSTUParameters, publicKey: PublicKey, digest: TArg<Uint8Array>, signature: Signature) => boolean;
26
- /** Decompress point */
27
- export declare const decompressPoint: (parameters: DSTUParameters, x: TArg<Uint8Array>) => Point;
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
+ }>;
28
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
+ }>;