@tideorg/js 0.13.19

package/dist/Cryptide/Signing/EdDSA.js

@@ -0,0 +1,67 @@
+// 
+// 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, CURVE } from "../Ed25519";
+import { SHA512_Digest } from "../Hashing/Hash";
+import { RandomBigInt, mod } from "../Math";
+import { base64ToBytes, BigIntFromByteArray, BigIntToByteArray, bytesToBase64, ConcatUint8Arrays, StringToUint8Array } from "../Serialization";
+/**
+ * Sign the msg with a private key in non-standard way as it uses a random number generator. Non-deterministic.
+ */
+export async function sign(msg, priv) {
+    if (typeof (msg) == 'string') {
+        msg = StringToUint8Array(msg);
+    }
+    const A = Point.BASE.mul(priv).toRawBytes();
+    const r = RandomBigInt();
+    const R = Point.BASE.mul(r).toRawBytes();
+    const to_hash2 = ConcatUint8Arrays([R, A, msg]);
+    const k = mod(BigIntFromByteArray(await SHA512_Digest(to_hash2)));
+    const S = mod(r + (k * priv));
+    const sig_bytes = ConcatUint8Arrays([R, BigIntToByteArray(S)]);
+    return bytesToBase64(sig_bytes);
+}
+/**
+ * Verify a EdDSA signature, given a signature, public key and message.
+ */
+export async function verify(sig, pub, msg) {
+    try {
+        if (typeof (msg) == 'string') {
+            msg = StringToUint8Array(msg);
+        }
+        const sig_bytes = base64ToBytes(sig);
+        if (sig_bytes.length != 64)
+            return false;
+        const R = Point.fromBytes(sig_bytes.slice(0, 32));
+        const S = BigIntFromByteArray(sig_bytes.slice(-32));
+        const A = typeof (pub) === 'string' ? Point.fromBase64(pub) : pub;
+        return await verifyRaw(S, R, A, msg);
+    }
+    catch {
+        return false; // very strict indeed
+    }
+}
+/**
+ * Verify a message with raw S and R
+ */
+export async function verifyRaw(S, R, A, M) {
+    if (S < BigInt(0) || S >= CURVE.n) {
+        return false;
+    }
+    const to_hash = ConcatUint8Arrays([R.toRawBytes(), A.toRawBytes(), M]);
+    const k = mod(BigIntFromByteArray(await SHA512_Digest(to_hash)));
+    return Point.BASE.mul(S).mul(BigInt(8)).equals(R.mul(BigInt(8)).add(A.mul(k).mul(BigInt(8))));
+}

package/dist/Cryptide/Signing/TideSignature.d.ts

@@ -0,0 +1,54 @@
+export declare class TideSignatureFormat {
+    Name: string;
+    Version: string;
+    Message: Uint8Array;
+    Header: () => string;
+    Footer: () => string;
+    constructor(message: string | Uint8Array);
+    format(): Uint8Array;
+}
+export declare class PolicyAuthorizedTideRequestSignatureFormat extends TideSignatureFormat {
+    Name: string;
+    Version: string;
+    constructor(issueTimeBytes: any, exp: bigint | number, modelId: any, draftHash: any);
+}
+export declare class URLSignatureFormat extends TideSignatureFormat {
+    Name: string;
+    Version: string;
+    constructor(message: any);
+}
+export declare class ClientURLSignatureFormat extends TideSignatureFormat {
+    Name: string;
+    Version: string;
+    constructor(message: any);
+}
+export declare class PublicKeySignatureFormat extends TideSignatureFormat {
+    Name: string;
+    Version: string;
+    constructor(message: any);
+}
+export declare class AuthorizerSignatureFormat extends TideSignatureFormat {
+    Name: string;
+    Version: string;
+    constructor(authflow: any, modelIds: any, authorizer: any);
+    format(): Uint8Array<ArrayBuffer>;
+}
+export declare class TidecloakSettingsSignatureFormat extends TideSignatureFormat {
+    Name: string;
+    Version: string;
+    constructor(message: any);
+}
+export declare class TestSignatureFormat extends TideSignatureFormat {
+    Name: string;
+    Version: string;
+    constructor(message: any);
+}
+export declare class PlainSignatureFormat extends TideSignatureFormat {
+    /**
+     * WARNING: Only use this class if you are SURE that the data you are signing is ALREADY serialized in some form.
+     * @param {string|Uint8Array} message
+     */
+    constructor(message: any);
+    format(): Uint8Array<ArrayBuffer>;
+}
+//# sourceMappingURL=TideSignature.d.ts.map

package/dist/Cryptide/Signing/TideSignature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TideSignature.d.ts","sourceRoot":"","sources":["../../../Cryptide/Signing/TideSignature.ts"],"names":[],"mappings":"AAoBA,qBAAa,mBAAmB;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,UAAU,CAAC;IACpB,MAAM,eAAyE;IAC/E,MAAM,eAAuE;gBAEjE,OAAO,EAAE,MAAM,GAAG,UAAU;IAOxC,MAAM,IAAI,UAAU;CAGvB;AAED,qBAAa,0CAA2C,SAAQ,mBAAmB;IAElF,IAAI,SAAiC;IACrC,OAAO,SAAO;gBACC,cAAc,KAAA,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,OAAO,KAAA,EAAE,SAAS,KAAA;CAQvE;AAED,qBAAa,kBAAmB,SAAQ,mBAAmB;IACvD,IAAI,SAAS;IACb,OAAO,SAAO;gBACF,OAAO,KAAA;CAGtB;AACD,qBAAa,wBAAyB,SAAQ,mBAAmB;IAC7D,IAAI,SAAe;IACnB,OAAO,SAAO;gBACF,OAAO,KAAA;CAGtB;AAED,qBAAa,wBAAyB,SAAQ,mBAAmB;IAC7D,IAAI,SAAe;IACnB,OAAO,SAAO;gBACF,OAAO,KAAA;CAGtB;AAED,qBAAa,yBAA0B,SAAQ,mBAAmB;IAC9D,IAAI,SAAgB;IACpB,OAAO,SAAO;gBACF,QAAQ,KAAA,EAAE,QAAQ,KAAA,EAAE,UAAU,KAAA;IAY1C,MAAM;CAGT;AAED,qBAAa,gCAAiC,SAAQ,mBAAmB;IACrE,IAAI,SAAuB;IAC3B,OAAO,SAAO;gBACF,OAAO,KAAA;CAGtB;AAED,qBAAa,mBAAoB,SAAQ,mBAAmB;IACxD,IAAI,SAAiB;IACrB,OAAO,SAAO;gBACF,OAAO,KAAA;CAGtB;AAED,qBAAa,oBAAqB,SAAQ,mBAAmB;IACzD;;;OAGG;gBACS,OAAO,KAAA;IAGnB,MAAM;CAGT"}

package/dist/Cryptide/Signing/TideSignature.js

@@ -0,0 +1,110 @@
+// 
+// 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 { Serialization } from "../index";
+import { ConcatUint8Arrays, StringToUint8Array } from "../Serialization";
+export class TideSignatureFormat {
+    constructor(message) {
+        this.Header = () => "=====TIDE_" + this.Name + ":" + this.Version + "_START=====\n";
+        this.Footer = () => "\n=====TIDE_" + this.Name + ":" + this.Version + "_END=====";
+        if (typeof (message) == 'string') {
+            this.Message = StringToUint8Array(message);
+        }
+        else if (message instanceof Uint8Array) {
+            this.Message = message.slice();
+        }
+        else
+            throw Error("Unknown type provided");
+    }
+    format() {
+        return ConcatUint8Arrays([StringToUint8Array(this.Header()), this.Message, StringToUint8Array(this.Footer())]);
+    }
+}
+export class PolicyAuthorizedTideRequestSignatureFormat extends TideSignatureFormat {
+    constructor(issueTimeBytes, exp, modelId, draftHash) {
+        const expiry = new Uint8Array(8);
+        const expiry_view = new DataView(expiry.buffer);
+        expiry_view.setBigInt64(0, typeof exp === "number" ? BigInt(exp) : exp, true);
+        const message = Serialization.ConcatUint8Arrays([issueTimeBytes, expiry, StringToUint8Array(modelId), draftHash]);
+        super(message);
+        this.Name = "PolicyAuthorizedTideRequest";
+        this.Version = "1";
+    }
+}
+export class URLSignatureFormat extends TideSignatureFormat {
+    constructor(message) {
+        super(message);
+        this.Name = "URL";
+        this.Version = "1";
+    }
+}
+export class ClientURLSignatureFormat extends TideSignatureFormat {
+    constructor(message) {
+        super(message);
+        this.Name = "ClientURL";
+        this.Version = "1";
+    }
+}
+export class PublicKeySignatureFormat extends TideSignatureFormat {
+    constructor(message) {
+        super(message);
+        this.Name = "PublicKey";
+        this.Version = "1";
+    }
+}
+export class AuthorizerSignatureFormat extends TideSignatureFormat {
+    constructor(authflow, modelIds, authorizer) {
+        const authflow_b = StringToUint8Array(authflow);
+        const models_b = modelIds.map(k => StringToUint8Array(k));
+        const authorizer_pack = Serialization.CreateTideMemory(authflow_b, 8 + (4 * models_b.length) + authflow_b.length + models_b.reduce((sum, next) => sum + next.length, 0) + authorizer.length);
+        Serialization.WriteValue(authorizer_pack, 1, authorizer);
+        models_b.forEach((model, i) => {
+            Serialization.WriteValue(authorizer_pack, i + 2, model);
+        });
+        super(authorizer_pack);
+        this.Name = "Authorizer";
+        this.Version = "1";
+    }
+    format() {
+        return this.Message.slice();
+    }
+}
+export class TidecloakSettingsSignatureFormat extends TideSignatureFormat {
+    constructor(message) {
+        super(message);
+        this.Name = "TidecloakSettings";
+        this.Version = "1";
+    }
+}
+export class TestSignatureFormat extends TideSignatureFormat {
+    constructor(message) {
+        super(message);
+        this.Name = "TestMessage";
+        this.Version = "1";
+    }
+}
+export class PlainSignatureFormat extends TideSignatureFormat {
+    /**
+     * WARNING: Only use this class if you are SURE that the data you are signing is ALREADY serialized in some form.
+     * @param {string|Uint8Array} message
+     */
+    constructor(message) {
+        super(message);
+    }
+    format() {
+        return this.Message.slice();
+    }
+}

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

@@ -0,0 +1,4 @@
+export * from './TideSignature';
+export * as EdDSA from './EdDSA';
+export * as BlindSig from './BlindSig';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../Cryptide/Signing/index.ts"],"names":[],"mappings":"AAiBA,cAAc,iBAAiB,CAAC;AAChC,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AACjC,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAC"}

package/dist/Cryptide/Signing/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 * from './TideSignature';
+export * as EdDSA from './EdDSA';
+export * as BlindSig from './BlindSig';

package/dist/Cryptide/TideKey.d.ts

@@ -0,0 +1,17 @@
+import { BaseComponent, BasePrivateComponent, BasePublicComponent } from "./Components/BaseComponent";
+export default class TideKey {
+    static NewKey(scheme: any): TideKey;
+    static FromSerializedComponent(c: Uint8Array | string): TideKey;
+    component: BaseComponent;
+    privateComponent: BasePrivateComponent;
+    publicComponent: BasePublicComponent;
+    constructor(c: BaseComponent);
+    get_private_component(): BasePrivateComponent;
+    get_public_component(): BasePublicComponent;
+    sign(message: any): Promise<any>;
+    verify(message: any, signature: any): Promise<any>;
+    asymmetricDecrypt(cipher: any): Promise<any>;
+    asymmetricEncrypt(message: any): Promise<any>;
+    prepVouchersReq(gORKn: any): Promise<any[]>;
+}
+//# sourceMappingURL=TideKey.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TideKey.d.ts","sourceRoot":"","sources":["../../Cryptide/TideKey.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,aAAa,EAAE,oBAAoB,EAAE,mBAAmB,EAAQ,MAAM,4BAA4B,CAAC;AAU5G,MAAM,CAAC,OAAO,OAAO,OAAO;IAExB,MAAM,CAAC,MAAM,CAAC,MAAM,KAAA;IAKpB,MAAM,CAAC,uBAAuB,CAAC,CAAC,EAAE,UAAU,GAAG,MAAM;IAIrD,SAAS,EAAE,aAAa,CAAa;IACrC,gBAAgB,EAAE,oBAAoB,CAAC;IACvC,eAAe,EAAE,mBAAmB,CAAC;gBAEzB,CAAC,EAAE,aAAa;IAI5B,qBAAqB,IAAI,oBAAoB;IAK7C,oBAAoB,IAAI,mBAAmB;IAMrC,IAAI,CAAC,OAAO,KAAA;IAIZ,MAAM,CAAC,OAAO,KAAA,EAAE,SAAS,KAAA;IAIzB,iBAAiB,CAAC,MAAM,KAAA;IAIxB,iBAAiB,CAAC,OAAO,KAAA;IAMzB,eAAe,CAAC,KAAK,KAAA;CAU9B"}

package/dist/Cryptide/TideKey.js

@@ -0,0 +1,84 @@
+// 
+// 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 { BaseComponent, BasePrivateComponent, BasePublicComponent, Seed } from "./Components/BaseComponent";
+import { Registery } from "./Components/ComponentRegistry";
+import Ed25519Scheme from "./Components/Schemes/Ed25519/Ed25519Scheme";
+import { computeSharedKey } from "./Encryption/DH";
+import { mod } from "./Math";
+import { BigIntFromByteArray } from "./Serialization";
+export default class TideKey {
+    static NewKey(scheme) {
+        const seedFactory = Registery[scheme.Name][Seed];
+        return new TideKey(seedFactory.Create(undefined));
+    }
+    static FromSerializedComponent(c) {
+        return new TideKey(BaseComponent.DeserializeComponent(c));
+    }
+    constructor(c) {
+        this.component = undefined;
+        if (c instanceof BaseComponent)
+            this.component = c;
+        else
+            throw Error("Expecting object derived from BaseComponent");
+    }
+    get_private_component() {
+        if (!hasOwnInstanceMethod(this.component, "GetPrivate") && !(this.component instanceof BasePrivateComponent))
+            throw Error("Cannot generate or find private component");
+        this.privateComponent = this.component instanceof BasePrivateComponent ? this.component : this.component.GetPrivate();
+        return this.privateComponent;
+    }
+    get_public_component() {
+        if (!hasOwnInstanceMethod(this.component, "GetPublic") && !(this.component instanceof BasePublicComponent))
+            throw Error("Cannot generate or find public component");
+        this.publicComponent = this.component instanceof BasePublicComponent ? this.component : this.component.GetPublic();
+        return this.publicComponent;
+    }
+    async sign(message) {
+        const f = this.component.Scheme.GetSigningFunction();
+        return await f(message, this.get_private_component());
+    }
+    async verify(message, signature) {
+        const f = this.component.Scheme.GetVerifyingFunction();
+        return await f(message, signature, this.get_public_component());
+    }
+    async asymmetricDecrypt(cipher) {
+        const d = this.component.Scheme.GetDecryptingFunction();
+        return await d(cipher, this.get_private_component());
+    }
+    async asymmetricEncrypt(message) {
+        const e = this.component.Scheme.GetEncryptingFunction();
+        return await e(message, this.get_public_component());
+    }
+    async prepVouchersReq(gORKn) {
+        // Ensure scheme is Ed25519 for tide vouchers
+        if (this.component.Scheme !== Ed25519Scheme)
+            throw Error("Cannot execute prepVouchersReq on a non Ed25519 key");
+        let blurKeyPub = [];
+        for (let i = 0; i < gORKn.length; i++) {
+            const z = mod(BigIntFromByteArray(await computeSharedKey(gORKn[i], this.get_private_component().priv)));
+            blurKeyPub[i] = gORKn[i].mul(z);
+        }
+        return blurKeyPub;
+    }
+}
+function hasOwnInstanceMethod(obj, methodName) {
+    // get the “own” prototype of this object’s class
+    const proto = Object.getPrototypeOf(obj);
+    // check it has its own property of that name, and that it’s a function
+    return Object.prototype.hasOwnProperty.call(proto, methodName)
+        && typeof proto[methodName] === 'function';
+}

package/dist/Cryptide/TideMemoryObjects.d.ts

@@ -0,0 +1,4 @@
+import { Ed25519PublicComponent } from "./Components/Schemes/Ed25519/Ed25519Components";
+export declare function CreateVRKPackage(gvrk: Ed25519PublicComponent, expiry: number | bigint): Uint8Array<ArrayBuffer>;
+export declare function CreateAuthorizerPackage(authFlow: string, signModels: string[], vrk_pack: Uint8Array): Uint8Array<ArrayBuffer>;
+//# sourceMappingURL=TideMemoryObjects.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"TideMemoryObjects.d.ts","sourceRoot":"","sources":["../../Cryptide/TideMemoryObjects.ts"],"names":[],"mappings":"AAmBA,OAAO,EAAE,sBAAsB,EAAE,MAAM,gDAAgD,CAAC;AAGxF,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,sBAAsB,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,2BAUrF;AACD,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,EAAE,QAAQ,EAAE,UAAU,2BAEnG"}

package/dist/Cryptide/TideMemoryObjects.js

@@ -0,0 +1,32 @@
+// 
+// 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 { CreateTideMemory, writeInt64LittleEndian, WriteValue } from "./Serialization";
+import { Utils } from "../index";
+import { AuthorizerSignatureFormat } from "./Signing/TideSignature";
+export function CreateVRKPackage(gvrk, expiry) {
+    const serializedgvrk = gvrk.Serialize().ToBytes();
+    const ex = typeof expiry == "bigint" ? expiry : BigInt(expiry);
+    if (ex < BigInt(Utils.CurrentTime() + 5))
+        throw Error("Expiry must be at least 5 seconds into future");
+    const time_b = writeInt64LittleEndian(ex);
+    const vrk_pack = CreateTideMemory(serializedgvrk, 4 + 4 + serializedgvrk.length + time_b.length);
+    WriteValue(vrk_pack, 1, time_b);
+    return vrk_pack;
+}
+export function CreateAuthorizerPackage(authFlow, signModels, vrk_pack) {
+    return new AuthorizerSignatureFormat(authFlow, signModels, vrk_pack).format();
+}

package/dist/Cryptide/index.d.ts

@@ -0,0 +1,11 @@
+export { default as TideKey } from "./TideKey";
+export * as Encryption from "./Encryption";
+export * as Signing from "./Signing";
+export * as Hashing from "./Hashing";
+export * as Interpolation from "./Interpolation";
+export * as Math from "./Math";
+export * as Serialization from "./Serialization";
+export * as Ed25519 from "./Ed25519";
+export * as TideMemoryObjects from "./TideMemoryObjects";
+export * as Components from "./Components";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../Cryptide/index.ts"],"names":[],"mappings":"AAkBA,OAAO,EAAE,OAAO,IAAI,OAAO,EAAE,MAAM,WAAW,CAAA;AAG9C,OAAO,KAAK,UAAU,MAAM,cAAc,CAAA;AAC1C,OAAO,KAAK,OAAO,MAAM,WAAW,CAAA;AACpC,OAAO,KAAK,OAAO,MAAM,WAAW,CAAA;AACpC,OAAO,KAAK,aAAa,MAAM,iBAAiB,CAAA;AAChD,OAAO,KAAK,IAAI,MAAM,QAAQ,CAAA;AAC9B,OAAO,KAAK,aAAa,MAAM,iBAAiB,CAAA;AAChD,OAAO,KAAK,OAAO,MAAM,WAAW,CAAA;AACpC,OAAO,KAAK,iBAAiB,MAAM,qBAAqB,CAAA;AACxD,OAAO,KAAK,UAAU,MAAM,cAAc,CAAA"}

package/dist/Cryptide/index.js

@@ -0,0 +1,28 @@
+// 
+// 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
+//
+// Top-level exports
+export { default as TideKey } from "./TideKey";
+// Namespace exports - for direct access
+export * as Encryption from "./Encryption";
+export * as Signing from "./Signing";
+export * as Hashing from "./Hashing";
+export * as Interpolation from "./Interpolation";
+export * as Math from "./Math";
+export * as Serialization from "./Serialization";
+export * as Ed25519 from "./Ed25519";
+export * as TideMemoryObjects from "./TideMemoryObjects";
+export * as Components from "./Components";

package/dist/Flow/DecryptionFlows/dVVKDecryptionFlow.d.ts

@@ -0,0 +1,16 @@
+import BaseTideRequest from "../../Models/BaseTideRequest";
+import { Doken } from "../../Models/Doken";
+import TideKey from "../../Cryptide/TideKey";
+export default class dVVKDecryptionFlow {
+    vvkid: string;
+    vvkPublic: any;
+    orks: any;
+    sessKey: TideKey;
+    doken: Doken;
+    getVouchersFunction: ((request: string) => Promise<string>) | null;
+    voucherURL: string;
+    constructor(vvkid: string, vvkPublic: any, orks: any, sessKey: TideKey, doken: Doken, voucherURL: string);
+    setVoucherRetrievalFunction(getVouchersFunction: (request: string) => Promise<string>): this;
+    start(request: BaseTideRequest, waitForAll?: boolean): Promise<Uint8Array<ArrayBuffer>[]>;
+}
+//# sourceMappingURL=dVVKDecryptionFlow.d.ts.map

package/dist/Flow/DecryptionFlows/dVVKDecryptionFlow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dVVKDecryptionFlow.d.ts","sourceRoot":"","sources":["../../../Flow/DecryptionFlows/dVVKDecryptionFlow.ts"],"names":[],"mappings":"AAkBA,OAAO,eAAe,MAAM,8BAA8B,CAAC;AAI3D,OAAO,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAC3C,OAAO,OAAO,MAAM,wBAAwB,CAAC;AAE7C,MAAM,CAAC,OAAO,OAAO,kBAAkB;IACnC,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,GAAG,CAAC;IACf,IAAI,EAAE,GAAG,CAAC;IACV,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,EAAE,KAAK,CAAC;IACb,mBAAmB,EAAE,CAAC,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,IAAI,CAAC;IACnE,UAAU,EAAE,MAAM,CAAC;gBAEP,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,UAAU,EAAE,MAAM;IAaxG,2BAA2B,CAAC,mBAAmB,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC;IAI/E,KAAK,CAAC,OAAO,EAAE,eAAe,EAAE,UAAU,GAAE,OAAe;CAYpE"}

package/dist/Flow/DecryptionFlows/dVVKDecryptionFlow.js

@@ -0,0 +1,47 @@
+// 
+// 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 { Max, sortORKs, Threshold, WaitForNumberofORKs } from "../../Tools/Utils";
+import NodeClient from "../../Clients/NodeClient";
+import VoucherFlow from "../VoucherFlows/VoucherFlow";
+import { GetKeys } from "../../Math/KeyDecryption";
+export default class dVVKDecryptionFlow {
+    constructor(vvkid, vvkPublic, orks, sessKey, doken, voucherURL) {
+        this.vvkid = vvkid;
+        this.vvkPublic = vvkPublic;
+        this.orks = orks;
+        this.orks = sortORKs(this.orks); // sort for bitwise!
+        if (!doken.payload.sessionKey.Equals(sessKey.get_public_component()))
+            throw Error("Mismatch between session key private and Doken session key public");
+        this.sessKey = sessKey;
+        this.doken = doken;
+        this.getVouchersFunction = null;
+        this.voucherURL = voucherURL;
+    }
+    setVoucherRetrievalFunction(getVouchersFunction) {
+        this.getVouchersFunction = getVouchersFunction;
+        return this;
+    }
+    async start(request, waitForAll = false) {
+        const pre_clients = this.orks.map(info => new NodeClient(info.orkURL).AddBearerAuthorization(this.sessKey.get_private_component().rawBytes, this.sessKey.get_public_component().Serialize().ToString(), this.doken.serialize()).EnableTideDH(info.orkPublic));
+        const voucherFlow = new VoucherFlow(this.orks.map(o => o.orkPaymentPublic), this.voucherURL, "vendordecrypt");
+        const { vouchers } = await voucherFlow.GetVouchers(this.getVouchersFunction);
+        const clients = await Promise.all(pre_clients); // to speed things up - computer shared key while grabbing vouchers
+        const pre_PreDecryptResponses = clients.map((client, i) => client.Decrypt(i, this.vvkid, request, vouchers.toORK(i)));
+        const { fulfilledResponses, bitwise } = await WaitForNumberofORKs(this.orks, pre_PreDecryptResponses, "VVK", waitForAll ? Max : Threshold, null, clients);
+        return GetKeys(fulfilledResponses, this.orks.map(o => BigInt(o.orkID))); // to be used for symmetric encryption now with caller
+    }
+}

package/dist/Flow/DecryptionFlows/index.d.ts

@@ -0,0 +1,2 @@
+export { default as dVVKDecryptionFlow } from './dVVKDecryptionFlow';
+//# sourceMappingURL=index.d.ts.map

package/dist/Flow/DecryptionFlows/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../Flow/DecryptionFlows/index.ts"],"names":[],"mappings":"AAiBA,OAAO,EAAE,OAAO,IAAI,kBAAkB,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/Flow/DecryptionFlows/index.js

@@ -0,0 +1,17 @@
+//
+// 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 dVVKDecryptionFlow } from './dVVKDecryptionFlow';

package/dist/Flow/EncryptionFlows/AuthorizedEncryptionFlow.d.ts

@@ -0,0 +1,13 @@
+/**
+ *
+ * @param {{
+ * vendorId: string,
+ * token: Doken,
+ * sessionKey: TideKey
+ * voucherURL: string,
+ * homeOrkUrl: string | null
+ * keyInfo: KeyInfo
+ * }} config
+ */
+export declare function AuthorizedEncryptionFlow(config: any): void;
+//# sourceMappingURL=AuthorizedEncryptionFlow.d.ts.map

package/dist/Flow/EncryptionFlows/AuthorizedEncryptionFlow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AuthorizedEncryptionFlow.d.ts","sourceRoot":"","sources":["../../../Flow/EncryptionFlows/AuthorizedEncryptionFlow.ts"],"names":[],"mappings":"AA4BA;;;;;;;;;;GAUG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,KAAA,QA6K9C"}