@li0ard/dstu 0.1.8 → 0.2.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.
Files changed (53) hide show
  1. package/README.md +4 -2
  2. package/dstu4145/ec/index.d.ts +4 -0
  3. package/dstu4145/ec/index.js +19 -0
  4. package/dstu4145/ec/wnaf.d.ts +2 -1
  5. package/dstu4145/ecies.d.ts +82 -0
  6. package/dstu4145/ecies.js +72 -0
  7. package/dstu4145/gf2m/index.js +2 -11
  8. package/dstu4145/gf2m/onb.js +30 -16
  9. package/dstu4145/gf2m/utils.d.ts +1 -1
  10. package/dstu4145/gf2m/utils.js +12 -8
  11. package/dstu4145/index.d.ts +16 -225
  12. package/dstu4145/index.js +20 -26
  13. package/dstu9041/curve.d.ts +4 -12
  14. package/dstu9041/curve.js +5 -3
  15. package/dstu9041/index.d.ts +2 -8
  16. package/dstu9041/index.js +10 -6
  17. package/dstu9311/hash.d.ts +46 -12
  18. package/dstu9311/hash.js +89 -28
  19. package/dstu9311/index.js +4 -5
  20. package/iso15946.d.ts +3 -0
  21. package/iso15946.js +56 -0
  22. package/kalyna/index.d.ts +1 -1
  23. package/kalyna/index.js +6 -6
  24. package/keywrap.js +6 -3
  25. package/kupyna/index.d.ts +116 -67
  26. package/kupyna/index.js +122 -61
  27. package/kupyna/kmac.d.ts +6 -6
  28. package/kupyna/kmac.js +20 -15
  29. package/modes/cbc.d.ts +1 -1
  30. package/modes/cbc.js +5 -7
  31. package/modes/ccm.js +12 -3
  32. package/modes/cfb.js +42 -51
  33. package/modes/cmac.js +4 -1
  34. package/modes/ctr.js +4 -3
  35. package/modes/ecb.js +2 -2
  36. package/modes/gcm.d.ts +4 -1
  37. package/modes/gcm.js +32 -5
  38. package/modes/gmac.js +4 -1
  39. package/modes/index.d.ts +1 -1
  40. package/modes/index.js +1 -1
  41. package/modes/kw.d.ts +2 -6
  42. package/modes/kw.js +9 -16
  43. package/modes/ofb.js +3 -3
  44. package/modes/xts.d.ts +2 -6
  45. package/modes/xts.js +7 -3
  46. package/package.json +4 -4
  47. package/padding.d.ts +1 -1
  48. package/padding.js +5 -0
  49. package/strumok/index.d.ts +3 -2
  50. package/strumok/index.js +4 -2
  51. package/types.d.ts +77 -0
  52. package/utils.d.ts +1 -0
  53. package/utils.js +14 -1
package/README.md CHANGED
@@ -20,7 +20,9 @@ npm i @li0ard/dstu
20
20
 
21
21
  ## Supported algorithms
22
22
 
23
- - Curves and ECDSA (DSTU 4145-2002, polynomial and optimal normal basis)
23
+ - Curves and ECDSA (DSTU 4145-2002)
24
+ - Supports polynomial and optimal normal basis
25
+ - Supports ECDH and encryption
24
26
  - Kalyna cipher (DSTU 7624:2014)
25
27
  - Kupyna hash function (DSTU 7564:2014)
26
28
  - Supports KMAC
@@ -33,7 +35,7 @@ npm i @li0ard/dstu
33
35
  ## Supported cipher modes
34
36
 
35
37
  - Cipher Block Chaining mode (CBC)
36
- - Counter with CBC-MAC (CCM) mode
38
+ - Counter with CBC-MAC mode (CCM)
37
39
  - Cipher Feedback mode (CFB)
38
40
  - Counter mode (CTR)
39
41
  - Electronic Codebook mode (ECB)
@@ -43,6 +43,7 @@ export declare const binaryWeierstrass: (parameters: DSTUParameters) => Readonly
43
43
  neg: /*elided*/ any[];
44
44
  };
45
45
  mulWnaf(f: BN): /*elided*/ any;
46
+ mulAdd(k: BN, Q: /*elided*/ any, l: BN): /*elided*/ any;
46
47
  };
47
48
  BASE: {
48
49
  _precomp?: {
@@ -67,6 +68,7 @@ export declare const binaryWeierstrass: (parameters: DSTUParameters) => Readonly
67
68
  neg: /*elided*/ any[];
68
69
  };
69
70
  mulWnaf(f: BN): /*elided*/ any;
71
+ mulAdd(k: BN, Q: /*elided*/ any, l: BN): /*elided*/ any;
70
72
  };
71
73
  ZERO: {
72
74
  _precomp?: {
@@ -91,6 +93,7 @@ export declare const binaryWeierstrass: (parameters: DSTUParameters) => Readonly
91
93
  neg: /*elided*/ any[];
92
94
  };
93
95
  mulWnaf(f: BN): /*elided*/ any;
96
+ mulAdd(k: BN, Q: /*elided*/ any, l: BN): /*elided*/ any;
94
97
  };
95
98
  /** Deserialize point from bytes (compressed/uncompressed) */
96
99
  fromBytes(bytes: TArg<Uint8Array>): {
@@ -116,6 +119,7 @@ export declare const binaryWeierstrass: (parameters: DSTUParameters) => Readonly
116
119
  neg: /*elided*/ any[];
117
120
  };
118
121
  mulWnaf(f: BN): /*elided*/ any;
122
+ mulAdd(k: BN, Q: /*elided*/ any, l: BN): /*elided*/ any;
119
123
  };
120
124
  };
121
125
  ORDER: BN;
@@ -195,6 +195,25 @@ export const binaryWeierstrass = (parameters) => {
195
195
  }
196
196
  return R;
197
197
  }
198
+ mulAdd(k, Q, l) {
199
+ const m = Math.max(k.bitLength(), l.bitLength()), Z = this.add(Q);
200
+ let R = Point.ZERO.clone();
201
+ for (let i = m - 1; i >= 0; --i) {
202
+ R = R.double();
203
+ if (k.testn(i)) {
204
+ if (l.testn(i)) {
205
+ R = R.add(Z);
206
+ continue;
207
+ }
208
+ R = R.add(this);
209
+ continue;
210
+ }
211
+ if (!l.testn(i))
212
+ continue;
213
+ R = R.add(Q);
214
+ }
215
+ return R;
216
+ }
198
217
  /** Deserialize point from bytes (compressed/uncompressed) */
199
218
  static fromBytes(bytes) {
200
219
  // Uncompressed
@@ -1,4 +1,5 @@
1
+ import type { TRet } from "@noble/hashes/utils.js";
1
2
  import BN from "bn.js";
2
3
  export declare const bitLength: (n: number) => number;
3
- export declare const windowNaf: (width: number, k: BN) => Int32Array;
4
+ export declare const windowNaf: (width: number, k: BN) => TRet<Int32Array>;
4
5
  export declare const getWindowSize: (bits: number) => number;
@@ -0,0 +1,82 @@
1
+ import { type CHash, type Hash, type TArg, type TRet } from "@noble/hashes/utils.js";
2
+ import type { ECDSA } from "../types.js";
3
+ /** Encrypted message */
4
+ export type EncryptedMessage = {
5
+ /** User keying material (UKM) for KDF */
6
+ ukm?: TArg<Uint8Array>;
7
+ /** Encryption IV */
8
+ iv: TArg<Uint8Array>;
9
+ /** Wrapped encryption key */
10
+ wcek: TArg<Uint8Array>;
11
+ /** Encrypted message */
12
+ data: TArg<Uint8Array>;
13
+ };
14
+ /**
15
+ * ECIES schema over DSTU 4145-2002.
16
+ * @param curve - Curve to use.
17
+ * @param hash - Hash function to use. (Output length must be 32 bytes)
18
+ * @param withCofactor - Whether to multiply shared key by curve cofactor (See {@link types!ECDSA.getSharedSecret ECDSA.getSharedSecret})
19
+ * @param useDstu9311 - Whether to use DSTU 9311:2024 instead of Kalyna-256?
20
+ */
21
+ export declare const dstu4145Encrypter: (curve: ECDSA, hash: CHash<Hash<any>>, withCofactor?: boolean, useDstu9311?: boolean) => Readonly<{
22
+ /**
23
+ * Encrypt message
24
+ * @param secretKeyA - Sender secret key.
25
+ * @param publicKeyB - Recipient public key.
26
+ * @param plaintext - Message to encrypt.
27
+ */
28
+ encrypt: (secretKeyA: TArg<Uint8Array>, publicKeyB: TArg<Uint8Array>, plaintext: TArg<Uint8Array>) => EncryptedMessage;
29
+ /**
30
+ * Decrypt message
31
+ * @param secretKeyB - Recipient secret key.
32
+ * @param publicKeyA - Sender public key.
33
+ * @param encryptedMessage - Encrypted message object.
34
+ */
35
+ decrypt: (secretKeyB: TArg<Uint8Array>, publicKeyA: TArg<Uint8Array>, encryptedMessage: EncryptedMessage) => TRet<Uint8Array>;
36
+ }>;
37
+ /**
38
+ * ECIES schema over DSTU 4145-2002.
39
+ *
40
+ * Uses GOST 34.311-95 as hash function.
41
+ * @param curve - Curve to use.
42
+ * @param withCofactor - Whether to multiply shared key by curve cofactor (See {@link types!ECDSA.getSharedSecret ECDSA.getSharedSecret})
43
+ */
44
+ export declare const dstu4145EncrypterWithGost: (curve: ECDSA, withCofactor?: boolean) => Readonly<{
45
+ /**
46
+ * Encrypt message
47
+ * @param secretKeyA - Sender secret key.
48
+ * @param publicKeyB - Recipient public key.
49
+ * @param plaintext - Message to encrypt.
50
+ */
51
+ encrypt: (secretKeyA: TArg<Uint8Array>, publicKeyB: TArg<Uint8Array>, plaintext: TArg<Uint8Array>) => EncryptedMessage;
52
+ /**
53
+ * Decrypt message
54
+ * @param secretKeyB - Recipient secret key.
55
+ * @param publicKeyA - Sender public key.
56
+ * @param encryptedMessage - Encrypted message object.
57
+ */
58
+ decrypt: (secretKeyB: TArg<Uint8Array>, publicKeyA: TArg<Uint8Array>, encryptedMessage: EncryptedMessage) => TRet<Uint8Array>;
59
+ }>;
60
+ /**
61
+ * ECIES schema over DSTU 4145-2002.
62
+ *
63
+ * Uses Kupyna-256 as hash function.
64
+ * @param curve - Curve to use.
65
+ * @param withCofactor - Whether to multiply shared key by curve cofactor (See {@link types!ECDSA.getSharedSecret ECDSA.getSharedSecret})
66
+ */
67
+ export declare const dstu4145EncrypterWithKupyna: (curve: ECDSA, withCofactor?: boolean) => Readonly<{
68
+ /**
69
+ * Encrypt message
70
+ * @param secretKeyA - Sender secret key.
71
+ * @param publicKeyB - Recipient public key.
72
+ * @param plaintext - Message to encrypt.
73
+ */
74
+ encrypt: (secretKeyA: TArg<Uint8Array>, publicKeyB: TArg<Uint8Array>, plaintext: TArg<Uint8Array>) => EncryptedMessage;
75
+ /**
76
+ * Decrypt message
77
+ * @param secretKeyB - Recipient secret key.
78
+ * @param publicKeyA - Sender public key.
79
+ * @param encryptedMessage - Encrypted message object.
80
+ */
81
+ decrypt: (secretKeyB: TArg<Uint8Array>, publicKeyA: TArg<Uint8Array>, encryptedMessage: EncryptedMessage) => TRet<Uint8Array>;
82
+ }>;
@@ -0,0 +1,72 @@
1
+ import { abytes, randomBytes } from "@noble/hashes/utils.js";
2
+ import { Dstu9311, gost3431195 } from "../dstu9311/index.js";
3
+ import { Kalyna256 } from "../kalyna/index.js";
4
+ import { keyWrap } from "../keywrap.js";
5
+ import { cfb } from "../modes/cfb.js";
6
+ import { kupyna256 } from "../kupyna/index.js";
7
+ import { iso15946_kdf } from "../iso15946.js";
8
+ /**
9
+ * ECIES schema over DSTU 4145-2002.
10
+ * @param curve - Curve to use.
11
+ * @param hash - Hash function to use. (Output length must be 32 bytes)
12
+ * @param withCofactor - Whether to multiply shared key by curve cofactor (See {@link types!ECDSA.getSharedSecret ECDSA.getSharedSecret})
13
+ * @param useDstu9311 - Whether to use DSTU 9311:2024 instead of Kalyna-256?
14
+ */
15
+ export const dstu4145Encrypter = (curve, hash, withCofactor = true, useDstu9311 = false) => {
16
+ const oid = useDstu9311 ? "1.2.804.2.1.1.1.1.1.1.5" : "1.2.804.2.1.1.1.1.1.3.11";
17
+ const Cipher = useDstu9311 ? Dstu9311 : Kalyna256;
18
+ const macLength = useDstu9311 ? 8 : 32;
19
+ const getSharedSecret = (sharedKey, ukm) => iso15946_kdf(hash, oid, sharedKey, ukm);
20
+ return Object.freeze({
21
+ /**
22
+ * Encrypt message
23
+ * @param secretKeyA - Sender secret key.
24
+ * @param publicKeyB - Recipient public key.
25
+ * @param plaintext - Message to encrypt.
26
+ */
27
+ encrypt: (secretKeyA, publicKeyB, plaintext) => {
28
+ abytes(secretKeyA, undefined, "secretKeyA");
29
+ abytes(publicKeyB, undefined, "publicKeyB");
30
+ abytes(plaintext, undefined, "plaintext");
31
+ const cek = randomBytes(32), ukm = randomBytes(64), iv = randomBytes(macLength);
32
+ const sharedKey = getSharedSecret(curve.getSharedSecret(secretKeyA, publicKeyB, withCofactor), ukm);
33
+ const wcek = keyWrap(sharedKey, useDstu9311).wrap(cek, iv);
34
+ const data = cfb(new Cipher(cek), iv).encrypt(plaintext);
35
+ return { ukm, iv, wcek, data };
36
+ },
37
+ /**
38
+ * Decrypt message
39
+ * @param secretKeyB - Recipient secret key.
40
+ * @param publicKeyA - Sender public key.
41
+ * @param encryptedMessage - Encrypted message object.
42
+ */
43
+ decrypt: (secretKeyB, publicKeyA, encryptedMessage) => {
44
+ abytes(secretKeyB, undefined, "secretKeyB");
45
+ abytes(publicKeyA, undefined, "publicKeyA");
46
+ abytes(encryptedMessage.data, undefined, "encryptedMessage.data");
47
+ abytes(encryptedMessage.iv, undefined, "encryptedMessage.iv");
48
+ abytes(encryptedMessage.wcek, undefined, "encryptedMessage.wcek");
49
+ if (encryptedMessage.ukm)
50
+ abytes(encryptedMessage.ukm, undefined, "encryptedMessage.ukm");
51
+ const sharedKey = getSharedSecret(curve.getSharedSecret(secretKeyB, publicKeyA, withCofactor), encryptedMessage.ukm);
52
+ const cek = keyWrap(sharedKey, useDstu9311).unwrap(encryptedMessage.wcek);
53
+ return cfb(new Cipher(cek), encryptedMessage.iv).decrypt(encryptedMessage.data);
54
+ }
55
+ });
56
+ };
57
+ /**
58
+ * ECIES schema over DSTU 4145-2002.
59
+ *
60
+ * Uses GOST 34.311-95 as hash function.
61
+ * @param curve - Curve to use.
62
+ * @param withCofactor - Whether to multiply shared key by curve cofactor (See {@link types!ECDSA.getSharedSecret ECDSA.getSharedSecret})
63
+ */
64
+ export const dstu4145EncrypterWithGost = (curve, withCofactor) => dstu4145Encrypter(curve, gost3431195, withCofactor, true);
65
+ /**
66
+ * ECIES schema over DSTU 4145-2002.
67
+ *
68
+ * Uses Kupyna-256 as hash function.
69
+ * @param curve - Curve to use.
70
+ * @param withCofactor - Whether to multiply shared key by curve cofactor (See {@link types!ECDSA.getSharedSecret ECDSA.getSharedSecret})
71
+ */
72
+ export const dstu4145EncrypterWithKupyna = (curve, withCofactor) => dstu4145Encrypter(curve, kupyna256, withCofactor);
@@ -1,5 +1,5 @@
1
1
  import BN from "bn.js";
2
- import { be2LEw, bn2LE, invWords, le2BN, modWords, mulWords, SQR_PRECOMP, WORD_BITS } from "./utils.js";
2
+ import { bn2LE, invWords, le2BN, modWords, mulWords, sqrWords, WORD_BITS } from "./utils.js";
3
3
  /** Compute curve modulo */
4
4
  export const computeMod = (m, ks) => {
5
5
  const modulo = new BN(0);
@@ -24,16 +24,7 @@ export const createField = (m, ks) => {
24
24
  ? sqr(x)
25
25
  : modw(mulWords(bn2LE(x), bn2LE(v)));
26
26
  const div = (x, v) => mul(x, invert(v));
27
- const sqr = (x) => {
28
- const bytes = x.toArray();
29
- const out = new Uint8Array(bytes.length * 2);
30
- for (let i = 0; i < bytes.length; i++) {
31
- const v = SQR_PRECOMP[bytes[i]];
32
- out[2 * i] = (v >> 8) & 0xff;
33
- out[2 * i + 1] = v & 0xff;
34
- }
35
- return modw(be2LEw(out));
36
- };
27
+ const sqr = (x) => modw(sqrWords(bn2LE(x)));
37
28
  const testBit = (x, i) => x.testn(i) ? 1 : 0;
38
29
  const invBit = (x, i) => x.setn(i, !x.testn(i));
39
30
  const sqrt = (x) => {
@@ -12,38 +12,52 @@ const decompress_matrix = (compress_mulp, mulp) => {
12
12
  temp.ishrn(9);
13
13
  }
14
14
  };
15
+ const bnToBits = (x, m) => {
16
+ const bits = new Uint8Array(m);
17
+ for (let i = 0; i < m; i++)
18
+ bits[i] = x.testn(i) ? 1 : 0;
19
+ return bits;
20
+ };
21
+ const bitsToBN = (bits) => {
22
+ const r = new BN(0);
23
+ for (let j = 0; j < bits.length; j++)
24
+ if (bits[j])
25
+ r.setn(j, 1);
26
+ return r;
27
+ };
15
28
  export const init_onb_parameters = (parameters) => {
16
29
  if (!parameters.onb)
17
30
  throw new Error("Invalid curve: Curve doesn't support ONB");
18
31
  const { m, onb, ks } = parameters;
32
+ const m_sub_1 = m - 1;
19
33
  const mulp = new Uint16Array(2 * m - 1);
20
34
  const compress_mulp = new BN(hexToBytes(onb.matrix), "le");
21
35
  decompress_matrix(compress_mulp, mulp);
22
36
  const root1 = new BN(hexToBytes(onb.root1), "le"), root2 = new BN(hexToBytes(onb.root2), "le");
37
+ const root2Bits = bnToBits(root2, m);
38
+ const bitAt = (bits, pos) => bits[pos % m];
23
39
  const multiplyOnb = (x) => {
24
- const r = new BN(0);
25
- const xb = (pos) => (x.testn(pos % m) ? 1 : 0);
26
- const yb = (pos) => (root2.testn(pos % m) ? 1 : 0);
40
+ const xBits = bnToBits(x, m);
41
+ const out = new Uint8Array(m);
27
42
  for (let j = 0; j < m; j++) {
28
43
  let bit = 0;
29
- for (let i = 0; i < m - 1; i++) {
30
- const t1 = yb(mulp[2 * i] + j + 1);
31
- const t2 = yb(mulp[2 * i + 1] + j + 1);
32
- const t3 = xb(i + j + 1);
44
+ const j1 = j + 1;
45
+ for (let i = 0; i < m_sub_1; i++) {
46
+ const i2 = i * 2;
47
+ const t1 = bitAt(root2Bits, mulp[i2] + j1), t2 = bitAt(root2Bits, mulp[i2 + 1] + j1), t3 = bitAt(xBits, i + j1);
33
48
  bit ^= (t1 ^ t2) & t3;
34
49
  }
35
- bit ^= yb(mulp[2 * m - 2] + j + 1) & xb(m - 1 + j + 1);
36
- if (bit)
37
- r.setn(j, 1);
50
+ bit ^= bitAt(root2Bits, mulp[2 * m - 2] + j1) & bitAt(xBits, m_sub_1 + j1);
51
+ out[j] = bit;
38
52
  }
39
- return r;
53
+ return bitsToBN(out);
40
54
  };
41
55
  const reverseBits = (x) => {
42
- const r = new BN(0);
56
+ const xBits = bnToBits(x, m);
57
+ const out = new Uint8Array(m);
43
58
  for (let i = 0; i < m; i++)
44
- if (x.testn(i))
45
- r.setn(m - 1 - i, 1);
46
- return r;
59
+ out[m_sub_1 - i] = xBits[i];
60
+ return bitsToBN(out);
47
61
  };
48
62
  const toPb = new Array(m);
49
63
  toPb[0] = root1.clone();
@@ -60,7 +74,7 @@ export const init_onb_parameters = (parameters) => {
60
74
  const r = new BN(0);
61
75
  for (let p = 0; p < m; p++)
62
76
  if (x.testn(p))
63
- r.ixor(toPb[m - 1 - p]);
77
+ r.ixor(toPb[m_sub_1 - p]);
64
78
  return r;
65
79
  },
66
80
  pbToOnb: (x) => {
@@ -4,7 +4,7 @@ export declare const SQR_PRECOMP: Uint16Array<ArrayBuffer>;
4
4
  export declare const WORD_BITS = 32;
5
5
  export declare const bn2LE: (x: BN, numWords?: number) => TRet<Uint32Array>;
6
6
  export declare const le2BN: (arr: TArg<Uint32Array>) => BN;
7
- export declare const be2LEw: (bytes: TArg<Uint8Array>) => TRet<Uint32Array>;
8
7
  export declare const mulWords: (a: TArg<Uint32Array>, b: TArg<Uint32Array>) => TRet<Uint32Array>;
8
+ export declare const sqrWords: (xw: TArg<Uint32Array>) => TRet<Uint32Array>;
9
9
  export declare const modWords: (a: TArg<Uint32Array>, poly: TArg<Int32Array>) => TRet<Uint32Array>;
10
10
  export declare const invWords: (a: TArg<Uint32Array>, poly: TArg<Uint32Array>) => TRet<Uint32Array>;
@@ -53,14 +53,6 @@ export const le2BN = (arr) => {
53
53
  }
54
54
  return new BN(bytes, "le");
55
55
  };
56
- export const be2LEw = (bytes) => {
57
- const n = bytes.length, arr = new Uint32Array(Math.max(1, Math.ceil(n / 4)));
58
- for (let i = 0; i < n; i++) {
59
- const b = bytes[n - 1 - i];
60
- arr[i >> 2] |= b << ((i & 3) * 8);
61
- }
62
- return arr;
63
- };
64
56
  const wBitLen = (words) => {
65
57
  let nz = words.length - 1;
66
58
  while (nz >= 0 && words[nz] === 0)
@@ -163,6 +155,18 @@ export const mulWords = (a, b) => {
163
155
  }
164
156
  return out;
165
157
  };
158
+ export const sqrWords = (xw) => {
159
+ const out = new Uint32Array(xw.length * 2);
160
+ for (let j = 0; j < xw.length; j++) {
161
+ const w = xw[j];
162
+ if (w === 0)
163
+ continue;
164
+ const b0 = w & 0xff, b1 = (w >>> 8) & 0xff, b2 = (w >>> 16) & 0xff, b3 = (w >>> 24) & 0xff;
165
+ out[2 * j] = SQR_PRECOMP[b0] | (SQR_PRECOMP[b1] << 16);
166
+ out[2 * j + 1] = SQR_PRECOMP[b2] | (SQR_PRECOMP[b3] << 16);
167
+ }
168
+ return out;
169
+ };
166
170
  export const modWords = (a, poly) => {
167
171
  const dN = Math.floor(poly[0] / WORD_BITS), len = Math.max(a.length, dN + 1), res = new Uint32Array(len);
168
172
  res.set(a);
@@ -1,246 +1,37 @@
1
- import { type TArg, type TRet } from "@noble/hashes/utils.js";
2
1
  import { type DSTUParameters } from "./const.js";
2
+ import type { ECDSA } from "../types.js";
3
3
  /** Create DSTU 4145-2002 signer (Big-Endian) */
4
- export declare const dstu4145: (parameters: DSTUParameters) => Readonly<{
5
- getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
6
- getSharedSecret: (secretKeyA: TArg<Uint8Array>, publicKeyB: TArg<Uint8Array>, withCofactor?: boolean) => TRet<Uint8Array>;
7
- sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
8
- verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
9
- keygen: (isCompressed?: boolean) => {
10
- secretKey: TRet<Uint8Array>;
11
- publicKey: TRet<Uint8Array>;
12
- };
13
- lengths: Readonly<{
14
- fieldByteLength: number;
15
- pointByteLength: number;
16
- scalarByteLength: number;
17
- signatureByteLength: number;
18
- }>;
19
- }>;
4
+ export declare const dstu4145: (parameters: DSTUParameters) => ECDSA;
20
5
  /**
21
6
  * Create DSTU 4145-2002 signer (Little-Endian)
22
7
  *
23
8
  * **NOTE:** Parameters MUST be in Big-Endian
24
9
  */
25
- export declare const dstu4145_le: (parameters: DSTUParameters) => Readonly<{
26
- getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
27
- getSharedSecret: (secretKeyA: TArg<Uint8Array>, publicKeyB: TArg<Uint8Array>, withCofactor?: boolean) => TRet<Uint8Array>;
28
- sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
29
- verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
30
- keygen: (isCompressed?: boolean) => {
31
- secretKey: TRet<Uint8Array>;
32
- publicKey: TRet<Uint8Array>;
33
- };
34
- lengths: Readonly<{
35
- fieldByteLength: number;
36
- pointByteLength: number;
37
- scalarByteLength: number;
38
- signatureByteLength: number;
39
- }>;
40
- }>;
10
+ export declare const dstu4145_le: (parameters: DSTUParameters) => ECDSA;
41
11
  export * from "./const.js";
42
12
  export * from "./ec/expand.js";
13
+ export * from "./ecies.js";
43
14
  /** DSTU 4145-2002 163 bit curve */
44
- export declare const dstu163: Readonly<{
45
- getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
46
- getSharedSecret: (secretKeyA: TArg<Uint8Array>, publicKeyB: TArg<Uint8Array>, withCofactor?: boolean) => TRet<Uint8Array>;
47
- sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
48
- verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
49
- keygen: (isCompressed?: boolean) => {
50
- secretKey: TRet<Uint8Array>;
51
- publicKey: TRet<Uint8Array>;
52
- };
53
- lengths: Readonly<{
54
- fieldByteLength: number;
55
- pointByteLength: number;
56
- scalarByteLength: number;
57
- signatureByteLength: number;
58
- }>;
59
- }>;
15
+ export declare const dstu163: ECDSA;
60
16
  /** DSTU 4145-2002 167 bit curve */
61
- export declare const dstu167: Readonly<{
62
- getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
63
- getSharedSecret: (secretKeyA: TArg<Uint8Array>, publicKeyB: TArg<Uint8Array>, withCofactor?: boolean) => TRet<Uint8Array>;
64
- sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
65
- verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
66
- keygen: (isCompressed?: boolean) => {
67
- secretKey: TRet<Uint8Array>;
68
- publicKey: TRet<Uint8Array>;
69
- };
70
- lengths: Readonly<{
71
- fieldByteLength: number;
72
- pointByteLength: number;
73
- scalarByteLength: number;
74
- signatureByteLength: number;
75
- }>;
76
- }>;
17
+ export declare const dstu167: ECDSA;
77
18
  /** DSTU 4145-2002 173 bit curve */
78
- export declare const dstu173: Readonly<{
79
- getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
80
- getSharedSecret: (secretKeyA: TArg<Uint8Array>, publicKeyB: TArg<Uint8Array>, withCofactor?: boolean) => TRet<Uint8Array>;
81
- sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
82
- verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
83
- keygen: (isCompressed?: boolean) => {
84
- secretKey: TRet<Uint8Array>;
85
- publicKey: TRet<Uint8Array>;
86
- };
87
- lengths: Readonly<{
88
- fieldByteLength: number;
89
- pointByteLength: number;
90
- scalarByteLength: number;
91
- signatureByteLength: number;
92
- }>;
93
- }>;
19
+ export declare const dstu173: ECDSA;
94
20
  /** DSTU 4145-2002 179 bit curve */
95
- export declare const dstu179: Readonly<{
96
- getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
97
- getSharedSecret: (secretKeyA: TArg<Uint8Array>, publicKeyB: TArg<Uint8Array>, withCofactor?: boolean) => TRet<Uint8Array>;
98
- sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
99
- verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
100
- keygen: (isCompressed?: boolean) => {
101
- secretKey: TRet<Uint8Array>;
102
- publicKey: TRet<Uint8Array>;
103
- };
104
- lengths: Readonly<{
105
- fieldByteLength: number;
106
- pointByteLength: number;
107
- scalarByteLength: number;
108
- signatureByteLength: number;
109
- }>;
110
- }>;
21
+ export declare const dstu179: ECDSA;
111
22
  /** DSTU 4145-2002 191 bit curve */
112
- export declare const dstu191: Readonly<{
113
- getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
114
- getSharedSecret: (secretKeyA: TArg<Uint8Array>, publicKeyB: TArg<Uint8Array>, withCofactor?: boolean) => TRet<Uint8Array>;
115
- sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
116
- verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
117
- keygen: (isCompressed?: boolean) => {
118
- secretKey: TRet<Uint8Array>;
119
- publicKey: TRet<Uint8Array>;
120
- };
121
- lengths: Readonly<{
122
- fieldByteLength: number;
123
- pointByteLength: number;
124
- scalarByteLength: number;
125
- signatureByteLength: number;
126
- }>;
127
- }>;
23
+ export declare const dstu191: ECDSA;
128
24
  /** DSTU 4145-2002 233 bit curve */
129
- export declare const dstu233: Readonly<{
130
- getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
131
- getSharedSecret: (secretKeyA: TArg<Uint8Array>, publicKeyB: TArg<Uint8Array>, withCofactor?: boolean) => TRet<Uint8Array>;
132
- sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
133
- verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
134
- keygen: (isCompressed?: boolean) => {
135
- secretKey: TRet<Uint8Array>;
136
- publicKey: TRet<Uint8Array>;
137
- };
138
- lengths: Readonly<{
139
- fieldByteLength: number;
140
- pointByteLength: number;
141
- scalarByteLength: number;
142
- signatureByteLength: number;
143
- }>;
144
- }>;
25
+ export declare const dstu233: ECDSA;
145
26
  /** DSTU 4145-2002 257 bit curve */
146
- export declare const dstu257: Readonly<{
147
- getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
148
- getSharedSecret: (secretKeyA: TArg<Uint8Array>, publicKeyB: TArg<Uint8Array>, withCofactor?: boolean) => TRet<Uint8Array>;
149
- sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
150
- verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
151
- keygen: (isCompressed?: boolean) => {
152
- secretKey: TRet<Uint8Array>;
153
- publicKey: TRet<Uint8Array>;
154
- };
155
- lengths: Readonly<{
156
- fieldByteLength: number;
157
- pointByteLength: number;
158
- scalarByteLength: number;
159
- signatureByteLength: number;
160
- }>;
161
- }>;
27
+ export declare const dstu257: ECDSA;
162
28
  /** DSTU 4145-2002 257 bit curve (LE) */
163
- export declare const dstu257_le: Readonly<{
164
- getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
165
- getSharedSecret: (secretKeyA: TArg<Uint8Array>, publicKeyB: TArg<Uint8Array>, withCofactor?: boolean) => TRet<Uint8Array>;
166
- sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
167
- verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
168
- keygen: (isCompressed?: boolean) => {
169
- secretKey: TRet<Uint8Array>;
170
- publicKey: TRet<Uint8Array>;
171
- };
172
- lengths: Readonly<{
173
- fieldByteLength: number;
174
- pointByteLength: number;
175
- scalarByteLength: number;
176
- signatureByteLength: number;
177
- }>;
178
- }>;
29
+ export declare const dstu257_le: ECDSA;
179
30
  /** DSTU 4145-2002 307 bit curve */
180
- export declare const dstu307: Readonly<{
181
- getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
182
- getSharedSecret: (secretKeyA: TArg<Uint8Array>, publicKeyB: TArg<Uint8Array>, withCofactor?: boolean) => TRet<Uint8Array>;
183
- sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
184
- verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
185
- keygen: (isCompressed?: boolean) => {
186
- secretKey: TRet<Uint8Array>;
187
- publicKey: TRet<Uint8Array>;
188
- };
189
- lengths: Readonly<{
190
- fieldByteLength: number;
191
- pointByteLength: number;
192
- scalarByteLength: number;
193
- signatureByteLength: number;
194
- }>;
195
- }>;
31
+ export declare const dstu307: ECDSA;
196
32
  /** DSTU 4145-2002 367 bit curve */
197
- export declare const dstu367: Readonly<{
198
- getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
199
- getSharedSecret: (secretKeyA: TArg<Uint8Array>, publicKeyB: TArg<Uint8Array>, withCofactor?: boolean) => TRet<Uint8Array>;
200
- sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
201
- verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
202
- keygen: (isCompressed?: boolean) => {
203
- secretKey: TRet<Uint8Array>;
204
- publicKey: TRet<Uint8Array>;
205
- };
206
- lengths: Readonly<{
207
- fieldByteLength: number;
208
- pointByteLength: number;
209
- scalarByteLength: number;
210
- signatureByteLength: number;
211
- }>;
212
- }>;
33
+ export declare const dstu367: ECDSA;
213
34
  /** DSTU 4145-2002 431 bit curve */
214
- export declare const dstu431: Readonly<{
215
- getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
216
- getSharedSecret: (secretKeyA: TArg<Uint8Array>, publicKeyB: TArg<Uint8Array>, withCofactor?: boolean) => TRet<Uint8Array>;
217
- sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
218
- verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
219
- keygen: (isCompressed?: boolean) => {
220
- secretKey: TRet<Uint8Array>;
221
- publicKey: TRet<Uint8Array>;
222
- };
223
- lengths: Readonly<{
224
- fieldByteLength: number;
225
- pointByteLength: number;
226
- scalarByteLength: number;
227
- signatureByteLength: number;
228
- }>;
229
- }>;
35
+ export declare const dstu431: ECDSA;
230
36
  /** DSTU 4145-2002 431 bit curve (LE) */
231
- export declare const dstu431_le: Readonly<{
232
- getPublicKey: (secretKey: TArg<Uint8Array>, isCompressed?: boolean) => TRet<Uint8Array>;
233
- getSharedSecret: (secretKeyA: TArg<Uint8Array>, publicKeyB: TArg<Uint8Array>, withCofactor?: boolean) => TRet<Uint8Array>;
234
- sign: (secretKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, rand?: TArg<Uint8Array>) => TRet<Uint8Array>;
235
- verify: (publicKey: TArg<Uint8Array>, digest: TArg<Uint8Array>, signature: TArg<Uint8Array>) => boolean;
236
- keygen: (isCompressed?: boolean) => {
237
- secretKey: TRet<Uint8Array>;
238
- publicKey: TRet<Uint8Array>;
239
- };
240
- lengths: Readonly<{
241
- fieldByteLength: number;
242
- pointByteLength: number;
243
- scalarByteLength: number;
244
- signatureByteLength: number;
245
- }>;
246
- }>;
37
+ export declare const dstu431_le: ECDSA;