@li0ard/dstu 0.0.1 → 0.1.0
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/LICENSE +21 -0
- package/README.md +37 -45
- package/const.d.ts +14 -0
- package/const.js +1084 -0
- package/dstu4145/const.d.ts +22 -0
- package/dstu4145/const.js +36 -0
- package/dstu4145/ec/curve.d.ts +17 -0
- package/dstu4145/ec/curve.js +82 -0
- package/dstu4145/ec/field.d.ts +30 -0
- package/dstu4145/ec/field.js +135 -0
- package/dstu4145/ec/index.d.ts +3 -0
- package/dstu4145/ec/index.js +3 -0
- package/dstu4145/ec/point.d.ts +12 -0
- package/dstu4145/ec/point.js +79 -0
- package/dstu4145/index.d.ts +28 -0
- package/dstu4145/index.js +70 -0
- package/index.d.ts +6 -0
- package/index.js +6 -0
- package/kalyna/index.d.ts +50 -0
- package/kalyna/index.js +211 -0
- package/kupyna/index.d.ts +162 -0
- package/kupyna/index.js +241 -0
- package/kupyna/kmac.d.ts +46 -0
- package/kupyna/kmac.js +124 -0
- package/modes/cbc.d.ts +5 -0
- package/modes/cbc.js +10 -0
- package/modes/cfb.d.ts +5 -0
- package/modes/cfb.js +72 -0
- package/modes/ctr.d.ts +5 -0
- package/modes/ctr.js +24 -0
- package/modes/ecb.d.ts +4 -0
- package/modes/ecb.js +17 -0
- package/modes/gcm.d.ts +5 -0
- package/modes/gcm.js +20 -0
- package/modes/index.d.ts +7 -0
- package/modes/index.js +7 -0
- package/modes/mac.d.ts +6 -0
- package/modes/mac.js +65 -0
- package/modes/ofb.d.ts +5 -0
- package/modes/ofb.js +11 -0
- package/package.json +47 -7
- package/padding.d.ts +3 -0
- package/padding.js +22 -0
- package/strumok/index.d.ts +24 -0
- package/strumok/index.js +360 -0
- package/types.d.ts +41 -0
- package/types.js +1 -0
- package/utils.d.ts +14 -0
- package/utils.js +81 -0
|
@@ -0,0 +1,22 @@
|
|
|
1
|
+
import type { TRet } from "@noble/hashes/utils.js";
|
|
2
|
+
export interface DSTUParameters {
|
|
3
|
+
a: number;
|
|
4
|
+
b: string;
|
|
5
|
+
order: string;
|
|
6
|
+
Gx: string;
|
|
7
|
+
Gy: string;
|
|
8
|
+
m: number;
|
|
9
|
+
ks: number[];
|
|
10
|
+
}
|
|
11
|
+
export interface PublicKey {
|
|
12
|
+
x: TRet<Uint8Array>;
|
|
13
|
+
y: TRet<Uint8Array>;
|
|
14
|
+
}
|
|
15
|
+
export interface Signature {
|
|
16
|
+
r: TRet<Uint8Array>;
|
|
17
|
+
s: TRet<Uint8Array>;
|
|
18
|
+
}
|
|
19
|
+
export declare const DSTU_163_TEST: DSTUParameters;
|
|
20
|
+
export declare const DSTU_191: DSTUParameters;
|
|
21
|
+
export declare const DSTU_257: DSTUParameters;
|
|
22
|
+
export declare const DSTU_431: DSTUParameters;
|
|
@@ -0,0 +1,36 @@
|
|
|
1
|
+
export const DSTU_163_TEST = {
|
|
2
|
+
a: 1,
|
|
3
|
+
b: "5FF6108462A2DC8210AB403925E638A19C1455D21",
|
|
4
|
+
order: "400000000000000000002BEC12BE2262D39BCF14D",
|
|
5
|
+
Gx: "72D867F93A93AC27DF9FF01AFFE74885C8C540420",
|
|
6
|
+
Gy: "0224A9C3947852B97C5599D5F4AB81122ADC3FD9B",
|
|
7
|
+
m: 163,
|
|
8
|
+
ks: [7, 6, 3]
|
|
9
|
+
};
|
|
10
|
+
export const DSTU_191 = {
|
|
11
|
+
a: 1,
|
|
12
|
+
b: "7BC86E2102902EC4D5890E8B6B4981FF27E0482750FEFC03",
|
|
13
|
+
order: "40000000000000000000000069A779CAC1DABC6788F7474F",
|
|
14
|
+
Gx: "714114B762F2FF4A7912A6D2AC58B9B5C2FCFE76DAEB7129",
|
|
15
|
+
Gy: "29C41E568B77C617EFE5902F11DB96FA9613CD8D03DB08DA",
|
|
16
|
+
m: 191,
|
|
17
|
+
ks: [9]
|
|
18
|
+
};
|
|
19
|
+
export const DSTU_257 = {
|
|
20
|
+
a: 0,
|
|
21
|
+
b: "01CEF494720115657E18F938D7A7942394FF9425C1458C57861F9EEA6ADBE3BE10",
|
|
22
|
+
order: "00800000000000000000000000000000006759213AF182E987D3E17714907D470D",
|
|
23
|
+
Gx: "002A29EF207D0E9B6C55CD260B306C7E007AC491CA1B10C62334A9E8DCD8D20FB7",
|
|
24
|
+
Gy: "010686D41FF744D4449FCCF6D8EEA03102E6812C93A9D60B978B702CF156D814EF",
|
|
25
|
+
m: 257,
|
|
26
|
+
ks: [12]
|
|
27
|
+
};
|
|
28
|
+
export const DSTU_431 = {
|
|
29
|
+
a: 1,
|
|
30
|
+
b: "03CE10490F6A708FC26DFE8C3D27C4F94E690134D5BFF988D8D28AAEAEDE975936C66BAC536B18AE2DC312CA493117DAA469C640CAF3",
|
|
31
|
+
order: "3FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFBA3175458009A8C0A724F02F81AA8A1FCBAF80D90C7A95110504CF",
|
|
32
|
+
Gx: "1A62BA79D98133A16BBAE7ED9A8E03C32E0824D57AEF72F88986874E5AAE49C27BED49A2A95058068426C2171E99FD3B43C5947C857D",
|
|
33
|
+
Gy: "70B5E1E14031C1F70BBEFE96BDDE66F451754B4CA5F48DA241F331AA396B8D1839A855C1769B1EA14BA53308B5E2723724E090E02DB9",
|
|
34
|
+
m: 431,
|
|
35
|
+
ks: [5, 3, 1]
|
|
36
|
+
};
|
|
@@ -0,0 +1,17 @@
|
|
|
1
|
+
import { Field } from "./field.js";
|
|
2
|
+
import { Point } from "../ec/point.js";
|
|
3
|
+
import type { DSTUParameters } from "../const.js";
|
|
4
|
+
export declare class Curve {
|
|
5
|
+
a: number;
|
|
6
|
+
b: Field;
|
|
7
|
+
order: Field;
|
|
8
|
+
base: Point;
|
|
9
|
+
m: number;
|
|
10
|
+
ks: number[];
|
|
11
|
+
constructor(params: DSTUParameters);
|
|
12
|
+
get modulo(): Field;
|
|
13
|
+
random(): Field;
|
|
14
|
+
truncate(value: Field): Field;
|
|
15
|
+
private fsquad;
|
|
16
|
+
expand(x: Field): Point;
|
|
17
|
+
}
|
|
@@ -0,0 +1,82 @@
|
|
|
1
|
+
import { Field } from "./field.js";
|
|
2
|
+
import { Point } from "../ec/point.js";
|
|
3
|
+
import { randomBytes } from "@noble/hashes/utils.js";
|
|
4
|
+
export class Curve {
|
|
5
|
+
a;
|
|
6
|
+
b;
|
|
7
|
+
order;
|
|
8
|
+
base;
|
|
9
|
+
m;
|
|
10
|
+
ks;
|
|
11
|
+
constructor(params) {
|
|
12
|
+
this.a = params.a;
|
|
13
|
+
this.b = Field.fromString(params.b, 16);
|
|
14
|
+
this.order = Field.fromString(params.order, 16);
|
|
15
|
+
this.base = new Point(Field.fromString(params.Gx, 16, this), Field.fromString(params.Gy, 16, this));
|
|
16
|
+
this.m = params.m;
|
|
17
|
+
this.ks = params.ks;
|
|
18
|
+
}
|
|
19
|
+
get modulo() {
|
|
20
|
+
const m = Field.get0();
|
|
21
|
+
m.setBit(this.m, 1);
|
|
22
|
+
m.setBit(0, 1);
|
|
23
|
+
for (const i of this.ks)
|
|
24
|
+
m.setBit(i, 1);
|
|
25
|
+
return m;
|
|
26
|
+
}
|
|
27
|
+
random() {
|
|
28
|
+
return this.truncate(Field.fromU8(randomBytes(Math.ceil(this.m / 8))));
|
|
29
|
+
}
|
|
30
|
+
truncate(value) {
|
|
31
|
+
const bitl_o = this.order.getLength();
|
|
32
|
+
let xbit = value.getLength();
|
|
33
|
+
const ret = value.clone();
|
|
34
|
+
while (bitl_o <= xbit) {
|
|
35
|
+
ret.setBit(xbit - 1, 0);
|
|
36
|
+
xbit = ret.getLength();
|
|
37
|
+
}
|
|
38
|
+
return ret.clone();
|
|
39
|
+
}
|
|
40
|
+
fsquad(v) {
|
|
41
|
+
const bitl_m = this.m;
|
|
42
|
+
const range_to = Math.floor((bitl_m - 1) / 2);
|
|
43
|
+
const val_a = v.mod();
|
|
44
|
+
let val_z = val_a.clone();
|
|
45
|
+
for (let idx = 1; idx <= range_to; idx++) {
|
|
46
|
+
val_z = val_z.mulmod(val_z);
|
|
47
|
+
val_z = val_z.mulmod(val_z);
|
|
48
|
+
val_z = val_z.add(val_a);
|
|
49
|
+
}
|
|
50
|
+
const val_w = val_z.mulmod(val_z).add(val_z);
|
|
51
|
+
if (val_w.compare(val_a) == 0)
|
|
52
|
+
return val_z.mod();
|
|
53
|
+
throw new Error("squad eq fail: no square root exists");
|
|
54
|
+
}
|
|
55
|
+
expand(x) {
|
|
56
|
+
const bit = x.testBit(0);
|
|
57
|
+
const xClean = x.clone();
|
|
58
|
+
xClean.setBit(0, 0);
|
|
59
|
+
const traceX = xClean.trace();
|
|
60
|
+
const a = this.a ?? 0;
|
|
61
|
+
if ((traceX === 1 && a === 0) || (traceX === 0 && a === 1))
|
|
62
|
+
xClean.setBit(0, 1);
|
|
63
|
+
const x2 = xClean.mulmod(xClean);
|
|
64
|
+
let rhs = x2.mulmod(xClean);
|
|
65
|
+
if (a === 1)
|
|
66
|
+
rhs = rhs.add(x2);
|
|
67
|
+
if (this.b)
|
|
68
|
+
rhs = rhs.add(this.b);
|
|
69
|
+
const x2inv = x2.invert();
|
|
70
|
+
const c = rhs.mulmod(x2inv);
|
|
71
|
+
const z = this.fsquad(c);
|
|
72
|
+
const y = z.mulmod(xClean);
|
|
73
|
+
const traceY = y.trace();
|
|
74
|
+
if ((traceY === 0 && bit === 1) || (traceY === 1 && bit === 0)) {
|
|
75
|
+
const currentBit = y.testBit(0);
|
|
76
|
+
y.setBit(0, 1 ^ currentBit);
|
|
77
|
+
}
|
|
78
|
+
xClean.curve = this;
|
|
79
|
+
y.curve = this;
|
|
80
|
+
return new Point(xClean, y);
|
|
81
|
+
}
|
|
82
|
+
}
|
|
@@ -0,0 +1,30 @@
|
|
|
1
|
+
import BN from "bn.js";
|
|
2
|
+
import type { Curve } from "./curve.js";
|
|
3
|
+
import type { TArg, TRet } from "@noble/hashes/utils.js";
|
|
4
|
+
export declare class Field {
|
|
5
|
+
curve: Curve | null;
|
|
6
|
+
value: BN;
|
|
7
|
+
constructor(value?: BN, curve?: Curve | null);
|
|
8
|
+
static fromString(str: string, base: number, curve?: Curve | null): Field;
|
|
9
|
+
static fromInt(v: number, curve?: Curve | null): Field;
|
|
10
|
+
static fromU8(v: Uint8Array, curve?: Curve | null): Field;
|
|
11
|
+
toString(base?: number): string;
|
|
12
|
+
compare(v: Field): number;
|
|
13
|
+
clone(): Field;
|
|
14
|
+
getLength(): number;
|
|
15
|
+
testBit(i: number): 0 | 1;
|
|
16
|
+
setBit(i: number, v: number): void;
|
|
17
|
+
shiftLeft(n: number): Field;
|
|
18
|
+
add(v: Field): Field;
|
|
19
|
+
static hashToField(curve: Curve, hash: TArg<Uint8Array>): Field;
|
|
20
|
+
static get0(curve?: Curve | null): Field;
|
|
21
|
+
static get1(curve?: Curve | null): Field;
|
|
22
|
+
is0(): boolean;
|
|
23
|
+
mod(): Field;
|
|
24
|
+
mulmod(v: Field): Field;
|
|
25
|
+
mul(v: Field): Field;
|
|
26
|
+
trace(): number;
|
|
27
|
+
div(v: Field): [Field, Field];
|
|
28
|
+
invert(): Field;
|
|
29
|
+
buf8(): TRet<Uint8Array>;
|
|
30
|
+
}
|
|
@@ -0,0 +1,135 @@
|
|
|
1
|
+
import BN from "bn.js";
|
|
2
|
+
export class Field {
|
|
3
|
+
curve = null;
|
|
4
|
+
value;
|
|
5
|
+
constructor(value = new BN(0), curve = null) {
|
|
6
|
+
this.value = value;
|
|
7
|
+
this.curve = curve;
|
|
8
|
+
}
|
|
9
|
+
static fromString(str, base, curve = null) {
|
|
10
|
+
return new Field(new BN(str, base), curve);
|
|
11
|
+
}
|
|
12
|
+
static fromInt(v, curve = null) {
|
|
13
|
+
return new Field(new BN(v), curve);
|
|
14
|
+
}
|
|
15
|
+
static fromU8(v, curve = null) {
|
|
16
|
+
return new Field(new BN(v, 16), curve);
|
|
17
|
+
}
|
|
18
|
+
toString(base = 10) {
|
|
19
|
+
return this.value.toString(base);
|
|
20
|
+
}
|
|
21
|
+
compare(v) {
|
|
22
|
+
return this.value.cmp(v.value);
|
|
23
|
+
}
|
|
24
|
+
clone() {
|
|
25
|
+
return Field.fromString(this.toString(16), 16, this.curve);
|
|
26
|
+
}
|
|
27
|
+
getLength() {
|
|
28
|
+
return this.value.bitLength();
|
|
29
|
+
}
|
|
30
|
+
testBit(i) {
|
|
31
|
+
return this.value.testn(i) ? 1 : 0;
|
|
32
|
+
}
|
|
33
|
+
setBit(i, v) {
|
|
34
|
+
this.value = this.value.setn(i, v == 1);
|
|
35
|
+
}
|
|
36
|
+
shiftLeft(n) {
|
|
37
|
+
if (n < 0)
|
|
38
|
+
throw new Error("Shift amount cannot be negative.");
|
|
39
|
+
return new Field(this.value.ushln(n), this.curve);
|
|
40
|
+
}
|
|
41
|
+
add(v) {
|
|
42
|
+
return new Field(this.value.xor(v.value), this.curve || v.curve);
|
|
43
|
+
}
|
|
44
|
+
static hashToField(curve, hash) {
|
|
45
|
+
return new Field(new BN(hash).maskn(curve.m), curve);
|
|
46
|
+
}
|
|
47
|
+
static get0(curve = null) {
|
|
48
|
+
return new Field(new BN(0), curve);
|
|
49
|
+
}
|
|
50
|
+
static get1(curve = null) {
|
|
51
|
+
return new Field(new BN(1), curve);
|
|
52
|
+
}
|
|
53
|
+
is0() {
|
|
54
|
+
return this.value.isZero();
|
|
55
|
+
}
|
|
56
|
+
mod() {
|
|
57
|
+
if (!this.curve)
|
|
58
|
+
throw new Error("Curve not specified");
|
|
59
|
+
const m = this.curve.modulo;
|
|
60
|
+
const cmp = this.compare(m);
|
|
61
|
+
if (cmp === 0)
|
|
62
|
+
return Field.get0();
|
|
63
|
+
if (cmp < 0)
|
|
64
|
+
return this.clone();
|
|
65
|
+
return this.div(m)[1];
|
|
66
|
+
}
|
|
67
|
+
mulmod(v) {
|
|
68
|
+
return this.mul(v).mod();
|
|
69
|
+
}
|
|
70
|
+
mul(v) {
|
|
71
|
+
let bag = Field.get0();
|
|
72
|
+
let shift = this.clone();
|
|
73
|
+
const vLen = v.getLength();
|
|
74
|
+
for (let i = 0; i < vLen; i++) {
|
|
75
|
+
if (v.testBit(i) == 1)
|
|
76
|
+
bag = bag.add(shift);
|
|
77
|
+
shift = shift.shiftLeft(1);
|
|
78
|
+
}
|
|
79
|
+
bag.curve = this.curve || v.curve;
|
|
80
|
+
return bag;
|
|
81
|
+
}
|
|
82
|
+
trace() {
|
|
83
|
+
if (!this.curve)
|
|
84
|
+
throw new Error("Curve not specified");
|
|
85
|
+
const m = this.curve.m;
|
|
86
|
+
let t = this.clone();
|
|
87
|
+
for (let i = 1; i < m; i++)
|
|
88
|
+
t = t.mulmod(t).add(this);
|
|
89
|
+
return t.testBit(0);
|
|
90
|
+
}
|
|
91
|
+
div(v) {
|
|
92
|
+
let res = '';
|
|
93
|
+
const c = this.compare(v);
|
|
94
|
+
if (c === 0)
|
|
95
|
+
return [Field.get1(), Field.get0()];
|
|
96
|
+
if (c < 0)
|
|
97
|
+
return [Field.get0(), this.clone()];
|
|
98
|
+
let bag = this.clone();
|
|
99
|
+
const vl = v.getLength();
|
|
100
|
+
while (true) {
|
|
101
|
+
const bl = bag.getLength();
|
|
102
|
+
const shift = v.clone().shiftLeft(bl - vl);
|
|
103
|
+
bag = bag.add(shift);
|
|
104
|
+
res += "1";
|
|
105
|
+
const blnew = bag.getLength();
|
|
106
|
+
const bdiff = bl - blnew;
|
|
107
|
+
if (blnew < vl) {
|
|
108
|
+
res += '0'.repeat(bl - vl);
|
|
109
|
+
return [Field.fromString(res, 2), bag];
|
|
110
|
+
}
|
|
111
|
+
if (bdiff > 1)
|
|
112
|
+
res += '0'.repeat(bdiff - 1);
|
|
113
|
+
}
|
|
114
|
+
}
|
|
115
|
+
invert() {
|
|
116
|
+
let r = this.mod();
|
|
117
|
+
let s = this.curve.modulo;
|
|
118
|
+
let u = Field.get1(this.curve);
|
|
119
|
+
let v = Field.get0(this.curve);
|
|
120
|
+
while (r.getLength() > 1) {
|
|
121
|
+
let j = s.getLength() - r.getLength();
|
|
122
|
+
if (j < 0) {
|
|
123
|
+
[r, s] = [s, r];
|
|
124
|
+
[u, v] = [v, u];
|
|
125
|
+
j = -j;
|
|
126
|
+
}
|
|
127
|
+
s = s.add(r.shiftLeft(j));
|
|
128
|
+
v = v.add(u.shiftLeft(j));
|
|
129
|
+
}
|
|
130
|
+
return u;
|
|
131
|
+
}
|
|
132
|
+
buf8() {
|
|
133
|
+
return new Uint8Array(this.value.toArray());
|
|
134
|
+
}
|
|
135
|
+
}
|
|
@@ -0,0 +1,12 @@
|
|
|
1
|
+
import { Field } from "./field.js";
|
|
2
|
+
export declare class Point {
|
|
3
|
+
x: Field;
|
|
4
|
+
y: Field;
|
|
5
|
+
constructor(x: Field, y: Field);
|
|
6
|
+
add(p: Point): Point;
|
|
7
|
+
mul(f: Field): Point;
|
|
8
|
+
negate(): Point;
|
|
9
|
+
clone(): Point;
|
|
10
|
+
iszero(): boolean;
|
|
11
|
+
compress(): Field;
|
|
12
|
+
}
|
|
@@ -0,0 +1,79 @@
|
|
|
1
|
+
import { Field } from "./field.js";
|
|
2
|
+
export class Point {
|
|
3
|
+
x;
|
|
4
|
+
y;
|
|
5
|
+
constructor(x, y) {
|
|
6
|
+
this.x = x;
|
|
7
|
+
this.y = y;
|
|
8
|
+
}
|
|
9
|
+
add(p) {
|
|
10
|
+
const curve = this.x.curve;
|
|
11
|
+
const a = Field.fromInt(curve?.a ?? 0, curve);
|
|
12
|
+
const pz = new Point(Field.get0(curve), Field.get0(curve));
|
|
13
|
+
const x0 = this.x.clone();
|
|
14
|
+
const y0 = this.y.clone();
|
|
15
|
+
const x1 = p.x.clone();
|
|
16
|
+
const y1 = p.y.clone();
|
|
17
|
+
if (this.iszero())
|
|
18
|
+
return p;
|
|
19
|
+
if (p.iszero())
|
|
20
|
+
return this;
|
|
21
|
+
let lbd;
|
|
22
|
+
let x2;
|
|
23
|
+
if (x0.compare(x1) !== 0) {
|
|
24
|
+
const tmp = y0.add(y1);
|
|
25
|
+
const tmp2 = x0.add(x1);
|
|
26
|
+
lbd = tmp.mulmod(tmp2.invert());
|
|
27
|
+
x2 = a.add(lbd.mulmod(lbd));
|
|
28
|
+
x2 = x2.add(lbd);
|
|
29
|
+
x2 = x2.add(x0);
|
|
30
|
+
x2 = x2.add(x1);
|
|
31
|
+
}
|
|
32
|
+
else {
|
|
33
|
+
if (y1.compare(y0) !== 0)
|
|
34
|
+
return pz;
|
|
35
|
+
if (x1.compare(Field.get0()) === 0)
|
|
36
|
+
return pz;
|
|
37
|
+
lbd = x1.add(p.y.mulmod(p.x.invert()));
|
|
38
|
+
x2 = lbd.mulmod(lbd).add(a);
|
|
39
|
+
x2 = x2.add(lbd);
|
|
40
|
+
}
|
|
41
|
+
let y2 = lbd.mulmod(x1.add(x2));
|
|
42
|
+
y2 = y2.add(x2);
|
|
43
|
+
y2 = y2.add(y1);
|
|
44
|
+
pz.x = x2.clone();
|
|
45
|
+
pz.y = y2.clone();
|
|
46
|
+
return pz;
|
|
47
|
+
}
|
|
48
|
+
mul(f) {
|
|
49
|
+
let pz = new Point(Field.get0(f.curve), Field.get0(f.curve));
|
|
50
|
+
let p = this.clone();
|
|
51
|
+
for (let j = f.getLength() - 1; j >= 0; j--) {
|
|
52
|
+
if (f.testBit(j) === 1) {
|
|
53
|
+
pz = pz.add(p);
|
|
54
|
+
p = p.add(p);
|
|
55
|
+
}
|
|
56
|
+
else {
|
|
57
|
+
p = pz.add(p);
|
|
58
|
+
pz = pz.add(pz);
|
|
59
|
+
}
|
|
60
|
+
}
|
|
61
|
+
return pz;
|
|
62
|
+
}
|
|
63
|
+
negate() {
|
|
64
|
+
return new Point(this.x, this.x.add(this.y));
|
|
65
|
+
}
|
|
66
|
+
clone() {
|
|
67
|
+
return new Point(this.x, this.y);
|
|
68
|
+
}
|
|
69
|
+
iszero() {
|
|
70
|
+
return this.x.is0() && this.y.is0();
|
|
71
|
+
}
|
|
72
|
+
compress() {
|
|
73
|
+
const x_inv = this.x.invert();
|
|
74
|
+
const tmp = x_inv.mulmod(this.y);
|
|
75
|
+
const trace = tmp.trace();
|
|
76
|
+
this.x.setBit(0, trace == 1 ? 1 : 0);
|
|
77
|
+
return this.x;
|
|
78
|
+
}
|
|
79
|
+
}
|
|
@@ -0,0 +1,28 @@
|
|
|
1
|
+
import { type TArg } from "@noble/hashes/utils.js";
|
|
2
|
+
import type { DSTUParameters, PublicKey, Signature } from "./const.js";
|
|
3
|
+
import { Point } from "./ec/index.js";
|
|
4
|
+
/**
|
|
5
|
+
* Generate public key from private
|
|
6
|
+
* @param parameters Curve parameters
|
|
7
|
+
* @param privateKey Private key
|
|
8
|
+
*/
|
|
9
|
+
export declare const getPublicKey: (parameters: DSTUParameters, privateKey: TArg<Uint8Array>) => PublicKey;
|
|
10
|
+
/**
|
|
11
|
+
* Generate signature of provided digest
|
|
12
|
+
* @param parameters Curve parameters
|
|
13
|
+
* @param privateKey Private key
|
|
14
|
+
* @param digest Digest to sign
|
|
15
|
+
* @param rand Optional. Predefined random data
|
|
16
|
+
*/
|
|
17
|
+
export declare const sign: (parameters: DSTUParameters, privateKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => Signature;
|
|
18
|
+
/**
|
|
19
|
+
* Verify signature of provided digest
|
|
20
|
+
* @param parameters Curve parameters
|
|
21
|
+
* @param publicKey Public key
|
|
22
|
+
* @param digest Digest to verify
|
|
23
|
+
* @param signature Signature
|
|
24
|
+
*/
|
|
25
|
+
export declare const verify: (parameters: DSTUParameters, publicKey: PublicKey, digest: TArg<Uint8Array>, signature: Signature) => boolean;
|
|
26
|
+
/** Decompress point */
|
|
27
|
+
export declare const decompressPoint: (parameters: DSTUParameters, x: TArg<Uint8Array>) => Point;
|
|
28
|
+
export * from "./const.js";
|
|
@@ -0,0 +1,70 @@
|
|
|
1
|
+
import { randomBytes } from "@noble/hashes/utils.js";
|
|
2
|
+
import { Curve, Field, Point } from "./ec/index.js";
|
|
3
|
+
import { BN } from "bn.js";
|
|
4
|
+
/**
|
|
5
|
+
* Generate public key from private
|
|
6
|
+
* @param parameters Curve parameters
|
|
7
|
+
* @param privateKey Private key
|
|
8
|
+
*/
|
|
9
|
+
export const getPublicKey = (parameters, privateKey) => {
|
|
10
|
+
const curve = new Curve(parameters);
|
|
11
|
+
const Q = curve.base.mul(Field.fromU8(privateKey, curve)).negate();
|
|
12
|
+
return { x: Q.x.buf8(), y: Q.y.buf8() };
|
|
13
|
+
};
|
|
14
|
+
/**
|
|
15
|
+
* Generate signature of provided digest
|
|
16
|
+
* @param parameters Curve parameters
|
|
17
|
+
* @param privateKey Private key
|
|
18
|
+
* @param digest Digest to sign
|
|
19
|
+
* @param rand Optional. Predefined random data
|
|
20
|
+
*/
|
|
21
|
+
export const sign = (parameters, privateKey, digest, rand) => {
|
|
22
|
+
const curve = new Curve(parameters);
|
|
23
|
+
const n = new BN(curve.order.value);
|
|
24
|
+
let e = rand ? new BN(rand).mod(n) : new BN(randomBytes(Math.ceil(curve.m / 8))).mod(n);
|
|
25
|
+
if (e.isZero())
|
|
26
|
+
e = new BN(1);
|
|
27
|
+
const d = new BN(privateKey).mod(n);
|
|
28
|
+
if (d.lten(0) || d.gte(curve.order.value))
|
|
29
|
+
throw new Error("Invalid private key");
|
|
30
|
+
// h = hash_to_field(H(T))
|
|
31
|
+
let h = Field.hashToField(curve, digest);
|
|
32
|
+
if (h.is0())
|
|
33
|
+
h = Field.get1();
|
|
34
|
+
// Fe = eP.x
|
|
35
|
+
const Fe = curve.base.mul(new Field(e)).x;
|
|
36
|
+
// r = h * Fe
|
|
37
|
+
const r = h.mulmod(Fe).value;
|
|
38
|
+
if (r.isZero())
|
|
39
|
+
return sign(parameters, privateKey, digest, rand);
|
|
40
|
+
// s = e + dr (mod n)
|
|
41
|
+
const s = e.add(d.mul(r)).mod(n);
|
|
42
|
+
if (s.isZero())
|
|
43
|
+
return sign(parameters, privateKey, digest, rand);
|
|
44
|
+
return { r: new Uint8Array(r.toArray()), s: new Uint8Array(s.toArray()) };
|
|
45
|
+
};
|
|
46
|
+
/**
|
|
47
|
+
* Verify signature of provided digest
|
|
48
|
+
* @param parameters Curve parameters
|
|
49
|
+
* @param publicKey Public key
|
|
50
|
+
* @param digest Digest to verify
|
|
51
|
+
* @param signature Signature
|
|
52
|
+
*/
|
|
53
|
+
export const verify = (parameters, publicKey, digest, signature) => {
|
|
54
|
+
const curve = new Curve(parameters);
|
|
55
|
+
const Q = new Point(Field.fromU8(publicKey.x, curve), Field.fromU8(publicKey.y, curve));
|
|
56
|
+
const _r = Field.fromU8(signature.r), _s = Field.fromU8(signature.s);
|
|
57
|
+
// h = hash_to_field(H(T))
|
|
58
|
+
const h = Field.hashToField(curve, digest);
|
|
59
|
+
// R = sP + rQ
|
|
60
|
+
const R = curve.base.mul(_s).add(Q.mul(_r));
|
|
61
|
+
// y = h * R.x
|
|
62
|
+
const y = h.mulmod(R.x);
|
|
63
|
+
return y.value.eq(_r.value);
|
|
64
|
+
};
|
|
65
|
+
/** Decompress point */
|
|
66
|
+
export const decompressPoint = (parameters, x) => {
|
|
67
|
+
const curve = new Curve(parameters);
|
|
68
|
+
return curve.expand(Field.fromU8(x, curve));
|
|
69
|
+
};
|
|
70
|
+
export * from "./const.js";
|
package/index.d.ts
ADDED
|
@@ -0,0 +1,6 @@
|
|
|
1
|
+
export * from "./dstu4145/index.js";
|
|
2
|
+
export { Kalyna128, Kalyna128_256, Kalyna256, Kalyna256_512, Kalyna512 } from "./kalyna/index.js";
|
|
3
|
+
export * from "./kupyna/index.js";
|
|
4
|
+
export * from "./modes/index.js";
|
|
5
|
+
export * from "./strumok/index.js";
|
|
6
|
+
export * from "./types.js";
|
package/index.js
ADDED
|
@@ -0,0 +1,6 @@
|
|
|
1
|
+
export * from "./dstu4145/index.js";
|
|
2
|
+
export { Kalyna128, Kalyna128_256, Kalyna256, Kalyna256_512, Kalyna512 } from "./kalyna/index.js";
|
|
3
|
+
export * from "./kupyna/index.js";
|
|
4
|
+
export * from "./modes/index.js";
|
|
5
|
+
export * from "./strumok/index.js";
|
|
6
|
+
export * from "./types.js";
|
|
@@ -0,0 +1,50 @@
|
|
|
1
|
+
import type { TArg, TRet } from "@noble/hashes/utils.js";
|
|
2
|
+
import type { Cipher } from "../types.js";
|
|
3
|
+
export declare abstract class Kalyna implements Cipher {
|
|
4
|
+
readonly N: number;
|
|
5
|
+
/** Block size */
|
|
6
|
+
readonly blockSize: number;
|
|
7
|
+
/** Key size */
|
|
8
|
+
readonly keySize: number;
|
|
9
|
+
private erk;
|
|
10
|
+
private drk;
|
|
11
|
+
private readonly numRounds;
|
|
12
|
+
private readonly glOffset;
|
|
13
|
+
private wordOffsets;
|
|
14
|
+
/** Kalyna abstract class */
|
|
15
|
+
constructor(key: TArg<Uint8Array>, N: number, isDouble?: boolean);
|
|
16
|
+
private expandKey;
|
|
17
|
+
private makeOddKey;
|
|
18
|
+
private addkey;
|
|
19
|
+
private subkey;
|
|
20
|
+
private column;
|
|
21
|
+
private G;
|
|
22
|
+
private GL;
|
|
23
|
+
private IMC;
|
|
24
|
+
private IG;
|
|
25
|
+
private IGL;
|
|
26
|
+
/** Encrypt block */
|
|
27
|
+
encrypt(block: TArg<Uint8Array>): TRet<Uint8Array>;
|
|
28
|
+
/** Decrypt block */
|
|
29
|
+
decrypt(block: TArg<Uint8Array>): TRet<Uint8Array>;
|
|
30
|
+
}
|
|
31
|
+
/** Kalyna 128/128 bit version */
|
|
32
|
+
export declare class Kalyna128 extends Kalyna {
|
|
33
|
+
constructor(key: TArg<Uint8Array>);
|
|
34
|
+
}
|
|
35
|
+
/** Kalyna 128/256 bit version */
|
|
36
|
+
export declare class Kalyna128_256 extends Kalyna {
|
|
37
|
+
constructor(key: TArg<Uint8Array>);
|
|
38
|
+
}
|
|
39
|
+
/** Kalyna 256 bit version */
|
|
40
|
+
export declare class Kalyna256 extends Kalyna {
|
|
41
|
+
constructor(key: TArg<Uint8Array>);
|
|
42
|
+
}
|
|
43
|
+
/** Kalyna 256/512 bit version */
|
|
44
|
+
export declare class Kalyna256_512 extends Kalyna {
|
|
45
|
+
constructor(key: TArg<Uint8Array>);
|
|
46
|
+
}
|
|
47
|
+
/** Kalyna 512 bit version */
|
|
48
|
+
export declare class Kalyna512 extends Kalyna {
|
|
49
|
+
constructor(key: TArg<Uint8Array>);
|
|
50
|
+
}
|