cojson 0.0.1 → 0.0.2

package/src/crypto.ts

@@ -0,0 +1,297 @@
+import { ed25519, x25519 } from "@noble/curves/ed25519";
+import { xsalsa20_poly1305, xsalsa20 } from "@noble/ciphers/salsa";
+import { JsonValue } from "./jsonValue";
+import { base58, base64url } from "@scure/base";
+import { default as stableStringify } from "fast-json-stable-stringify";
+import { blake3 } from "@noble/hashes/blake3";
+import { randomBytes } from "@noble/ciphers/webcrypto/utils";
+import { RawCoValueID, SessionID, TransactionID } from "./coValue";
+
+export type SignatorySecret = `signatorySecret_z${string}`;
+export type SignatoryID = `signatory_z${string}`;
+export type Signature = `signature_z${string}`;
+
+export type RecipientSecret = `recipientSecret_z${string}`;
+export type RecipientID = `recipient_z${string}`;
+export type Sealed<T> = `sealed_U${string}` & { __type: T };
+
+const textEncoder = new TextEncoder();
+const textDecoder = new TextDecoder();
+
+export function newRandomSignatory(): SignatorySecret {
+    return `signatorySecret_z${base58.encode(
+        ed25519.utils.randomPrivateKey()
+    )}`;
+}
+
+export function getSignatoryID(secret: SignatorySecret): SignatoryID {
+    return `signatory_z${base58.encode(
+        ed25519.getPublicKey(
+            base58.decode(secret.substring("signatorySecret_z".length))
+        )
+    )}`;
+}
+
+export function sign(secret: SignatorySecret, message: JsonValue): Signature {
+    const signature = ed25519.sign(
+        textEncoder.encode(stableStringify(message)),
+        base58.decode(secret.substring("signatorySecret_z".length))
+    );
+    return `signature_z${base58.encode(signature)}`;
+}
+
+export function verify(
+    signature: Signature,
+    message: JsonValue,
+    id: SignatoryID
+): boolean {
+    return ed25519.verify(
+        base58.decode(signature.substring("signature_z".length)),
+        textEncoder.encode(stableStringify(message)),
+        base58.decode(id.substring("signatory_z".length))
+    );
+}
+
+export function newRandomRecipient(): RecipientSecret {
+    return `recipientSecret_z${base58.encode(x25519.utils.randomPrivateKey())}`;
+}
+
+export function getRecipientID(secret: RecipientSecret): RecipientID {
+    return `recipient_z${base58.encode(
+        x25519.getPublicKey(
+            base58.decode(secret.substring("recipientSecret_z".length))
+        )
+    )}`;
+}
+
+export type SealedSet<T> = {
+    [recipient: RecipientID]: Sealed<T>;
+};
+
+export function seal<T extends JsonValue>(
+    message: T,
+    from: RecipientSecret,
+    to: Set<RecipientID>,
+    nOnceMaterial: { in: RawCoValueID; tx: TransactionID }
+): SealedSet<T> {
+    const nOnce = blake3(
+        textEncoder.encode(stableStringify(nOnceMaterial))
+    ).slice(0, 24);
+
+    const recipientsSorted = Array.from(to).sort();
+    const recipientPubs = recipientsSorted.map((recipient) => {
+        return base58.decode(recipient.substring("recipient_z".length));
+    });
+    const senderPriv = base58.decode(
+        from.substring("recipientSecret_z".length)
+    );
+
+    const plaintext = textEncoder.encode(stableStringify(message));
+
+    const sealedSet: SealedSet<T> = {};
+
+    for (let i = 0; i < recipientsSorted.length; i++) {
+        const recipient = recipientsSorted[i]!;
+        const sharedSecret = x25519.getSharedSecret(
+            senderPriv,
+            recipientPubs[i]!
+        );
+
+        const sealedBytes = xsalsa20_poly1305(sharedSecret, nOnce).encrypt(
+            plaintext
+        );
+
+        sealedSet[recipient] = `sealed_U${base64url.encode(
+            sealedBytes
+        )}` as Sealed<T>;
+    }
+
+    return sealedSet;
+}
+
+export function openAs<T extends JsonValue>(
+    sealedSet: SealedSet<T>,
+    recipient: RecipientSecret,
+    from: RecipientID,
+    nOnceMaterial: { in: RawCoValueID; tx: TransactionID }
+): T | undefined {
+    const nOnce = blake3(
+        textEncoder.encode(stableStringify(nOnceMaterial))
+    ).slice(0, 24);
+
+    const recipientPriv = base58.decode(
+        recipient.substring("recipientSecret_z".length)
+    );
+
+    const senderPub = base58.decode(from.substring("recipient_z".length));
+
+    const sealed = sealedSet[getRecipientID(recipient)];
+
+    if (!sealed) {
+        return undefined;
+    }
+
+    const sealedBytes = base64url.decode(sealed.substring("sealed_U".length));
+
+    const sharedSecret = x25519.getSharedSecret(recipientPriv, senderPub);
+
+    const plaintext = xsalsa20_poly1305(sharedSecret, nOnce).decrypt(
+        sealedBytes
+    );
+
+    try {
+        return JSON.parse(textDecoder.decode(plaintext));
+    } catch (e) {
+        console.error("Failed to decrypt/parse sealed message", e);
+        return undefined;
+    }
+}
+
+export type Hash = `hash_z${string}`;
+
+export function secureHash(value: JsonValue): Hash {
+    return `hash_z${base58.encode(
+        blake3(textEncoder.encode(stableStringify(value)))
+    )}`;
+}
+
+export class StreamingHash {
+    state: ReturnType<typeof blake3.create>;
+
+    constructor(fromClone?: ReturnType<typeof blake3.create>) {
+        this.state = fromClone || blake3.create({});
+    }
+
+    update(value: JsonValue) {
+        this.state.update(textEncoder.encode(stableStringify(value)));
+    }
+
+    digest(): Hash {
+        const hash = this.state.digest();
+        return `hash_z${base58.encode(hash)}`;
+    }
+
+    clone(): StreamingHash {
+        return new StreamingHash(this.state.clone());
+    }
+}
+
+export type ShortHash = `shortHash_z${string}`;
+
+export function shortHash(value: JsonValue): ShortHash {
+    return `shortHash_z${base58.encode(
+        blake3(textEncoder.encode(stableStringify(value))).slice(0, 19)
+    )}`;
+}
+
+export type Encrypted<
+    T extends JsonValue,
+    N extends JsonValue
+> = `encrypted_U${string}` & { __type: T; __nOnceMaterial: N };
+
+export type KeySecret = `keySecret_z${string}`;
+export type KeyID = `key_z${string}`;
+
+export function newRandomKeySecret(): { secret: KeySecret; id: KeyID } {
+    return {
+        secret: `keySecret_z${base58.encode(randomBytes(32))}`,
+        id: `key_z${base58.encode(randomBytes(12))}`,
+    };
+}
+
+function encrypt<T extends JsonValue, N extends JsonValue>(
+    value: T,
+    keySecret: KeySecret,
+    nOnceMaterial: N
+): Encrypted<T, N> {
+    const keySecretBytes = base58.decode(
+        keySecret.substring("keySecret_z".length)
+    );
+    const nOnce = blake3(
+        textEncoder.encode(stableStringify(nOnceMaterial))
+    ).slice(0, 24);
+
+    const plaintext = textEncoder.encode(stableStringify(value));
+    const ciphertext = xsalsa20(keySecretBytes, nOnce, plaintext);
+    return `encrypted_U${base64url.encode(ciphertext)}` as Encrypted<T, N>;
+}
+
+export function encryptForTransaction<T extends JsonValue>(
+    value: T,
+    keySecret: KeySecret,
+    nOnceMaterial: { in: RawCoValueID; tx: TransactionID }
+): Encrypted<T, { in: RawCoValueID; tx: TransactionID }> {
+    return encrypt(value, keySecret, nOnceMaterial);
+}
+
+export function sealKeySecret(keys: {
+    toSeal: { id: KeyID; secret: KeySecret };
+    sealing: { id: KeyID; secret: KeySecret };
+}): {
+    sealed: KeyID;
+    sealing: KeyID;
+    encrypted: Encrypted<KeySecret, { sealed: KeyID; sealing: KeyID }>;
+} {
+    const nOnceMaterial = {
+        sealed: keys.toSeal.id,
+        sealing: keys.sealing.id,
+    };
+
+    return {
+        sealed: keys.toSeal.id,
+        sealing: keys.sealing.id,
+        encrypted: encrypt(
+            keys.toSeal.secret,
+            keys.sealing.secret,
+            nOnceMaterial
+        ),
+    };
+}
+
+function decrypt<T extends JsonValue, N extends JsonValue>(
+    encrypted: Encrypted<T, N>,
+    keySecret: KeySecret,
+    nOnceMaterial: N
+): T | undefined {
+    const keySecretBytes = base58.decode(
+        keySecret.substring("keySecret_z".length)
+    );
+    const nOnce = blake3(
+        textEncoder.encode(stableStringify(nOnceMaterial))
+    ).slice(0, 24);
+
+    const ciphertext = base64url.decode(
+        encrypted.substring("encrypted_U".length)
+    );
+    const plaintext = xsalsa20(keySecretBytes, nOnce, ciphertext);
+
+    try {
+        return JSON.parse(textDecoder.decode(plaintext));
+    } catch (e) {
+        return undefined;
+    }
+}
+
+export function decryptForTransaction<T extends JsonValue>(
+    encrypted: Encrypted<T, { in: RawCoValueID; tx: TransactionID }>,
+    keySecret: KeySecret,
+    nOnceMaterial: { in: RawCoValueID; tx: TransactionID }
+): T | undefined {
+    return decrypt(encrypted, keySecret, nOnceMaterial);
+}
+
+export function unsealKeySecret(
+    sealedInfo: {
+        sealed: KeyID;
+        sealing: KeyID;
+        encrypted: Encrypted<KeySecret, { sealed: KeyID; sealing: KeyID }>;
+    },
+    sealingSecret: KeySecret
+): KeySecret | undefined {
+    const nOnceMaterial = {
+        sealed: sealedInfo.sealed,
+        sealing: sealedInfo.sealing,
+    };
+
+    return decrypt(sealedInfo.encrypted, sealingSecret, nOnceMaterial);
+}

package/src/index.ts

@@ -0,0 +1,14 @@
+import { ContentType } from "./contentType";
+import { JsonValue } from "./jsonValue";
+import { CoValue } from "./coValue";
+import { LocalNode } from "./node";
+
+type Value = JsonValue | ContentType;
+
+export {
+    JsonValue,
+    ContentType,
+    Value,
+    LocalNode,
+    CoValue
+}

package/src/jsonValue.ts

@@ -0,0 +1,6 @@
+import { CoValueID, ContentType } from "./contentType";
+
+export type JsonAtom = string | number | boolean | null;
+export type JsonValue = JsonAtom | JsonArray | JsonObject | CoValueID<ContentType>;
+export type JsonArray = JsonValue[];
+export type JsonObject = { [key: string]: JsonValue; };

package/src/node.ts

@@ -0,0 +1,193 @@
+import { newRandomKeySecret, seal } from "./crypto";
+import {
+    RawCoValueID,
+    CoValue,
+    AgentCredential,
+    AgentID,
+    SessionID,
+    Agent,
+    getAgent,
+    getAgentID,
+    getAgentCoValueHeader,
+    CoValueHeader,
+    agentIDfromSessionID,
+    newRandomAgentCredential,
+} from "./coValue";
+import { Team, expectTeamContent } from "./permissions";
+import { SyncManager } from "./sync";
+
+export class LocalNode {
+    coValues: { [key: RawCoValueID]: CoValueState } = {};
+    agentCredential: AgentCredential;
+    agentID: AgentID;
+    ownSessionID: SessionID;
+    sync = new SyncManager(this);
+
+    constructor(agentCredential: AgentCredential, ownSessionID: SessionID) {
+        this.agentCredential = agentCredential;
+        const agent = getAgent(agentCredential);
+        const agentID = getAgentID(agent);
+        this.agentID = agentID;
+        this.ownSessionID = ownSessionID;
+
+        const agentCoValue = new CoValue(getAgentCoValueHeader(agent), this);
+        this.coValues[agentCoValue.id] = {
+            state: "loaded",
+            coValue: agentCoValue,
+        };
+    }
+
+    createCoValue(header: CoValueHeader): CoValue {
+        const coValue = new CoValue(header, this);
+        this.coValues[coValue.id] = { state: "loaded", coValue: coValue };
+
+        void this.sync.syncCoValue(coValue);
+
+        return coValue;
+    }
+
+    loadCoValue(id: RawCoValueID): Promise<CoValue> {
+        let entry = this.coValues[id];
+        if (!entry) {
+            entry = newLoadingState();
+
+            this.coValues[id] = entry;
+
+            this.sync.loadFromPeers(id);
+        }
+        if (entry.state === "loaded") {
+            return Promise.resolve(entry.coValue);
+        }
+        return entry.done;
+    }
+
+    expectCoValueLoaded(id: RawCoValueID, expectation?: string): CoValue {
+        const entry = this.coValues[id];
+        if (!entry) {
+            throw new Error(
+                `${expectation ? expectation + ": " : ""}Unknown CoValue ${id}`
+            );
+        }
+        if (entry.state === "loading") {
+            throw new Error(
+                `${
+                    expectation ? expectation + ": " : ""
+                }CoValue ${id} not yet loaded`
+            );
+        }
+        return entry.coValue;
+    }
+
+    createAgent(publicNickname: string): AgentCredential {
+        const agentCredential = newRandomAgentCredential(publicNickname);
+
+        this.createCoValue(getAgentCoValueHeader(getAgent(agentCredential)));
+
+        return agentCredential;
+    }
+
+    expectAgentLoaded(id: AgentID, expectation?: string): Agent {
+        const coValue = this.expectCoValueLoaded(
+            id,
+            expectation
+        );
+
+        if (coValue.header.type !== "comap" || coValue.header.ruleset.type !== "agent") {
+            throw new Error(
+                `${
+                    expectation ? expectation + ": " : ""
+                }CoValue ${id} is not an agent`
+            );
+        }
+
+        return {
+            recipientID: coValue.header.ruleset.initialRecipientID,
+            signatoryID: coValue.header.ruleset.initialSignatoryID,
+            publicNickname: coValue.header.publicNickname?.replace("agent-", ""),
+        }
+    }
+
+    createTeam(): Team {
+        const teamCoValue = this.createCoValue({
+            type: "comap",
+            ruleset: { type: "team", initialAdmin: this.agentID },
+            meta: null,
+            publicNickname: "team",
+        });
+
+        let teamContent = expectTeamContent(teamCoValue.getCurrentContent());
+
+        teamContent = teamContent.edit((editable) => {
+            editable.set(this.agentID, "admin", "trusting");
+
+            const readKey = newRandomKeySecret();
+            const revelation = seal(
+                readKey.secret,
+                this.agentCredential.recipientSecret,
+                new Set([getAgent(this.agentCredential).recipientID]),
+                {
+                    in: teamCoValue.id,
+                    tx: teamCoValue.nextTransactionID(),
+                }
+            );
+
+            editable.set(
+                "readKey",
+                { keyID: readKey.id, revelation },
+                "trusting"
+            );
+        });
+
+        return new Team(teamContent, this);
+    }
+
+    testWithDifferentCredentials(
+        agentCredential: AgentCredential,
+        ownSessionID: SessionID
+    ): LocalNode {
+        const newNode = new LocalNode(agentCredential, ownSessionID);
+
+        newNode.coValues = Object.fromEntries(
+            Object.entries(this.coValues)
+                .map(([id, entry]) => {
+                    if (entry.state === "loading") {
+                        return undefined;
+                    }
+
+                    const newCoValue = new CoValue(
+                        entry.coValue.header,
+                        newNode
+                    );
+
+                    newCoValue.sessions = entry.coValue.sessions;
+
+                    return [id, { state: "loaded", coValue: newCoValue }];
+                })
+                .filter((x): x is Exclude<typeof x, undefined> => !!x)
+        );
+
+        return newNode;
+    }
+}
+
+type CoValueState =
+    | {
+          state: "loading";
+          done: Promise<CoValue>;
+          resolve: (coValue: CoValue) => void;
+      }
+    | { state: "loaded"; coValue: CoValue };
+
+export function newLoadingState(): CoValueState {
+    let resolve: (coValue: CoValue) => void;
+
+    const promise = new Promise<CoValue>((r) => {
+        resolve = r;
+    });
+
+    return {
+        state: "loading",
+        done: promise,
+        resolve: resolve!,
+    };
+}