@li0ard/dstu 0.1.5 → 0.1.7
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 +5 -0
- package/dstu4145/const.d.ts +2 -0
- package/dstu4145/const.js +17 -0
- package/dstu4145/ec/index.d.ts +8 -4
- package/dstu4145/ec/index.js +24 -6
- package/dstu4145/ec/math.js +2 -0
- package/dstu4145/index.d.ts +11 -0
- package/dstu4145/index.js +35 -6
- package/dstu9041/curve.js +13 -10
- package/dstu9041/index.d.ts +2 -2
- package/dstu9041/index.js +48 -44
- package/dstu9311/const.d.ts +29 -0
- package/dstu9311/const.js +150 -0
- package/dstu9311/hash.d.ts +34 -0
- package/dstu9311/hash.js +91 -0
- package/dstu9311/index.d.ts +16 -0
- package/dstu9311/index.js +59 -0
- package/index.d.ts +2 -0
- package/index.js +2 -0
- package/keywrap.d.ts +6 -0
- package/keywrap.js +34 -0
- package/modes/cbc.d.ts +2 -3
- package/modes/cbc.js +6 -5
- package/modes/cfb.d.ts +3 -4
- package/modes/cfb.js +88 -56
- package/modes/cmac.d.ts +2 -0
- package/modes/cmac.js +45 -0
- package/modes/ctr.d.ts +2 -3
- package/modes/ctr.js +25 -14
- package/modes/ecb.d.ts +2 -3
- package/modes/gcm.d.ts +2 -3
- package/modes/gcm.js +18 -14
- package/modes/gmac.d.ts +3 -0
- package/modes/gmac.js +40 -0
- package/modes/index.d.ts +3 -1
- package/modes/index.js +3 -1
- package/modes/kw.d.ts +5 -4
- package/modes/kw.js +63 -56
- package/modes/ofb.d.ts +2 -3
- package/modes/ofb.js +3 -2
- package/modes/xts.d.ts +7 -0
- package/modes/xts.js +93 -0
- package/package.json +3 -2
- package/strumok/index.d.ts +4 -3
- package/strumok/index.js +42 -277
- package/types.d.ts +5 -3
- package/utils.d.ts +5 -0
- package/utils.js +14 -2
- package/modes/mac.d.ts +0 -6
- package/modes/mac.js +0 -61
package/README.md
CHANGED
|
@@ -26,6 +26,8 @@ npm i @li0ard/dstu
|
|
|
26
26
|
- Supports KMAC
|
|
27
27
|
- Strumok stream cipher (DSTU 8845:2019)
|
|
28
28
|
- ECIES encryption schema over Twisted Edwards curves (DSTU 9041:2020)
|
|
29
|
+
- DSTU 9311:2024 cipher (republished DSTU GOST 28147:2009)
|
|
30
|
+
- GOST 34.311-95 hash function over DSTU 9311:2024
|
|
29
31
|
|
|
30
32
|
## Supported cipher modes
|
|
31
33
|
|
|
@@ -36,6 +38,9 @@ npm i @li0ard/dstu
|
|
|
36
38
|
- Galois Counter mode (GCM)
|
|
37
39
|
- Message Authentication Code mode (MAC and GMAC)
|
|
38
40
|
- Output Feedback mode (OFB)
|
|
41
|
+
- Key wrapping (KW)
|
|
42
|
+
- Supports [`Dstu7624Wrap`](https://zakon.rada.gov.ua/laws/show/z0108-13)
|
|
43
|
+
- XEX Tweakable Block Ciphertext Stealing (XTS)
|
|
39
44
|
|
|
40
45
|
## Supported curves
|
|
41
46
|
|
package/dstu4145/const.d.ts
CHANGED
|
@@ -22,6 +22,8 @@ export interface DSTUShortParameters {
|
|
|
22
22
|
export interface DSTUParameters extends DSTUShortParameters {
|
|
23
23
|
/** Curve order */
|
|
24
24
|
order: string;
|
|
25
|
+
/** Curve cofactor */
|
|
26
|
+
cofactor: 2 | 4;
|
|
25
27
|
/** Base point `X` coordinate */
|
|
26
28
|
Gx: string;
|
|
27
29
|
/** Base point `Y` coordinate */
|
package/dstu4145/const.js
CHANGED
|
@@ -3,6 +3,7 @@ export const DSTU_163 = {
|
|
|
3
3
|
a: 1,
|
|
4
4
|
b: "05FF6108462A2DC8210AB403925E638A19C1455D21",
|
|
5
5
|
order: "0400000000000000000002BEC12BE2262D39BCF14D",
|
|
6
|
+
cofactor: 2,
|
|
6
7
|
Gx: "02E2F85F5DD74CE983A5C4237229DAF8A3F35823BE",
|
|
7
8
|
Gy: "03826F008A8C51D7B95284D9D03FF0E00CE2CD723A",
|
|
8
9
|
m: 163,
|
|
@@ -13,6 +14,7 @@ export const DSTU_163_TEST = {
|
|
|
13
14
|
a: 1,
|
|
14
15
|
b: "05FF6108462A2DC8210AB403925E638A19C1455D21",
|
|
15
16
|
order: "0400000000000000000002BEC12BE2262D39BCF14D",
|
|
17
|
+
cofactor: 2,
|
|
16
18
|
Gx: "072D867F93A93AC27DF9FF01AFFE74885C8C540420",
|
|
17
19
|
Gy: "00224A9C3947852B97C5599D5F4AB81122ADC3FD9B",
|
|
18
20
|
m: 163,
|
|
@@ -23,6 +25,7 @@ export const DSTU_167 = {
|
|
|
23
25
|
a: 1,
|
|
24
26
|
b: "6EE3CEEB230811759F20518A0930F1A4315A827DAC",
|
|
25
27
|
order: "3FFFFFFFFFFFFFFFFFFFFFB12EBCC7D7F29FF7701F",
|
|
28
|
+
cofactor: 2,
|
|
26
29
|
Gx: "7A1F6653786A68192803910A3D30B2A2018B21CD54",
|
|
27
30
|
Gy: "5F49EB26781C0EC6B8909156D98ED435E45FD59918",
|
|
28
31
|
m: 167,
|
|
@@ -33,6 +36,7 @@ export const DSTU_173 = {
|
|
|
33
36
|
a: 0,
|
|
34
37
|
b: "108576C80499DB2FC16EDDF6853BBB278F6B6FB437D9",
|
|
35
38
|
order: "0800000000000000000000189B4E67606E3825BB2831",
|
|
39
|
+
cofactor: 4,
|
|
36
40
|
Gx: "04D41A619BCC6EADF0448FA22FAD567A9181D37389CA",
|
|
37
41
|
Gy: "10B51CC12849B234C75E6DD2028BF7FF5C1CE0D991A1",
|
|
38
42
|
m: 173,
|
|
@@ -48,6 +52,7 @@ export const DSTU_173_ONB = {
|
|
|
48
52
|
a: 0,
|
|
49
53
|
b: "043D7E139319F43BA00944915740E1E6651B06E278C7",
|
|
50
54
|
order: "800000000000000000000189B4E67606E3825BB2831",
|
|
55
|
+
cofactor: 4,
|
|
51
56
|
Gx: "0A3B8B8D704089B24318CAA51917CB6E424B4E6DEA56",
|
|
52
57
|
Gy: "005A43D5EE1F400349CF35150C74F119A39145F0CB08",
|
|
53
58
|
m: 173,
|
|
@@ -59,6 +64,7 @@ export const DSTU_173_ONB_TEST = {
|
|
|
59
64
|
a: 0,
|
|
60
65
|
b: "043D7E139319F43BA00944915740E1E6651B06E278C7",
|
|
61
66
|
order: "800000000000000000000189B4E67606E3825BB2831",
|
|
67
|
+
cofactor: 4,
|
|
62
68
|
Gx: "1D26E5282C2647E1B0327CB4F6087932A0A1F006A89F",
|
|
63
69
|
Gy: "0322218E4551CF8F6E3345644A10B2408F5DF19EC2C7",
|
|
64
70
|
m: 173,
|
|
@@ -70,6 +76,7 @@ export const DSTU_179 = {
|
|
|
70
76
|
a: 1,
|
|
71
77
|
b: "04A6E0856526436F2F88DD07A341E32D04184572BEB710",
|
|
72
78
|
order: "03FFFFFFFFFFFFFFFFFFFFFFB981960435FE5AB64236EF",
|
|
79
|
+
cofactor: 2,
|
|
73
80
|
Gx: "06BA06FE51464B2BD26DC57F48819BA9954667022C7D03",
|
|
74
81
|
Gy: "025FBC363582DCEC065080CA8287AAFF09788A66DC3A9E",
|
|
75
82
|
m: 179,
|
|
@@ -80,6 +87,7 @@ export const DSTU_179_ONB = {
|
|
|
80
87
|
a: 1,
|
|
81
88
|
b: "019C9EBC4FD8308193D3A61762C547C82F2E6B2182CBCB",
|
|
82
89
|
order: "03FFFFFFFFFFFFFFFFFFFFFFB981960435FE5AB64236EF",
|
|
90
|
+
cofactor: 2,
|
|
83
91
|
Gx: "011F4112265410477159E0D3E39BC4AC4ADE43B21B66B9",
|
|
84
92
|
Gy: "02CA5F0B34C61A86216F13766591CB266E2819EE582B3C",
|
|
85
93
|
m: 179,
|
|
@@ -95,6 +103,7 @@ export const DSTU_191 = {
|
|
|
95
103
|
a: 1,
|
|
96
104
|
b: "7BC86E2102902EC4D5890E8B6B4981FF27E0482750FEFC03",
|
|
97
105
|
order: "40000000000000000000000069A779CAC1DABC6788F7474F",
|
|
106
|
+
cofactor: 2,
|
|
98
107
|
Gx: "714114B762F2FF4A7912A6D2AC58B9B5C2FCFE76DAEB7129",
|
|
99
108
|
Gy: "29C41E568B77C617EFE5902F11DB96FA9613CD8D03DB08DA",
|
|
100
109
|
m: 191,
|
|
@@ -105,6 +114,7 @@ export const DSTU_191_ONB = {
|
|
|
105
114
|
a: 1,
|
|
106
115
|
b: "13871C9D29D6CEEA740FD57444F72FDBAE559C13A1E31EF8",
|
|
107
116
|
order: "40000000000000000000000069A779CAC1DABC6788F7474F",
|
|
117
|
+
cofactor: 2,
|
|
108
118
|
Gx: "7159E0D3E39BC4AC4ADE43B21B66B94F2AF25ABEEB1D85D3",
|
|
109
119
|
Gy: "57E45D546BE6201E9705E029535D009D31F51D81E18226BE",
|
|
110
120
|
m: 191,
|
|
@@ -120,6 +130,7 @@ export const DSTU_233 = {
|
|
|
120
130
|
a: 1,
|
|
121
131
|
b: "6973B15095675534C7CF7E64A21BD54EF5DD3B8A0326AA936ECE454D2C",
|
|
122
132
|
order: "01000000000000000000000000000013E974E72F8A6922031D2603CFE0D7",
|
|
133
|
+
cofactor: 2,
|
|
123
134
|
Gx: "3FCDA526B6CDF83BA1118DF35B3C31761D3545F32728D003EEB25EFE96",
|
|
124
135
|
Gy: "9CA8B57A934C54DEEDA9E54A7BBAD95E3B2E91C54D32BE0B9DF96D8D35",
|
|
125
136
|
m: 233,
|
|
@@ -130,6 +141,7 @@ export const DSTU_233_ONB = {
|
|
|
130
141
|
a: 1,
|
|
131
142
|
b: "80F920952A702C75B704A424C018EEA55AA44664F3A003E0962D4F9A8E",
|
|
132
143
|
order: "01000000000000000000000000000013E974E72F8A6922031D2603CFE0D7",
|
|
144
|
+
cofactor: 2,
|
|
133
145
|
Gx: "A0823B8ACF069F1CDE256256F21D90DB35CA795792D5F758EC2E9992FB",
|
|
134
146
|
Gy: "019DAE222AF326D33AFB7761953F624A23D3EB1CA7A1C300F0AA9953CA85",
|
|
135
147
|
m: 233,
|
|
@@ -145,6 +157,7 @@ export const DSTU_257 = {
|
|
|
145
157
|
a: 0,
|
|
146
158
|
b: "01CEF494720115657E18F938D7A7942394FF9425C1458C57861F9EEA6ADBE3BE10",
|
|
147
159
|
order: "00800000000000000000000000000000006759213AF182E987D3E17714907D470D",
|
|
160
|
+
cofactor: 4,
|
|
148
161
|
Gx: "002A29EF207D0E9B6C55CD260B306C7E007AC491CA1B10C62334A9E8DCD8D20FB7",
|
|
149
162
|
Gy: "010686D41FF744D4449FCCF6D8EEA03102E6812C93A9D60B978B702CF156D814EF",
|
|
150
163
|
m: 257,
|
|
@@ -155,6 +168,7 @@ export const DSTU_307 = {
|
|
|
155
168
|
a: 1,
|
|
156
169
|
b: "0393C7F7D53666B5054B5E6C6D3DE94F4296C0C599E2E2E241050DF18B6090BDC90186904968BB",
|
|
157
170
|
order: "03FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC079C2F3825DA70D390FBBA588D4604022B7B7",
|
|
171
|
+
cofactor: 2,
|
|
158
172
|
Gx: "0216EE8B189D291A0224984C1E92F1D16BF75CCD825A087A239B276D3167743C52C02D6E7232AA",
|
|
159
173
|
Gy: "05D9306BACD22B7FAEB09D2E049C6E2866C5D1677762A8F2F2DC9A11C7F7BE8340AB2237C7F2A0",
|
|
160
174
|
m: 307,
|
|
@@ -165,6 +179,7 @@ export const DSTU_367 = {
|
|
|
165
179
|
a: 1,
|
|
166
180
|
b: "43FC8AD242B0B7A6F3D1627AD5654447556B47BF6AA4A64B0C2AFE42CADAB8F93D92394C79A79755437B56995136",
|
|
167
181
|
order: "40000000000000000000000000000000000000000000009C300B75A3FA824F22428FD28CE8812245EF44049B2D49",
|
|
182
|
+
cofactor: 2,
|
|
168
183
|
Gx: "324A6EDDD512F08C49A99AE0D3F961197A76413E7BE81A400CA681E09639B5FE12E59A109F78BF4A373541B3B9A1",
|
|
169
184
|
Gy: "01AB597A5B4477F59E39539007C7F977D1A567B92B043A49C6B61984C3FE3481AAF454CD41BA1F051626442B3C10",
|
|
170
185
|
m: 367,
|
|
@@ -175,6 +190,7 @@ export const DSTU_431 = {
|
|
|
175
190
|
a: 1,
|
|
176
191
|
b: "03CE10490F6A708FC26DFE8C3D27C4F94E690134D5BFF988D8D28AAEAEDE975936C66BAC536B18AE2DC312CA493117DAA469C640CAF3",
|
|
177
192
|
order: "3FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFBA3175458009A8C0A724F02F81AA8A1FCBAF80D90C7A95110504CF",
|
|
193
|
+
cofactor: 2,
|
|
178
194
|
Gx: "1A62BA79D98133A16BBAE7ED9A8E03C32E0824D57AEF72F88986874E5AAE49C27BED49A2A95058068426C2171E99FD3B43C5947C857D",
|
|
179
195
|
Gy: "70B5E1E14031C1F70BBEFE96BDDE66F451754B4CA5F48DA241F331AA396B8D1839A855C1769B1EA14BA53308B5E2723724E090E02DB9",
|
|
180
196
|
m: 431,
|
|
@@ -185,6 +201,7 @@ export const DSTU_431_ONB = {
|
|
|
185
201
|
a: 1,
|
|
186
202
|
b: "53FB7AF7B4407000A6F226AD6BAD28378646BD83F1F940810A4C19536EE65E53F40F973F2F06C5E80EFE3B43651BD5FF8B06BA5F9299",
|
|
187
203
|
order: "3FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFBA3175458009A8C0A724F02F81AA8A1FCBAF80D90C7A95110504CF",
|
|
204
|
+
cofactor: 2,
|
|
188
205
|
Gx: "2020182CFCD7C724157B363D4ABFD4C16251773C595D4E5C88572FA9D5EBB58142326448C08D3EE3E17E40B835D3090DCFBA7C5ADEA6",
|
|
189
206
|
Gy: "18E1B6EFB28EEF8A1F9C1859ED57C74CA747E4E1A60294C005D1920E80903A432929855828DD7F21714F837E119A044987F00110ADAD",
|
|
190
207
|
m: 431,
|
package/dstu4145/ec/index.d.ts
CHANGED
|
@@ -28,8 +28,9 @@ export declare const binaryWeierstrass: (parameters: DSTUParameters) => Readonly
|
|
|
28
28
|
_double?: /*elided*/ any;
|
|
29
29
|
x: BN;
|
|
30
30
|
y: BN;
|
|
31
|
+
assertValidity(): /*elided*/ any;
|
|
31
32
|
add(p: /*elided*/ any): /*elided*/ any;
|
|
32
|
-
mul(f: BN): /*elided*/ any;
|
|
33
|
+
mul(f: BN | number): /*elided*/ any;
|
|
33
34
|
negate(): /*elided*/ any;
|
|
34
35
|
clone(): /*elided*/ any;
|
|
35
36
|
isZero(): boolean;
|
|
@@ -51,8 +52,9 @@ export declare const binaryWeierstrass: (parameters: DSTUParameters) => Readonly
|
|
|
51
52
|
_double?: /*elided*/ any;
|
|
52
53
|
x: BN;
|
|
53
54
|
y: BN;
|
|
55
|
+
assertValidity(): /*elided*/ any;
|
|
54
56
|
add(p: /*elided*/ any): /*elided*/ any;
|
|
55
|
-
mul(f: BN): /*elided*/ any;
|
|
57
|
+
mul(f: BN | number): /*elided*/ any;
|
|
56
58
|
negate(): /*elided*/ any;
|
|
57
59
|
clone(): /*elided*/ any;
|
|
58
60
|
isZero(): boolean;
|
|
@@ -74,8 +76,9 @@ export declare const binaryWeierstrass: (parameters: DSTUParameters) => Readonly
|
|
|
74
76
|
_double?: /*elided*/ any;
|
|
75
77
|
x: BN;
|
|
76
78
|
y: BN;
|
|
79
|
+
assertValidity(): /*elided*/ any;
|
|
77
80
|
add(p: /*elided*/ any): /*elided*/ any;
|
|
78
|
-
mul(f: BN): /*elided*/ any;
|
|
81
|
+
mul(f: BN | number): /*elided*/ any;
|
|
79
82
|
negate(): /*elided*/ any;
|
|
80
83
|
clone(): /*elided*/ any;
|
|
81
84
|
isZero(): boolean;
|
|
@@ -98,8 +101,9 @@ export declare const binaryWeierstrass: (parameters: DSTUParameters) => Readonly
|
|
|
98
101
|
_double?: /*elided*/ any;
|
|
99
102
|
x: BN;
|
|
100
103
|
y: BN;
|
|
104
|
+
assertValidity(): /*elided*/ any;
|
|
101
105
|
add(p: /*elided*/ any): /*elided*/ any;
|
|
102
|
-
mul(f: BN): /*elided*/ any;
|
|
106
|
+
mul(f: BN | number): /*elided*/ any;
|
|
103
107
|
negate(): /*elided*/ any;
|
|
104
108
|
clone(): /*elided*/ any;
|
|
105
109
|
isZero(): boolean;
|
package/dstu4145/ec/index.js
CHANGED
|
@@ -11,6 +11,15 @@ export const binaryWeierstrass = (parameters) => {
|
|
|
11
11
|
const order = field.fromHexStringOrBytes(parameters.order);
|
|
12
12
|
const b = toInternal(field.fromHexStringOrBytes(parameters.b));
|
|
13
13
|
const c = field.sqrt(b);
|
|
14
|
+
const isValidXY = (x, y) => {
|
|
15
|
+
const x2 = field.sqr(x);
|
|
16
|
+
const lhs = field.sqr(y).ixor(field.mul(x, y));
|
|
17
|
+
const rhs = field.mul(x2, x).ixor(b);
|
|
18
|
+
// `a` must be 0 or 1, so if a = 1, just add x^2
|
|
19
|
+
if (parameters.a === 1)
|
|
20
|
+
rhs.ixor(x2);
|
|
21
|
+
return lhs.eq(rhs);
|
|
22
|
+
};
|
|
14
23
|
const scalarByteLength = Math.ceil(order.bitLength() / 8), pointByteLength = field.LENGTH * 2;
|
|
15
24
|
const lengths = Object.freeze({
|
|
16
25
|
fieldByteLength: field.LENGTH,
|
|
@@ -45,6 +54,13 @@ export const binaryWeierstrass = (parameters) => {
|
|
|
45
54
|
constructor(x, y) {
|
|
46
55
|
this.x = x;
|
|
47
56
|
this.y = y;
|
|
57
|
+
this.assertValidity();
|
|
58
|
+
}
|
|
59
|
+
assertValidity() {
|
|
60
|
+
// Skip if point is infinity
|
|
61
|
+
if (!isValidXY(this.x, this.y) && !this.x.isZero() && !this.y.isZero())
|
|
62
|
+
throw new Error("Assertation failed: point isn't on curve");
|
|
63
|
+
return this;
|
|
48
64
|
}
|
|
49
65
|
add(p) {
|
|
50
66
|
const pz = Point.ZERO.clone();
|
|
@@ -79,6 +95,8 @@ export const binaryWeierstrass = (parameters) => {
|
|
|
79
95
|
return pz;
|
|
80
96
|
}
|
|
81
97
|
mul(f) {
|
|
98
|
+
if (typeof f == "number")
|
|
99
|
+
f = new BN(f);
|
|
82
100
|
if (f.isZero() || this.x.isZero())
|
|
83
101
|
return Point.ZERO.clone();
|
|
84
102
|
let X1 = this.x.clone(), Z1 = new BN(1);
|
|
@@ -101,12 +119,12 @@ export const binaryWeierstrass = (parameters) => {
|
|
|
101
119
|
return this.negate();
|
|
102
120
|
const A = field.mul(this.x, Z1).ixor(X1);
|
|
103
121
|
const B = field.mul(this.x, Z2).ixor(X2);
|
|
104
|
-
const
|
|
105
|
-
const
|
|
106
|
-
const
|
|
107
|
-
const
|
|
108
|
-
const Xk = field.mul(X1, field.mul(
|
|
109
|
-
const Yk = field.mul(field.mul(A,
|
|
122
|
+
const C = field.mul(Z1, Z2);
|
|
123
|
+
const D = field.mul(C, this.x);
|
|
124
|
+
const E = field.invert(field.mul(D, Z1));
|
|
125
|
+
const F = field.mul(A, B).ixor(field.mul(C, xSqr.ixor(this.y)));
|
|
126
|
+
const Xk = field.mul(X1, field.mul(D, E));
|
|
127
|
+
const Yk = field.mul(field.mul(A, F), E).ixor(this.y);
|
|
110
128
|
return new Point(Xk, Yk);
|
|
111
129
|
}
|
|
112
130
|
negate() { return new Point(this.x.clone(), this.x.xor(this.y)); }
|
package/dstu4145/ec/math.js
CHANGED
|
@@ -107,6 +107,8 @@ export const createField = (m, ks) => {
|
|
|
107
107
|
return bMod(le2BN(words));
|
|
108
108
|
};
|
|
109
109
|
const mul = (x, v) => {
|
|
110
|
+
if (x.eq(v))
|
|
111
|
+
return sqr(x);
|
|
110
112
|
const table = new Array(MUL_TABLE_SIZE);
|
|
111
113
|
table[0] = new BN(0);
|
|
112
114
|
for (let i = 1; i < MUL_TABLE_SIZE; i++) {
|
package/dstu4145/index.d.ts
CHANGED
|
@@ -3,6 +3,7 @@ import { type DSTUParameters } from "./const.js";
|
|
|
3
3
|
/** Create DSTU 4145-2002 signer (Big-Endian) */
|
|
4
4
|
export declare const dstu4145: (parameters: DSTUParameters) => Readonly<{
|
|
5
5
|
getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
|
|
6
|
+
getSharedSecret: (secretKeyA: TArg<Uint8Array>, publicKeyB: TArg<Uint8Array>, withCofactor?: boolean) => TRet<Uint8Array>;
|
|
6
7
|
sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
|
|
7
8
|
verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
|
|
8
9
|
keygen: (isCompressed?: boolean) => {
|
|
@@ -21,6 +22,7 @@ export * from "./ec/expand.js";
|
|
|
21
22
|
/** DSTU 4145-2002 163 bit curve */
|
|
22
23
|
export declare const dstu163: Readonly<{
|
|
23
24
|
getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
|
|
25
|
+
getSharedSecret: (secretKeyA: TArg<Uint8Array>, publicKeyB: TArg<Uint8Array>, withCofactor?: boolean) => TRet<Uint8Array>;
|
|
24
26
|
sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
|
|
25
27
|
verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
|
|
26
28
|
keygen: (isCompressed?: boolean) => {
|
|
@@ -37,6 +39,7 @@ export declare const dstu163: Readonly<{
|
|
|
37
39
|
/** DSTU 4145-2002 167 bit curve */
|
|
38
40
|
export declare const dstu167: Readonly<{
|
|
39
41
|
getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
|
|
42
|
+
getSharedSecret: (secretKeyA: TArg<Uint8Array>, publicKeyB: TArg<Uint8Array>, withCofactor?: boolean) => TRet<Uint8Array>;
|
|
40
43
|
sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
|
|
41
44
|
verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
|
|
42
45
|
keygen: (isCompressed?: boolean) => {
|
|
@@ -53,6 +56,7 @@ export declare const dstu167: Readonly<{
|
|
|
53
56
|
/** DSTU 4145-2002 173 bit curve */
|
|
54
57
|
export declare const dstu173: Readonly<{
|
|
55
58
|
getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
|
|
59
|
+
getSharedSecret: (secretKeyA: TArg<Uint8Array>, publicKeyB: TArg<Uint8Array>, withCofactor?: boolean) => TRet<Uint8Array>;
|
|
56
60
|
sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
|
|
57
61
|
verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
|
|
58
62
|
keygen: (isCompressed?: boolean) => {
|
|
@@ -69,6 +73,7 @@ export declare const dstu173: Readonly<{
|
|
|
69
73
|
/** DSTU 4145-2002 179 bit curve */
|
|
70
74
|
export declare const dstu179: Readonly<{
|
|
71
75
|
getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
|
|
76
|
+
getSharedSecret: (secretKeyA: TArg<Uint8Array>, publicKeyB: TArg<Uint8Array>, withCofactor?: boolean) => TRet<Uint8Array>;
|
|
72
77
|
sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
|
|
73
78
|
verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
|
|
74
79
|
keygen: (isCompressed?: boolean) => {
|
|
@@ -85,6 +90,7 @@ export declare const dstu179: Readonly<{
|
|
|
85
90
|
/** DSTU 4145-2002 191 bit curve */
|
|
86
91
|
export declare const dstu191: Readonly<{
|
|
87
92
|
getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
|
|
93
|
+
getSharedSecret: (secretKeyA: TArg<Uint8Array>, publicKeyB: TArg<Uint8Array>, withCofactor?: boolean) => TRet<Uint8Array>;
|
|
88
94
|
sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
|
|
89
95
|
verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
|
|
90
96
|
keygen: (isCompressed?: boolean) => {
|
|
@@ -101,6 +107,7 @@ export declare const dstu191: Readonly<{
|
|
|
101
107
|
/** DSTU 4145-2002 233 bit curve */
|
|
102
108
|
export declare const dstu233: Readonly<{
|
|
103
109
|
getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
|
|
110
|
+
getSharedSecret: (secretKeyA: TArg<Uint8Array>, publicKeyB: TArg<Uint8Array>, withCofactor?: boolean) => TRet<Uint8Array>;
|
|
104
111
|
sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
|
|
105
112
|
verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
|
|
106
113
|
keygen: (isCompressed?: boolean) => {
|
|
@@ -117,6 +124,7 @@ export declare const dstu233: Readonly<{
|
|
|
117
124
|
/** DSTU 4145-2002 257 bit curve */
|
|
118
125
|
export declare const dstu257: Readonly<{
|
|
119
126
|
getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
|
|
127
|
+
getSharedSecret: (secretKeyA: TArg<Uint8Array>, publicKeyB: TArg<Uint8Array>, withCofactor?: boolean) => TRet<Uint8Array>;
|
|
120
128
|
sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
|
|
121
129
|
verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
|
|
122
130
|
keygen: (isCompressed?: boolean) => {
|
|
@@ -133,6 +141,7 @@ export declare const dstu257: Readonly<{
|
|
|
133
141
|
/** DSTU 4145-2002 307 bit curve */
|
|
134
142
|
export declare const dstu307: Readonly<{
|
|
135
143
|
getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
|
|
144
|
+
getSharedSecret: (secretKeyA: TArg<Uint8Array>, publicKeyB: TArg<Uint8Array>, withCofactor?: boolean) => TRet<Uint8Array>;
|
|
136
145
|
sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
|
|
137
146
|
verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
|
|
138
147
|
keygen: (isCompressed?: boolean) => {
|
|
@@ -149,6 +158,7 @@ export declare const dstu307: Readonly<{
|
|
|
149
158
|
/** DSTU 4145-2002 367 bit curve */
|
|
150
159
|
export declare const dstu367: Readonly<{
|
|
151
160
|
getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
|
|
161
|
+
getSharedSecret: (secretKeyA: TArg<Uint8Array>, publicKeyB: TArg<Uint8Array>, withCofactor?: boolean) => TRet<Uint8Array>;
|
|
152
162
|
sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
|
|
153
163
|
verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
|
|
154
164
|
keygen: (isCompressed?: boolean) => {
|
|
@@ -165,6 +175,7 @@ export declare const dstu367: Readonly<{
|
|
|
165
175
|
/** DSTU 4145-2002 431 bit curve */
|
|
166
176
|
export declare const dstu431: Readonly<{
|
|
167
177
|
getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
|
|
178
|
+
getSharedSecret: (secretKeyA: TArg<Uint8Array>, publicKeyB: TArg<Uint8Array>, withCofactor?: boolean) => TRet<Uint8Array>;
|
|
168
179
|
sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
|
|
169
180
|
verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
|
|
170
181
|
keygen: (isCompressed?: boolean) => {
|
package/dstu4145/index.js
CHANGED
|
@@ -6,29 +6,41 @@ import BN from "bn.js";
|
|
|
6
6
|
export const dstu4145 = (parameters) => {
|
|
7
7
|
const curve = binaryWeierstrass(parameters);
|
|
8
8
|
const { Field, Point, MASK, lengths } = curve;
|
|
9
|
-
|
|
9
|
+
/**
|
|
10
|
+
* Computes public key for a secret key
|
|
11
|
+
* @param isCompressed - whether to return compact (default), or full key
|
|
12
|
+
* @returns Public key, full when `isCompressed=false`; short when `isCompressed=true`
|
|
13
|
+
*/
|
|
14
|
+
const getPublicKey = (secretKey, isCompressed = false) => Point.BASE.mul(Field.fromHexStringOrBytes(secretKey)).negate().toBytes(isCompressed);
|
|
10
15
|
const randomPrivateKey = () => Field.toBytes(new BN(randomBytes(lengths.scalarByteLength)).imaskn(MASK), lengths.scalarByteLength);
|
|
16
|
+
/**
|
|
17
|
+
* Computes presign (ephermeral keypair)
|
|
18
|
+
* @param rand Predefined secret ephermeral key
|
|
19
|
+
* @returns Ephemeral public key (`Fe`) and secret key (`e`)
|
|
20
|
+
*/
|
|
11
21
|
const computePresign = (rand) => {
|
|
12
|
-
const e = (rand
|
|
13
|
-
? new BN(rand)
|
|
14
|
-
: new BN(randomBytes(lengths.scalarByteLength))).imaskn(MASK);
|
|
22
|
+
const e = new BN(rand ?? randomBytes(lengths.scalarByteLength)).imaskn(MASK);
|
|
15
23
|
if (rand && e.isZero())
|
|
16
24
|
throw new Error("Invalid custom rand for presign (rand = 0)");
|
|
17
|
-
if (e.isZero())
|
|
25
|
+
else if (e.isZero())
|
|
18
26
|
return computePresign(rand);
|
|
19
|
-
const Fe = Point.BASE.
|
|
27
|
+
const Fe = Point.BASE.mul(e).x;
|
|
20
28
|
if (Fe.isZero())
|
|
21
29
|
return computePresign(rand);
|
|
22
30
|
return { Fe, e };
|
|
23
31
|
};
|
|
32
|
+
/** Converts hash into field element */
|
|
24
33
|
const prepareHash = (digest) => {
|
|
25
34
|
let h = curve.toInternalField(Field.hashToField(digest));
|
|
26
35
|
if (h.isZero())
|
|
27
36
|
h = new BN(1);
|
|
28
37
|
return h;
|
|
29
38
|
};
|
|
39
|
+
/** Signs a message hash with a secret key. */
|
|
30
40
|
const sign = (secretKey, digest, rand) => {
|
|
31
41
|
const d = new BN(secretKey), h = prepareHash(digest), { Fe, e } = computePresign(rand);
|
|
42
|
+
if (d.isZero() || d.gte(curve.ORDER))
|
|
43
|
+
throw new Error("Invalid private key, must be in range 1 < key < order");
|
|
32
44
|
const r = curve.toExternalField(Field.mul(h, Fe)).imaskn(MASK);
|
|
33
45
|
if (r.isZero())
|
|
34
46
|
return sign(secretKey, digest, rand);
|
|
@@ -37,6 +49,7 @@ export const dstu4145 = (parameters) => {
|
|
|
37
49
|
return sign(secretKey, digest, rand);
|
|
38
50
|
return concatBytes(Field.toBytes(s, lengths.scalarByteLength), Field.toBytes(r, lengths.scalarByteLength));
|
|
39
51
|
};
|
|
52
|
+
/** Verifies a signature against message hash and public key. */
|
|
40
53
|
const verify = (publicKey, digest, signature) => {
|
|
41
54
|
if (signature.length != lengths.signatureByteLength)
|
|
42
55
|
throw new Error("Invalid signature length");
|
|
@@ -49,6 +62,21 @@ export const dstu4145 = (parameters) => {
|
|
|
49
62
|
const y = curve.toExternalField(Field.mul(h, R.x)).imaskn(MASK);
|
|
50
63
|
return y.eq(r);
|
|
51
64
|
};
|
|
65
|
+
/**
|
|
66
|
+
* Computes shared secret key
|
|
67
|
+
* @param withCofactor Multiply result by curve cofactor? (default - `true`)
|
|
68
|
+
*/
|
|
69
|
+
const getSharedSecret = (secretKeyA, publicKeyB, withCofactor = true) => {
|
|
70
|
+
const d = new BN(secretKeyA), Q = Point.fromBytes(publicKeyB);
|
|
71
|
+
if (d.isZero() || d.gte(curve.ORDER))
|
|
72
|
+
throw new Error("Invalid private key, must be in range 1 < key < order");
|
|
73
|
+
let R = Q.mul(d);
|
|
74
|
+
if (withCofactor)
|
|
75
|
+
R = R.mul(curve.parameters.cofactor);
|
|
76
|
+
if (R.isZero())
|
|
77
|
+
throw new Error(`Invalid parameters, shared secret is point at infinity`);
|
|
78
|
+
return Field.toBytes(curve.toExternalField(R.x), lengths.fieldByteLength);
|
|
79
|
+
};
|
|
52
80
|
const keygen = (isCompressed = false) => {
|
|
53
81
|
const secretKey = randomPrivateKey();
|
|
54
82
|
const publicKey = getPublicKey(secretKey, isCompressed);
|
|
@@ -56,6 +84,7 @@ export const dstu4145 = (parameters) => {
|
|
|
56
84
|
};
|
|
57
85
|
return Object.freeze({
|
|
58
86
|
getPublicKey,
|
|
87
|
+
getSharedSecret,
|
|
59
88
|
sign,
|
|
60
89
|
verify,
|
|
61
90
|
keygen,
|
package/dstu9041/curve.js
CHANGED
|
@@ -2,27 +2,30 @@ import { Field, mod } from "@noble/curves/abstract/modular.js";
|
|
|
2
2
|
import { bitGet, bitLen, bytesToNumberBE, randomBytes } from "@noble/curves/utils.js";
|
|
3
3
|
import { concatBytes } from "@noble/hashes/utils.js";
|
|
4
4
|
export const dstu9041Curve = (parameters) => {
|
|
5
|
+
if (parameters.a != 2n)
|
|
6
|
+
throw new Error("Unsuppored `a` parameter, must be 2");
|
|
5
7
|
if (mod(parameters.p, 8n) != 5n)
|
|
6
8
|
throw new Error("Unsupported `p` prime");
|
|
7
9
|
const Fp = Field(parameters.p), Fn = Field(parameters.n);
|
|
10
|
+
const { a, d, Gx, Gy } = parameters;
|
|
8
11
|
const isValidXY = (x, y) => {
|
|
9
12
|
const x2 = Fp.sqr(x);
|
|
10
13
|
const y2 = Fp.sqr(y);
|
|
11
|
-
const left = Fp.add(x2, Fp.mul(
|
|
12
|
-
const right = Fp.add(Fp.ONE, Fp.mul(
|
|
14
|
+
const left = Fp.add(x2, Fp.mul(a, y2));
|
|
15
|
+
const right = Fp.add(Fp.ONE, Fp.mul(d, Fp.mul(x2, y2)));
|
|
13
16
|
return Fp.eql(left, right);
|
|
14
17
|
};
|
|
15
|
-
if (!isValidXY(
|
|
18
|
+
if (!isValidXY(Gx, Gy))
|
|
16
19
|
throw new Error("Invalid base point");
|
|
17
20
|
const p_minus_1 = Fp.sub(Fp.ZERO, Fp.ONE);
|
|
18
21
|
const p_minus_1_over_2 = Fp.div(Fp.sub(Fp.ORDER, Fp.ONE), 2n);
|
|
19
|
-
const a_over_d = Fp.div(
|
|
22
|
+
const a_over_d = Fp.div(a, d);
|
|
20
23
|
class Point {
|
|
21
24
|
X;
|
|
22
25
|
Y;
|
|
23
26
|
Z;
|
|
24
|
-
static BASE = Point
|
|
25
|
-
static ZERO = Point.
|
|
27
|
+
static BASE = new Point(Gx, Gy, Fp.ONE);
|
|
28
|
+
static ZERO = new Point(Fp.ONE, Fp.ZERO, Fp.ONE);
|
|
26
29
|
static Fp = Fp;
|
|
27
30
|
static Fn = Fn;
|
|
28
31
|
constructor(X, Y, Z) {
|
|
@@ -42,13 +45,13 @@ export const dstu9041Curve = (parameters) => {
|
|
|
42
45
|
const B = Fp.sqr(A);
|
|
43
46
|
const C = Fp.mul(this.X, other.X);
|
|
44
47
|
const D = Fp.mul(this.Y, other.Y);
|
|
45
|
-
const E = Fp.mul(
|
|
48
|
+
const E = Fp.mul(d, Fp.mul(C, D));
|
|
46
49
|
const F = Fp.sub(B, E);
|
|
47
50
|
const G = Fp.add(B, E);
|
|
48
51
|
const self_sum = Fp.add(this.X, this.Y);
|
|
49
52
|
const other_sum = Fp.add(other.X, other.Y);
|
|
50
53
|
const cross = Fp.mul(self_sum, other_sum);
|
|
51
|
-
const xr = Fp.mul(Fp.mul(A, G), Fp.sub(C, Fp.mul(
|
|
54
|
+
const xr = Fp.mul(Fp.mul(A, G), Fp.sub(C, Fp.mul(a, D)));
|
|
52
55
|
const yr = Fp.mul(Fp.mul(A, F), Fp.sub(Fp.sub(cross, C), D));
|
|
53
56
|
const zr = Fp.mul(F, G);
|
|
54
57
|
return new Point(xr, yr, zr);
|
|
@@ -59,7 +62,7 @@ export const dstu9041Curve = (parameters) => {
|
|
|
59
62
|
let S = new Point(this.X, this.Y, this.Z);
|
|
60
63
|
for (let i = bitLen(scalar) - 2; i >= 0; i--) {
|
|
61
64
|
S = S.add(S);
|
|
62
|
-
if (bitGet(scalar, i) ==
|
|
65
|
+
if (bitGet(scalar, i) == Fp.ONE)
|
|
63
66
|
S = S.add(this);
|
|
64
67
|
}
|
|
65
68
|
return S;
|
|
@@ -91,7 +94,7 @@ export const dstu9041Curve = (parameters) => {
|
|
|
91
94
|
Fp.eql(x2, a_over_d))
|
|
92
95
|
throw new Error("Invalid x-coordinate, can't recover y");
|
|
93
96
|
const num = Fp.sub(Fp.ONE, x2);
|
|
94
|
-
const denom = Fp.sub(
|
|
97
|
+
const denom = Fp.sub(a, Fp.mul(d, x2));
|
|
95
98
|
const v = Fp.div(num, denom);
|
|
96
99
|
if (Fp.pow(v, p_minus_1_over_2) != Fp.ONE)
|
|
97
100
|
throw new Error("Invalid x-coordinate, non-complience with euler criterion");
|
package/dstu9041/index.d.ts
CHANGED
|
@@ -6,7 +6,7 @@ export declare const dstu9041_256: Readonly<{
|
|
|
6
6
|
secretKey: TRet<Uint8Array>;
|
|
7
7
|
publicKey: TRet<Uint8Array>;
|
|
8
8
|
};
|
|
9
|
-
encrypt: (
|
|
9
|
+
encrypt: (plaintext: TArg<Uint8Array>, publicKey: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
|
|
10
10
|
decrypt: (ciphertext: TArg<Uint8Array>, privateKey: TArg<Uint8Array>) => TRet<Uint8Array>;
|
|
11
11
|
}>;
|
|
12
12
|
/** DSTU 9041:2020 (512 bit) */
|
|
@@ -16,6 +16,6 @@ export declare const dstu9041_512: Readonly<{
|
|
|
16
16
|
secretKey: TRet<Uint8Array>;
|
|
17
17
|
publicKey: TRet<Uint8Array>;
|
|
18
18
|
};
|
|
19
|
-
encrypt: (
|
|
19
|
+
encrypt: (plaintext: TArg<Uint8Array>, publicKey: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
|
|
20
20
|
decrypt: (ciphertext: TArg<Uint8Array>, privateKey: TArg<Uint8Array>) => TRet<Uint8Array>;
|
|
21
21
|
}>;
|