@li0ard/dstu 0.1.1 → 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.
- package/dstu4145/ec/expand.js +27 -111
- package/dstu4145/ec/index.d.ts +53 -725
- package/dstu4145/ec/index.js +66 -173
- package/dstu4145/ec/math.d.ts +22 -0
- package/dstu4145/ec/math.js +100 -0
- package/dstu4145/ec/onb.js +3 -28
- package/dstu4145/index.js +23 -26
- package/package.json +1 -1
package/dstu4145/ec/index.js
CHANGED
|
@@ -2,123 +2,27 @@ import { concatBytes } from "@noble/hashes/utils.js";
|
|
|
2
2
|
import BN from "bn.js";
|
|
3
3
|
import { bitLength, getWindowSize, windowNaf } from "./wnaf.js";
|
|
4
4
|
import { init_onb_parameters } from "./onb.js";
|
|
5
|
-
|
|
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
|
-
};
|
|
5
|
+
import { createField } from "./math.js";
|
|
13
6
|
export const binaryWeierstrass = (parameters) => {
|
|
14
|
-
|
|
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
|
-
}
|
|
7
|
+
const field = createField(parameters.m, parameters.ks);
|
|
103
8
|
const onb = parameters.onb ? init_onb_parameters(parameters) : undefined;
|
|
104
|
-
|
|
105
|
-
const
|
|
106
|
-
|
|
107
|
-
const
|
|
108
|
-
|
|
109
|
-
const
|
|
110
|
-
|
|
111
|
-
|
|
112
|
-
|
|
113
|
-
|
|
114
|
-
|
|
115
|
-
const lengths = Object.freeze({ fieldByteLength, pointByteLength, scalarByteLength, signatureByteLength });
|
|
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
|
+
});
|
|
116
20
|
// Point operations
|
|
117
21
|
class Point {
|
|
118
22
|
x;
|
|
119
23
|
y;
|
|
120
|
-
static BASE = new Point(toInternal(
|
|
121
|
-
static ZERO = new Point(
|
|
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));
|
|
122
26
|
_precomp;
|
|
123
27
|
_double;
|
|
124
28
|
constructor(x, y) {
|
|
@@ -129,40 +33,39 @@ export const binaryWeierstrass = (parameters) => {
|
|
|
129
33
|
const pz = Point.ZERO.clone();
|
|
130
34
|
const x0 = this.x.clone(), y0 = this.y.clone();
|
|
131
35
|
const x1 = p.x.clone(), y1 = p.y.clone();
|
|
132
|
-
if (this.
|
|
36
|
+
if (this.isZero())
|
|
133
37
|
return p;
|
|
134
|
-
if (p.
|
|
38
|
+
if (p.isZero())
|
|
135
39
|
return this;
|
|
136
40
|
let lbd, x2;
|
|
137
|
-
if (x0.
|
|
138
|
-
const tmp = y0.
|
|
139
|
-
lbd =
|
|
140
|
-
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);
|
|
141
45
|
if (parameters.a === 1)
|
|
142
|
-
x2.setBit(0, 1 ^
|
|
143
|
-
x2 = x2.
|
|
46
|
+
x2 = field.setBit(x2, 0, 1 ^ field.testBit(x2, 0));
|
|
47
|
+
x2 = x2.xor(lbd).xor(x0).xor(x1);
|
|
144
48
|
}
|
|
145
49
|
else {
|
|
146
|
-
if (y1.
|
|
50
|
+
if (y1.cmp(y0) !== 0)
|
|
147
51
|
return pz;
|
|
148
|
-
if (x1.
|
|
52
|
+
if (x1.isZero())
|
|
149
53
|
return pz;
|
|
150
|
-
lbd = x1.
|
|
151
|
-
x2 =
|
|
54
|
+
lbd = x1.xor(field.mul(p.y, field.invert(p.x)));
|
|
55
|
+
x2 = field.sqr(lbd);
|
|
152
56
|
if (parameters.a === 1)
|
|
153
|
-
x2.setBit(0, 1 ^
|
|
154
|
-
x2 = x2.
|
|
57
|
+
x2 = field.setBit(x2, 0, 1 ^ field.testBit(x2, 0));
|
|
58
|
+
x2 = x2.xor(lbd);
|
|
155
59
|
}
|
|
156
|
-
const y2 =
|
|
60
|
+
const y2 = field.mul(lbd, x1.xor(x2)).xor(x2).xor(y1);
|
|
157
61
|
pz.x = x2;
|
|
158
62
|
pz.y = y2;
|
|
159
63
|
return pz;
|
|
160
64
|
}
|
|
161
65
|
mul(f) {
|
|
162
|
-
let pz = Point.ZERO.clone();
|
|
163
|
-
let
|
|
164
|
-
|
|
165
|
-
if (f.testBit(j) === 1) {
|
|
66
|
+
let pz = Point.ZERO.clone(), p = this.clone();
|
|
67
|
+
for (let j = f.bitLength() - 1; j >= 0; j--) {
|
|
68
|
+
if (f.testn(j)) {
|
|
166
69
|
pz = pz.add(p);
|
|
167
70
|
p = p.add(p);
|
|
168
71
|
}
|
|
@@ -173,21 +76,17 @@ export const binaryWeierstrass = (parameters) => {
|
|
|
173
76
|
}
|
|
174
77
|
return pz;
|
|
175
78
|
}
|
|
176
|
-
negate() { return new Point(this.x, this.x.
|
|
79
|
+
negate() { return new Point(this.x, this.x.xor(this.y)); }
|
|
177
80
|
clone() { return new Point(this.x, this.y); }
|
|
178
|
-
|
|
81
|
+
isZero() { return this.x.isZero() && this.y.isZero(); }
|
|
179
82
|
compress() {
|
|
180
|
-
const
|
|
181
|
-
|
|
182
|
-
const trace = tmp.trace();
|
|
183
|
-
const xExt = toExternal(this.x);
|
|
184
|
-
xExt.setBit(0, trace);
|
|
185
|
-
return xExt;
|
|
83
|
+
const tmp = field.mul(field.invert(this.x), this.y);
|
|
84
|
+
return field.setBit(toExternal(this.x), 0, field.trace(tmp));
|
|
186
85
|
}
|
|
187
86
|
toBytes(isCompressed = false) {
|
|
188
87
|
if (isCompressed)
|
|
189
|
-
return this.compress().
|
|
190
|
-
return concatBytes(toExternal(this.x).
|
|
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));
|
|
191
90
|
}
|
|
192
91
|
double() { return this.add(this); }
|
|
193
92
|
timesPow2(e) {
|
|
@@ -213,10 +112,10 @@ export const binaryWeierstrass = (parameters) => {
|
|
|
213
112
|
return { pos, neg };
|
|
214
113
|
}
|
|
215
114
|
mulWnaf(f) {
|
|
216
|
-
let width = getWindowSize(f.
|
|
115
|
+
let width = getWindowSize(f.bitLength());
|
|
217
116
|
width = Math.max(2, Math.min(16, width));
|
|
218
117
|
const { pos, neg } = this.precomp(width);
|
|
219
|
-
const wnaf = windowNaf(width, f
|
|
118
|
+
const wnaf = windowNaf(width, f);
|
|
220
119
|
let R = Point.ZERO;
|
|
221
120
|
let i = wnaf.length;
|
|
222
121
|
if (i > 1) {
|
|
@@ -248,53 +147,47 @@ export const binaryWeierstrass = (parameters) => {
|
|
|
248
147
|
return R;
|
|
249
148
|
}
|
|
250
149
|
static expand(xExt) {
|
|
251
|
-
const bit =
|
|
252
|
-
|
|
253
|
-
xCleanExt.setBit(0, 0);
|
|
150
|
+
const bit = field.testBit(xExt, 0);
|
|
151
|
+
let xCleanExt = xExt.clone();
|
|
152
|
+
xCleanExt = field.setBit(xCleanExt, 0, 0);
|
|
254
153
|
const a = parameters.a ?? 0;
|
|
255
|
-
const traceX = onb ?
|
|
154
|
+
const traceX = onb ? field.traceOnb(xCleanExt) : field.trace(xCleanExt);
|
|
256
155
|
if ((traceX === 1 && a === 0) || (traceX === 0 && a === 1))
|
|
257
|
-
xCleanExt.setBit(0, 1);
|
|
156
|
+
xCleanExt = field.setBit(xCleanExt, 0, 1);
|
|
258
157
|
const xClean = toInternal(xCleanExt);
|
|
259
|
-
const x2 =
|
|
260
|
-
let rhs =
|
|
158
|
+
const x2 = field.sqr(xClean);
|
|
159
|
+
let rhs = field.mul(x2, xClean);
|
|
261
160
|
if (a === 1)
|
|
262
|
-
rhs = rhs.
|
|
161
|
+
rhs = rhs.xor(x2);
|
|
263
162
|
if (b)
|
|
264
|
-
rhs = rhs.
|
|
265
|
-
|
|
266
|
-
const
|
|
267
|
-
const z = c.fsquad();
|
|
268
|
-
const traceZ = z.trace();
|
|
163
|
+
rhs = rhs.xor(b);
|
|
164
|
+
let z = field.sqrt(field.mul(rhs, field.invert(x2)));
|
|
165
|
+
const traceZ = field.trace(z);
|
|
269
166
|
if ((traceZ === 0 && bit === 1) || (traceZ === 1 && bit === 0)) {
|
|
270
|
-
const currentBit =
|
|
271
|
-
z.setBit(0, 1 ^ currentBit);
|
|
167
|
+
const currentBit = field.testBit(z, 0);
|
|
168
|
+
z = field.setBit(z, 0, 1 ^ currentBit);
|
|
272
169
|
}
|
|
273
|
-
return new Point(xClean,
|
|
170
|
+
return new Point(xClean, field.mul(z, xClean));
|
|
274
171
|
}
|
|
275
172
|
static fromBytes(bytes) {
|
|
276
173
|
if (bytes.length == pointByteLength)
|
|
277
|
-
return new Point(toInternal(
|
|
278
|
-
else if (bytes.length ==
|
|
279
|
-
return Point.expand(
|
|
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));
|
|
280
177
|
else
|
|
281
|
-
throw new Error(`Invalid bytes length. Must be ${pointByteLength} for uncompressed and ${
|
|
178
|
+
throw new Error(`Invalid bytes length. Must be ${pointByteLength} for uncompressed and ${field.LENGTH} for compressed`);
|
|
282
179
|
}
|
|
283
180
|
}
|
|
284
|
-
|
|
285
|
-
const
|
|
286
|
-
|
|
287
|
-
|
|
288
|
-
return new Field(bn.maskn(k));
|
|
289
|
-
};
|
|
290
|
-
// precompute
|
|
291
|
-
Point.BASE.mulWnaf(new Field(new BN(3)));
|
|
181
|
+
const k = order.bitLength() - 1;
|
|
182
|
+
const truncate = (x) => x.maskn(k);
|
|
183
|
+
// Precompute
|
|
184
|
+
Point.BASE.mulWnaf(new BN(3));
|
|
292
185
|
return Object.freeze({
|
|
293
|
-
Field, Point,
|
|
294
|
-
ORDER: order,
|
|
186
|
+
Field: field, Point,
|
|
187
|
+
ORDER: order,
|
|
295
188
|
parameters, lengths,
|
|
296
|
-
hashToField,
|
|
297
189
|
isOnb: !!onb,
|
|
190
|
+
truncate,
|
|
298
191
|
toInternalField: toInternal,
|
|
299
192
|
toExternalField: toExternal
|
|
300
193
|
});
|
|
@@ -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
|
+
};
|
package/dstu4145/ec/onb.js
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
import BN from "bn.js";
|
|
2
|
-
import { computeMod } from "./index.js";
|
|
3
2
|
import { hexToBytes } from "@noble/hashes/utils.js";
|
|
3
|
+
import { createField } from "./math.js";
|
|
4
4
|
const decompress_matrix = (compress_mulp, mulp) => {
|
|
5
5
|
const bitLen = compress_mulp.bitLength();
|
|
6
6
|
const mlen = Math.ceil(bitLen / 9);
|
|
@@ -16,8 +16,7 @@ const decompress_matrix = (compress_mulp, mulp) => {
|
|
|
16
16
|
export const init_onb_parameters = (curve) => {
|
|
17
17
|
if (!curve.onb)
|
|
18
18
|
throw new Error("Invalid curve: Curve doesn't support ONB");
|
|
19
|
-
const { m
|
|
20
|
-
const modulo = computeMod(m, ks);
|
|
19
|
+
const { m } = curve;
|
|
21
20
|
const mulp = new Uint16Array(2 * m - 1);
|
|
22
21
|
const compress_mulp = new BN(hexToBytes(curve.onb.matrix), "le");
|
|
23
22
|
decompress_matrix(compress_mulp, mulp);
|
|
@@ -47,33 +46,9 @@ export const init_onb_parameters = (curve) => {
|
|
|
47
46
|
r.setn(m - 1 - i, 1);
|
|
48
47
|
return r;
|
|
49
48
|
};
|
|
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
49
|
const toPb = new Array(m);
|
|
76
50
|
toPb[0] = root1.clone();
|
|
51
|
+
const { mul } = createField(m, curve.ks);
|
|
77
52
|
for (let i = 1; i < m; i++)
|
|
78
53
|
toPb[i] = mul(toPb[i - 1], toPb[i - 1]);
|
|
79
54
|
const _toOnb = new Array(m);
|
package/dstu4145/index.js
CHANGED
|
@@ -1,58 +1,55 @@
|
|
|
1
1
|
import { concatBytes, randomBytes } from "@noble/hashes/utils.js";
|
|
2
|
-
import { DSTU_163,
|
|
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
5
|
/** Create DSTU 4145-2002 signer (Big-Endian) */
|
|
6
6
|
export const dstu4145 = (parameters) => {
|
|
7
7
|
const curve = binaryWeierstrass(parameters);
|
|
8
|
-
const
|
|
9
|
-
const getPublicKey = (secretKey, isCompressed = false) =>
|
|
10
|
-
const randomPrivateKey = () =>
|
|
11
|
-
.maskn(k)
|
|
12
|
-
.toArray("be", curve.lengths.scalarByteLength));
|
|
8
|
+
const { Field, Point, truncate } = curve;
|
|
9
|
+
const getPublicKey = (secretKey, isCompressed = false) => Point.BASE.mul(Field.fromHexStringOrBytes(secretKey)).negate().toBytes(isCompressed);
|
|
10
|
+
const randomPrivateKey = () => Field.toBytes(truncate(new BN(randomBytes(curve.lengths.scalarByteLength))), curve.lengths.scalarByteLength);
|
|
13
11
|
const computePresign = (rand) => {
|
|
14
|
-
const e = (rand
|
|
12
|
+
const e = truncate(rand
|
|
15
13
|
? new BN(rand)
|
|
16
|
-
: new BN(randomBytes(curve.lengths.scalarByteLength)))
|
|
14
|
+
: new BN(randomBytes(curve.lengths.scalarByteLength)));
|
|
17
15
|
if (rand && e.isZero())
|
|
18
16
|
throw new Error("Invalid custom rand for presign (rand = 0)");
|
|
19
17
|
if (e.isZero())
|
|
20
18
|
return computePresign(rand);
|
|
21
|
-
const xR =
|
|
22
|
-
if (xR.
|
|
19
|
+
const xR = Point.BASE.mul(e).x;
|
|
20
|
+
if (xR.isZero())
|
|
23
21
|
return computePresign(rand);
|
|
24
22
|
return { Fe: xR, e };
|
|
25
23
|
};
|
|
26
24
|
const prepareHash = (digest) => {
|
|
27
|
-
let h = curve.toInternalField(curve.hashToField(digest));
|
|
28
|
-
if (h.
|
|
29
|
-
h =
|
|
25
|
+
let h = curve.toInternalField(curve.Field.hashToField(digest));
|
|
26
|
+
if (h.isZero())
|
|
27
|
+
h = new BN(1);
|
|
30
28
|
return h;
|
|
31
29
|
};
|
|
32
30
|
const sign = (secretKey, digest, rand) => {
|
|
33
|
-
const d = new BN(secretKey).mod(curve.ORDER
|
|
31
|
+
const d = new BN(secretKey).mod(curve.ORDER);
|
|
34
32
|
const h = prepareHash(digest);
|
|
35
33
|
const { Fe, e } = computePresign(rand);
|
|
36
|
-
const r = curve.toExternalField(
|
|
34
|
+
const r = truncate(curve.toExternalField(Field.mul(h, Fe)));
|
|
37
35
|
if (r.isZero())
|
|
38
36
|
return sign(secretKey, digest, rand);
|
|
39
|
-
const s = e.add(d.mul(r)).mod(curve.ORDER
|
|
37
|
+
const s = e.add(d.mul(r)).mod(curve.ORDER); // BN
|
|
40
38
|
if (s.isZero())
|
|
41
39
|
return sign(secretKey, digest, rand);
|
|
42
|
-
return concatBytes(
|
|
40
|
+
return concatBytes(Field.toBytes(s, curve.lengths.scalarByteLength), Field.toBytes(r, curve.lengths.scalarByteLength));
|
|
43
41
|
};
|
|
44
42
|
const verify = (publicKey, digest, signature) => {
|
|
45
43
|
if (signature.length != curve.lengths.signatureByteLength)
|
|
46
44
|
throw new Error("Invalid signature length");
|
|
47
|
-
const Q =
|
|
48
|
-
const _s = curve.Field.
|
|
49
|
-
if (_s.
|
|
50
|
-
|| _r.value.isZero() || _r.value.gte(curve.ORDER.value))
|
|
45
|
+
const Q = Point.fromBytes(publicKey);
|
|
46
|
+
const _s = curve.Field.fromHexStringOrBytes(signature.subarray(0, curve.lengths.scalarByteLength)), _r = curve.Field.fromHexStringOrBytes(signature.subarray(curve.lengths.scalarByteLength));
|
|
47
|
+
if (_s.isZero() || _s.gte(curve.ORDER) || _r.isZero() || _r.gte(curve.ORDER))
|
|
51
48
|
return false;
|
|
52
|
-
const h = prepareHash(digest);
|
|
53
|
-
const R =
|
|
54
|
-
const y = curve.toExternalField(
|
|
55
|
-
return y.eq(_r
|
|
49
|
+
const h = prepareHash(digest); // Field
|
|
50
|
+
const R = Point.BASE.mulWnaf(_s).add(Q.mulWnaf(_r));
|
|
51
|
+
const y = truncate(curve.toExternalField(Field.mul(h, R.x)));
|
|
52
|
+
return y.eq(_r);
|
|
56
53
|
};
|
|
57
54
|
const keygen = (isCompressed = false) => {
|
|
58
55
|
const secretKey = randomPrivateKey();
|
|
@@ -70,7 +67,7 @@ export const dstu4145 = (parameters) => {
|
|
|
70
67
|
export * from "./const.js";
|
|
71
68
|
export * from "./ec/expand.js";
|
|
72
69
|
// ONB curves don't preinitialized because `multiplyOnb` is slow O(m^3) function
|
|
73
|
-
// You need to initialize
|
|
70
|
+
// You need to initialize them manually via `dstu4145`
|
|
74
71
|
/** DSTU 4145-2002 163 bit curve */
|
|
75
72
|
export const dstu163 = dstu4145(DSTU_163);
|
|
76
73
|
/** DSTU 4145-2002 167 bit curve */
|