@vanaheimr/cose 0.9.0

package/dist/key.d.ts

@@ -0,0 +1,201 @@
+import type { CoseAlgorithm } from './algorithm.ts';
+import type { CborEntry, CborValue } from './cbor.ts';
+import type { CoseCurve } from './curve.ts';
+import type { DigestAlgorithm } from './ecdsa.ts';
+/** Key type 7, a key pair belonging to an algorithm rather than a curve. */
+export declare const KEY_TYPE_AKP = 7;
+/** Key type 4, a shared secret [RFC 9053, Section 7.3]. */
+export declare const KEY_TYPE_SYMMETRIC = 4;
+/**
+ * The labels of a COSE *key*, which are not the labels of a header bucket:
+ * 3 is the algorithm here and the content type there, 4 is the key operations
+ * here and the key identifier there.
+ */
+export declare const KeyLabel: {
+    readonly keyType: 1;
+    readonly keyIdentifier: 2;
+    readonly algorithm: 3;
+    readonly keyOperations: 4;
+    readonly curve: -1;
+    readonly x: -2;
+    readonly y: -3;
+    readonly d: -4;
+    readonly pub: -1;
+    readonly priv: -2;
+    readonly k: -1;
+};
+export interface CoseKeyParts {
+    readonly keyIdentifier?: Uint8Array | null;
+    readonly algorithm?: CoseAlgorithm | null;
+}
+export declare class CoseKey {
+    readonly keyType: number;
+    readonly keyIdentifier: Uint8Array | null;
+    readonly algorithm: CoseAlgorithm | null;
+    readonly keyOperations: CborValue | null;
+    /** The curve identifier as it travels, also when it is not registered. */
+    readonly curveId: number | null;
+    /** EC2 and OKP: the coordinates and the private scalar. */
+    readonly x: Uint8Array | null;
+    readonly y: Uint8Array | null;
+    readonly d: Uint8Array | null;
+    /** AKP: the public key, and the private key — which is always the seed. */
+    readonly pub: Uint8Array | null;
+    readonly priv: Uint8Array | null;
+    /** Symmetric: the shared secret. There is no public half of one. */
+    readonly k: Uint8Array | null;
+    /** Header parameters this implementation does not know, kept for the round trip. */
+    readonly additional: readonly CborEntry[];
+    private constructor();
+    private get fields();
+    private copy;
+    /** The curve of this key, or null when it names none or an unregistered one. */
+    get curve(): CoseCurve | null;
+    /**
+     * Whether this key carries secret key material.
+     *
+     * A symmetric key is *always* secret — it has nothing else — which is why
+     * `k` counts here beside the two private halves.
+     */
+    get isPrivate(): boolean;
+    /**
+     * An elliptic curve key pair from its private scalar.
+     *
+     * The public point is recomputed rather than asked for, which is what the
+     * examples of RFC 9052 do as well: a private COSE key always carries the
+     * full pair, and the two halves cannot disagree.
+     */
+    static fromPrivateScalar(curve: CoseCurve, d: Uint8Array, parts?: CoseKeyParts): CoseKey;
+    /**
+     * An octet key pair from its private key.
+     *
+     * There is no `y`: an EdDSA public key is the whole of `x`.
+     */
+    static fromOkpPrivateKey(curve: CoseCurve, d: Uint8Array, parts?: CoseKeyParts): CoseKey;
+    /**
+     * An algorithm key pair from its seed.
+     *
+     * The private key of an ML-DSA COSE key is the 32-byte seed and nothing
+     * else [RFC 9964] — not the expanded secret key, which is up to 4896 bytes
+     * and derivable from it. The algorithm is not optional here: an ML-DSA
+     * public key does not say which parameter set produced it, so a key that
+     * did not name one could not be used, and could not even be identified,
+     * since its thumbprint covers the algorithm.
+     */
+    static fromAkpSeed(algorithm: CoseAlgorithm, seed: Uint8Array, parts?: CoseKeyParts): CoseKey;
+    /**
+     * A public algorithm key pair, from the public key alone.
+     *
+     * This is the form a certificate hands over: a `SubjectPublicKeyInfo`
+     * carries the public key and names the parameter set in its algorithm
+     * identifier, and there is no seed to be had. The algorithm is required
+     * for the same reason as in {@link fromAkpSeed} — the bytes do not say
+     * which parameter set produced them, and the thumbprint covers `alg`.
+     */
+    static fromAkpPublicKey(algorithm: CoseAlgorithm, pub: Uint8Array, parts?: CoseKeyParts): CoseKey;
+    /**
+     * A symmetric key, which is a shared secret and nothing else.
+     *
+     * No length is enforced. RFC 9053 says an HMAC key SHOULD be as wide as
+     * the hash output, which is advice about key management rather than a rule
+     * about the primitive — RFC 2104 accepts any width and the published test
+     * vectors of RFC 4231 include a four-byte key. What a caller must not do
+     * is derive one from a password, and no length check would catch that.
+     */
+    static fromSymmetricKey(k: Uint8Array, parts?: CoseKeyParts): CoseKey;
+    /** A public octet key pair, which is the whole of `x` and nothing else. */
+    static fromOkpPublicKey(curve: CoseCurve, x: Uint8Array, parts?: CoseKeyParts): CoseKey;
+    /** A public elliptic curve key from its coordinates. */
+    static fromCoordinates(curve: CoseCurve, x: Uint8Array, y: Uint8Array, parts?: CoseKeyParts): CoseKey;
+    /**
+     * Parse a COSE key.
+     *
+     * Widths are deliberately not checked here — only that the CBOR types are
+     * what they claim to be. A key with a shortened coordinate is a real key
+     * that a real implementation produced, and reading it is how one finds out
+     * that it is wrong; the refusal belongs at the point where the key would
+     * be used, where the error can say what was expected.
+     *
+     * A duplicate label takes its last value, which is what a lenient CBOR map
+     * does everywhere else in COSE.
+     */
+    static parse(input: CborValue | Uint8Array): CoseKey;
+    private static readKeyType;
+    private static parseCurveKey;
+    private static parseSymmetric;
+    private static parseAkp;
+    /**
+     * The y coordinate, which may travel as a byte string or as the parity bit
+     * of a compressed point.
+     */
+    private static resolveY;
+    /**
+     * A CBOR map holding this key.
+     *
+     * The labels are written in ascending encoded order — 1, 2, 3, 4, −1, −2,
+     * −3, −4 — which happens to be exactly the deterministic order of
+     * RFC 8949 Section 4.2.1, so a canonical re-encoding moves nothing.
+     *
+     * A key whose y arrived as a sign bit does *not* round-trip byte for byte:
+     * y is always written as the byte string form, which every implementation
+     * understands.
+     */
+    toCbor(): CborValue;
+    /** The CBOR encoding of this key. */
+    toBytes(): Uint8Array;
+    /**
+     * This key without its private half.
+     *
+     * A symmetric key has no such form, and saying so is the point rather than
+     * a limitation: RFC 9053 states outright that the structure "does not have
+     * a form that contains only public members". Returning the key unchanged
+     * here — which is what stripping `d` and `priv` from it would do — would
+     * hand a caller the shared secret under a name promising the opposite.
+     */
+    publicKey(): CoseKey;
+    /** A copy of this key carrying the given algorithm. */
+    withAlgorithm(algorithm: CoseAlgorithm): CoseKey;
+    private requireCurve;
+    /**
+     * The public key, in whatever form its key type gives it: `04 ‖ x ‖ y` for
+     * EC2, the whole of `x` for OKP, `pub` for AKP.
+     */
+    publicKeyBytes(): Uint8Array;
+    /**
+     * The secret this key holds: the scalar for EC2 and OKP, the seed for AKP,
+     * the shared key itself for a symmetric one.
+     */
+    privateKeyBytes(): Uint8Array;
+    /**
+     * The input of the COSE Key Thumbprint [RFC 9679, Section 3]: the required
+     * parameters of this key, and nothing else, in deterministic encoding.
+     *
+     * Leaving out the optional parameters is what makes the thumbprint an
+     * identity rather than a checksum — the public and the private half of one
+     * key pair produce the same value, and adding a key identifier does not
+     * change it.
+     *
+     * An AKP key is the exception that proves the rule: its algorithm *is*
+     * required [RFC 9964], because an ML-DSA public key does not say which
+     * parameter set produced it, and two keys of different strengths must not
+     * be able to share an identity.
+     */
+    thumbprintInput(): Uint8Array;
+    /** The COSE Key Thumbprint [RFC 9679], untruncated. */
+    thumbprint(hash?: DigestAlgorithm): Uint8Array;
+    /**
+     * The leading bytes of the thumbprint, for use as a key identifier.
+     *
+     * Two properties make this worth preferring over a self-chosen prefix.
+     * Everyone holding the public key can recompute it, so no registry is
+     * needed beyond an agreement on its length. And because the thumbprint
+     * covers the curve — or, for an algorithm key pair, the algorithm — a
+     * signer who changes strength necessarily has a different key and
+     * therefore a different identifier: a downgrade under an unchanged
+     * identity is not expressible.
+     */
+    thumbprintKeyIdentifier(length?: number, hash?: DigestAlgorithm): Uint8Array;
+    /** A copy of this key whose key identifier is its own thumbprint. */
+    withThumbprintKeyIdentifier(length?: number, hash?: DigestAlgorithm): CoseKey;
+}
+//# sourceMappingURL=key.d.ts.map

package/dist/key.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"key.d.ts","sourceRoot":"","sources":["../src/key.ts"],"names":[],"mappings":"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"}

package/dist/labels.d.ts

@@ -0,0 +1,51 @@
+import type { CborValue } from './cbor.ts';
+/** The header parameter labels this implementation knows by name. */
+export declare const HeaderLabel: {
+    /** The cryptographic algorithm [RFC 9052]. */
+    readonly algorithm: 1;
+    /** The labels a recipient is required to understand [RFC 9052]. */
+    readonly critical: 2;
+    /** The content type of the payload [RFC 9052]. */
+    readonly contentType: 3;
+    /** The key identifier [RFC 9052]. */
+    readonly keyIdentifier: 4;
+    /** The initialization vector [RFC 9052]. */
+    readonly iv: 5;
+    /** The partial initialization vector [RFC 9052]. */
+    readonly partialIv: 6;
+    /** The countersignature of RFC 8152, superseded by label 11 [RFC 9338]. */
+    readonly counterSignature: 7;
+    /** The countersignature that also covers the signature it signs [RFC 9338]. */
+    readonly counterSignatureV2: 11;
+    /** The abbreviated countersignature, not implemented here [RFC 9338]. */
+    readonly counterSignature0V2: 12;
+    /** An unordered bag of X.509 certificates [RFC 9360]. */
+    readonly x5Bag: 32;
+    /** An ordered X.509 certificate chain [RFC 9360]. */
+    readonly x5Chain: 33;
+    /** The hash of an X.509 certificate [RFC 9360]. */
+    readonly x5T: 34;
+    /** A URI naming an X.509 certificate [RFC 9360]. */
+    readonly x5U: 35;
+};
+/** A header parameter label as it travels: an integer, or a text string. */
+export declare const label: (value: number) => CborValue;
+/**
+ * The name of a header parameter label, for error messages.
+ */
+export declare function headerLabelName(value: CborValue): string;
+/**
+ * Whether this implementation understands and processes the given header
+ * parameter, which is what the `crit` header parameter asks about
+ * [RFC 9052, Section 3.1].
+ *
+ * Four labels, and deliberately not the X.509 ones. Whether a certificate
+ * chain has been *understood* is a property of the verification being
+ * performed rather than of the library: whoever verifies with a bare public
+ * key has not looked at any certificate and must not claim otherwise. Callers
+ * that do process one say so per call, through `alsoUnderstood`.
+ */
+export declare function isUnderstood(value: CborValue): boolean;
+/** Whether two header parameter labels are the same label. */
+export declare function sameLabel(left: CborValue, right: CborValue): boolean;
+//# sourceMappingURL=labels.d.ts.map

package/dist/labels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"labels.d.ts","sourceRoot":"","sources":["../src/labels.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AAG3C,qEAAqE;AACrE,eAAO,MAAM,WAAW;IAEpB,8CAA8C;;IAG9C,mEAAmE;;IAGnE,kDAAkD;;IAGlD,qCAAqC;;IAGrC,4CAA4C;;IAG5C,oDAAoD;;IAGpD,2EAA2E;;IAG3E,+EAA+E;;IAG/E,yEAAyE;;IAGzE,yDAAyD;;IAGzD,qDAAqD;;IAGrD,mDAAmD;;IAGnD,oDAAoD;;CAG9C,CAAC;AAGX,4EAA4E;AAC5E,eAAO,MAAM,KAAK,GAAI,OAAO,MAAM,KAAG,SACnB,CAAC;AAGpB;;GAEG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,SAAS,GAAG,MAAM,CA2BxD;AAGD;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAMtD;AAGD,8DAA8D;AAC9D,wBAAgB,SAAS,CAAC,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,GAAG,OAAO,CAUpE"}

package/dist/mac.d.ts

@@ -0,0 +1,93 @@
+import type { CoseAlgorithm } from './algorithm.ts';
+import type { CborValue } from './cbor.ts';
+import type { Verification } from './errors.ts';
+import { CoseHeaders } from './headers.ts';
+import type { CoseKey } from './key.ts';
+import { CoseRecipient } from './recipient.ts';
+/** The CBOR tag of a COSE_Mac message. */
+export declare const COSE_MAC_TAG = 97;
+/** The context string of a COSE_Mac authentication tag [RFC 9052, Section 6.3]. */
+export declare const MAC_CONTEXT = "MAC";
+/** What a party authenticating may choose. */
+export interface MacOptions {
+    /** Data authenticated along with the payload without travelling in the message. */
+    readonly externalAad?: Uint8Array | null;
+    /** Whether to omit the payload from the message. */
+    readonly detachPayload?: boolean;
+    /**
+     * Whether to rewrite a CBOR payload in the deterministic encoding of
+     * RFC 8949 §4.2.1 before authenticating it, so that a receiver who parses
+     * and re-serializes the record arrives at the very bytes this tag covers.
+     * Defaults to true. A payload that is not CBOR is authenticated as it is.
+     */
+    readonly canonicalizePayload?: boolean;
+    /** Whether to wrap the message within CBOR tag 97. Defaults to true. */
+    readonly tagged?: boolean;
+}
+/** What a party checking may have to supply. */
+export interface MacVerifyOptions {
+    /** The data that was authenticated along with the payload. */
+    readonly externalAad?: Uint8Array | null;
+    /** The payload, when the message carries a detached one. */
+    readonly detachedPayload?: Uint8Array | null;
+    /** The algorithm the caller expects. */
+    readonly expectedAlgorithm?: CoseAlgorithm | null;
+    /** Header parameters the caller processes itself. */
+    readonly alsoUnderstood?: readonly CborValue[];
+}
+export declare class CoseMac {
+    /** The serialized protected bucket, exactly as authenticated and received. */
+    readonly protectedHeaderBytes: Uint8Array;
+    /** The protected header parameters, which the authentication tag covers. */
+    readonly protectedHeader: CoseHeaders;
+    /** The unprotected header parameters, which it does not. */
+    readonly unprotectedHeader: CoseHeaders;
+    /** The authenticated payload, or null when it is detached. */
+    readonly payload: Uint8Array | null;
+    /** The authentication tag — not the CBOR tag. */
+    readonly tag: Uint8Array;
+    /** How the content key reaches each party. */
+    readonly recipients: readonly CoseRecipient[];
+    /** Whether this message is wrapped within CBOR tag 97. */
+    readonly isTagged: boolean;
+    constructor(protectedHeaderBytes: Uint8Array, unprotectedHeader: CoseHeaders | null, payload: Uint8Array | null, tag: Uint8Array, recipients: readonly CoseRecipient[], isTagged?: boolean);
+    /** Whether the payload is detached. */
+    get isDetached(): boolean;
+    /** The MAC algorithm, protected bucket first. */
+    get algorithm(): CoseAlgorithm | null;
+    /**
+     * The encoded MAC_structure [RFC 9052, Section 6.3] with the `"MAC"`
+     * context — the one difference from a COSE_Mac0's.
+     */
+    static toBeMaced(protectedHeaderBytes: Uint8Array, payload: Uint8Array, externalAad?: Uint8Array | null): Uint8Array;
+    /** The encoded MAC_structure of this message. */
+    toBeMaced(options?: {
+        externalAad?: Uint8Array | null;
+        detachedPayload?: Uint8Array | null;
+    }): Uint8Array;
+    /**
+     * Authenticate a payload under a content key, and deliver that key to each
+     * recipient.
+     *
+     * The content key is the caller's rather than generated here, for the same
+     * reason as everywhere else in this package: a generated one would make the
+     * message unreproducible, and whoever has a key management scheme has it
+     * for a reason.
+     */
+    static create(payload: Uint8Array, contentKey: CoseKey, recipients: readonly CoseRecipient[], options?: MacOptions): CoseMac;
+    /**
+     * Verify this message with a key one of its recipients was built for.
+     *
+     * Every recipient is tried, because a party holding one key does not
+     * generally know which entry in the list is theirs.
+     */
+    verify(key: CoseKey, options?: MacVerifyOptions): Verification;
+    /** Read a COSE_Mac message, tagged or not. */
+    static parse(input: Uint8Array | CborValue): CoseMac;
+    /** The CBOR form of this message. */
+    toCbor(): CborValue;
+    /** The CBOR encoding of this message. */
+    toBytes(): Uint8Array;
+    toString(): string;
+}
+//# sourceMappingURL=mac.d.ts.map

package/dist/mac.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mac.d.ts","sourceRoot":"","sources":["../src/mac.ts"],"names":[],"mappings":"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"}

package/dist/mac0.d.ts

@@ -0,0 +1,132 @@
+import type { CoseAlgorithm } from './algorithm.ts';
+import type { CborValue } from './cbor.ts';
+import type { Verification } from './errors.ts';
+import { CoseHeaders } from './headers.ts';
+import type { CoseKey } from './key.ts';
+/** The CBOR tag of a COSE_Mac0 message. */
+export declare const COSE_MAC0_TAG = 17;
+/** The context string of a COSE_Mac0 authentication tag [RFC 9052, Section 6.3]. */
+export declare const MAC0_CONTEXT = "MAC0";
+/** What a party computing an authentication tag may choose. */
+export interface Mac0Options {
+    /** A key identifier for the unprotected bucket, defaulting to the key's own. */
+    readonly keyIdentifier?: Uint8Array | null;
+    /** Data authenticated along with the payload without travelling in the message. */
+    readonly externalAad?: Uint8Array | null;
+    /** Whether to omit the payload from the message. */
+    readonly detachPayload?: boolean;
+    /**
+     * Whether to rewrite a CBOR payload in the deterministic encoding of
+     * RFC 8949 §4.2.1 before authenticating it, so that a receiver who parses
+     * and re-serializes the record arrives at the very bytes this tag covers.
+     * Defaults to true. A payload that is not CBOR is authenticated as it is.
+     */
+    readonly canonicalizePayload?: boolean;
+    /** Whether to wrap the message within CBOR tag 17. Defaults to true. */
+    readonly tagged?: boolean;
+}
+/** What a party checking an authentication tag may have to supply. */
+export interface Mac0VerifyOptions {
+    /** The data that was authenticated along with the payload. */
+    readonly externalAad?: Uint8Array | null;
+    /** The payload, when the message carries a detached one. */
+    readonly detachedPayload?: Uint8Array | null;
+    /**
+     * The algorithm the caller expects, required whenever the message states
+     * its algorithm within the unprotected bucket only.
+     */
+    readonly expectedAlgorithm?: CoseAlgorithm | null;
+    /**
+     * Header parameters the caller processes itself, and which a `crit`
+     * header parameter may therefore demand.
+     */
+    readonly alsoUnderstood?: readonly CborValue[];
+}
+export declare class CoseMac0 {
+    /**
+     * The serialized protected bucket, exactly as authenticated and as
+     * received: a zero-length byte string when there are no protected header
+     * parameters.
+     */
+    readonly protectedHeaderBytes: Uint8Array;
+    /** The protected header parameters, which the authentication tag covers. */
+    readonly protectedHeader: CoseHeaders;
+    /**
+     * The unprotected header parameters, which the tag does not cover and
+     * which therefore must not be trusted after a successful verification.
+     */
+    readonly unprotectedHeader: CoseHeaders;
+    /** The authenticated payload, or null when it is detached. */
+    readonly payload: Uint8Array | null;
+    /** The authentication tag — not the CBOR tag. */
+    readonly tag: Uint8Array;
+    /**
+     * Whether this message is wrapped within CBOR tag 17. The tag is not
+     * covered by the authentication tag, but it is preserved so that a parsed
+     * message re-encodes to the very same bytes.
+     */
+    readonly isTagged: boolean;
+    constructor(protectedHeaderBytes: Uint8Array, unprotectedHeader: CoseHeaders | null, payload: Uint8Array | null, tag: Uint8Array, isTagged?: boolean);
+    /** Whether the payload is detached. */
+    get isDetached(): boolean;
+    /**
+     * The MAC algorithm, taken from the protected bucket and only otherwise
+     * from the unprotected one.
+     */
+    get algorithm(): CoseAlgorithm | null;
+    /** The key identifier, protected bucket first. */
+    get keyIdentifier(): Uint8Array | null;
+    /**
+     * The encoded MAC_structure [RFC 9052, Section 6.3], which is the byte
+     * string the MAC is actually computed over:
+     *
+     * <code>
+     * MAC_structure = [
+     *     context      : "MAC0",
+     *     protected    : empty_or_serialized_map,
+     *     external_aad : bstr,
+     *     payload      : bstr
+     * ]
+     * </code>
+     *
+     * The full payload goes in here regardless of how it travels, so a
+     * detached message and an attached one carry the very same tag.
+     */
+    static toBeMaced(protectedHeaderBytes: Uint8Array, payload: Uint8Array, externalAad?: Uint8Array | null): Uint8Array;
+    /** The encoded MAC_structure of this message. */
+    toBeMaced(options?: {
+        externalAad?: Uint8Array | null;
+        detachedPayload?: Uint8Array | null;
+    }): Uint8Array;
+    /**
+     * Authenticate a payload, placing the algorithm within the protected
+     * bucket and the key identifier within the unprotected one.
+     */
+    static create(payload: Uint8Array, key: CoseKey, options?: Mac0Options): CoseMac0;
+    /** Authenticate a payload with header buckets the caller composed. */
+    static createWithHeaders(payload: Uint8Array, key: CoseKey, protectedHeader: CoseHeaders, unprotectedHeader?: CoseHeaders | null, options?: Mac0Options): CoseMac0;
+    /**
+     * Verify the authentication tag of this message.
+     *
+     * A failed verification is not an exception — it is the expected outcome
+     * of checking untrusted data — so the reason travels in the result. The
+     * comparison itself is constant time, which matters here in a way it does
+     * not for a signature: an early-returning compare would tell whoever is
+     * guessing a tag how many of their leading bytes were right.
+     */
+    verify(key: CoseKey, options?: Mac0VerifyOptions): Verification;
+    /** Read a COSE_Mac0 message, tagged or not. */
+    static parse(input: Uint8Array | CborValue): CoseMac0;
+    /** The CBOR form of this message. */
+    toCbor(): CborValue;
+    /** The CBOR encoding of this message. */
+    toBytes(): Uint8Array;
+    /**
+     * A copy of this message without its payload.
+     *
+     * The tag stays valid: it never covered the message, only the
+     * MAC_structure, and the MAC_structure always holds the full payload.
+     */
+    detach(): CoseMac0;
+}
+//# sourceMappingURL=mac0.d.ts.map

package/dist/mac0.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mac0.d.ts","sourceRoot":"","sources":["../src/mac0.ts"],"names":[],"mappings":"AAgDA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAqB,gBAAgB,CAAC;AAGnE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAyB,WAAW,CAAC;AAE9D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAsB,aAAa,CAAC;AAChE,OAAO,EAAE,WAAW,EACqB,MAAS,cAAc,CAAC;AAEjE,OAAO,KAAK,EAAE,OAAO,EAAE,MAA2B,UAAU,CAAC;AAM7D,2CAA2C;AAC3C,eAAO,MAAM,aAAa,KAAK,CAAC;AAEhC,oFAAoF;AACpF,eAAO,MAAM,YAAY,SAAS,CAAC;AAGnC,+DAA+D;AAC/D,MAAM,WAAW,WAAW;IAExB,gFAAgF;IAChF,QAAQ,CAAC,aAAa,CAAC,EAAG,UAAU,GAAG,IAAI,CAAC;IAE5C,mFAAmF;IACnF,QAAQ,CAAC,WAAW,CAAC,EAAK,UAAU,GAAG,IAAI,CAAC;IAE5C,oDAAoD;IACpD,QAAQ,CAAC,aAAa,CAAC,EAAG,OAAO,CAAC;IAElC;;;;;OAKG;IACH,QAAQ,CAAC,mBAAmB,CAAC,EAAG,OAAO,CAAC;IAGxC,wEAAwE;IACxE,QAAQ,CAAC,MAAM,CAAC,EAAU,OAAO,CAAC;CAErC;AAGD,sEAAsE;AACtE,MAAM,WAAW,iBAAiB;IAE9B,8DAA8D;IAC9D,QAAQ,CAAC,WAAW,CAAC,EAAS,UAAU,GAAG,IAAI,CAAC;IAEhD,4DAA4D;IAC5D,QAAQ,CAAC,eAAe,CAAC,EAAK,UAAU,GAAG,IAAI,CAAC;IAEhD;;;OAGG;IACH,QAAQ,CAAC,iBAAiB,CAAC,EAAG,aAAa,GAAG,IAAI,CAAC;IAEnD;;;OAGG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAM,SAAS,SAAS,EAAE,CAAC;CAEtD;AAGD,qBAAa,QAAQ;IAEjB;;;;OAIG;IACH,SAAgB,oBAAoB,EAAG,UAAU,CAAC;IAElD,4EAA4E;IAC5E,SAAgB,eAAe,EAAQ,WAAW,CAAC;IAEnD;;;OAGG;IACH,SAAgB,iBAAiB,EAAM,WAAW,CAAC;IAEnD,8DAA8D;IAC9D,SAAgB,OAAO,EAAgB,UAAU,GAAG,IAAI,CAAC;IAEzD,iDAAiD;IACjD,SAAgB,GAAG,EAAoB,UAAU,CAAC;IAElD;;;;OAIG;IACH,SAAgB,QAAQ,EAAe,OAAO,CAAC;gBAG5B,oBAAoB,EAAE,UAAU,EAChC,iBAAiB,EAAK,WAAW,GAAG,IAAI,EACxC,OAAO,EAAe,UAAU,GAAG,IAAI,EACvC,GAAG,EAAmB,UAAU,EAChC,QAAQ,UAAoB;IAY/C,uCAAuC;IACvC,IAAW,UAAU,IAAI,OAAO,CAE/B;IAED;;;OAGG;IACH,IAAW,SAAS,IAAI,aAAa,GAAG,IAAI,CAE3C;IAED,kDAAkD;IAClD,IAAW,aAAa,IAAI,UAAU,GAAG,IAAI,CAE5C;IAKD;;;;;;;;;;;;;;;OAeG;WACW,SAAS,CAAC,oBAAoB,EAAE,UAAU,EAChC,OAAO,EAAe,UAAU,EAChC,WAAW,GAAW,UAAU,GAAG,IAAW,GAAG,UAAU;IAYnF,iDAAiD;IAC1C,SAAS,CAAC,OAAO,GAAE;QAAE,WAAW,CAAC,EAAM,UAAU,GAAG,IAAI,CAAC;QACpC,eAAe,CAAC,EAAE,UAAU,GAAG,IAAI,CAAA;KAAO,GAAG,UAAU;IAkBnF;;;OAGG;WACW,MAAM,CAAC,OAAO,EAAE,UAAU,EACnB,GAAG,EAAM,OAAO,EAChB,OAAO,GAAE,WAAgB,GAAG,QAAQ;IAsBzD,sEAAsE;WACxD,iBAAiB,CAAC,OAAO,EAAa,UAAU,EAC9B,GAAG,EAAiB,OAAO,EAC3B,eAAe,EAAK,WAAW,EAC/B,iBAAiB,GAAG,WAAW,GAAG,IAAW,EAC7C,OAAO,GAAa,WAAgB,GAAG,QAAQ;IAoC/E;;;;;;;;OAQG;IACI,MAAM,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,GAAE,iBAAsB,GAAG,YAAY;IAqD1E,+CAA+C;WACjC,KAAK,CAAC,KAAK,EAAE,UAAU,GAAG,SAAS,GAAG,QAAQ;IA8C5D,qCAAqC;IAC9B,MAAM,IAAI,SAAS;IAc1B,yCAAyC;IAClC,OAAO,IAAI,UAAU;IAK5B;;;;;OAKG;IACI,MAAM,IAAI,QAAQ;CAK5B"}

package/dist/mldsa.d.ts

@@ -0,0 +1,29 @@
+/** The three parameter sets RFC 9964 registers. */
+export declare const MLDSA_PARAMETER_SETS: readonly ["ML-DSA-44", "ML-DSA-65", "ML-DSA-87"];
+export type MldsaParameterSet = typeof MLDSA_PARAMETER_SETS[number];
+/** The sizes RFC 9964 prints, in bytes. */
+export declare const MLDSA_SIZES: Readonly<Record<MldsaParameterSet, {
+    publicKey: number;
+    signature: number;
+}>>;
+/** The length of an ML-DSA private key, which is always the seed. */
+export declare const MLDSA_SEED_SIZE = 32;
+/** Whether the given name is a parameter set this build can compute with. */
+export declare const isMldsaParameterSet: (parameterSet: string) => parameterSet is MldsaParameterSet;
+/**
+ * The public key belonging to a seed.
+ *
+ * Deriving rather than storing it is what keeps `priv` at 32 bytes: the
+ * expanded secret key of ML-DSA-87 is 4896.
+ */
+export declare function mldsaPublicKeyFor(parameterSet: string, seed: Uint8Array): Uint8Array;
+/**
+ * Sign the Sig_structure itself, deterministically.
+ *
+ * `extraEntropy: false` selects the deterministic variant of FIPS 204, in
+ * which the per-signature randomness is 32 zero bytes rather than drawn.
+ */
+export declare function mldsaSign(parameterSet: string, message: Uint8Array, seed: Uint8Array): Uint8Array;
+/** Verify an ML-DSA signature over the Sig_structure. */
+export declare function mldsaVerify(parameterSet: string, signature: Uint8Array, message: Uint8Array, publicKey: Uint8Array): boolean;
+//# sourceMappingURL=mldsa.d.ts.map

package/dist/mldsa.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mldsa.d.ts","sourceRoot":"","sources":["../src/mldsa.ts"],"names":[],"mappings":"AAgDA,mDAAmD;AACnD,eAAO,MAAM,oBAAoB,kDAAmD,CAAC;AAErF,MAAM,MAAM,iBAAiB,GAAG,OAAO,oBAAoB,CAAC,MAAM,CAAC,CAAC;AAUpE,2CAA2C;AAC3C,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,iBAAiB,EACjB;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC,CAIlF,CAAC;AAGF,qEAAqE;AACrE,eAAO,MAAM,eAAe,KAAK,CAAC;AAelC,6EAA6E;AAC7E,eAAO,MAAM,mBAAmB,GAAI,cAAc,MAAM,KAAG,YAAY,IAAI,iBAC5C,CAAC;AAGhC;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAAC,YAAY,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,UAAU,CAMpF;AAGD;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,YAAY,EAAE,MAAM,EACpB,OAAO,EAAO,UAAU,EACxB,IAAI,EAAU,UAAU,GAAG,UAAU,CAQ9D;AAGD,yDAAyD;AACzD,wBAAgB,WAAW,CAAC,YAAY,EAAE,MAAM,EACpB,SAAS,EAAK,UAAU,EACxB,OAAO,EAAO,UAAU,EACxB,SAAS,EAAK,UAAU,GAAG,OAAO,CAc7D"}

package/dist/payload.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Rewrite a payload in the deterministic encoding of RFC 8949 Section 4.2.1,
+ * or return it unchanged where it is not one well-formed CBOR data item and
+ * nothing else.
+ *
+ * Not being CBOR is not an error here: text, JSON, an image or a detached
+ * hash have no canonical CBOR form to be rewritten into, and a COSE payload is
+ * allowed to be any of them.
+ */
+export declare function canonicalizePayload(payload: Uint8Array): Uint8Array;
+/**
+ * Whether a payload survives being decoded and encoded again: whether it is
+ * one well-formed CBOR data item whose deterministic encoding is the payload
+ * itself.
+ *
+ * Deliberately the round trip rather than a strict decode. What a forwarding
+ * receiver actually does is decode and re-encode, so the question worth
+ * answering is whether that changes anything — not whether a list of rules is
+ * satisfied.
+ *
+ * A payload that is not CBOR is not canonical: there is nothing here to have
+ * an opinion about.
+ */
+export declare function isCanonicalPayload(payload: Uint8Array): boolean;
+//# sourceMappingURL=payload.d.ts.map

package/dist/payload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"payload.d.ts","sourceRoot":"","sources":["../src/payload.ts"],"names":[],"mappings":"AAgCA;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,UAAU,GAAG,UAAU,CAYnE;AAGD;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAU/D"}

package/dist/recipient.d.ts

@@ -0,0 +1,65 @@
+import type { CoseAlgorithm } from './algorithm.ts';
+import type { CborValue } from './cbor.ts';
+import { CoseHeaders } from './headers.ts';
+import type { CoseKey } from './key.ts';
+/** What a party building a recipient structure may choose. */
+export interface RecipientOptions {
+    /** A key identifier for the unprotected bucket, defaulting to the key's own. */
+    readonly keyIdentifier?: Uint8Array | null;
+    /** Recipient structures nested below this one. */
+    readonly recipients?: readonly CoseRecipient[];
+}
+export declare class CoseRecipient {
+    /** The serialized protected bucket — empty for both implemented routes. */
+    readonly protectedHeaderBytes: Uint8Array;
+    /** The protected header parameters. */
+    readonly protectedHeader: CoseHeaders;
+    /** The unprotected header parameters, which is where `alg` and `kid` live here. */
+    readonly unprotectedHeader: CoseHeaders;
+    /** The wrapped content key, or a zero-length string for `direct`. */
+    readonly ciphertext: Uint8Array;
+    /** Recipient structures nested below this one. */
+    readonly recipients: readonly CoseRecipient[];
+    constructor(protectedHeaderBytes: Uint8Array, unprotectedHeader: CoseHeaders | null, ciphertext: Uint8Array, recipients?: readonly CoseRecipient[]);
+    /** The recipient algorithm, protected bucket first. */
+    get algorithm(): CoseAlgorithm | null;
+    /** The key identifier, protected bucket first. */
+    get keyIdentifier(): Uint8Array | null;
+    /**
+     * A `direct` recipient: the key it names *is* the content key.
+     *
+     * RFC 9053 §6.1.1 requires the protected bucket to be zero length, and
+     * nothing is carried in the ciphertext either — so this structure conveys
+     * a key identifier and an algorithm and no key material at all.
+     */
+    static direct(key: CoseKey, options?: RecipientOptions): CoseRecipient;
+    /**
+     * A key-wrap recipient: the content key, encrypted under the given
+     * key-encryption key.
+     *
+     * The algorithm follows from the width of the *key-encryption* key rather
+     * than from the content key, which is the direction people get wrong:
+     * `A256KW` wraps a 128-bit content key perfectly well.
+     */
+    static keyWrap(contentKey: Uint8Array, keyEncryptionKey: CoseKey, options?: RecipientOptions): CoseRecipient;
+    /**
+     * The content key this recipient carries, or null when the given key is
+     * not the one it was built for.
+     *
+     * Null rather than an exception, and rather than a reason: a party holding
+     * several keys tries them in turn, and "not this one" is the ordinary
+     * answer rather than an error. For key wrap it is also the *only* honest
+     * answer — RFC 3394's integrity check is what distinguishes a wrong key
+     * from a right one, and saying more about which would say something about
+     * the key.
+     */
+    contentKey(key: CoseKey): Uint8Array | null;
+    /** Read a COSE_recipient. */
+    static parse(value: CborValue): CoseRecipient;
+    /** The CBOR form of this recipient. */
+    toCbor(): CborValue;
+    toString(): string;
+}
+/** The key-wrap algorithm a key-encryption key of the given width belongs to. */
+export declare function keyWrapAlgorithmFor(keySize: number): CoseAlgorithm;
+//# sourceMappingURL=recipient.d.ts.map

package/dist/recipient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recipient.d.ts","sourceRoot":"","sources":["../src/recipient.ts"],"names":[],"mappings":"AAuDA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAqB,gBAAgB,CAAC;AAGnE,OAAO,KAAK,EAAa,SAAS,EAAE,MAAc,WAAW,CAAC;AAE9D,OAAO,EAAE,WAAW,EAAE,MAA4B,cAAc,CAAC;AAEjE,OAAO,KAAK,EAAE,OAAO,EAAE,MAA2B,UAAU,CAAC;AAI7D,8DAA8D;AAC9D,MAAM,WAAW,gBAAgB;IAE7B,gFAAgF;IAChF,QAAQ,CAAC,aAAa,CAAC,EAAG,UAAU,GAAG,IAAI,CAAC;IAE5C,kDAAkD;IAClD,QAAQ,CAAC,UAAU,CAAC,EAAM,SAAS,aAAa,EAAE,CAAC;CAEtD;AAGD,qBAAa,aAAa;IAEtB,2EAA2E;IAC3E,SAAgB,oBAAoB,EAAG,UAAU,CAAC;IAElD,uCAAuC;IACvC,SAAgB,eAAe,EAAQ,WAAW,CAAC;IAEnD,mFAAmF;IACnF,SAAgB,iBAAiB,EAAM,WAAW,CAAC;IAEnD,qEAAqE;IACrE,SAAgB,UAAU,EAAa,UAAU,CAAC;IAElD,kDAAkD;IAClD,SAAgB,UAAU,EAAa,SAAS,aAAa,EAAE,CAAC;gBAG7C,oBAAoB,EAAE,UAAU,EAChC,iBAAiB,EAAK,WAAW,GAAG,IAAI,EACxC,UAAU,EAAY,UAAU,EAChC,UAAU,GAAY,SAAS,aAAa,EAAO;IAWtE,uDAAuD;IACvD,IAAW,SAAS,IAAI,aAAa,GAAG,IAAI,CAE3C;IAED,kDAAkD;IAClD,IAAW,aAAa,IAAI,UAAU,GAAG,IAAI,CAE5C;IAKD;;;;;;OAMG;WACW,MAAM,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,GAAE,gBAAqB,GAAG,aAAa;IAejF;;;;;;;OAOG;WACW,OAAO,CAAC,UAAU,EAAS,UAAU,EAC7B,gBAAgB,EAAG,OAAO,EAC1B,OAAO,GAAY,gBAAqB,GAAG,aAAa;IAyB9E;;;;;;;;;;OAUG;IACI,UAAU,CAAC,GAAG,EAAE,OAAO,GAAG,UAAU,GAAG,IAAI;IAgClD,6BAA6B;WACf,KAAK,CAAC,KAAK,EAAE,SAAS,GAAG,aAAa;IAsCpD,uCAAuC;IAChC,MAAM,IAAI,SAAS;IAcnB,QAAQ,IAAI,MAAM;CAI5B;AAGD,iFAAiF;AACjF,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,aAAa,CAUlE"}