@li0ard/dstu 0.1.3 → 0.1.5

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/README.md CHANGED
@@ -20,11 +20,12 @@ npm i @li0ard/dstu
20
20
 
21
21
  ## Supported algorithms
22
22
 
23
- - Curves and DSA (DSTU 4145-2002, polynomial and optimal normal basis)
23
+ - Curves and ECDSA (DSTU 4145-2002, polynomial and optimal normal basis)
24
24
  - Kalyna cipher (DSTU 7624:2014)
25
25
  - Kupyna hash function (DSTU 7564:2014)
26
26
  - Supports KMAC
27
27
  - Strumok stream cipher (DSTU 8845:2019)
28
+ - ECIES encryption schema over Twisted Edwards curves (DSTU 9041:2020)
28
29
 
29
30
  ## Supported cipher modes
30
31
 
@@ -10,30 +10,29 @@ export const expandPoint = (xBytes, params) => {
10
10
  const bInt = field.fromHexStringOrBytes(params.b);
11
11
  const b = (onb && converter) ? converter.onbToPb(bInt) : bInt;
12
12
  const x = field.fromHexStringOrBytes(xBytes);
13
- const bit = field.testBit(x, 0);
13
+ const bit = x.testn(0);
14
14
  let xClean = x.clone();
15
- xClean = field.setBit(xClean, 0, 0);
15
+ xClean.setn(0, 0);
16
16
  const traceX = onb ? field.traceOnb(xClean) : field.trace(xClean);
17
17
  if ((traceX === 1 && a === 0) || (traceX === 0 && a === 1))
18
- xClean = field.setBit(xClean, 0, 1);
19
- const qxOut = xClean.clone();
18
+ xClean.setn(0, 1);
19
+ const xOut = xClean.clone();
20
20
  if (onb && converter)
21
21
  xClean = converter.onbToPb(xClean);
22
22
  const x2 = field.sqr(xClean);
23
- let rhs = field.mul(x2, xClean);
23
+ const rhs = field.mul(x2, xClean);
24
24
  if (a === 1)
25
- rhs = rhs.xor(x2);
26
- if (b)
27
- rhs = rhs.xor(b);
28
- let z = field.solve_quad(field.mul(rhs, field.invert(x2)));
25
+ rhs.ixor(x2);
26
+ rhs.ixor(b);
27
+ const z = field.solve_quad(field.div(rhs, x2));
29
28
  const traceZ = field.trace(z);
30
- if ((traceZ === 0 && bit === 1) || (traceZ === 1 && bit === 0))
31
- z = field.setBit(z, 0, 1 ^ field.testBit(z, 0));
29
+ if ((traceZ === 0 && bit) || (traceZ === 1 && !bit))
30
+ field.invBit(z, 0);
32
31
  let y = field.mul(z, xClean);
33
32
  if (onb && converter)
34
33
  y = converter.pbToOnb(y);
35
34
  return {
36
- x: field.toBytes(qxOut, field.LENGTH),
35
+ x: field.toBytes(xOut, field.LENGTH),
37
36
  y: field.toBytes(y, field.LENGTH)
38
37
  };
39
38
  };
@@ -7,14 +7,15 @@ export declare const binaryWeierstrass: (parameters: DSTUParameters) => Readonly
7
7
  LENGTH: number;
8
8
  mod: (f: BN) => BN;
9
9
  mul: (x: BN, v: BN) => BN;
10
+ div: (x: BN, v: BN) => BN;
10
11
  sqr: (x: BN) => BN;
12
+ sqrt: (x: BN) => BN;
11
13
  invert: (f: BN) => BN;
12
14
  solve_quad: (v: BN) => BN;
13
- testBit: (x: BN, i: number) => 0 | 1;
14
- setBit: (x: BN, i: number, v: number) => BN;
15
15
  trace: (x: BN) => 0 | 1;
16
16
  traceOnb: (x: BN) => 0 | 1;
17
17
  hashToField: (hash: TArg<Uint8Array>) => BN;
18
+ invBit: (x: BN, i: number) => BN;
18
19
  fromHexStringOrBytes: (v: string | Uint8Array) => BN;
19
20
  toBytes: (x: BN, length?: number) => TRet<Uint8Array>;
20
21
  }>;
@@ -88,29 +89,7 @@ export declare const binaryWeierstrass: (parameters: DSTUParameters) => Readonly
88
89
  };
89
90
  mulWnaf(f: BN): /*elided*/ any;
90
91
  };
91
- expand(xExt: BN): {
92
- _precomp?: {
93
- pos: /*elided*/ any[];
94
- neg: /*elided*/ any[];
95
- };
96
- _double?: /*elided*/ any;
97
- x: BN;
98
- y: BN;
99
- add(p: /*elided*/ any): /*elided*/ any;
100
- mul(f: BN): /*elided*/ any;
101
- negate(): /*elided*/ any;
102
- clone(): /*elided*/ any;
103
- isZero(): boolean;
104
- compress(): BN;
105
- toBytes(isCompressed?: boolean): TRet<Uint8Array>;
106
- double(): /*elided*/ any;
107
- timesPow2(e: number): /*elided*/ any;
108
- precomp(width: number): {
109
- pos: /*elided*/ any[];
110
- neg: /*elided*/ any[];
111
- };
112
- mulWnaf(f: BN): /*elided*/ any;
113
- };
92
+ /** Deserialize point from bytes (compressed/uncompressed) */
114
93
  fromBytes(bytes: TArg<Uint8Array>): {
115
94
  _precomp?: {
116
95
  pos: /*elided*/ any[];
@@ -136,6 +115,7 @@ export declare const binaryWeierstrass: (parameters: DSTUParameters) => Readonly
136
115
  };
137
116
  };
138
117
  ORDER: BN;
118
+ MASK: number;
139
119
  parameters: DSTUParameters;
140
120
  lengths: Readonly<{
141
121
  fieldByteLength: number;
@@ -144,7 +124,6 @@ export declare const binaryWeierstrass: (parameters: DSTUParameters) => Readonly
144
124
  signatureByteLength: number;
145
125
  }>;
146
126
  isOnb: boolean;
147
- truncate: (x: BN) => BN;
148
127
  toInternalField: (f: BN) => BN;
149
128
  toExternalField: (f: BN) => BN;
150
129
  }>;
@@ -10,6 +10,7 @@ export const binaryWeierstrass = (parameters) => {
10
10
  const toExternal = (f) => onb ? onb.pbToOnb(f) : f.clone();
11
11
  const order = field.fromHexStringOrBytes(parameters.order);
12
12
  const b = toInternal(field.fromHexStringOrBytes(parameters.b));
13
+ const c = field.sqrt(b);
13
14
  const scalarByteLength = Math.ceil(order.bitLength() / 8), pointByteLength = field.LENGTH * 2;
14
15
  const lengths = Object.freeze({
15
16
  fieldByteLength: field.LENGTH,
@@ -17,6 +18,22 @@ export const binaryWeierstrass = (parameters) => {
17
18
  scalarByteLength,
18
19
  signatureByteLength: scalarByteLength * 2
19
20
  });
21
+ const Madd = (X1, Z1, X2, Z2, x) => {
22
+ const A = field.mul(X1, Z2);
23
+ const B = field.mul(Z1, X2);
24
+ const T = field.mul(A, B);
25
+ const Znew = field.sqr(A.ixor(B));
26
+ const Xnew = field.mul(Znew, x).ixor(T);
27
+ return [Xnew, Znew];
28
+ };
29
+ const Mdouble = (X, Z) => {
30
+ const X2 = field.sqr(X);
31
+ const Z2 = field.sqr(Z);
32
+ const T = field.sqr(field.mul(Z2, c));
33
+ const Znew = field.mul(X2, Z2);
34
+ const Xnew = field.sqr(X2).ixor(T);
35
+ return [Xnew, Znew];
36
+ };
20
37
  // Point operations
21
38
  class Point {
22
39
  x;
@@ -39,49 +56,65 @@ export const binaryWeierstrass = (parameters) => {
39
56
  return this;
40
57
  let lbd, x2;
41
58
  if (x0.cmp(x1) !== 0) {
42
- const tmp = y0.xor(y1), tmp2 = x0.xor(x1);
43
- lbd = field.mul(tmp, field.invert(tmp2));
59
+ lbd = field.div(y0.xor(y1), x0.xor(x1));
44
60
  x2 = field.sqr(lbd);
45
61
  if (parameters.a === 1)
46
- x2 = field.setBit(x2, 0, 1 ^ field.testBit(x2, 0));
47
- x2 = x2.xor(lbd).xor(x0).xor(x1);
62
+ field.invBit(x2, 0);
63
+ x2.ixor(lbd).ixor(x0).ixor(x1);
48
64
  }
49
65
  else {
50
66
  if (y1.cmp(y0) !== 0)
51
67
  return pz;
52
68
  if (x1.isZero())
53
69
  return pz;
54
- lbd = x1.xor(field.mul(p.y, field.invert(p.x)));
70
+ lbd = x1.xor(field.div(p.y, p.x));
55
71
  x2 = field.sqr(lbd);
56
72
  if (parameters.a === 1)
57
- x2 = field.setBit(x2, 0, 1 ^ field.testBit(x2, 0));
58
- x2 = x2.xor(lbd);
73
+ field.invBit(x2, 0);
74
+ x2.ixor(lbd);
59
75
  }
60
- const y2 = field.mul(lbd, x1.xor(x2)).xor(x2).xor(y1);
76
+ const y2 = field.mul(lbd, x1.xor(x2)).ixor(x2).ixor(y1);
61
77
  pz.x = x2;
62
78
  pz.y = y2;
63
79
  return pz;
64
80
  }
65
81
  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);
82
+ if (f.isZero() || this.x.isZero())
83
+ return Point.ZERO.clone();
84
+ let X1 = this.x.clone(), Z1 = new BN(1);
85
+ const xSqr = field.sqr(this.x);
86
+ let X2 = field.sqr(xSqr).ixor(b), Z2 = xSqr.clone();
87
+ for (let i = f.bitLength() - 2; i >= 0; i--) {
88
+ if (f.testn(i)) {
89
+ [X1, Z1] = Madd(X1, Z1, X2, Z2, this.x);
90
+ [X2, Z2] = Mdouble(X2, Z2);
71
91
  }
72
92
  else {
73
- p = pz.add(p);
74
- pz = pz.add(pz);
93
+ [X2, Z2] = Madd(X2, Z2, X1, Z1, this.x);
94
+ [X1, Z1] = Mdouble(X1, Z1);
75
95
  }
76
96
  }
77
- return pz;
97
+ // Convert projective coords to affine
98
+ if (Z1.isZero())
99
+ return Point.ZERO.clone();
100
+ if (Z2.isZero())
101
+ return this.negate();
102
+ const A = field.mul(this.x, Z1).ixor(X1);
103
+ const B = field.mul(this.x, Z2).ixor(X2);
104
+ const Z1Z2 = field.mul(Z1, Z2);
105
+ const Z1Z2x = field.mul(Z1Z2, this.x);
106
+ const D = field.invert(field.mul(Z1Z2x, Z1));
107
+ const N = field.mul(A, B).ixor(field.mul(Z1Z2, xSqr.ixor(this.y)));
108
+ const Xk = field.mul(X1, field.mul(Z1Z2x, D));
109
+ const Yk = field.mul(field.mul(A, N), D).ixor(this.y);
110
+ return new Point(Xk, Yk);
78
111
  }
79
- negate() { return new Point(this.x, this.x.xor(this.y)); }
80
- clone() { return new Point(this.x, this.y); }
112
+ negate() { return new Point(this.x.clone(), this.x.xor(this.y)); }
113
+ clone() { return new Point(this.x.clone(), this.y.clone()); }
81
114
  isZero() { return this.x.isZero() && this.y.isZero(); }
82
115
  compress() {
83
- const tmp = field.mul(field.invert(this.x), this.y);
84
- return field.setBit(toExternal(this.x), 0, field.trace(tmp));
116
+ const tmp = field.div(this.y, this.x);
117
+ return toExternal(this.x).setn(0, field.trace(tmp));
85
118
  }
86
119
  toBytes(isCompressed = false) {
87
120
  if (isCompressed)
@@ -145,45 +178,43 @@ export const binaryWeierstrass = (parameters) => {
145
178
  }
146
179
  return R;
147
180
  }
148
- static expand(xExt) {
149
- const bit = field.testBit(xExt, 0);
150
- let xCleanExt = xExt.clone();
151
- xCleanExt = field.setBit(xCleanExt, 0, 0);
152
- const traceX = onb ? field.traceOnb(xCleanExt) : field.trace(xCleanExt);
153
- if ((traceX === 1 && parameters.a === 0) || (traceX === 0 && parameters.a === 1))
154
- xCleanExt = field.setBit(xCleanExt, 0, 1);
155
- const xClean = toInternal(xCleanExt);
156
- const x2 = field.sqr(xClean);
157
- let rhs = field.mul(x2, xClean);
158
- if (parameters.a === 1)
159
- rhs = rhs.xor(x2);
160
- if (b)
161
- rhs = rhs.xor(b);
162
- let z = field.solve_quad(field.mul(rhs, field.invert(x2)));
163
- const traceZ = field.trace(z);
164
- if ((traceZ === 0 && bit === 1) || (traceZ === 1 && bit === 0))
165
- z = field.setBit(z, 0, 1 ^ field.testBit(z, 0));
166
- return new Point(xClean, field.mul(z, xClean));
167
- }
181
+ /** Deserialize point from bytes (compressed/uncompressed) */
168
182
  static fromBytes(bytes) {
183
+ // Uncompressed
169
184
  if (bytes.length == pointByteLength)
170
185
  return new Point(toInternal(field.fromHexStringOrBytes(bytes.subarray(0, field.LENGTH))), toInternal(field.fromHexStringOrBytes(bytes.subarray(field.LENGTH))));
171
- else if (bytes.length == field.LENGTH)
172
- return Point.expand(field.fromHexStringOrBytes(bytes));
186
+ // Compressed (need to recover y-coord)
187
+ else if (bytes.length == field.LENGTH) {
188
+ const xExt = field.fromHexStringOrBytes(bytes);
189
+ const bit = xExt.testn(0);
190
+ xExt.setn(0, 0);
191
+ const traceX = onb ? field.traceOnb(xExt) : field.trace(xExt);
192
+ if ((traceX === 1 && parameters.a === 0) || (traceX === 0 && parameters.a === 1))
193
+ xExt.setn(0, 1);
194
+ const x = toInternal(xExt);
195
+ const x2 = field.sqr(x);
196
+ const rhs = field.mul(x2, x);
197
+ if (parameters.a === 1)
198
+ rhs.ixor(x2);
199
+ rhs.ixor(b);
200
+ const z = field.solve_quad(field.div(rhs, x2));
201
+ const traceZ = field.trace(z);
202
+ if ((traceZ === 0 && bit) || (traceZ === 1 && !bit))
203
+ field.invBit(z, 0);
204
+ return new Point(x, field.mul(z, x));
205
+ }
173
206
  else
174
207
  throw new Error(`Invalid bytes length. Must be ${pointByteLength} for uncompressed and ${field.LENGTH} for compressed`);
175
208
  }
176
209
  }
177
- const k = order.bitLength() - 1;
178
- const truncate = (x) => x.maskn(k);
179
210
  // Precompute
180
- Point.BASE.mulWnaf(new BN(3));
211
+ Point.BASE.precomp(4);
181
212
  return Object.freeze({
182
213
  Field: field, Point,
183
214
  ORDER: order,
215
+ MASK: order.bitLength() - 1,
184
216
  parameters, lengths,
185
217
  isOnb: !!onb,
186
- truncate,
187
218
  toInternalField: toInternal,
188
219
  toExternalField: toExternal
189
220
  });
@@ -8,14 +8,15 @@ export declare const createField: (m: number, ks: number[]) => Readonly<{
8
8
  LENGTH: number;
9
9
  mod: (f: BN) => BN;
10
10
  mul: (x: BN, v: BN) => BN;
11
+ div: (x: BN, v: BN) => BN;
11
12
  sqr: (x: BN) => BN;
13
+ sqrt: (x: BN) => BN;
12
14
  invert: (f: BN) => BN;
13
15
  solve_quad: (v: BN) => BN;
14
- testBit: (x: BN, i: number) => 0 | 1;
15
- setBit: (x: BN, i: number, v: number) => BN;
16
16
  trace: (x: BN) => 0 | 1;
17
17
  traceOnb: (x: BN) => 0 | 1;
18
18
  hashToField: (hash: TArg<Uint8Array>) => BN;
19
+ invBit: (x: BN, i: number) => BN;
19
20
  fromHexStringOrBytes: (v: string | Uint8Array) => BN;
20
21
  toBytes: (x: BN, length?: number) => TRet<Uint8Array>;
21
22
  }>;
@@ -53,21 +53,21 @@ const le2BN = (arr) => {
53
53
  }
54
54
  return new BN(bytes, "le");
55
55
  };
56
- const xorShiftedWordInto = (arr, val, shift) => {
56
+ const xorShiftedWordInto = (dst, val, shift) => {
57
57
  if (val === 0 || shift < 0)
58
58
  return;
59
59
  const wordShift = shift >>> 5, bitShift = shift & 31;
60
60
  if (bitShift === 0) {
61
- if (wordShift < arr.length)
62
- arr[wordShift] ^= (val >>> 0);
61
+ if (wordShift < dst.length)
62
+ dst[wordShift] ^= (val >>> 0);
63
63
  }
64
64
  else {
65
65
  const lo = (val << bitShift) >>> 0;
66
66
  const hi = (val >>> (WORD_BITS - bitShift)) >>> 0;
67
- if (wordShift < arr.length)
68
- arr[wordShift] ^= lo;
69
- if (wordShift + 1 < arr.length)
70
- arr[wordShift + 1] ^= hi;
67
+ if (wordShift < dst.length)
68
+ dst[wordShift] ^= lo;
69
+ if (wordShift + 1 < dst.length)
70
+ dst[wordShift + 1] ^= hi;
71
71
  }
72
72
  };
73
73
  /** Compute curve modulo */
@@ -81,39 +81,14 @@ export const computeMod = (m, ks) => {
81
81
  };
82
82
  /** Create `GF(2^m)` field */
83
83
  export const createField = (m, ks) => {
84
- const modulo = computeMod(m, ks);
85
- /*const mod = (f: BN): BN => {
86
- const cmp = f.cmp(modulo);
87
- if(cmp === 0) return new BN(0);
88
- if(cmp < 0) return f.clone();
89
-
90
- let bag = f;
91
- const vl = modulo.bitLength();
92
- while(true) {
93
- bag = bag.xor(modulo.ushln(bag.bitLength() - vl));
94
- if (bag.bitLength() < vl) return bag;
95
- }
96
- }
97
-
98
- const mul = (x: BN, v: BN): BN => {
99
- let bag = new BN(0), shift = x;
100
- for(let i = 0; i < v.bitLength(); i++) {
101
- if(v.testn(i)) bag = bag.xor(shift);
102
- shift = shift.ushln(1);
103
- }
104
-
105
- return mod(bag);
106
- }*/
107
- const wordsPerElement = Math.ceil(m / WORD_BITS);
108
- const wordsForProduct = 2 * wordsPerElement;
109
- const vl = modulo.bitLength();
84
+ const modulo = computeMod(m, ks), wordsPerElement = Math.ceil(m / WORD_BITS), wordsForProduct = 2 * wordsPerElement, vl = modulo.bitLength();
110
85
  const bMod = (f) => {
86
+ // `f` will be mutated
111
87
  if (f.bitLength() <= m)
112
- return f.clone();
113
- let bag = f;
114
- while (bag.bitLength() > m)
115
- bag = bag.xor(modulo.ushln(bag.bitLength() - vl));
116
- return bag;
88
+ return f;
89
+ while (f.bitLength() > m)
90
+ f.ixor(modulo.ushln(f.bitLength() - vl));
91
+ return f;
117
92
  };
118
93
  const mod = (f) => {
119
94
  if (f.bitLength() <= m)
@@ -140,7 +115,7 @@ export const createField = (m, ks) => {
140
115
  table[i] = table[i ^ lowBit].xor(x.ushln(lowBitIdx));
141
116
  }
142
117
  const vb = v.bitLength();
143
- let acc = new BN(0);
118
+ const acc = new BN(0);
144
119
  for (let win = Math.ceil(vb / MUL_WINDOW) - 1; win >= 0; win--) {
145
120
  let windowVal = 0;
146
121
  for (let b = 0; b < MUL_WINDOW; b++) {
@@ -148,10 +123,11 @@ export const createField = (m, ks) => {
148
123
  if (bitPos < vb && v.testn(bitPos))
149
124
  windowVal |= (1 << b);
150
125
  }
151
- acc = acc.ushln(MUL_WINDOW).xor(table[windowVal]);
126
+ acc.iushln(MUL_WINDOW).ixor(table[windowVal]);
152
127
  }
153
128
  return mod(acc);
154
129
  };
130
+ const div = (x, v) => mul(x, invert(v));
155
131
  const sqr = (x) => {
156
132
  const bytes = x.toArray();
157
133
  const out = new Uint8Array(bytes.length * 2);
@@ -163,11 +139,17 @@ export const createField = (m, ks) => {
163
139
  return mod(new BN(out));
164
140
  };
165
141
  const testBit = (x, i) => x.testn(i) ? 1 : 0;
166
- const setBit = (x, i, v) => x.setn(i, v == 1);
142
+ const invBit = (x, i) => x.setn(i, !x.testn(i));
143
+ const sqrt = (x) => {
144
+ let r = mod(x);
145
+ for (let i = 0; i < m - 1; i++)
146
+ r = sqr(r);
147
+ return r;
148
+ };
167
149
  const trace = (x) => {
168
150
  let t = x;
169
151
  for (let i = 1; i < m; i++)
170
- t = sqr(t).xor(x);
152
+ t = sqr(t).ixor(x);
171
153
  return testBit(t, 0);
172
154
  };
173
155
  const traceOnb = (x) => {
@@ -179,11 +161,11 @@ export const createField = (m, ks) => {
179
161
  const htrace = (x) => {
180
162
  let ht = x;
181
163
  for (let i = 1; i <= Math.floor((m - 1) / 2); i++)
182
- ht = sqr(sqr(ht)).xor(x);
164
+ ht = sqr(sqr(ht)).ixor(x);
183
165
  return ht;
184
166
  };
185
167
  const invert = (f) => {
186
- let r = mod(f), s = modulo;
168
+ let r = mod(f), s = modulo.clone();
187
169
  let u = new BN(1), v = new BN(0);
188
170
  while (r.bitLength() > 1) {
189
171
  let j = s.bitLength() - r.bitLength();
@@ -196,27 +178,27 @@ export const createField = (m, ks) => {
196
178
  v = buf;
197
179
  j = -j;
198
180
  }
199
- s = s.xor(r.ushln(j));
200
- v = v.xor(u.ushln(j));
181
+ s.ixor(r.ushln(j));
182
+ v.ixor(u.ushln(j));
201
183
  }
202
184
  return u;
203
185
  };
204
186
  const solve_quad = (v) => {
205
187
  const a = mod(v), z = htrace(a);
206
- if (sqr(z).xor(z).cmp(a) == 0)
188
+ if (sqr(z).ixor(z).cmp(a) == 0)
207
189
  return mod(z);
208
190
  throw new Error("squad eq fail: no square root exists");
209
191
  };
210
192
  const hashToField = (hash) => {
211
193
  const h = new BN(hash);
212
- return h.maskn(Math.min(m, h.bitLength()));
194
+ return h.imaskn(Math.min(m, h.bitLength()));
213
195
  };
214
196
  const fromHexStringOrBytes = (v) => new BN(v, 16);
215
197
  const toBytes = (x, length) => new Uint8Array(x.toArray("be", length));
216
198
  return Object.freeze({
217
199
  MODULO: modulo, LENGTH: Math.ceil(m / 8),
218
- mod, mul, sqr, invert, solve_quad,
219
- testBit, setBit, trace, traceOnb, hashToField,
200
+ mod, mul, div, sqr, sqrt, invert,
201
+ solve_quad, trace, traceOnb, hashToField, invBit,
220
202
  fromHexStringOrBytes, toBytes
221
203
  });
222
204
  };
@@ -5,11 +5,11 @@ const decompress_matrix = (compress_mulp, mulp) => {
5
5
  const mlen = Math.ceil(compress_mulp.bitLength() / 9);
6
6
  if (mlen === 0)
7
7
  return;
8
- let temp = compress_mulp;
8
+ const temp = compress_mulp;
9
9
  const mask = new BN(0x1ff);
10
10
  for (let j = mlen - 1; j >= 0; j--) {
11
11
  mulp[j] = temp.and(mask).toNumber();
12
- temp = temp.shrn(9);
12
+ temp.ishrn(9);
13
13
  }
14
14
  };
15
15
  export const init_onb_parameters = (parameters) => {
@@ -20,10 +20,10 @@ export const init_onb_parameters = (parameters) => {
20
20
  const compress_mulp = new BN(hexToBytes(onb.matrix), "le");
21
21
  decompress_matrix(compress_mulp, mulp);
22
22
  const root1 = new BN(hexToBytes(onb.root1), "le"), root2 = new BN(hexToBytes(onb.root2), "le");
23
- const multiplyOnb = (x, y) => {
23
+ const multiplyOnb = (x) => {
24
24
  const r = new BN(0);
25
25
  const xb = (pos) => (x.testn(pos % m) ? 1 : 0);
26
- const yb = (pos) => (y.testn(pos % m) ? 1 : 0);
26
+ const yb = (pos) => (root2.testn(pos % m) ? 1 : 0);
27
27
  for (let j = 0; j < m; j++) {
28
28
  let bit = 0;
29
29
  for (let i = 0; i < m - 1; i++) {
@@ -47,27 +47,27 @@ export const init_onb_parameters = (parameters) => {
47
47
  };
48
48
  const toPb = new Array(m);
49
49
  toPb[0] = root1.clone();
50
- const { mul } = createField(m, ks);
50
+ const { sqr } = createField(m, ks);
51
51
  for (let i = 1; i < m; i++)
52
- toPb[i] = mul(toPb[i - 1], toPb[i - 1]);
52
+ toPb[i] = sqr(toPb[i - 1]);
53
53
  const _toOnb = new Array(m);
54
- _toOnb[0] = new BN(1).shln(m).subn(1);
54
+ _toOnb[0] = new BN(1).ishln(m).isubn(1);
55
55
  for (let i = 1; i < m; i++)
56
- _toOnb[i] = multiplyOnb(_toOnb[i - 1], root2);
56
+ _toOnb[i] = multiplyOnb(_toOnb[i - 1]);
57
57
  const toOnb = _toOnb.map(reverseBits);
58
58
  return Object.freeze({
59
59
  onbToPb: (x) => {
60
- let r = new BN(0);
60
+ const r = new BN(0);
61
61
  for (let p = 0; p < m; p++)
62
62
  if (x.testn(p))
63
- r = r.xor(toPb[m - 1 - p]);
63
+ r.ixor(toPb[m - 1 - p]);
64
64
  return r;
65
65
  },
66
66
  pbToOnb: (x) => {
67
- let r = new BN(0);
67
+ const r = new BN(0);
68
68
  for (let j = 0; j < m; j++)
69
69
  if (x.testn(j))
70
- r = r.xor(toOnb[j]);
70
+ r.ixor(toOnb[j]);
71
71
  return r;
72
72
  }
73
73
  });
@@ -4,7 +4,7 @@ import BN from "bn.js";
4
4
  const DEFAULT_CUTOFFS = [13, 41, 121, 337, 897, 2305];
5
5
  export const bitLength = (n) => n === 0 ? 0 : 32 - Math.clz32(n);
6
6
  const compactNaf = (k) => {
7
- if (k.bitLength() >= 1 << 16)
7
+ if (k.bitLength() >= (1 << 16))
8
8
  throw new Error("'k' must have bitlength < 2^16");
9
9
  if (k.isZero())
10
10
  return new Int32Array(0);
package/dstu4145/index.js CHANGED
@@ -5,18 +5,18 @@ 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 { Field, Point, truncate, lengths } = 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(lengths.scalarByteLength))), lengths.scalarByteLength);
8
+ const { Field, Point, MASK, lengths } = curve;
9
+ const getPublicKey = (secretKey, isCompressed = false) => Point.BASE.mulWnaf(Field.fromHexStringOrBytes(secretKey)).negate().toBytes(isCompressed);
10
+ const randomPrivateKey = () => Field.toBytes(new BN(randomBytes(lengths.scalarByteLength)).imaskn(MASK), lengths.scalarByteLength);
11
11
  const computePresign = (rand) => {
12
- const e = truncate(rand
12
+ const e = (rand
13
13
  ? new BN(rand)
14
- : new BN(randomBytes(lengths.scalarByteLength)));
14
+ : new BN(randomBytes(lengths.scalarByteLength))).imaskn(MASK);
15
15
  if (rand && e.isZero())
16
16
  throw new Error("Invalid custom rand for presign (rand = 0)");
17
17
  if (e.isZero())
18
18
  return computePresign(rand);
19
- const Fe = Point.BASE.mul(e).x;
19
+ const Fe = Point.BASE.mulWnaf(e).x;
20
20
  if (Fe.isZero())
21
21
  return computePresign(rand);
22
22
  return { Fe, e };
@@ -29,7 +29,7 @@ export const dstu4145 = (parameters) => {
29
29
  };
30
30
  const sign = (secretKey, digest, rand) => {
31
31
  const d = new BN(secretKey), h = prepareHash(digest), { Fe, e } = computePresign(rand);
32
- const r = truncate(curve.toExternalField(Field.mul(h, Fe)));
32
+ const r = curve.toExternalField(Field.mul(h, Fe)).imaskn(MASK);
33
33
  if (r.isZero())
34
34
  return sign(secretKey, digest, rand);
35
35
  const s = e.add(d.mul(r)).mod(curve.ORDER);
@@ -45,8 +45,8 @@ export const dstu4145 = (parameters) => {
45
45
  if (s.isZero() || s.gte(curve.ORDER) || r.isZero() || r.gte(curve.ORDER))
46
46
  return false;
47
47
  const h = prepareHash(digest);
48
- const R = Point.BASE.mulWnaf(s).add(Q.mulWnaf(r));
49
- const y = truncate(curve.toExternalField(Field.mul(h, R.x)));
48
+ const R = Point.BASE.mulWnaf(s).add(Q.mul(r));
49
+ const y = curve.toExternalField(Field.mul(h, R.x)).imaskn(MASK);
50
50
  return y.eq(r);
51
51
  };
52
52
  const keygen = (isCompressed = false) => {