signify-ts 0.1.1 → 0.2.1

package/src/keri/core/authing.ts

@@ -1,129 +1,117 @@
-import {Signer} from "./signer";
-import {Verfer} from "./verfer";
-import {desiginput, normalize, siginput} from "./httping";
-import {b} from "./core";
-import {parseDictionary} from "structured-headers";
-import {Signage, signature} from "../end/ending";
-import {Cigar} from "./cigar";
-import {Siger} from "./siger";
-
-import Base64 from "urlsafe-base64"
-
+import { Signer } from './signer';
+import { Verfer } from './verfer';
+import { desiginput, normalize, siginput } from './httping';
+import { Signage, signature, designature } from '../end/ending';
+import { Cigar } from './cigar';
+import { Siger } from './siger';
 export class Authenticater {
-
     static DefaultFields = [
-        "Signify-Resource",
-        "@method",
-        "@path",
-        "Signify-Timestamp"
-    ]
+        '@method',
+        '@path',
+        'signify-resource',
+        'signify-timestamp',
+    ];
     private _verfer: Verfer;
     private readonly _csig: Signer;
 
-    constructor(csig: Signer, aaid: string) {
-        this._csig = csig
-        this._verfer = new Verfer({qb64: aaid})
+    constructor(csig: Signer, verfer: Verfer) {
+        this._csig = csig;
+        this._verfer = verfer;
     }
 
     verify(headers: Headers, method: string, path: string): boolean {
-        let siginput = headers.get("Signature-Input")
+        const siginput = headers.get('Signature-Input');
         if (siginput == null) {
-            return false
+            return false;
         }
-        let signature = headers.get("Signature")
+        const signature = headers.get('Signature');
         if (signature == null) {
-            return false
+            return false;
         }
-
-        let inputs = desiginput(siginput)
-        inputs = inputs.filter((input) => input.name == "signify")
-
+        let inputs = desiginput(siginput);
+        inputs = inputs.filter((input) => input.name == 'signify');
         if (inputs.length == 0) {
-            return false
+            return false;
         }
-
         inputs.forEach((input) => {
-            let items = new Array<string>()
+            const items = new Array<string>();
             input.fields!.forEach((field: string) => {
-                if (field.startsWith("@")) {
-                    if (field == "@method") {
-                        items.push(`"${field}": ${method}`)
-                    } else if (field == "@path") {
-                        items.push(`"${field}": ${path}`)
+                if (field.startsWith('@')) {
+                    if (field == '@method') {
+                        items.push(`"${field}": ${method}`);
+                    } else if (field == '@path') {
+                        items.push(`"${field}": ${path}`);
                     }
                 } else {
                     if (headers.has(field)) {
-                        let value = normalize(headers.get(field) as string)
-                        items.push(`"${field}": ${value}`)
+                        const value = normalize(headers.get(field) as string);
+                        items.push(`"${field}": ${value}`);
                     }
                 }
-            })
-
-            let values = new Array<string>()
-            values.push(`(${input.fields!.join(" ")})`)
-            values.push(`created=${input.created}`)
-
+            });
+            const values = new Array<string>();
+            values.push(`(${input.fields!.join(' ')})`);
+            values.push(`created=${input.created}`);
             if (input.expires != undefined) {
-                values.push(`expires=${input.expires}`)
+                values.push(`expires=${input.expires}`);
             }
             if (input.nonce != undefined) {
-                values.push(`nonce=${input.nonce}`)
+                values.push(`nonce=${input.nonce}`);
             }
             if (input.keyid != undefined) {
-                values.push(`keyid=${input.keyid}`)
+                values.push(`keyid=${input.keyid}`);
             }
             if (input.context != undefined) {
-                values.push(`context=${input.context}`)
+                values.push(`context=${input.context}`);
             }
             if (input.alg != undefined) {
-                values.push(`alg=${input.alg}`)
+                values.push(`alg=${input.alg}`);
             }
-
-            let params = values.join(";")
-
-            items.push(`"@signature-params: ${params}"`)
-            let ser = b(items.join("\n"))
-
-            let signage = parseDictionary(signature!)
-            if (!signage.has("indexed")) {
-                throw new Error(`invalid signate ${signage}`)
-            }
-
-            let item = signage.get("indexed")!
-            let raw = Base64.decode(item[1].get(input.name) as string)
-
-            if (!this._verfer.verify(raw, ser)) {
-                throw new Error(`Signature for {inputage} invalid.`)
+            const params = values.join(';');
+            items.push(`"@signature-params: ${params}"`);
+            const ser = items.join('\n');
+            const signage = designature(signature!);
+            const cig = signage[0].markers.get(input.name);
+            if (!this._verfer.verify(cig.raw, ser)) {
+                throw new Error(`Signature for ${input.keyid} invalid.`);
             }
-        })
+        });
 
-        return true
+        return true;
     }
 
-    sign(headers: Headers, method: string, path: string, fields?: Array<string>): Headers {
+    sign(
+        headers: Headers,
+        method: string,
+        path: string,
+        fields?: Array<string>
+    ): Headers {
         if (fields == undefined) {
-            fields = Authenticater.DefaultFields
+            fields = Authenticater.DefaultFields;
         }
 
-        let [header, sig] = siginput(this._csig, {
-            name: "signify", method, path, headers, fields, alg: "ed25519",
-            keyid: this._csig.verfer.qb64
-        })
+        const [header, sig] = siginput(this._csig, {
+            name: 'signify',
+            method,
+            path,
+            headers,
+            fields,
+            alg: 'ed25519',
+            keyid: this._csig.verfer.qb64,
+        });
 
         header.forEach((value, key) => {
-            headers.append(key, value)
-        })
+            headers.append(key, value);
+        });
 
-        let markers = new Map<string, Siger|Cigar>()
-        markers.set("signify", sig)
-        let signage = new Signage(markers, false)
-        let signed = signature([signage])
+        const markers = new Map<string, Siger | Cigar>();
+        markers.set('signify', sig);
+        const signage = new Signage(markers, false);
+        const signed = signature([signage]);
         signed.forEach((value, key) => {
-            headers.append(key, value)
-        })
+            headers.append(key, value);
+        });
 
-        return headers
+        return headers;
     }
-
-
-}
+}

package/src/keri/core/bexter.ts

@@ -0,0 +1,138 @@
+import { BexDex, Matter, MatterArgs, MtrDex } from './matter';
+import { EmptyMaterialError } from './kering';
+import Base64 from 'urlsafe-base64';
+
+const B64REX = '^[A-Za-z0-9\\-_]*$';
+export const Reb64 = new RegExp(B64REX);
+
+/*
+
+    Bexter is subclass of Matter, cryptographic material, for variable length
+    strings that only contain Base64 URL safe characters, i.e. Base64 text (bext).
+    When created using the 'bext' paramaeter, the encoded matter in qb64 format
+    in the text domain is more compact than would be the case if the string were
+    passed in as raw bytes. The text is used as is to form the value part of the
+    qb64 version not including the leader.
+
+    Due to ambiguity that arises from pre-padding bext whose length is a multiple of
+    three with one or more 'A' chars. Any bext that starts with an 'A' and whose length
+    is either a multiple of 3 or 4 may not round trip. Bext with a leading 'A'
+    whose length is a multiple of four may have the leading 'A' stripped when
+    round tripping.
+
+        Bexter(bext='ABBB').bext == 'BBB'
+        Bexter(bext='BBB').bext == 'BBB'
+        Bexter(bext='ABBB').qb64 == '4AABABBB' == Bexter(bext='BBB').qb64
+
+    To avoid this problem, only use for applications of base 64 strings that
+    never start with 'A'
+
+    Examples: base64 text strings:
+
+    bext = ""
+    qb64 = '4AAA'
+
+    bext = "-"
+    qb64 = '6AABAAA-'
+
+    bext = "-A"
+    qb64 = '5AABAA-A'
+
+    bext = "-A-"
+    qb64 = '4AABA-A-'
+
+    bext = "-A-B"
+    qb64 = '4AAB-A-B'
+
+
+    Example uses:
+        CESR encoded paths for nested SADs and SAIDs
+        CESR encoded fractionally weighted threshold expressions
+
+
+    Attributes:
+
+    Inherited Properties:  (See Matter)
+        .pad  is int number of pad chars given raw
+
+        .code is  str derivation code to indicate cypher suite
+        .raw is bytes crypto material only without code
+        .index is int count of attached crypto material by context (receipts)
+        .qb64 is str in Base64 fully qualified with derivation code + crypto mat
+        .qb64b is bytes in Base64 fully qualified with derivation code + crypto mat
+        .qb2  is bytes in binary with derivation code + crypto material
+        .transferable is Boolean, True when transferable derivation code False otherwise
+
+    Properties:
+        .text is the Base64 text value, .qb64 with text code and leader removed.
+
+    Hidden:
+        ._pad is method to compute  .pad property
+        ._code is str value for .code property
+        ._raw is bytes value for .raw property
+        ._index is int value for .index property
+        ._infil is method to compute fully qualified Base64 from .raw and .code
+        ._exfil is method to extract .code and .raw from fully qualified Base64
+
+    Methods:
+
+
+
+
+ */
+
+export class Bexter extends Matter {
+    constructor(
+        { raw, code = MtrDex.StrB64_L0, qb64b, qb64, qb2 }: MatterArgs,
+        bext?: string
+    ) {
+        if (
+            raw === undefined &&
+            qb64b === undefined &&
+            qb64 === undefined &&
+            qb2 === undefined
+        ) {
+            if (bext === undefined)
+                throw new EmptyMaterialError('Missing bext string.');
+
+            const match = Reb64.exec(bext);
+            if (!match) throw new Error('Invalid Base64.');
+
+            raw = Bexter._rawify(bext);
+        }
+
+        super({ raw, code, qb64b, qb64, qb2 });
+
+        if (!BexDex.has(this.code))
+            throw new Error(`Invalid code = ${this.code} for Bexter.`);
+    }
+
+    static _rawify(bext: string): Uint8Array {
+        const ts = bext.length % 4; // bext size mod 4
+        const ws = (4 - ts) % 4; // pre conv wad size in chars
+        const ls = (3 - ts) % 3; // post conv lead size in bytes
+        const wad = new Array(ws);
+        wad.fill('A');
+        const base = wad.join('') + bext; // pre pad with wad of zeros in Base64 == 'A'
+        const raw = Base64.decode(base); // [ls:]  // convert and remove leader
+
+        return Uint8Array.from(raw).subarray(ls); // raw binary equivalent of text
+    }
+
+    get bext(): string {
+        const sizage = Matter.Sizes.get(this.code);
+        const wad = Uint8Array.from(new Array(sizage?.ls).fill(0));
+        const bext = Base64.encode(Buffer.from([...wad, ...this.raw]));
+
+        let ws = 0;
+        if (sizage?.ls === 0 && bext !== undefined) {
+            if (bext[0] === 'A') {
+                ws = 1;
+            }
+        } else {
+            ws = (sizage?.ls! + 1) % 4;
+        }
+
+        return bext.substring(ws);
+    }
+}

package/src/keri/core/cigar.ts

@@ -1,19 +1,18 @@
-import {Verfer} from "./verfer";
-import {Matter, MatterArgs} from "./matter";
-
+import { Verfer } from './verfer';
+import { Matter, MatterArgs } from './matter';
 
 export class Cigar extends Matter {
-    private _verfer: Verfer | undefined
-    constructor({raw, code, qb64, qb64b, qb2}:MatterArgs, verfer?: Verfer) {
-        super({raw, code, qb64, qb64b, qb2});
-        this._verfer = verfer
+    private _verfer: Verfer | undefined;
+    constructor({ raw, code, qb64, qb64b, qb2 }: MatterArgs, verfer?: Verfer) {
+        super({ raw, code, qb64, qb64b, qb2 });
+        this._verfer = verfer;
     }
 
     get verfer(): Verfer | undefined {
-        return this._verfer
+        return this._verfer;
     }
 
-    set verfer(verfer:Verfer|undefined) {
-        this._verfer = verfer
+    set verfer(verfer: Verfer | undefined) {
+        this._verfer = verfer;
     }
-}
+}

package/src/keri/core/cipher.ts

@@ -1,25 +1,34 @@
-import {Matter, MatterArgs, MtrDex} from "./matter";
-import {Decrypter} from "./decrypter";
-
+import { Matter, MatterArgs, MtrDex } from './matter';
+import { Decrypter } from './decrypter';
 
 export class Cipher extends Matter {
-    constructor({raw, code, qb64, qb64b, qb2}:MatterArgs) {
+    constructor({ raw, code, qb64, qb64b, qb2 }: MatterArgs) {
         if (raw != undefined && code == undefined) {
             if (raw.length == Matter._rawSize(MtrDex.X25519_Cipher_Salt)) {
-                code = MtrDex.X25519_Cipher_Salt
-            } else if (raw.length  == Matter._rawSize(MtrDex.X25519_Cipher_Seed)) {
-                code = MtrDex.X25519_Cipher_Salt
+                code = MtrDex.X25519_Cipher_Salt;
+            } else if (
+                raw.length == Matter._rawSize(MtrDex.X25519_Cipher_Seed)
+            ) {
+                code = MtrDex.X25519_Cipher_Salt;
             }
         }
-        super({raw: raw, code: code, qb64b: qb64b, qb64: qb64, qb2: qb2});
+        super({ raw: raw, code: code, qb64b: qb64b, qb64: qb64, qb2: qb2 });
 
-        if (!(Array.from([MtrDex.X25519_Cipher_Salt, MtrDex.X25519_Cipher_Seed]).includes(this.code))) {
-            throw new Error(`Unsupported Cipher code == ${this.code}`)
+        if (
+            !Array.from([
+                MtrDex.X25519_Cipher_Salt,
+                MtrDex.X25519_Cipher_Seed,
+            ]).includes(this.code)
+        ) {
+            throw new Error(`Unsupported Cipher code == ${this.code}`);
         }
     }
 
-    decrypt(prikey: Uint8Array | undefined = undefined, seed: Uint8Array | undefined = undefined) {
-        let decrypter = new Decrypter({qb64b: prikey}, seed)
-        return decrypter.decrypt(this.qb64b)
+    decrypt(
+        prikey: Uint8Array | undefined = undefined,
+        seed: Uint8Array | undefined = undefined
+    ) {
+        const decrypter = new Decrypter({ qb64b: prikey }, seed);
+        return decrypter.decrypt(this.qb64b);
     }
-}
+}