@vanaheimr/cose 0.9.0

package/dist/algorithm.d.ts

@@ -0,0 +1,137 @@
+import type { CborValue } from './cbor.ts';
+import type { CoseCurve } from './curve.ts';
+import type { DigestAlgorithm } from './ecdsa.ts';
+/**
+ * Which machinery an algorithm needs.
+ *
+ * The distinction that earns its place here is `ecdsa` against the other two:
+ * ECDSA signs a *digest* of the message, chosen by the algorithm, while EdDSA
+ * and ML-DSA are pure and take the message itself. Handing a pure signer a
+ * digest produces a signature that is valid for the digest and that nobody
+ * else will ever accept — a failure with no symptom until the day two
+ * implementations meet.
+ */
+export type AlgorithmFamily = 'ecdsa' | 'eddsa' | 'mldsa' | 'hmac' | 'aesgcm' | 'keywrap' | 'direct' | 'none';
+/** An algorithm in the COSE registry. */
+export interface CoseAlgorithm {
+    /** The IANA identifier, as it travels in the `alg` header parameter. */
+    readonly id: number;
+    /** The registered name, e.g. `ES256`. Case sensitive. */
+    readonly name: string;
+    /** The registered description. */
+    readonly description: string;
+    /** Which signature machinery this needs. */
+    readonly family: AlgorithmFamily;
+    /** The message digest, or null for a pure scheme that defines none. */
+    readonly hash: DigestAlgorithm | null;
+    /** The curve this algorithm is defined on, or null when it leaves it to the key. */
+    readonly curve: CoseCurve | null;
+    /** The ML-DSA parameter set, or null for everything else. */
+    readonly parameterSet: string | null;
+    /**
+     * The width of the authentication tag in bytes, for a MAC algorithm.
+     *
+     * It is part of the identifier rather than a parameter: `HMAC 256/64` and
+     * `HMAC 256/256` are two registered algorithms over the same hash, and a
+     * verifier learns which width to expect from the message.
+     */
+    readonly tagSize: number | null;
+    /**
+     * The width of the key in bytes, for an algorithm that fixes one.
+     *
+     * AES algorithms do: `A128GCM` and `A256GCM` are two registered identifiers
+     * over one cipher, and the width is what tells them apart. The signature
+     * algorithms leave it to the curve or to the parameter set.
+     */
+    readonly keySize: number | null;
+    /** Whether this implementation can sign and verify with it. */
+    readonly signing: boolean;
+    /** Whether the registry marks it deprecated. */
+    readonly deprecated: boolean;
+}
+/** The algorithms this implementation knows by name. */
+export declare const CoseAlgorithms: {
+    readonly ES256: CoseAlgorithm;
+    readonly ES384: CoseAlgorithm;
+    readonly ES512: CoseAlgorithm;
+    readonly ES256K: CoseAlgorithm;
+    readonly ESP256: CoseAlgorithm;
+    readonly ESP384: CoseAlgorithm;
+    readonly ESP512: CoseAlgorithm;
+    readonly ESB256: CoseAlgorithm;
+    readonly ESB320: CoseAlgorithm;
+    readonly ESB384: CoseAlgorithm;
+    readonly ESB512: CoseAlgorithm;
+    readonly EdDSA: CoseAlgorithm;
+    readonly Ed25519: CoseAlgorithm;
+    readonly Ed448: CoseAlgorithm;
+    readonly MLDSA44: CoseAlgorithm;
+    readonly MLDSA65: CoseAlgorithm;
+    readonly MLDSA87: CoseAlgorithm;
+    readonly HMAC256_64: CoseAlgorithm;
+    readonly HMAC256_256: CoseAlgorithm;
+    readonly HMAC384_384: CoseAlgorithm;
+    readonly HMAC512_512: CoseAlgorithm;
+    readonly A128GCM: CoseAlgorithm;
+    readonly A192GCM: CoseAlgorithm;
+    readonly A256GCM: CoseAlgorithm;
+    readonly A128KW: CoseAlgorithm;
+    readonly A192KW: CoseAlgorithm;
+    readonly A256KW: CoseAlgorithm;
+    readonly direct: CoseAlgorithm;
+    readonly SHA256: CoseAlgorithm;
+    readonly SHA384: CoseAlgorithm;
+    readonly SHA512: CoseAlgorithm;
+    readonly SHA1: CoseAlgorithm;
+};
+/** Every registered algorithm, in registry order. */
+export declare const ALL_ALGORITHMS: readonly CoseAlgorithm[];
+/** The algorithm with the given identifier, or null when it is not registered. */
+export declare function algorithmById(id: number): CoseAlgorithm | null;
+/** The algorithm with the given name, or null. Case sensitive. */
+export declare function algorithmByName(name: string): CoseAlgorithm | null;
+/**
+ * The algorithm a header parameter names.
+ *
+ * An unregistered identifier is not an error here. A message that names an
+ * algorithm nobody knows is still worth reading — its headers, its key
+ * identifier and its payload are all inspectable — and it fails at the point
+ * where it would have to be verified, where the failure means something.
+ */
+export declare function algorithmFromCbor(value: CborValue): CoseAlgorithm;
+/** The header parameter value naming this algorithm. */
+export declare const algorithmToCbor: (value: CoseAlgorithm) => CborValue;
+/** Whether two algorithms are the same algorithm. */
+export declare const sameAlgorithm: (left: CoseAlgorithm, right: CoseAlgorithm) => boolean;
+/**
+ * The curve a signature with this algorithm runs on.
+ *
+ * A fully-specified algorithm names it, and then the key has to agree; the
+ * three older ones leave it to the key entirely. Checking the agreement is
+ * what stops a `ESP256` message from being verified with a P-384 key, which no
+ * amount of correct arithmetic further down would catch.
+ */
+export declare function resolveCurve(value: CoseAlgorithm, keyCurve: CoseCurve | null): CoseCurve;
+/**
+ * Sign the Sig_structure of a message with the given algorithm.
+ *
+ * Note which of the three branches hashes and which do not. ECDSA signs a
+ * digest of the Sig_structure; EdDSA and ML-DSA sign the Sig_structure itself.
+ * Getting that backwards yields a signature that verifies against nothing but
+ * an implementation making the same mistake.
+ */
+export declare function signWith(value: CoseAlgorithm, keyCurve: CoseCurve | null, toBeSigned: Uint8Array, privateKey: Uint8Array): Uint8Array;
+/**
+ * The authentication tag of a MAC_structure.
+ *
+ * Deliberately *not* reachable through {@link signWith}: a MAC is not a
+ * signature with a shorter key, and an API that let one stand in for the other
+ * would let a caller believe a message was signed when it was merely
+ * authenticated between two parties who share a secret.
+ */
+export declare function macWith(value: CoseAlgorithm, toBeMaced: Uint8Array, key: Uint8Array): Uint8Array;
+/** Whether an authentication tag is the right one, compared in constant time. */
+export declare function verifyMacWith(value: CoseAlgorithm, toBeMaced: Uint8Array, tag: Uint8Array, key: Uint8Array): boolean;
+/** Verify a signature over the Sig_structure of a message. */
+export declare function verifyWith(value: CoseAlgorithm, keyCurve: CoseCurve | null, toBeSigned: Uint8Array, signature: Uint8Array, publicKey: Uint8Array): boolean;
+//# sourceMappingURL=algorithm.d.ts.map

package/dist/algorithm.d.ts.map

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

package/dist/asn1.d.ts

@@ -0,0 +1,114 @@
+/** The universal ASN.1 tags this package meets. */
+export declare const Tag: {
+    readonly boolean: 1;
+    readonly integer: 2;
+    readonly bitString: 3;
+    readonly octetString: 4;
+    readonly null: 5;
+    readonly objectIdentifier: 6;
+    readonly utf8String: 12;
+    readonly printableString: 19;
+    readonly teletexString: 20;
+    readonly ia5String: 22;
+    readonly utcTime: 23;
+    readonly generalizedTime: 24;
+    readonly bmpString: 30;
+    readonly universalString: 28;
+    readonly sequence: 48;
+    readonly set: 49;
+};
+/** A context-specific constructed tag, e.g. `[0]` is `contextTag(0)`. */
+export declare const contextTag: (number: number) => number;
+/**
+ * One tag-length-value record.
+ *
+ * `content` is the value octets and `encoded` the whole record — identifier,
+ * length and value. Both matter: the content is what a field says, the
+ * encoding is what a signature covers.
+ */
+export interface Asn1Node {
+    /** The identifier octet. */
+    readonly tag: number;
+    /** The value octets, without identifier or length. */
+    readonly content: Uint8Array;
+    /** The complete record, exactly as it appeared. */
+    readonly encoded: Uint8Array;
+}
+/**
+ * A cursor over a sequence of DER records.
+ *
+ * The `what` is carried only so that a failure can say which structure was
+ * being read; a message naming a byte offset and nothing else is a message
+ * that has to be debugged rather than read.
+ */
+export declare class DerReader {
+    private readonly data;
+    private readonly what;
+    private at;
+    constructor(data: Uint8Array, what: string);
+    /** Whether every record has been read. */
+    get atEnd(): boolean;
+    /** The octets not yet read. */
+    get remaining(): Uint8Array;
+    private fail;
+    /**
+     * Read the next record, optionally insisting on a tag.
+     *
+     * The length rules are DER's: definite always, short form below 128,
+     * long form minimally encoded and never longer than eight octets — which
+     * is far more than a certificate can need and still shorter than the point
+     * where a length stops fitting a JavaScript number.
+     */
+    read(expectedTag?: number): Asn1Node;
+    /** Read the next record when it carries the given tag, else read nothing. */
+    readOptional(tag: number): Asn1Node | null;
+    /** Whether a record with the given tag comes next. */
+    peekIs(tag: number): boolean;
+    /** Insist that nothing follows, which is how trailing data is caught. */
+    expectEnd(): void;
+}
+/** A cursor over the contents of a constructed record. */
+export declare const contentsOf: (node: Asn1Node, what: string) => DerReader;
+/**
+ * A DER INTEGER as a bigint, two's complement and minimally encoded.
+ *
+ * Certificates hold signed integers here — a serial number is defined as one
+ * — so a leading 0x00 before a high bit is padding and a leading 0x00 before
+ * anything else is a violation.
+ */
+export declare function derInteger(node: Asn1Node, what: string): bigint;
+/**
+ * A DER BIT STRING, as whole octets.
+ *
+ * Every bit string a certificate carries a key or a signature in is octet
+ * aligned, so an unused-bit count other than zero is refused rather than
+ * shifted — `keyUsage` is the one exception and reads the count itself.
+ */
+export declare function derBitString(node: Asn1Node, what: string): Uint8Array;
+/** A DER BIT STRING with its unused-bit count, which `keyUsage` needs. */
+export declare function derBitStringRaw(node: Asn1Node, what: string): {
+    unusedBits: number;
+    bytes: Uint8Array;
+};
+/** A DER BOOLEAN. DER admits exactly two encodings, and 0x01 is not one of them. */
+export declare function derBoolean(node: Asn1Node, what: string): boolean;
+/**
+ * A DER OBJECT IDENTIFIER, in dotted decimal.
+ *
+ * The first two arcs share one octet — `40·first + second` — which is why
+ * `2.16.840…` and `1.2.840…` both begin with a byte in the eighties, and why
+ * the first arc is recovered by division rather than by lookup.
+ */
+export declare function derObjectIdentifier(node: Asn1Node, what: string): string;
+/** A DER string, in whichever of the X.509 string types it was written. */
+export declare function derString(node: Asn1Node, what: string): string;
+/**
+ * A DER UTCTime or GeneralizedTime.
+ *
+ * DER admits exactly one form of each: seconds present, no fractional part,
+ * and Zulu — so anything else is refused rather than guessed at. The
+ * two-digit year of a UTCTime is windowed as RFC 5280 Section 4.1.2.5.1
+ * requires, 50 and above being the twentieth century.
+ */
+export declare function derTime(node: Asn1Node, what: string): Date;
+//# sourceMappingURL=asn1.d.ts.map

package/dist/asn1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"asn1.d.ts","sourceRoot":"","sources":["../src/asn1.ts"],"names":[],"mappings":"AAgCA,mDAAmD;AACnD,eAAO,MAAM,GAAG;;;;;;;;;;;;;;;;;CAiBN,CAAC;AAGX,yEAAyE;AACzE,eAAO,MAAM,UAAU,GAAI,QAAQ,MAAM,KAAG,MAAuB,CAAC;AAYpE;;;;;;GAMG;AACH,MAAM,WAAW,QAAQ;IAErB,4BAA4B;IAC5B,QAAQ,CAAC,GAAG,EAAO,MAAM,CAAC;IAE1B,sDAAsD;IACtD,QAAQ,CAAC,OAAO,EAAG,UAAU,CAAC;IAE9B,mDAAmD;IACnD,QAAQ,CAAC,OAAO,EAAG,UAAU,CAAC;CAEjC;AAGD;;;;;;GAMG;AACH,qBAAa,SAAS;IAElB,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAc;IACnC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAU;IAC/B,OAAO,CAAU,EAAE,CAAY;gBAGZ,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM;IAOjD,0CAA0C;IAC1C,IAAW,KAAK,IAAI,OAAO,CAE1B;IAGD,+BAA+B;IAC/B,IAAW,SAAS,IAAI,UAAU,CAEjC;IAGD,OAAO,CAAC,IAAI;IAKZ;;;;;;;OAOG;IACI,IAAI,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,QAAQ;IAkE3C,6EAA6E;IACtE,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,QAAQ,GAAG,IAAI;IAUjD,sDAAsD;IAC/C,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAKnC,yEAAyE;IAClE,SAAS,IAAI,IAAI;CAO3B;AAGD,0DAA0D;AAC1D,eAAO,MAAM,UAAU,GAAI,MAAM,QAAQ,EAAE,MAAM,MAAM,KAAG,SACrB,CAAC;AAKtC;;;;;;GAMG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAsB/D;AAGD;;;;;;GAMG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,GAAG,UAAU,CASrE;AAGD,0EAA0E;AAC1E,wBAAgB,eAAe,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,GAAG;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,UAAU,CAAA;CAAE,CAevG;AAGD,oFAAoF;AACpF,wBAAgB,UAAU,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAahE;AAGD;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAoDxE;AAGD,2EAA2E;AAC3E,wBAAgB,SAAS,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CA2B9D;AAkCD;;;;;;;GAOG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAmC1D"}

package/dist/cbor.d.ts

@@ -0,0 +1,65 @@
+/**
+ * The one seam between this COSE implementation and a CBOR codec.
+ *
+ * COSE is a thin layer over CBOR, and everything delicate about it is a
+ * question of exact bytes: what a signature covers, whether an empty protected
+ * bucket is `h''` or `h'A0'`, whether a map keeps the order it arrived in.
+ * Keeping the codec behind a single module means those questions are answered
+ * in one place — and it means where the codec comes from is one line rather
+ * than a hundred imports.
+ *
+ * That line names the published `@vanaheimr/metrological-cbor`, an ordinary
+ * dependency pinned by the lock file. It was a sibling checkout until the
+ * codec's first release; the one arrangement that still builds both sides
+ * from source is the cross-signing conformance suite, whose job is exactly
+ * that — what it signs has to be what the codec produces *today* — and which
+ * has its own repository and its own checkout layout for it. Here, drift
+ * arrives the way it does for every consumer: as a release, which the nightly
+ * installs the day it appears.
+ *
+ * The codec is the one from Metrological CBOR, which is a deterministic
+ * encoder by default — and that default is wrong here. A COSE message is
+ * somebody else's bytes: its header maps are in the order the signer wrote
+ * them, and re-sorting them on the way out would invalidate signatures this
+ * implementation never touched. Every encode below therefore passes
+ * `PRESERVE`, and the one place that does not is the RFC 9679 thumbprint,
+ * where deterministic encoding is what the specification asks for.
+ */
+export { cbor } from '@vanaheimr/metrological-cbor';
+export type { CborValue } from '@vanaheimr/metrological-cbor';
+import type { CborValue } from '@vanaheimr/metrological-cbor';
+/** One entry of a CBOR map. */
+export type CborEntry = readonly [CborValue, CborValue];
+/**
+ * Encoder options for reproducing foreign bytes: no sorting, no float
+ * re-widening. What was read is what is written.
+ */
+export declare const PRESERVE: {
+    readonly mapKeys: "preserve";
+    readonly floats: "preserve";
+};
+/**
+ * Encoder options for the deterministic encoding of RFC 8949 Section 4.2.1,
+ * which RFC 9679 requires for a COSE Key Thumbprint.
+ */
+export declare const DETERMINISTIC: {
+    readonly mapKeys: "sorted";
+    readonly floats: "shortest";
+};
+/** Encode a value as the bytes of a COSE message or structure. */
+export declare const encode: (value: CborValue) => Uint8Array;
+/**
+ * Decode the bytes of a COSE message.
+ *
+ * Deliberately not in strict mode: a COSE message arrives from the wire and
+ * has to be read as it is. Rejecting a message because its unprotected bucket
+ * is not in deterministic order would refuse messages that are perfectly valid
+ * COSE — and would refuse them *after* the signature over the protected part
+ * would have verified.
+ */
+export declare const decode: (data: Uint8Array) => CborValue;
+/** Whether two byte strings are equal. */
+export declare function bytesEqual(left: Uint8Array, right: Uint8Array): boolean;
+/** The empty byte string, which COSE uses rather more often than one expects. */
+export declare const NO_BYTES: Uint8Array<ArrayBuffer>;
+//# sourceMappingURL=cbor.d.ts.map

package/dist/cbor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cbor.d.ts","sourceRoot":"","sources":["../src/cbor.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,EAAE,IAAI,EAAE,MAAa,8BAA8B,CAAC;AAC3D,YAAY,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAG9D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAC;AAG9D,+BAA+B;AAC/B,MAAM,MAAM,SAAS,GAAG,SAAS,CAAC,SAAS,EAAE,SAAS,CAAC,CAAC;AAGxD;;;GAGG;AACH,eAAO,MAAM,QAAQ;;;CAAuD,CAAC;AAG7E;;;GAGG;AACH,eAAO,MAAM,aAAa;;;CAAqD,CAAC;AAGhF,kEAAkE;AAClE,eAAO,MAAM,MAAM,GAAI,OAAO,SAAS,KAAG,UACV,CAAC;AAGjC;;;;;;;;GAQG;AACH,eAAO,MAAM,MAAM,GAAI,MAAM,UAAU,KAAG,SACF,CAAC;AAGzC,0CAA0C;AAC1C,wBAAgB,UAAU,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,GAAG,OAAO,CAYvE;AAGD,iFAAiF;AACjF,eAAO,MAAM,QAAQ,yBAAmB,CAAC"}

package/dist/curve.d.ts

@@ -0,0 +1,65 @@
+/**
+ * The COSE elliptic curve registry [IANA, "COSE Elliptic Curves"].
+ *
+ * Two widths are recorded per curve and they are kept apart on purpose: the
+ * *field* size is the width of a coordinate, the *order* size is the width of
+ * a private key and of each half of an ECDSA signature. They coincide for
+ * every curve in this registry, and they are still two different quantities —
+ * a curve where they differ would silently produce keys other implementations
+ * reject.
+ *
+ * P-521 is 66 bytes, not 64 and not 65. Its field is 521 bits wide, which is
+ * 65 bytes and one bit.
+ */
+/** A curve in the COSE registry. */
+export interface CoseCurve {
+    /** The IANA identifier, as it travels in a COSE key. */
+    readonly id: number;
+    /** The registered name, e.g. `P-256`. Case sensitive. */
+    readonly name: string;
+    /** The key type this curve belongs to: 2 = EC2, 1 = OKP. */
+    readonly keyType: number;
+    /**
+     * On an EC2 curve, the width of one coordinate. On an OKP curve, the width
+     * of the public key, which is the whole of `x` — there is no `y`.
+     */
+    readonly fieldSize: number | null;
+    /**
+     * On an EC2 curve, the width of a private key and of each half of a
+     * signature. On an OKP curve, the width of the private key.
+     *
+     * Ed448 is 57 bytes and not 56: RFC 8032 appends a sign bit to the 456-bit
+     * encoding, which costs a whole further octet.
+     */
+    readonly orderSize: number | null;
+}
+/** Key type 2, elliptic curve keys with x and y coordinates [RFC 9052, Section 7]. */
+export declare const KEY_TYPE_EC2 = 2;
+/** Key type 1, octet key pairs [RFC 9052, Section 7]. */
+export declare const KEY_TYPE_OKP = 1;
+/** The curves this implementation knows by name. */
+export declare const CoseCurves: {
+    readonly P256: CoseCurve;
+    readonly P384: CoseCurve;
+    readonly P521: CoseCurve;
+    readonly X25519: CoseCurve;
+    readonly X448: CoseCurve;
+    readonly Ed25519: CoseCurve;
+    readonly Ed448: CoseCurve;
+    readonly secp256k1: CoseCurve;
+    readonly brainpoolP256r1: CoseCurve;
+    readonly brainpoolP320r1: CoseCurve;
+    readonly brainpoolP384r1: CoseCurve;
+    readonly brainpoolP512r1: CoseCurve;
+};
+/** Every registered curve, in registry order. */
+export declare const ALL_CURVES: readonly CoseCurve[];
+/** The curve with the given identifier, or null when it is not registered. */
+export declare function curveById(id: number): CoseCurve | null;
+/**
+ * The curve with the given name, or null.
+ *
+ * Case sensitive, like the registry: `p-256` is not `P-256`.
+ */
+export declare function curveByName(name: string): CoseCurve | null;
+//# sourceMappingURL=curve.d.ts.map

package/dist/curve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"curve.d.ts","sourceRoot":"","sources":["../src/curve.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;GAYG;AAGH,oCAAoC;AACpC,MAAM,WAAW,SAAS;IAEtB,wDAAwD;IACxD,QAAQ,CAAC,EAAE,EAAW,MAAM,CAAC;IAE7B,yDAAyD;IACzD,QAAQ,CAAC,IAAI,EAAS,MAAM,CAAC;IAE7B,4DAA4D;IAC5D,QAAQ,CAAC,OAAO,EAAM,MAAM,CAAC;IAE7B;;;OAGG;IACH,QAAQ,CAAC,SAAS,EAAI,MAAM,GAAG,IAAI,CAAC;IAEpC;;;;;;OAMG;IACH,QAAQ,CAAC,SAAS,EAAI,MAAM,GAAG,IAAI,CAAC;CAEvC;AAQD,sFAAsF;AACtF,eAAO,MAAM,YAAY,IAAI,CAAC;AAE9B,yDAAyD;AACzD,eAAO,MAAM,YAAY,IAAI,CAAC;AAG9B,oDAAoD;AACpD,eAAO,MAAM,UAAU;;;;;;;;;;;;;CAoBb,CAAC;AAGX,iDAAiD;AACjD,eAAO,MAAM,UAAU,EAAE,SAAS,SAAS,EAA8B,CAAC;AAG1E,8EAA8E;AAC9E,wBAAgB,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAEtD;AAGD;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAE1D"}

package/dist/ecdsa.d.ts

@@ -0,0 +1,56 @@
+import type { CHash } from '@noble/hashes/utils.js';
+import type { CoseCurve } from './curve.ts';
+/** The digest algorithms COSE signature algorithms use. */
+export type DigestAlgorithm = 'sha256' | 'sha384' | 'sha512';
+/** The implementation behind each digest name — shared with the HMAC in `hmac.ts`. */
+export declare const HASHES: Record<DigestAlgorithm, CHash>;
+/** Whether this build can sign and verify on the given curve. */
+export declare const isImplemented: (curve: CoseCurve) => boolean;
+/** The message digest an algorithm signs over. */
+export declare const digest: (algorithm: DigestAlgorithm, data: Uint8Array) => Uint8Array;
+/**
+ * Sign the given digest, returning the COSE wire form `r ‖ s`.
+ *
+ * `prehash: false` says the input already *is* the digest — the caller hashed
+ * the Sig_structure, because which digest to use is a property of the COSE
+ * algorithm rather than of the curve.
+ *
+ * `lowS: false` is the load-bearing one. The underlying library normalizes `s`
+ * to its low form by default, and COSE does not: RFC 6979 publishes the
+ * un-normalized values, and so does every implementation that follows it. With
+ * normalization on, this library would produce signatures that verify
+ * everywhere and are nevertheless *different bytes* from the ones the C#
+ * reference implementation produces for the same key and the same message —
+ * which would quietly destroy the one property that makes a deterministic
+ * signature worth having.
+ */
+export declare function sign(curve: CoseCurve, messageHash: Uint8Array, privateKey: Uint8Array): Uint8Array;
+/**
+ * Verify a `r ‖ s` signature over the given digest.
+ *
+ * A signature of the wrong width is refused before it reaches the curve, with
+ * an error that names the likely cause: nearly every such signature is a DER
+ * encoding that was never converted.
+ */
+export declare function verify(curve: CoseCurve, signature: Uint8Array, messageHash: Uint8Array, publicKey: Uint8Array): boolean;
+/**
+ * The uncompressed public key `04 ‖ x ‖ y` belonging to a private key.
+ */
+export declare function publicKeyFor(curve: CoseCurve, privateKey: Uint8Array): Uint8Array;
+/**
+ * Recover the y coordinate of a point from its x coordinate and the parity of
+ * its y [RFC 9052, Section 7.1.1].
+ *
+ * A COSE key may carry `y` as a boolean rather than as a byte string, which
+ * halves the size of the key. There are two points with any given x, and the
+ * boolean says which of the two: the sign bit is the parity of y.
+ */
+export declare function decompressY(curve: CoseCurve, x: Uint8Array, oddY: boolean): Uint8Array;
+/**
+ * Whether the point `04 ‖ x ‖ y` lies on the curve.
+ *
+ * A public key that does not is not merely useless: handing one to a
+ * verification is how invalid-curve attacks start.
+ */
+export declare function isOnCurve(curve: CoseCurve, uncompressed: Uint8Array): boolean;
+//# sourceMappingURL=ecdsa.d.ts.map

package/dist/ecdsa.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ecdsa.d.ts","sourceRoot":"","sources":["../src/ecdsa.ts"],"names":[],"mappings":"AAmCA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAwC,wBAAwB,CAAC;AAOtF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAoC,YAAY,CAAC;AAkC1E,2DAA2D;AAC3D,MAAM,MAAM,eAAe,GAAG,QAAQ,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAE7D,sFAAsF;AACtF,eAAO,MAAM,MAAM,EAAE,MAAM,CAAC,eAAe,EAAE,KAAK,CAA8B,CAAC;AAgCjF,iEAAiE;AACjE,eAAO,MAAM,aAAa,GAAI,OAAO,SAAS,KAAG,OACpB,CAAC;AAe9B,kDAAkD;AAClD,eAAO,MAAM,MAAM,GAAI,WAAW,eAAe,EAAE,MAAM,UAAU,KAAG,UAC3C,CAAC;AAG5B;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,IAAI,CAAC,KAAK,EAAO,SAAS,EACrB,WAAW,EAAE,UAAU,EACvB,UAAU,EAAG,UAAU,GAAG,UAAU,CAKxD;AAGD;;;;;;GAMG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAQ,SAAS,EACtB,SAAS,EAAI,UAAU,EACvB,WAAW,EAAE,UAAU,EACvB,SAAS,EAAI,UAAU,GAAG,OAAO,CAiBvD;AAGD;;GAEG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,UAAU,GAAG,UAAU,CAEjF;AAGD;;;;;;;GAOG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,SAAS,EAAE,CAAC,EAAE,UAAU,EAAE,IAAI,EAAE,OAAO,GAAG,UAAU,CAYtF;AAGD;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,UAAU,GAAG,OAAO,CAU7E"}

package/dist/eddsa.d.ts

@@ -0,0 +1,14 @@
+import type { CoseCurve } from './curve.ts';
+/** Whether this build can sign and verify on the given EdDSA curve. */
+export declare const isEddsaCurve: (curve: CoseCurve) => boolean;
+/** The signature width of an EdDSA curve, in bytes. */
+export declare function eddsaSignatureSize(curve: CoseCurve): number;
+/**
+ * Sign the Sig_structure itself — not a digest of it.
+ */
+export declare function eddsaSign(curve: CoseCurve, message: Uint8Array, privateKey: Uint8Array): Uint8Array;
+/** Verify an EdDSA signature over the Sig_structure. */
+export declare function eddsaVerify(curve: CoseCurve, signature: Uint8Array, message: Uint8Array, publicKey: Uint8Array): boolean;
+/** The public key belonging to an EdDSA private key. */
+export declare function eddsaPublicKeyFor(curve: CoseCurve, privateKey: Uint8Array): Uint8Array;
+//# sourceMappingURL=eddsa.d.ts.map

package/dist/eddsa.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eddsa.d.ts","sourceRoot":"","sources":["../src/eddsa.ts"],"names":[],"mappings":"AA8BA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAc,YAAY,CAAC;AAkBpD,uEAAuE;AACvE,eAAO,MAAM,YAAY,GAAI,OAAO,SAAS,KAAG,OACnB,CAAC;AAe9B,uDAAuD;AACvD,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,SAAS,GAAG,MAAM,CAO3D;AAGD;;GAEG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAO,SAAS,EACrB,OAAO,EAAK,UAAU,EACtB,UAAU,EAAE,UAAU,GAAG,UAAU,CAI5D;AAGD,wDAAwD;AACxD,wBAAgB,WAAW,CAAC,KAAK,EAAM,SAAS,EACpB,SAAS,EAAE,UAAU,EACrB,OAAO,EAAI,UAAU,EACrB,SAAS,EAAE,UAAU,GAAG,OAAO,CAgB1D;AAGD,wDAAwD;AACxD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,UAAU,GAAG,UAAU,CAEtF"}

package/dist/encrypt.d.ts

@@ -0,0 +1,140 @@
+import type { CoseAlgorithm } from './algorithm.ts';
+import type { CborValue } from './cbor.ts';
+import type { Decryption } 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_Encrypt0 message. */
+export declare const COSE_ENCRYPT0_TAG = 16;
+/** The CBOR tag of a COSE_Encrypt message. */
+export declare const COSE_ENCRYPT_TAG = 96;
+/** The context string of a COSE_Encrypt0 [RFC 9052, Section 5.3]. */
+export declare const ENCRYPT0_CONTEXT = "Encrypt0";
+/** The context string of the body of a COSE_Encrypt. */
+export declare const ENCRYPT_CONTEXT = "Encrypt";
+/**
+ * The encoded `Enc_structure` [RFC 9052, Section 5.3]:
+ *
+ * ```
+ * Enc_structure = [ context, protected : empty_or_serialized_map, external_aad : bstr ]
+ * ```
+ */
+export declare function encStructure(context: string, protectedHeaderBytes: Uint8Array, externalAad?: Uint8Array | null): Uint8Array;
+/** What a party encrypting may choose. */
+export interface EncryptOptions {
+    /**
+     * The nonce, which is required.
+     *
+     * There is no default and there will not be one. A nonce reused with the
+     * same key breaks AES-GCM outright, and this package has no way of knowing
+     * which nonces a caller has already spent.
+     */
+    readonly iv: Uint8Array;
+    /** 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 ciphertext from the message. */
+    readonly detachPayload?: boolean;
+    /** Whether to wrap the message within its CBOR tag. Defaults to true. */
+    readonly tagged?: boolean;
+}
+/** What a party decrypting may have to supply. */
+export interface DecryptOptions {
+    /** The data that was authenticated along with the payload. */
+    readonly externalAad?: Uint8Array | null;
+    /** The ciphertext, when the message carries a detached one. */
+    readonly detachedCiphertext?: Uint8Array | null;
+    /** The algorithm the caller expects. */
+    readonly expectedAlgorithm?: CoseAlgorithm | null;
+    /** Header parameters the caller processes itself. */
+    readonly alsoUnderstood?: readonly CborValue[];
+}
+/** Everything the two encrypted structures share. */
+declare abstract class CoseEncryptedBase {
+    /** The serialized protected bucket, exactly as authenticated and received. */
+    readonly protectedHeaderBytes: Uint8Array;
+    /** The protected header parameters, which the AEAD tag covers. */
+    readonly protectedHeader: CoseHeaders;
+    /** The unprotected header parameters, which it does not. */
+    readonly unprotectedHeader: CoseHeaders;
+    /** The ciphertext with the AEAD tag appended, or null when detached. */
+    readonly ciphertext: Uint8Array | null;
+    /** Whether this message is wrapped within its CBOR tag. */
+    readonly isTagged: boolean;
+    protected constructor(protectedHeaderBytes: Uint8Array, unprotectedHeader: CoseHeaders | null, ciphertext: Uint8Array | null, isTagged: boolean);
+    /** The content encryption algorithm, protected bucket first. */
+    get algorithm(): CoseAlgorithm | null;
+    /** The key identifier, protected bucket first. */
+    get keyIdentifier(): Uint8Array | null;
+    /** The nonce, from either bucket. It travels in the clear and must never repeat. */
+    get iv(): Uint8Array | null;
+    /** Whether the ciphertext is detached. */
+    get isDetached(): boolean;
+    /**
+     * Decrypt with a content encryption key that has already been established.
+     *
+     * The shared half of both structures: `COSE_Encrypt0` uses it with the key
+     * the caller passed, `COSE_Encrypt` with the one a recipient yielded.
+     */
+    protected decryptWith(contentKey: Uint8Array, context: string, options: DecryptOptions): Decryption;
+}
+/**
+ * A COSE_Encrypt0 message: encrypted for a recipient who already holds the key.
+ */
+export declare class CoseEncrypt0 extends CoseEncryptedBase {
+    constructor(protectedHeaderBytes: Uint8Array, unprotectedHeader: CoseHeaders | null, ciphertext: Uint8Array | null, isTagged?: boolean);
+    /** The encoded Enc_structure of this message. */
+    toBeEncrypted(externalAad?: Uint8Array | null): Uint8Array;
+    /** Encrypt a payload, with the algorithm in the protected bucket. */
+    static encrypt(plaintext: Uint8Array, key: CoseKey, options: EncryptOptions): CoseEncrypt0;
+    /** Encrypt a payload with header buckets the caller composed. */
+    static encryptWithHeaders(plaintext: Uint8Array, key: CoseKey, protectedHeader: CoseHeaders, unprotectedHeader: CoseHeaders | null, options: EncryptOptions): CoseEncrypt0;
+    /** Decrypt this message with the key it was encrypted for. */
+    decrypt(key: CoseKey, options?: DecryptOptions): Decryption;
+    /** Read a COSE_Encrypt0 message, tagged or not. */
+    static parse(input: Uint8Array | CborValue): CoseEncrypt0;
+    /** The CBOR form of this message. */
+    toCbor(): CborValue;
+    /** The CBOR encoding of this message. */
+    toBytes(): Uint8Array;
+    toString(): string;
+}
+/**
+ * A COSE_Encrypt message: encrypted once, with the content key delivered to
+ * each recipient in a structure of its own.
+ */
+export declare class CoseEncrypt extends CoseEncryptedBase {
+    /** How the content key reaches each party. */
+    readonly recipients: readonly CoseRecipient[];
+    constructor(protectedHeaderBytes: Uint8Array, unprotectedHeader: CoseHeaders | null, ciphertext: Uint8Array | null, recipients: readonly CoseRecipient[], isTagged?: boolean);
+    /** The encoded Enc_structure of this message. */
+    toBeEncrypted(externalAad?: Uint8Array | null): Uint8Array;
+    /**
+     * Encrypt a payload under a content key, and deliver that key to each
+     * recipient.
+     *
+     * The content key is the caller's, not this method's, for the same reason
+     * the nonce is: generating one here would make the message
+     * unreproducible, and a caller who has a key management scheme has one for
+     * a reason.
+     */
+    static encrypt(plaintext: Uint8Array, contentKey: CoseKey, recipients: readonly CoseRecipient[], options: EncryptOptions): CoseEncrypt;
+    /**
+     * Decrypt 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. A recipient that does
+     * not yield a key is not an error — it is somebody else's.
+     */
+    decrypt(key: CoseKey, options?: DecryptOptions): Decryption;
+    /** Read a COSE_Encrypt message, tagged or not. */
+    static parse(input: Uint8Array | CborValue): CoseEncrypt;
+    /** The CBOR form of this message. */
+    toCbor(): CborValue;
+    /** The CBOR encoding of this message. */
+    toBytes(): Uint8Array;
+    toString(): string;
+}
+export {};
+//# sourceMappingURL=encrypt.d.ts.map

package/dist/encrypt.d.ts.map

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