@tideorg/js 0.0.1

package/dist/Cryptide/Encryption/ElGamal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ElGamal.d.ts","sourceRoot":"","sources":["../../../Cryptide/Encryption/ElGamal.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAQnC,MAAM,CAAC,OAAO,OAAO,OAAO;WACX,WAAW,CAAC,UAAU,EAAE,UAAU,EAAE,SAAS,EAAE,KAAK;WAIpD,cAAc,CAAC,UAAU,EAAE,UAAU,EAAE,SAAS,EAAE,KAAK;WAOvD,iCAAiC,CAAC,UAAU,EAAE,UAAU,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,EAAE,UAAU;;;;WAW/F,WAAW,CAAC,YAAY,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,UAAU;WAWxD,cAAc,CAAC,YAAY,EAAE,UAAU,EAAE,CAAC,EAAE,MAAM,GAAG,UAAU;CAS/E"}

package/dist/Cryptide/Encryption/ElGamal.js

@@ -0,0 +1,61 @@
+// 
+// Tide Protocol - Infrastructure for a TRUE Zero-Trust paradigm
+// Copyright (C) 2022 Tide Foundation Ltd
+// 
+// This program is free software and is subject to the terms of 
+// the Tide Community Open Code License as published by the 
+// Tide Foundation Limited. You may modify it and redistribute 
+// it in accordance with and subject to the terms of that License.
+// This program is distributed WITHOUT WARRANTY of any kind, 
+// including without any implied warranty of MERCHANTABILITY or 
+// FITNESS FOR A PARTICULAR PURPOSE.
+// See the Tide Community Open Code License for more details.
+// You should have received a copy of the Tide Community Open 
+// Code License along with this program.
+// If not, see https://tide.org/licenses_tcoc2-0-0-en
+//
+import { Point } from "../Ed25519";
+import { RandomBigInt } from "../Math";
+import { encryptDataRawOutput, decryptDataRawOutput } from "./AES";
+import { SHA256_Digest } from "../Hashing/Hash";
+import { BigIntFromByteArray, ConcatUint8Arrays, base64ToBytes, bytesToBase64 } from "../Serialization";
+import TideKey from "../TideKey";
+import { Ed25519PrivateComponent } from "../Components/Schemes/Ed25519";
+export default class ElGamal {
+    static async encryptData(secretData, publicKey) {
+        return bytesToBase64(await this.encryptDataRaw(secretData, publicKey));
+    }
+    static async encryptDataRaw(secretData, publicKey) {
+        const r = RandomBigInt();
+        const c1 = Point.BASE.mul(r).toRawBytes();
+        const c2 = await encryptDataRawOutput(secretData, await SHA256_Digest(publicKey.mul(r).toRawBytes()));
+        return ConcatUint8Arrays([c1, c2]);
+    }
+    static async encryptDataRaw_withAuthentication(secretData, publicKey, authMsg) {
+        const r = RandomBigInt();
+        const c1 = Point.BASE.mul(r).toRawBytes();
+        const c2 = await encryptDataRawOutput(secretData, await SHA256_Digest(publicKey.mul(r).toRawBytes()));
+        const authSig = await (new TideKey(new Ed25519PrivateComponent(r)).sign(authMsg));
+        return {
+            cipher: ConcatUint8Arrays([c1, c2]),
+            auth: authSig
+        };
+    }
+    static async decryptData(base64_c1_c2, k) {
+        const priv = typeof (k) == 'bigint' ? k : BigIntFromByteArray(k);
+        const b = base64ToBytes(base64_c1_c2);
+        const c1 = b.slice(0, 32);
+        const c2 = b.slice(32);
+        const c1Point = Point.fromBytes(c1);
+        const decrypted = await decryptDataRawOutput(c2, await SHA256_Digest(c1Point.mul(priv).toRawBytes()));
+        return decrypted;
+    }
+    static async decryptDataRaw(base64_c1_c2, k) {
+        const priv = typeof (k) == 'bigint' ? k : BigIntFromByteArray(k);
+        const c1 = base64_c1_c2.slice(0, 32);
+        const c2 = base64_c1_c2.slice(32);
+        const c1Point = Point.fromBytes(c1);
+        const decrypted = await decryptDataRawOutput(c2, await SHA256_Digest(c1Point.mul(priv).toRawBytes()));
+        return decrypted;
+    }
+}

package/dist/Cryptide/Encryption/index.d.ts

@@ -0,0 +1,4 @@
+export { default as ElGamal } from './ElGamal';
+export * as AES from './AES';
+export * as DH from './DH';
+//# sourceMappingURL=index.d.ts.map

package/dist/Cryptide/Encryption/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../Cryptide/Encryption/index.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,OAAO,IAAI,OAAO,EAAE,MAAM,WAAW,CAAC;AAC/C,OAAO,KAAK,GAAG,MAAM,OAAO,CAAC;AAC7B,OAAO,KAAK,EAAE,MAAM,MAAM,CAAC"}

package/dist/Cryptide/Encryption/index.js

@@ -0,0 +1,19 @@
+//
+// Tide Protocol - Infrastructure for a TRUE Zero-Trust paradigm
+// Copyright (C) 2022 Tide Foundation Ltd
+//
+// This program is free software and is subject to the terms of
+// the Tide Community Open Code License as published by the
+// Tide Foundation Limited. You may modify it and redistribute
+// it in accordance with and subject to the terms of that License.
+// This program is distributed WITHOUT WARRANTY of any kind,
+// including without any implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE.
+// See the Tide Community Open Code License for more details.
+// You should have received a copy of the Tide Community Open
+// Code License along with this program.
+// If not, see https://tide.org/licenses_tcoc2-0-0-en
+//
+export { default as ElGamal } from './ElGamal';
+export * as AES from './AES';
+export * as DH from './DH';

package/dist/Cryptide/Hashing/H2P.d.ts

@@ -0,0 +1,6 @@
+import { Point } from "../Ed25519";
+/**
+ * Hashes a msg to a point on the ed25519 curve.
+ */
+export default function HashToPoint(msg: string | Uint8Array): Promise<Point>;
+//# sourceMappingURL=H2P.d.ts.map

package/dist/Cryptide/Hashing/H2P.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"H2P.d.ts","sourceRoot":"","sources":["../../../Cryptide/Hashing/H2P.ts"],"names":[],"mappings":"AAyCA,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAmLnC;;GAEG;AACH,wBAA8B,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,GAAG,OAAO,CAAC,KAAK,CAAC,CASlF"}

package/dist/Cryptide/Hashing/H2P.js

@@ -0,0 +1,235 @@
+//
+// Tide Protocol - Infrastructure for a TRUE Zero-Trust paradigm
+// Copyright (C) 2022 Tide Foundation Ltd
+//
+// This program is free software and is subject to the terms of
+// the Tide Community Open Code License as published by the
+// Tide Foundation Limited. You may modify it and redistribute
+// it in accordance with and subject to the terms of that License.
+// This program is distributed WITHOUT WARRANTY of any kind,
+// including without any implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE.
+// See the Tide Community Open Code License for more details.
+// You should have received a copy of the Tide Community Open
+// Code License along with this program.
+// If not, see https://tide.org/licenses_tcoc2-0-0-en
+//
+// Some parts of the code were taken from @noble/curves project and are protected under the following license:
+//
+// The MIT License (MIT)
+// 
+// Copyright (c) 2022 Paul Miller (https://paulmillr.com)
+// 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+// 
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+// 
+import { Point } from "../Ed25519";
+import { ConcatUint8Arrays, BigIntFromByteArray } from "../Serialization";
+import { mod, mod_inv } from "../Math";
+import { SHA512_Digest } from "./Hash";
+const curveP = BigInt("57896044618658097711785492504343953926634992332820282019728792003956564819949");
+const _0n = BigInt(0), _1n = BigInt(1), _2n = BigInt(2);
+function Fp_FpInvertBatch(nums) {
+    const tmp = new Array(nums.length);
+    // Walk from first to last, multiply them by each other MOD p
+    const lastMultiplied = nums.reduce((acc, num, i) => {
+        if (num === _0n)
+            return acc;
+        tmp[i] = acc;
+        return multiply_nums(acc, num);
+    }, _1n);
+    // Invert last element
+    const inverted = mod_inv(lastMultiplied, curveP);
+    // Walk from last to first, multiply them by inverted each other MOD p
+    nums.reduceRight((acc, num, i) => {
+        if (num === _0n)
+            return acc;
+        tmp[i] = multiply_nums(acc, tmp[i]);
+        return multiply_nums(acc, num);
+    }, inverted);
+    return tmp;
+}
+;
+//functions from field
+function cmov(a, b, c) { return (c ? b : a); }
+; //returns b if c is true and returns a if c is false
+function add_nums(num1, num2, modulus = curveP) { return mod(num1 + num2, modulus); }
+; //adds 2 numbers together then uses mod to ensure that they are not greater than the curveP value
+function multiply_nums(num1, num2, modulus = curveP) { return mod(BigInt(num1 * num2), modulus); }
+; //multiplies numbers then reduces them below curveP
+function to_the_power_of(number, power, modulus = curveP) {
+    if (power < _0n)
+        throw new Error('Expected power > 0');
+    if (power === _0n)
+        return _1n;
+    if (power === _1n)
+        return number;
+    let p = _1n;
+    let d = number;
+    while (power > _0n) {
+        if (power & _1n)
+            p = multiply_nums(p, d, modulus);
+        d = multiply_nums(d, d, modulus);
+        power >>= _1n;
+    }
+    ;
+    return p;
+}
+; // raises a number to a certain power while keeping values below curveP
+//constants used in the map_to_curve functions
+const ELL2_C1_EDWARDS = BigInt('6853475219497561581579357271197624642482790079785650197046958215289687604742'); //hard coded as the field only has one value in this case Fp = Field(ED25519_P, undefined, true); ELL2_C1_EDWARDS = FpSqrtEven(Fp, Fp.neg(BigInt(486664))); // sgn0(c1) MUST equal 0
+const ELL2_C1 = (curveP + BigInt(3)) / BigInt(8); // 1. c1 = (q + 3) / 8       # Integer arithmetic
+const ELL2_C2 = to_the_power_of(_2n, ELL2_C1); // 2. c2 = 2^c1
+const ELL2_C3 = BigInt('38214883241950591754978413199355411911188925816896391856984770930832735035197'); //hard coded sqrt value of ELL2_C3 = Fp.sqrt(Fp.neg(Fp.ONE)); // 3. c3 = sqrt(-1)
+const ELL2_C4 = (curveP - BigInt(5)) / BigInt(8); // 4. c4 = (q - 5) / 8       # Integer arithmetic
+const ELL2_J = BigInt(486662);
+function map_to_curve_elligator2_curve25519_(u) {
+    let tv1 = multiply_nums(u, u); //  1.  tv1 = u^2
+    tv1 = multiply_nums(tv1, _2n); //  2.  tv1 = 2 * tv1
+    let xd = add_nums(tv1, _1n); //  3.   xd = tv1 + 1         # Nonzero: -1 is square (mod p), tv1 is not
+    let x1n = -ELL2_J; //  4.  x1n = -J              # x1 = x1n / xd = -J / (1 + 2 * u^2)
+    let tv2 = multiply_nums(xd, xd); //  5.  tv2 = xd^2
+    let gxd = multiply_nums(tv2, xd); //  6.  gxd = tv2 * xd        # gxd = xd^3
+    let gx1 = multiply_nums(tv1, ELL2_J); //  7.  gx1 = J * tv1         # x1n + J * xd
+    gx1 = multiply_nums(gx1, x1n); //  8.  gx1 = gx1 * x1n       # x1n^2 + J * x1n * xd
+    gx1 = add_nums(gx1, tv2); //  9.  gx1 = gx1 + tv2       # x1n^2 + J * x1n * xd + xd^2
+    gx1 = multiply_nums(gx1, x1n); //  10. gx1 = gx1 * x1n       # x1n^3 + J * x1n^2 * xd + x1n * xd^2
+    let tv3 = multiply_nums(gxd, gxd); //  11. tv3 = gxd^2
+    tv2 = multiply_nums(tv3, tv3); //  12. tv2 = tv3^2           # gxd^4
+    tv3 = multiply_nums(tv3, gxd); //  13. tv3 = tv3 * gxd       # gxd^3
+    tv3 = multiply_nums(tv3, gx1); //  14. tv3 = tv3 * gx1       # gx1 * gxd^3
+    tv2 = multiply_nums(tv2, tv3); //  15. tv2 = tv2 * tv3       # gx1 * gxd^7
+    let y11 = to_the_power_of(tv2, ELL2_C4); //  16. y11 = tv2^c4        # (gx1 * gxd^7)^((p - 5) / 8)
+    y11 = multiply_nums(y11, tv3); //  17. y11 = y11 * tv3       # gx1*gxd^3*(gx1*gxd^7)^((p-5)/8)
+    let y12 = multiply_nums(y11, ELL2_C3); //  18. y12 = y11 * c3
+    tv2 = multiply_nums(y11, y11); //  19. tv2 = y11^2
+    tv2 = multiply_nums(tv2, gxd); //  20. tv2 = tv2 * gxd
+    let e1 = (tv2 === gx1); //  21.  e1 = tv2 == gx1
+    let y1 = cmov(y12, y11, e1); //  22.  y1 = CMOV(y12, y11, e1)  # If g(x1) is square, this is its sqrt
+    let x2n = multiply_nums(x1n, tv1); //  23. x2n = x1n * tv1       # x2 = x2n / xd = 2 * u^2 * x1n / xd
+    let y21 = multiply_nums(y11, u); //  24. y21 = y11 * u
+    y21 = multiply_nums(y21, ELL2_C2); //  25. y21 = y21 * c2
+    let y22 = multiply_nums(y21, ELL2_C3); //  26. y22 = y21 * c3
+    let gx2 = multiply_nums(gx1, tv1); //  27. gx2 = gx1 * tv1       # g(x2) = gx2 / gxd = 2 * u^2 * g(x1)
+    tv2 = multiply_nums(y21, y21); //  28. tv2 = y21^2
+    tv2 = multiply_nums(tv2, gxd); //  29. tv2 = tv2 * gxd
+    let e2 = (tv2 === gx2); //  30.  e2 = tv2 == gx2
+    let y2 = cmov(y22, y21, e2); //  31.  y2 = CMOV(y22, y21, e2)  # If g(x2) is square, this is its sqrt
+    tv2 = multiply_nums(y1, y1); //  32. tv2 = y1^2
+    tv2 = multiply_nums(tv2, gxd); //  33. tv2 = tv2 * gxd
+    let e3 = (tv2 === gx1); //  34.  e3 = tv2 == gx1
+    let xn = cmov(x2n, x1n, e3); //  35.  xn = CMOV(x2n, x1n, e3)  # If e3, x = x1, else x = x2
+    let y = cmov(y2, y1, e3); //  36.   y = CMOV(y2, y1, e3)    # If e3, y = y1, else y = y2
+    let e4 = ((y & _1n) === _1n); //  37.  e4 = sgn0(y) == 1        # Fix sign of y
+    y = cmov(y, -y, e3 !== e4); //  38.   y = CMOV(y, -y, e3 XOR e4)
+    return { xMn: xn, xMd: xd, yMn: y, yMd: _1n }; //  39. return (xn, xd, y, 1)
+}
+function map_to_curve_elligator2_edwards25519_(u) {
+    const { xMn, xMd, yMn, yMd } = map_to_curve_elligator2_curve25519_(u); //  1.  (xMn, xMd, yMn, yMd) =
+    // map_to_curve_elligator2_curve25519(u)
+    let xn = multiply_nums(xMn, yMd); //  2.  xn = xMn * yMd
+    xn = multiply_nums(xn, ELL2_C1_EDWARDS); //  3.  xn = xn * c1
+    let xd = multiply_nums(xMd, yMn); //  4.  xd = xMd * yMn    # xn / xd = c1 * xM / yM
+    let yn = mod(xMn - xMd, curveP); //  5.  yn = xMn - xMd
+    let yd = add_nums(xMn, xMd); //  6.  yd = xMn + xMd    # (n / d - 1) / (n / d + 1) = (n - d) / (n + d)
+    let tv1 = multiply_nums(xd, yd); //  7. tv1 = xd * yd
+    let e = (tv1 === _0n); //  8.   e = tv1 == 0
+    xn = cmov(xn, _0n, e); //  9.  xn = CMOV(xn, 0, e)
+    xd = cmov(xd, _1n, e); //  10. xd = CMOV(xd, 1, e)
+    yn = cmov(yn, _1n, e); //  11. yn = CMOV(yn, 1, e)
+    yd = cmov(yd, _1n, e); //  12. yd = CMOV(yd, 1, e)
+    const inv = Fp_FpInvertBatch([xd, yd]); // batch division
+    return { x: multiply_nums(xn, inv[0]), y: multiply_nums(yn, inv[1]) }; //  13. return (xn, xd, yn, yd)
+}
+function i2osp(value, length) {
+    if (value < 0 || value >= 1 << (8 * length)) {
+        throw new Error(`bad I2OSP call: value=${value} length=${length}`);
+    }
+    const res = Array.from({ length }).fill(0);
+    for (let i = length - 1; i >= 0; i--) {
+        res[i] = value & 0xff;
+        value >>>= 8;
+    }
+    return new Uint8Array(res);
+} //takes a value and a length, an array is created with that length. Then takes the smallest 8 bits from the value and places it at the end of the array. 
+//Repeats this with the next 8 bits and places them in the next last value in the array for the rest of the value  
+function strxor(a, b) {
+    const arr = new Uint8Array(a.length);
+    for (let i = 0; i < a.length; i++) {
+        arr[i] = a[i] ^ b[i];
+    }
+    return arr;
+}
+; //does bitwise xor on all values in 2 arrays and returns a new array with the results
+async function expand_message_xmd(msg, DST, len_in_bytes) {
+    const b_in_bytes = 64;
+    const r_in_bytes = 128;
+    const ell = Math.ceil(len_in_bytes / b_in_bytes);
+    if (ell > 255)
+        throw new Error('Invalid xmd length');
+    const DST_prime = ConcatUint8Arrays([DST, i2osp(DST.length, 1)]);
+    const Z_pad = i2osp(0, r_in_bytes);
+    const len_in_bytes_str = i2osp(len_in_bytes, 2);
+    const b = new Array(ell);
+    const arr = ConcatUint8Arrays([Z_pad, msg, len_in_bytes_str, i2osp(0, 1), DST_prime]);
+    const b_0 = await SHA512_Digest(arr);
+    const promise_b = SHA512_Digest((ConcatUint8Arrays([b_0, i2osp(1, 1), DST_prime])));
+    b[0] = await promise_b;
+    for (let i = 1; i <= ell; i++) {
+        const args = [strxor(b_0, b[i - 1]), i2osp(i + 1, 1), DST_prime];
+        b[i] = await SHA512_Digest(ConcatUint8Arrays(args));
+    }
+    const pseudo_random_bytes = ConcatUint8Arrays(b);
+    return pseudo_random_bytes.slice(0, len_in_bytes);
+}
+; //a message and a DST that are encoded into Uint8arrays are hashed into a certain number of values according to len_in_bytes
+async function hashtofield(msg) {
+    const _DST = 'QUUX-V01-CS02-with-edwards25519_XMD:SHA-512_ELL2_RO_', m = 1, count = 2, k = 128, p = BigInt('57896044618658097711785492504343953926634992332820282019728792003956564819949');
+    const DST = new TextEncoder().encode(_DST);
+    const log2p = p.toString(2).length;
+    const L = Math.ceil((log2p + k) / 8);
+    const len_in_bytes = count * m * L;
+    let prb = await expand_message_xmd(msg, DST, len_in_bytes);
+    const u = new Array(count);
+    for (let i = 0; i < count; i++) {
+        const e = new Array(m);
+        for (let j = 0; j < m; j++) {
+            const elm_offset = L * (j + i * m);
+            const tv = prb.subarray(elm_offset, elm_offset + L);
+            e[j] = mod(BigIntFromByteArray(tv.reverse()), p);
+        }
+        u[i] = e;
+    }
+    return u;
+}
+; //takes in a message hashes it with expand_message_xmd and splits the resulting value into 2 parts
+/**
+ * Hashes a msg to a point on the ed25519 curve.
+ */
+export default async function HashToPoint(msg) {
+    const arr = typeof (msg) === 'string' ? new TextEncoder().encode(msg) : msg;
+    const u = await hashtofield(arr);
+    const x0y0 = map_to_curve_elligator2_edwards25519_(u[0][0]);
+    const x1y1 = map_to_curve_elligator2_edwards25519_(u[1][0]);
+    const p0 = Point.fromAffine(x0y0);
+    const p1 = Point.fromAffine(x1y1);
+    const P = p0.add(p1).clearCofactor();
+    return P;
+}
+; //hashtofield takes an Uint8array encoded message and gives back 2 values. the map_to_curve function then uses those values to generate 2 x and y values
+// 2 Points are created using the x and y values. The points are added to each other and then are muliplied by 8 to give the final point.

package/dist/Cryptide/Hashing/Hash.d.ts

@@ -0,0 +1,8 @@
+import { Point } from "../Ed25519";
+export declare function SHA256_Digest(message: string | Uint8Array): Promise<Uint8Array<ArrayBuffer>>;
+export declare function SHA512_Digest(message: string | Uint8Array): Promise<Uint8Array<ArrayBuffer>>;
+/**
+ * DO NOT USE THIS TO SIGN. THE KEY IS THE HASH OF THE FIRST MESSAGE PASSED. THIS FUNCTION IS FOR HASHING MULTIPLE MESSAGES.
+ */
+export declare function HMAC_forHashing(message: string, pub: Point): Promise<Uint8Array<ArrayBuffer>>;
+//# sourceMappingURL=Hash.d.ts.map

package/dist/Cryptide/Hashing/Hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Hash.d.ts","sourceRoot":"","sources":["../../../Cryptide/Hashing/Hash.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnC,wBAAsB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU,oCAK/D;AAED,wBAAsB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,UAAU,oCAK/D;AAED;;GAEG;AACH,wBAAsB,eAAe,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,KAAK,oCAehE"}

package/dist/Cryptide/Hashing/Hash.js

@@ -0,0 +1,43 @@
+// 
+// Tide Protocol - Infrastructure for a TRUE Zero-Trust paradigm
+// Copyright (C) 2022 Tide Foundation Ltd
+// 
+// This program is free software and is subject to the terms of 
+// the Tide Community Open Code License as published by the 
+// Tide Foundation Limited. You may modify it and redistribute 
+// it in accordance with and subject to the terms of that License.
+// This program is distributed WITHOUT WARRANTY of any kind, 
+// including without any implied warranty of MERCHANTABILITY or 
+// FITNESS FOR A PARTICULAR PURPOSE.
+// See the Tide Community Open Code License for more details.
+// You should have received a copy of the Tide Community Open 
+// Code License along with this program.
+// If not, see https://tide.org/licenses_tcoc2-0-0-en
+//
+export async function SHA256_Digest(message) {
+    const data = typeof (message) === 'string' ? new TextEncoder().encode(message) : message;
+    const hash = await crypto.subtle.digest('SHA-256', data);
+    return new Uint8Array(hash);
+}
+export async function SHA512_Digest(message) {
+    const data = typeof (message) === 'string' ? new TextEncoder().encode(message) : message;
+    const hash = await crypto.subtle.digest('SHA-512', data);
+    return new Uint8Array(hash);
+}
+/**
+ * DO NOT USE THIS TO SIGN. THE KEY IS THE HASH OF THE FIRST MESSAGE PASSED. THIS FUNCTION IS FOR HASHING MULTIPLE MESSAGES.
+ */
+export async function HMAC_forHashing(message, pub) {
+    const tx = new TextEncoder();
+    const key = await SHA256_Digest(tx.encode(message));
+    const cryptoKey = await crypto.subtle.importKey('raw', // raw format for Uint8Array input
+    key, // the Uint8Array key data
+    {
+        name: 'HMAC',
+        hash: { name: 'SHA-256' }, // specifying the hash algorithm to use with HMAC
+    }, false, // whether the key is extractable
+    ['sign'] // allowed key usages
+    );
+    const hash = await window.crypto.subtle.sign("HMAC", cryptoKey, pub.toRawBytes());
+    return new Uint8Array(hash);
+}

package/dist/Cryptide/Hashing/index.d.ts

@@ -0,0 +1,3 @@
+export * as Hash from './Hash';
+export { default as HashToPoint } from './H2P';
+//# sourceMappingURL=index.d.ts.map

package/dist/Cryptide/Hashing/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../Cryptide/Hashing/index.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,IAAI,MAAM,QAAQ,CAAC;AAC/B,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,OAAO,CAAC"}

package/dist/Cryptide/Hashing/index.js

@@ -0,0 +1,18 @@
+//
+// Tide Protocol - Infrastructure for a TRUE Zero-Trust paradigm
+// Copyright (C) 2022 Tide Foundation Ltd
+//
+// This program is free software and is subject to the terms of
+// the Tide Community Open Code License as published by the
+// Tide Foundation Limited. You may modify it and redistribute
+// it in accordance with and subject to the terms of that License.
+// This program is distributed WITHOUT WARRANTY of any kind,
+// including without any implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE.
+// See the Tide Community Open Code License for more details.
+// You should have received a copy of the Tide Community Open
+// Code License along with this program.
+// If not, see https://tide.org/licenses_tcoc2-0-0-en
+//
+export * as Hash from './Hash';
+export { default as HashToPoint } from './H2P';

package/dist/Cryptide/Interpolation.d.ts

@@ -0,0 +1,20 @@
+import { Point } from "./Ed25519";
+import { Ed25519PublicComponent } from "./Components/Schemes/Ed25519/Ed25519Components";
+export declare function GetLi(xi: bigint, xs: bigint[], m?: bigint): bigint;
+export declare function GetLis(ids: bigint[]): bigint[];
+export declare function AggregatePoints(points: Point[]): Point;
+export declare function AggregatePublicComponents(points: Ed25519PublicComponent[]): Ed25519PublicComponent;
+export declare function AggregatePublicComponentArrays(pointArrays: Ed25519PublicComponent[][]): Ed25519PublicComponent[];
+/**
+ * Will aggregate all points at corresponding indexes. E.g. all points from each array at index 0 will be summed.
+ */
+export declare function AggregatePointArrays(pointArrays: Point[][]): Point[];
+/**
+ * Will aggregate all points and multiply by corresponding li of id.
+ */
+export declare function AggregatePointsWithIds(points: Point[], ids: bigint[]): Point;
+/**
+ * Will aggregate all points and multiply by corresponding li.
+ */
+export declare function AggregatePointsWithLis(points: Point[], lis: bigint[]): Point;
+//# sourceMappingURL=Interpolation.d.ts.map

package/dist/Cryptide/Interpolation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Interpolation.d.ts","sourceRoot":"","sources":["../../Cryptide/Interpolation.ts"],"names":[],"mappings":"AAkBA,OAAO,EAAE,KAAK,EAAS,MAAM,WAAW,CAAC;AACzC,OAAO,EAAE,sBAAsB,EAAE,MAAM,gDAAgD,CAAC;AAExF,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,CAAC,GAAE,MAAgB,GAAG,MAAM,CAK3E;AAED,wBAAgB,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,YAEnC;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,KAAK,EAAE,SAG9C;AACD,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,sBAAsB,EAAE,0BAGzE;AAED,wBAAgB,8BAA8B,CAAC,WAAW,EAAE,sBAAsB,EAAE,EAAE,4BAIrF;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,KAAK,EAAE,EAAE,WAI1D;AACD;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,KAAK,CAG5E;AACD;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,GAAG,KAAK,CAE5E"}

package/dist/Cryptide/Interpolation.js

@@ -0,0 +1,68 @@
+// 
+// Tide Protocol - Infrastructure for a TRUE Zero-Trust paradigm
+// Copyright (C) 2022 Tide Foundation Ltd
+// 
+// This program is free software and is subject to the terms of 
+// the Tide Community Open Code License as published by the 
+// Tide Foundation Limited. You may modify it and redistribute 
+// it in accordance with and subject to the terms of that License.
+// This program is distributed WITHOUT WARRANTY of any kind, 
+// including without any implied warranty of MERCHANTABILITY or 
+// FITNESS FOR A PARTICULAR PURPOSE.
+// See the Tide Community Open Code License for more details.
+// You should have received a copy of the Tide Community Open 
+// Code License along with this program.
+// If not, see https://tide.org/licenses_tcoc2-0-0-en
+//
+import { mod, mod_inv } from "./Math";
+import { Point, CURVE } from "./Ed25519";
+import { Ed25519PublicComponent } from "./Components/Schemes/Ed25519/Ed25519Components";
+export function GetLi(xi, xs, m = CURVE.n) {
+    var li = xs.filter(xj => xj != xi)
+        .map(xj => mod(mod_inv(xj - xi, m) * xj), m)
+        .reduce((li, num) => mod(li * num, m));
+    return li;
+}
+export function GetLis(ids) {
+    return ids.map(id => GetLi(id, ids, CURVE.n));
+}
+export function AggregatePoints(points) {
+    if (points.every(p => p == null))
+        return null;
+    else
+        return points.reduce((sum, next) => next == null ? sum : sum.add(next), Point.ZERO);
+}
+export function AggregatePublicComponents(points) {
+    if (points.every(p => p == null))
+        return null;
+    else
+        return points.reduce((sum, next) => next == null ? sum : sum.AddComponent(next), new Ed25519PublicComponent(Point.ZERO));
+}
+export function AggregatePublicComponentArrays(pointArrays) {
+    const arrayDepth = pointArrays[0].length;
+    if (!pointArrays.every(array => array.length == arrayDepth))
+        throw Error("Inconsistent amount of array depths");
+    return pointArrays[0].map((_, i) => AggregatePublicComponents(pointArrays.map(array => array[i])));
+}
+/**
+ * Will aggregate all points at corresponding indexes. E.g. all points from each array at index 0 will be summed.
+ */
+export function AggregatePointArrays(pointArrays) {
+    const arrayDepth = pointArrays[0].length;
+    if (!pointArrays.every(array => array.length == arrayDepth))
+        throw Error("Inconsistent amount of array depths");
+    return pointArrays[0].map((_, i) => AggregatePoints(pointArrays.map(array => array[i])));
+}
+/**
+ * Will aggregate all points and multiply by corresponding li of id.
+ */
+export function AggregatePointsWithIds(points, ids) {
+    const lis = GetLis(ids);
+    return AggregatePoints(points.map((p, i) => p.mul(lis[i])));
+}
+/**
+ * Will aggregate all points and multiply by corresponding li.
+ */
+export function AggregatePointsWithLis(points, lis) {
+    return AggregatePoints(points.map((p, i) => p.mul(lis[i])));
+}

package/dist/Cryptide/Math.d.ts

@@ -0,0 +1,11 @@
+import { Point } from "./Ed25519";
+export declare function mod(a: bigint, b?: bigint): bigint;
+export declare function median(numbers: bigint[]): any;
+export declare function RandomBigInt(): bigint;
+export declare function GenSessKey(): Uint8Array<ArrayBufferLike>;
+export declare function CreateGPrismAuth(gPassPRISM: Point): Promise<Point>;
+export declare function GetPublic(a: bigint | Uint8Array): Point;
+export declare function Min(arr: number[]): number;
+export declare function mod_inv(number: bigint, modulo?: bigint): bigint;
+export declare function SumPoints(points: Point[]): Point;
+//# sourceMappingURL=Math.d.ts.map

package/dist/Cryptide/Math.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Math.d.ts","sourceRoot":"","sources":["../../Cryptide/Math.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAS,KAAK,EAAE,MAAM,WAAW,CAAC;AAUzC,wBAAgB,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,GAAE,MAAgB,GAAG,MAAM,CAG1D;AAED,wBAAgB,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,OASvC;AAED,wBAAgB,YAAY,IAAI,MAAM,CAIrC;AAED,wBAAgB,UAAU,gCAEzB;AACD,wBAAsB,gBAAgB,CAAC,UAAU,EAAE,KAAK,kBAEvD;AAED,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,UAAU,SAG/C;AAED,wBAAgB,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,UAShC;AAED,wBAAgB,OAAO,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,GAAE,MAAgB,GAAG,MAAM,CAmBxE;AAED,wBAAgB,SAAS,CAAC,MAAM,EAAE,KAAK,EAAE,SAExC"}

package/dist/Cryptide/Math.js

@@ -0,0 +1,81 @@
+// 
+// Tide Protocol - Infrastructure for a TRUE Zero-Trust paradigm
+// Copyright (C) 2022 Tide Foundation Ltd
+// 
+// This program is free software and is subject to the terms of 
+// the Tide Community Open Code License as published by the 
+// Tide Foundation Limited. You may modify it and redistribute 
+// it in accordance with and subject to the terms of that License.
+// This program is distributed WITHOUT WARRANTY of any kind, 
+// including without any implied warranty of MERCHANTABILITY or 
+// FITNESS FOR A PARTICULAR PURPOSE.
+// See the Tide Community Open Code License for more details.
+// You should have received a copy of the Tide Community Open 
+// Code License along with this program.
+// If not, see https://tide.org/licenses_tcoc2-0-0-en
+//
+import { CURVE, Point } from "./Ed25519";
+import { BigIntFromByteArray, BigIntToByteArray } from "../Cryptide/Serialization";
+const _0n = BigInt(0);
+const _1n = BigInt(1);
+const _2n = BigInt(2);
+export function mod(a, b = CURVE.n) {
+    var res = a % b;
+    return res >= BigInt(0) ? res : b + res;
+}
+export function median(numbers) {
+    const sorted = Array.from(numbers).sort();
+    const middle = Math.floor(sorted.length / 2);
+    if (sorted.length % 2 === 0) {
+        return ((sorted[middle - 1] + (sorted[middle])) / _2n);
+    }
+    return sorted[middle];
+}
+export function RandomBigInt() {
+    const buf = new Uint8Array(32);
+    window.crypto.getRandomValues(buf);
+    return mod(BigIntFromByteArray(buf), CURVE.n);
+}
+export function GenSessKey() {
+    return BigIntToByteArray(RandomBigInt());
+}
+export async function CreateGPrismAuth(gPassPRISM) {
+    return Point.BASE.mul(await gPassPRISM.hash());
+}
+export function GetPublic(a) {
+    let num = typeof (a) == 'bigint' ? a : BigIntFromByteArray(a);
+    return Point.BASE.mul(num);
+}
+export function Min(arr) {
+    let minValue = arr[0]; // Initialize with the first element
+    for (let i = 1; i < arr.length; i++) {
+        if (arr[i] < minValue) {
+            minValue = arr[i];
+        }
+    }
+    return minValue;
+}
+export function mod_inv(number, modulo = CURVE.n) {
+    if (number === _0n || modulo <= _0n) {
+        throw new Error(`invert: expected positive integers, got n=${number} mod=${modulo}`);
+    }
+    let a = mod(number, modulo);
+    let b = modulo;
+    // prettier-ignore
+    let x = _0n, y = _1n, u = _1n, v = _0n;
+    while (a !== _0n) {
+        const q = b / a;
+        const r = b % a;
+        const m = x - u * q;
+        const n = y - v * q;
+        // prettier-ignore
+        b = a, a = r, x = u, y = v, u = m, v = n;
+    }
+    const gcd = b;
+    if (gcd !== _1n)
+        throw new Error('invert: does not exist');
+    return mod(x, modulo);
+}
+export function SumPoints(points) {
+    return points.reduce((sum, next) => sum.add(next));
+}