signify-ts 0.4.0 → 0.4.1

package/dist/keri/core/authing.js

@@ -1,16 +1,42 @@
-import { desiginput, HEADER_SIG_INPUT, HEADER_SIG_TIME, normalize, siginput, } from "./httping.js";
+import libsodium from 'libsodium-wrappers-sumo';
+import { desiginput, HEADER_SIG, HEADER_SIG_DESTINATION, HEADER_SIG_INPUT, HEADER_SIG_SENDER, HEADER_SIG_TIME, normalize, siginput, } from "./httping.js";
 import { Signage, signature, designature } from "../end/ending.js";
-export class Authenticater {
+import { Diger } from "./diger.js";
+import { MtrDex } from "./matter.js";
+import { b, d } from "./core.js";
+export class Authenticator {
     constructor(csig, verfer) {
-        this._csig = csig;
-        this._verfer = verfer;
+        this.csig = csig;
+        this.verfer = verfer;
     }
-    verify(headers, method, path) {
+}
+export class SignedHeaderAuthenticator extends Authenticator {
+    async prepare(request, _local, _remote) {
+        const headers = request.headers;
+        const signedHeaders = this.sign(request.headers, request.method, new URL(request.url).pathname);
+        signedHeaders.forEach((value, key) => {
+            headers.set(key, value);
+        });
+        return request;
+    }
+    async verify(request, response, _local, remote) {
+        if (response.status === 401) {
+            throw new Error(`HTTP ${request.method} ${new URL(request.url).pathname} - ${response.status} ${response.statusText}`);
+        }
+        if (remote !== response.headers.get(HEADER_SIG_SENDER)) {
+            throw new Error('message from a different remote agent');
+        }
+        if (!this.verifyHeaders(response.headers, request.method, new URL(request.url).pathname)) {
+            throw new Error('response verification failed');
+        }
+        return response;
+    }
+    verifyHeaders(headers, method, path) {
         const siginput = headers.get(HEADER_SIG_INPUT);
         if (siginput == null) {
             return false;
         }
-        const signature = headers.get('Signature');
+        const signature = headers.get(HEADER_SIG);
         if (signature == null) {
             return false;
         }
@@ -61,24 +87,21 @@ export class Authenticater {
             const signage = designature(signature);
             const markers = signage[0].markers;
             const cig = markers.get(input.name);
-            if (!cig || !this._verfer.verify(cig.raw, ser)) {
+            if (!cig || !this.verfer.verify(cig.raw, ser)) {
                 throw new Error(`Signature for ${input.keyid} invalid.`);
             }
         });
         return true;
     }
-    sign(headers, method, path, fields) {
-        if (fields == undefined) {
-            fields = Authenticater.DefaultFields;
-        }
-        const [header, sig] = siginput(this._csig, {
+    sign(headers, method, path) {
+        const [header, sig] = siginput(this.csig, {
             name: 'signify',
             method,
             path,
             headers,
-            fields,
+            fields: SignedHeaderAuthenticator.DefaultFields,
             alg: 'ed25519',
-            keyid: this._csig.verfer.qb64,
+            keyid: this.csig.verfer.qb64,
         });
         header.forEach((value, key) => {
             headers.append(key, value);
@@ -93,9 +116,159 @@ export class Authenticater {
         return headers;
     }
 }
-Authenticater.DefaultFields = [
+SignedHeaderAuthenticator.DefaultFields = [
     '@method',
     '@path',
     'signify-resource',
     HEADER_SIG_TIME.toLowerCase(),
 ];
+export class EssrAuthenticator extends Authenticator {
+    constructor(csig, verfer) {
+        super(csig, verfer);
+        const sigkey = new Uint8Array(this.csig.raw.length + this.csig.verfer.raw.length);
+        sigkey.set(this.csig.raw);
+        sigkey.set(this.csig.verfer.raw, this.csig.raw.length);
+        this.cx25519Priv =
+            libsodium.crypto_sign_ed25519_sk_to_curve25519(sigkey);
+        this.cx25519Pub = libsodium.crypto_scalarmult_base(this.cx25519Priv);
+        this.vx25519Pub = libsodium.crypto_sign_ed25519_pk_to_curve25519(this.verfer.raw);
+    }
+    async prepare(request, local, remote) {
+        const dt = new Date().toISOString().replace('Z', '000+00:00');
+        const headers = new Headers();
+        headers.set(HEADER_SIG_SENDER, local);
+        headers.set(HEADER_SIG_DESTINATION, remote);
+        headers.set(HEADER_SIG_TIME, dt);
+        headers.set('Content-Type', 'application/octet-stream');
+        const requestStr = await EssrAuthenticator.serializeRequest(request);
+        const raw = libsodium.crypto_box_seal(requestStr, this.vx25519Pub);
+        const diger = new Diger({ code: MtrDex.Blake3_256 }, raw);
+        const payload = {
+            src: local,
+            dest: remote,
+            d: diger.qb64,
+            dt,
+        };
+        const sig = this.csig.sign(b(JSON.stringify(payload)));
+        const markers = new Map();
+        markers.set('signify', sig);
+        const signage = new Signage(markers, false);
+        const signed = signature([signage]);
+        signed.forEach((value, key) => {
+            headers.append(key, value);
+        });
+        return new Request(new URL(request.url).origin + '/', {
+            method: 'POST',
+            body: raw,
+            headers,
+        });
+    }
+    async verify(request, response, local, remote) {
+        if (response.status === 401) {
+            throw new Error(`HTTP ${request.method} ${new URL(request.url).pathname} - ${response.status} ${response.statusText}`);
+        }
+        return await this.unwrap(response, remote, local);
+    }
+    static async serializeRequest(request) {
+        let headers = '';
+        request.headers.forEach((value, name) => {
+            headers += `${name}: ${value}\r\n`;
+        });
+        let body = '';
+        if (request.method !== 'GET' && request.body) {
+            const bytes = await this.streamToBytes(request.body);
+            try {
+                body = new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+            }
+            catch (e) {
+                throw new Error('Failed to serialize ESSR request - body is not valid UTF-8', { cause: e });
+            }
+        }
+        return `${request.method} ${request.url} HTTP/1.1\r\n${headers}\r\n${body}`;
+    }
+    static async streamToBytes(stream) {
+        const reader = stream.getReader();
+        const chunks = [];
+        let done, value;
+        while ((({ done, value } = await reader.read()), !done)) {
+            if (value)
+                chunks.push(value);
+        }
+        reader.releaseLock();
+        const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0);
+        const result = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const chunk of chunks) {
+            result.set(chunk, offset);
+            offset += chunk.length;
+        }
+        return result;
+    }
+    async unwrap(wrapper, sender, receiver) {
+        const signature = wrapper.headers.get(HEADER_SIG);
+        if (!signature) {
+            throw new Error('Signature is missing from ESSR payload');
+        }
+        if (wrapper.headers.get(HEADER_SIG_SENDER) !== sender) {
+            throw new Error('Message from a different remote agent');
+        }
+        if (wrapper.headers.get(HEADER_SIG_DESTINATION) !== receiver) {
+            throw new Error('Invalid ESSR payload, missing or incorrect destination prefix');
+        }
+        const dt = wrapper.headers.get(HEADER_SIG_TIME);
+        if (!dt) {
+            throw new Error('Timestamp is missing from ESSR payload');
+        }
+        const ciphertext = new Uint8Array(await wrapper.arrayBuffer());
+        const diger = new Diger({ code: MtrDex.Blake3_256 }, ciphertext);
+        const payload = {
+            src: sender,
+            dest: receiver,
+            d: diger.qb64,
+            dt,
+        };
+        const signages = designature(signature);
+        const markers = signages[0].markers;
+        const cig = markers.get('signify');
+        if (!cig) {
+            throw new Error('Invalid signature format - missing "signify" marker');
+        }
+        const verified = this.verfer.verify(cig.raw, b(JSON.stringify(payload)));
+        if (!verified) {
+            throw new Error('Invalid signature');
+        }
+        const response = EssrAuthenticator.deserializeResponse(d(this.decrypt(ciphertext)));
+        if (response.headers.get(HEADER_SIG_SENDER) !== sender) {
+            throw new Error('Invalid ESSR payload, missing or incorrect encrypted sender');
+        }
+        return response;
+    }
+    // KERIA seals the response to the client key it has in the controller's KEL
+    decrypt(ciphertext) {
+        try {
+            return libsodium.crypto_box_seal_open(ciphertext, this.cx25519Pub, this.cx25519Priv);
+        }
+        catch (e) {
+            throw new Error('Failed to decrypt ESSR response - sealed to a different client key', { cause: e });
+        }
+    }
+    static deserializeResponse(httpString) {
+        const sep = httpString.indexOf('\r\n\r\n');
+        const head = sep === -1 ? httpString.trimEnd() : httpString.slice(0, sep);
+        const [statusLine, ...headerLines] = head.split('\r\n');
+        const [, statusCode, ...statusTextArr] = statusLine.split(' ');
+        const body = sep === -1 ? '' : httpString.slice(sep + 4);
+        const headers = new Headers();
+        for (const line of headerLines) {
+            const i = line.indexOf(':');
+            if (i !== -1) {
+                headers.append(line.slice(0, i).trim(), line.slice(i + 1).trim());
+            }
+        }
+        return new Response(body.length ? body : null, {
+            status: Number(statusCode),
+            statusText: statusTextArr.join(' '),
+            headers,
+        });
+    }
+}

package/dist/keri/core/eventing.js

@@ -286,7 +286,7 @@ export function messagize(serder, sigers, seal, wigers, cigars, pipelined = fals
                 atc = concat(atc, new Counter({ code: CtrDex.TransIdxSigGroups, count: 1 })
                     .qb64b);
                 atc = concat(atc, new TextEncoder().encode(seal[1].i));
-                atc = concat(atc, new Seqner({ sn: parseInt(seal[1].s) }).qb64b);
+                atc = concat(atc, new Seqner({ snh: seal[1].s }).qb64b);
                 atc = concat(atc, new TextEncoder().encode(seal[1].d));
             }
             else if (seal[0] == 'SealLast') {

package/dist/keri/core/httping.d.ts

@@ -1,8 +1,11 @@
 import { Signer } from './signer.ts';
 import { Cigar } from './cigar.ts';
 import { Siger } from './siger.ts';
+export declare const HEADER_SIG: string;
 export declare const HEADER_SIG_INPUT: string;
 export declare const HEADER_SIG_TIME: string;
+export declare const HEADER_SIG_SENDER: string;
+export declare const HEADER_SIG_DESTINATION: string;
 export declare function normalize(header: string): string;
 export interface SiginputArgs {
     name: string;

package/dist/keri/core/httping.js

@@ -2,8 +2,11 @@ import { serializeDictionary, parseDictionary, } from 'structured-headers';
 import { b } from "./core.js";
 import { nowUTC } from "./utils.js";
 import { encodeBase64Url } from "./base64.js";
+export const HEADER_SIG = normalize('Signature');
 export const HEADER_SIG_INPUT = normalize('Signature-Input');
 export const HEADER_SIG_TIME = normalize('Signify-Timestamp');
+export const HEADER_SIG_SENDER = normalize('Signify-Resource');
+export const HEADER_SIG_DESTINATION = normalize('Signify-Receiver');
 export function normalize(header) {
     return header.trim();
 }

package/dist/keri/core/keeping.d.ts

@@ -57,7 +57,7 @@ export interface IdentifierManager<T extends IdentifierManagerParams = Identifie
      * `ondex` matches its `index`. `ondices[j] === undefined` is the explicit
      * current-only case for that signature, so no `ondex` is emitted.
      */
-    sign(ser: Uint8Array, indexed?: boolean, indices?: number[], ondices?: Array<number | undefined>, rotated?: boolean): Promise<SignResult>;
+    sign(ser: Uint8Array, indexed?: boolean, indices?: number[], ondices?: Ondex[], rotated?: boolean): Promise<SignResult>;
 }
 /**
  * Creates IdentifierManager instances based on the algorithm and key indexes.
@@ -113,7 +113,7 @@ export declare class SaltyIdentifierManager implements IdentifierManager {
     params(): SaltyManagerParams;
     incept(transferable: boolean): Promise<IdentifierManagerResult>;
     rotate(ncodes: string[], transferable: boolean): Promise<[string[], string[]]>;
-    sign(ser: Uint8Array, indexed?: boolean, indices?: number[] | undefined, ondices?: Array<number | undefined> | undefined, _rotated?: boolean): Promise<SignResult>;
+    sign(ser: Uint8Array, indexed?: boolean, indices?: number[] | undefined, ondices?: Ondex[] | undefined, _rotated?: boolean): Promise<SignResult>;
 }
 export declare class RandyIdentifierManager implements IdentifierManager {
     private salter;
@@ -137,8 +137,9 @@ export declare class RandyIdentifierManager implements IdentifierManager {
     params(): RandyManagerParams;
     incept(transferable: boolean): Promise<IdentifierManagerResult>;
     rotate(ncodes: string[], transferable: boolean): Promise<IdentifierManagerResult>;
-    sign(ser: Uint8Array, indexed?: boolean, indices?: number[] | undefined, ondices?: Array<number | undefined> | undefined, _rotated?: boolean): Promise<SignResult>;
+    sign(ser: Uint8Array, indexed?: boolean, indices?: number[] | undefined, ondices?: Ondex[] | undefined, _rotated?: boolean): Promise<SignResult>;
 }
+type Ondex = number | undefined;
 /**
  * Identifier manager for group identifiers.
  *
@@ -225,7 +226,7 @@ export declare class GroupIdentifierManager implements IdentifierManager {
     /**
      * Signs for the group by delegating to the local member keeper.
      */
-    sign(ser: Uint8Array, indexed?: boolean, _indices?: number[] | undefined, _ondices?: Array<number | undefined> | undefined, rotated?: boolean): Promise<SignResult>;
+    sign(ser: Uint8Array, indexed?: boolean, _indices?: number[] | undefined, _ondices?: Ondex[] | undefined, rotated?: boolean): Promise<SignResult>;
     /**
      * Finds the prior next digest position that precommitted the current key.
      *
@@ -236,23 +237,9 @@ export declare class GroupIdentifierManager implements IdentifierManager {
      */
     private priorNextIndexForKey;
     params(): {
-        mhab: {
-            name: string;
-            prefix: string;
-            icp_dt: string;
-            state: import("../../types/keria-api-schema.ts").components["schemas"]["KeyStateRecord"];
-            transferable: boolean;
-            windexes: string[];
-        } & ({
-            salty: import("../../types/keria-api-schema.ts").components["schemas"]["SaltyState"];
-        } | {
-            randy: import("../../types/keria-api-schema.ts").components["schemas"]["RandyKeyState"];
-        } | {
-            group: import("../../types/keria-api-schema.ts").components["schemas"]["GroupKeyState"];
-        } | {
-            extern: import("../../types/keria-api-schema.ts").components["schemas"]["ExternState"];
-        });
+        mhab: HabState;
         keys: string[];
         ndigs: string[];
     };
 }
+export {};

package/dist/keri/core/keeping.js

@@ -162,9 +162,11 @@ export class SaltyIdentifierManager {
             const sigers = [];
             let i = 0;
             for (const [j, signer] of signers.signers.entries()) {
-                if (indices != undefined) {
-                    i = indices[j];
-                    if (typeof i != 'number' || i < 0) {
+                if (indices &&
+                    indices.length > 0 &&
+                    indices.length === signers.signers.length) {
+                    i = indices[j]; // default indexing behavior of pulling index order from signer order
+                    if (!Number.isInteger(i) || i < 0) {
                         throw new Error(`Invalid signing index = ${i}, not whole number.`);
                     }
                 }
@@ -172,7 +174,10 @@ export class SaltyIdentifierManager {
                     i = j;
                 }
                 let o = 0;
-                if (ondices != undefined) {
+                // if ondices are specified then the count and order should match the indices list
+                // even if a given ondex is "undefined" which means to ignore the ondex (dual indexed sig)
+                // for that given index.
+                if (ondices && ondices.length > 0) {
                     o = ondices[j];
                     if (o !== undefined && (!Number.isInteger(o) || o < 0)) {
                         throw new Error(`Invalid ondex = ${o}, not whole number.`);

package/dist/keri/core/keyState.d.ts

@@ -17,15 +17,39 @@ export type RandyKeyState = components['schemas']['RandyKeyState'];
 /**
  * Defining properties a multi-signature group identifier manager.
  */
-export type GroupKeyState = components['schemas']['GroupKeyState'];
+export type GroupKeyState = Omit<components['schemas']['GroupKeyState'], 'mhab'> & {
+    mhab: HabState;
+};
 /**
  * Defining properties for an external module identifier manager that uses externally managed keys such as in an HSM or a KMS system.
  */
 export type ExternState = components['schemas']['ExternState'];
+type SchemaHabState = components['schemas']['HabState'];
 /**
- * Defining properties of an identifier habitat, know as a Hab in KERIpy.
+ * Defining properties of an identifier habitat, known as a Hab in KERIpy.
+ *
+ * Omitting `state` alone would erase the algo variants — `keyof` a union of disjoint objects is
+ * `never` — so they are re-spelled, which also points `group` at the local GroupKeyState above.
  */
-export type HabState = components['schemas']['HabState'];
+type BaseHabState = Omit<SchemaHabState, 'state' | 'salty' | 'randy' | 'group' | 'extern'> & ({
+    salty: SaltyKeyState;
+} | {
+    randy: RandyKeyState;
+} | {
+    group: GroupKeyState;
+} | {
+    extern: ExternState;
+});
+/** Multisig group whose inception is still collecting member signatures; no key state yet. */
+export type PendingHabState = BaseHabState & {
+    state?: undefined;
+};
+/** Fully inceptioned identifier; key state present. */
+export type HabState = BaseHabState & {
+    state: KeyState;
+};
+export declare function isAccepted(hab: HabState | PendingHabState): hab is HabState;
+export declare function requireKeyState(hab: HabState | PendingHabState): KeyState;
 export type Icp = components['schemas']['ICP_V_1'] | components['schemas']['ICP_V_2'];
 export type Ixn = components['schemas']['IXN_V_1'] | components['schemas']['IXN_V_2'];
 export type ExnV1 = components['schemas']['EXN_V_1'];
@@ -50,6 +74,7 @@ export type DoneOperation = components['schemas']['DoneOperation'];
 export type CredentialOperation = components['schemas']['CredentialOperation'];
 export type GroupOperation = components['schemas']['GroupOperation'];
 export type DelegatorOperation = components['schemas']['DelegatorOperation'];
+export type KelOperation = components['schemas']['KelOperation'];
 export type PendingOOBIOperation = components['schemas']['PendingOOBIOperation'];
 export type PendingQueryOperation = components['schemas']['PendingQueryOperation'];
 export type PendingEndRoleOperation = components['schemas']['PendingEndRoleOperation'];
@@ -97,3 +122,4 @@ export type FailedDelegatorOperation = components['schemas']['FailedDelegatorOpe
 export type FailedOperation = FailedOOBIOperation | FailedQueryOperation | FailedEndRoleOperation | FailedWitnessOperation | FailedDelegationOperation | FailedRegistryOperation | FailedLocSchemeOperation | FailedChallengeOperation | FailedExchangeOperation | FailedSubmitOperation | FailedDoneOperation | FailedCredentialOperation | FailedGroupOperation | FailedDelegatorOperation;
 export type GenericOperation = OOBIOperation | QueryOperation | EndRoleOperation | WitnessOperation | DelegationOperation | RegistryOperation | LocSchemeOperation | ChallengeOperation | ExchangeOperation | SubmitOperation | DoneOperation | CredentialOperation | GroupOperation | DelegatorOperation;
 export type EndRole = components['schemas']['EndRole'];
+export {};

package/dist/keri/core/keyState.js

@@ -1 +1,9 @@
-export {};
+export function isAccepted(hab) {
+    return hab.state !== undefined;
+}
+export function requireKeyState(hab) {
+    if (!isAccepted(hab)) {
+        throw new Error(`No key state for identifier ${hab.name}`);
+    }
+    return hab.state;
+}

package/dist/keri/end/ending.js

@@ -1,5 +1,6 @@
 import { Siger } from "../core/siger.js";
 import { Cigar } from "../core/cigar.js";
+import { HEADER_SIG } from "../core/httping.js";
 export const FALSY = [false, 0, '?0', 'no', 'false', 'False', 'off'];
 export const TRUTHY = [true, 1, '?1', 'yes', 'true', 'True', 'on'];
 export class Signage {
@@ -77,7 +78,7 @@ export function signature(signages) {
         }));
         values.push(items.join(';'));
     }
-    return new Headers([['Signature', values.join(',')]]);
+    return new Headers([[HEADER_SIG, values.join(',')]]);
 }
 export function designature(value) {
     const values = value.replace(' ', '').split(',');