@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.
@@ -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
- 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
- };
5
+ import { createField } from "./math.js";
13
6
  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
- }
7
+ const field = createField(parameters.m, parameters.ks);
103
8
  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 });
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(Field.fromString(parameters.Gx)), toInternal(Field.fromString(parameters.Gy)));
121
- static ZERO = new Point(Field.get0(), Field.get0());
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.iszero())
36
+ if (this.isZero())
133
37
  return p;
134
- if (p.iszero())
38
+ if (p.isZero())
135
39
  return this;
136
40
  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);
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 ^ x2.testBit(0));
143
- x2 = x2.add(lbd).add(x0).add(x1);
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.compare(y0) !== 0)
50
+ if (y1.cmp(y0) !== 0)
147
51
  return pz;
148
- if (x1.compare(Field.get0()) === 0)
52
+ if (x1.isZero())
149
53
  return pz;
150
- lbd = x1.add(p.y.mul(p.x.invert()));
151
- x2 = lbd.mul(lbd);
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 ^ x2.testBit(0));
154
- x2 = x2.add(lbd);
57
+ x2 = field.setBit(x2, 0, 1 ^ field.testBit(x2, 0));
58
+ x2 = x2.xor(lbd);
155
59
  }
156
- const y2 = lbd.mul(x1.add(x2)).add(x2).add(y1);
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 p = this.clone();
164
- for (let j = f.getLength() - 1; j >= 0; j--) {
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.add(this.y)); }
79
+ negate() { return new Point(this.x, this.x.xor(this.y)); }
177
80
  clone() { return new Point(this.x, this.y); }
178
- iszero() { return this.x.is0() && this.y.is0(); }
81
+ isZero() { return this.x.isZero() && this.y.isZero(); }
179
82
  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;
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().toBytes(fieldByteLength);
190
- return concatBytes(toExternal(this.x).toBytes(fieldByteLength), toExternal(this.y).toBytes(fieldByteLength));
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.value.bitLength());
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.value);
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 = xExt.testBit(0);
252
- const xCleanExt = xExt.clone();
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 ? xCleanExt.traceOnb() : xCleanExt.trace();
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 = xClean.mul(xClean);
260
- let rhs = x2.mul(xClean);
158
+ const x2 = field.sqr(xClean);
159
+ let rhs = field.mul(x2, xClean);
261
160
  if (a === 1)
262
- rhs = rhs.add(x2);
161
+ rhs = rhs.xor(x2);
263
162
  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();
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 = z.testBit(0);
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, z.mul(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(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));
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 ${fieldByteLength} for compressed`);
178
+ throw new Error(`Invalid bytes length. Must be ${pointByteLength} for uncompressed and ${field.LENGTH} for compressed`);
282
179
  }
283
180
  }
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)));
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, MODULO: modulo,
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
+ };
@@ -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, ks } = curve;
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, DSTU_163_TEST, DSTU_167, DSTU_173, DSTU_173_ONB, DSTU_173_ONB_TEST, DSTU_179, DSTU_179_ONB, DSTU_191, DSTU_191_ONB, DSTU_233, DSTU_233_ONB, DSTU_257, DSTU_307, DSTU_367, DSTU_431, DSTU_431_ONB } from "./const.js";
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 k = curve.ORDER.getLength() - 1;
9
- const getPublicKey = (secretKey, isCompressed = false) => curve.Point.BASE.mul(curve.Field.fromBytes(secretKey)).negate().toBytes(isCompressed);
10
- const randomPrivateKey = () => new Uint8Array(new BN(randomBytes(curve.lengths.scalarByteLength))
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))).maskn(k);
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 = curve.Point.BASE.mul(new curve.Field(e)).x;
22
- if (xR.is0())
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.is0())
29
- h = curve.Field.get1();
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.value);
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(h.mul(Fe)).value.maskn(k);
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.value);
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(new Uint8Array(s.toArray("be", curve.lengths.scalarByteLength)), new Uint8Array(r.toArray("be", curve.lengths.scalarByteLength)));
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 = curve.Point.fromBytes(publicKey);
48
- const _s = curve.Field.fromBytes(signature.subarray(0, curve.lengths.scalarByteLength)), _r = curve.Field.fromBytes(signature.subarray(curve.lengths.scalarByteLength));
49
- if (_s.value.isZero() || _s.value.gte(curve.ORDER.value)
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 = curve.Point.BASE.mulWnaf(_s).add(Q.mulWnaf(_r));
54
- const y = curve.toExternalField(h.mul(R.x)).value.maskn(k);
55
- return y.eq(_r.value);
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 it manually via `dstu4145`
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 */
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@li0ard/dstu",
3
- "version": "0.1.1",
3
+ "version": "0.1.2",
4
4
  "main": "index.js",
5
5
  "types": "index.d.ts",
6
6
  "type": "module",