@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 +2 -1
- package/dstu4145/ec/expand.js +11 -12
- package/dstu4145/ec/index.d.ts +5 -26
- package/dstu4145/ec/index.js +77 -46
- package/dstu4145/ec/math.d.ts +3 -2
- package/dstu4145/ec/math.js +32 -50
- package/dstu4145/ec/onb.js +12 -12
- package/dstu4145/ec/wnaf.js +1 -1
- package/dstu4145/index.js +9 -9
- package/dstu9041/curve.d.ts +431 -0
- package/dstu9041/curve.js +129 -0
- package/dstu9041/index.d.ts +21 -0
- package/dstu9041/index.js +98 -0
- package/index.d.ts +1 -0
- package/index.js +1 -0
- package/kupyna/index.js +2 -1
- package/kupyna/kmac.js +2 -1
- package/modes/cbc.js +4 -6
- package/modes/cfb.js +24 -31
- package/modes/ctr.js +2 -2
- package/modes/ecb.js +2 -2
- package/modes/gcm.js +14 -16
- package/modes/index.d.ts +1 -0
- package/modes/index.js +1 -0
- package/modes/kw.d.ts +6 -0
- package/modes/kw.js +74 -0
- package/modes/mac.js +55 -59
- package/modes/ofb.js +3 -4
- package/package.json +3 -2
- package/utils.d.ts +1 -7
- package/utils.js +1 -23
package/README.md
CHANGED
|
@@ -20,11 +20,12 @@ npm i @li0ard/dstu
|
|
|
20
20
|
|
|
21
21
|
## Supported algorithms
|
|
22
22
|
|
|
23
|
-
- Curves and
|
|
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
|
|
package/dstu4145/ec/expand.js
CHANGED
|
@@ -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 =
|
|
13
|
+
const bit = x.testn(0);
|
|
14
14
|
let xClean = x.clone();
|
|
15
|
-
xClean
|
|
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
|
|
19
|
-
const
|
|
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
|
-
|
|
23
|
+
const rhs = field.mul(x2, xClean);
|
|
24
24
|
if (a === 1)
|
|
25
|
-
rhs
|
|
26
|
-
|
|
27
|
-
|
|
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
|
|
31
|
-
|
|
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(
|
|
35
|
+
x: field.toBytes(xOut, field.LENGTH),
|
|
37
36
|
y: field.toBytes(y, field.LENGTH)
|
|
38
37
|
};
|
|
39
38
|
};
|
package/dstu4145/ec/index.d.ts
CHANGED
|
@@ -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
|
-
|
|
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
|
}>;
|
package/dstu4145/ec/index.js
CHANGED
|
@@ -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
|
-
|
|
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
|
-
|
|
47
|
-
x2
|
|
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.
|
|
70
|
+
lbd = x1.xor(field.div(p.y, p.x));
|
|
55
71
|
x2 = field.sqr(lbd);
|
|
56
72
|
if (parameters.a === 1)
|
|
57
|
-
|
|
58
|
-
x2
|
|
73
|
+
field.invBit(x2, 0);
|
|
74
|
+
x2.ixor(lbd);
|
|
59
75
|
}
|
|
60
|
-
const y2 = field.mul(lbd, x1.xor(x2)).
|
|
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
|
-
|
|
67
|
-
|
|
68
|
-
|
|
69
|
-
|
|
70
|
-
|
|
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
|
-
|
|
74
|
-
|
|
93
|
+
[X2, Z2] = Madd(X2, Z2, X1, Z1, this.x);
|
|
94
|
+
[X1, Z1] = Mdouble(X1, Z1);
|
|
75
95
|
}
|
|
76
96
|
}
|
|
77
|
-
|
|
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.
|
|
84
|
-
return
|
|
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
|
-
|
|
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
|
-
|
|
172
|
-
|
|
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.
|
|
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
|
});
|
package/dstu4145/ec/math.d.ts
CHANGED
|
@@ -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
|
}>;
|
package/dstu4145/ec/math.js
CHANGED
|
@@ -53,21 +53,21 @@ const le2BN = (arr) => {
|
|
|
53
53
|
}
|
|
54
54
|
return new BN(bytes, "le");
|
|
55
55
|
};
|
|
56
|
-
const xorShiftedWordInto = (
|
|
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 <
|
|
62
|
-
|
|
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 <
|
|
68
|
-
|
|
69
|
-
if (wordShift + 1 <
|
|
70
|
-
|
|
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
|
|
113
|
-
|
|
114
|
-
|
|
115
|
-
|
|
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
|
-
|
|
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
|
|
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
|
|
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).
|
|
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)).
|
|
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
|
|
200
|
-
v
|
|
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).
|
|
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.
|
|
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,
|
|
219
|
-
|
|
200
|
+
mod, mul, div, sqr, sqrt, invert,
|
|
201
|
+
solve_quad, trace, traceOnb, hashToField, invBit,
|
|
220
202
|
fromHexStringOrBytes, toBytes
|
|
221
203
|
});
|
|
222
204
|
};
|
package/dstu4145/ec/onb.js
CHANGED
|
@@ -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
|
-
|
|
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
|
|
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
|
|
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) => (
|
|
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 {
|
|
50
|
+
const { sqr } = createField(m, ks);
|
|
51
51
|
for (let i = 1; i < m; i++)
|
|
52
|
-
toPb[i] =
|
|
52
|
+
toPb[i] = sqr(toPb[i - 1]);
|
|
53
53
|
const _toOnb = new Array(m);
|
|
54
|
-
_toOnb[0] = new BN(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]
|
|
56
|
+
_toOnb[i] = multiplyOnb(_toOnb[i - 1]);
|
|
57
57
|
const toOnb = _toOnb.map(reverseBits);
|
|
58
58
|
return Object.freeze({
|
|
59
59
|
onbToPb: (x) => {
|
|
60
|
-
|
|
60
|
+
const r = new BN(0);
|
|
61
61
|
for (let p = 0; p < m; p++)
|
|
62
62
|
if (x.testn(p))
|
|
63
|
-
r
|
|
63
|
+
r.ixor(toPb[m - 1 - p]);
|
|
64
64
|
return r;
|
|
65
65
|
},
|
|
66
66
|
pbToOnb: (x) => {
|
|
67
|
-
|
|
67
|
+
const r = new BN(0);
|
|
68
68
|
for (let j = 0; j < m; j++)
|
|
69
69
|
if (x.testn(j))
|
|
70
|
-
r
|
|
70
|
+
r.ixor(toOnb[j]);
|
|
71
71
|
return r;
|
|
72
72
|
}
|
|
73
73
|
});
|
package/dstu4145/ec/wnaf.js
CHANGED
|
@@ -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,
|
|
9
|
-
const getPublicKey = (secretKey, isCompressed = false) => Point.BASE.
|
|
10
|
-
const randomPrivateKey = () => Field.toBytes(
|
|
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 =
|
|
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.
|
|
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 =
|
|
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.
|
|
49
|
-
const y =
|
|
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) => {
|