@sebastienrousseau/crypto-lib 0.0.2 → 0.0.8

package/dist/streaming/web-streams.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WEB_STREAM_HASH_ALGORITHMS = void 0;
+exports.createEncryptStream = createEncryptStream;
+exports.createDecryptStream = createDecryptStream;
+exports.createHashStream = createHashStream;
+const chacha_js_1 = require("@noble/ciphers/chacha.js");
+const utils_js_1 = require("@noble/ciphers/utils.js");
+const sha2_js_1 = require("@noble/hashes/sha2.js");
+const sha3_js_1 = require("@noble/hashes/sha3.js");
+const blake3_js_1 = require("@noble/hashes/blake3.js");
+const TS = globalThis
+    .TransformStream;
+const NONCE_LEN = 24;
+exports.WEB_STREAM_HASH_ALGORITHMS = [
+    "sha256",
+    "sha512",
+    "sha3-256",
+    "sha3-512",
+    "blake3",
+];
+const HEX_RE = /^[0-9a-fA-F]*$/;
+function toKey(key) {
+    if (key instanceof Uint8Array) {
+        if (key.length !== 32) {
+            throw new Error(`Key must be 32 bytes, got ${key.length}`);
+        }
+        return key;
+    }
+    if (!HEX_RE.test(key))
+        throw new Error("Invalid hex key");
+    const buf = Buffer.from(key, "hex");
+    if (buf.length !== 32) {
+        throw new Error(`Key must be 32 bytes (256 bits), got ${buf.length}`);
+    }
+    return buf;
+}
+const hashFactories = {
+    sha256: () => sha2_js_1.sha256.create(),
+    sha512: () => sha2_js_1.sha512.create(),
+    "sha3-256": () => sha3_js_1.sha3_256.create(),
+    "sha3-512": () => sha3_js_1.sha3_512.create(),
+    blake3: () => blake3_js_1.blake3.create(),
+};
+function createEncryptStream(options) {
+    const keyBytes = toKey(options.key);
+    const chunks = [];
+    let totalLen = 0;
+    return new TS({
+        transform(chunk) {
+            chunks.push(chunk);
+            totalLen += chunk.length;
+        },
+        flush(controller) {
+            const plaintext = new Uint8Array(totalLen);
+            let offset = 0;
+            for (const c of chunks) {
+                plaintext.set(c, offset);
+                offset += c.length;
+            }
+            const nonce = (0, utils_js_1.randomBytes)(NONCE_LEN);
+            const cipher = (0, chacha_js_1.xchacha20poly1305)(keyBytes, nonce);
+            const encrypted = cipher.encrypt(plaintext);
+            const output = new Uint8Array(NONCE_LEN + encrypted.length);
+            output.set(nonce, 0);
+            output.set(encrypted, NONCE_LEN);
+            controller.enqueue(output);
+        },
+    });
+}
+function createDecryptStream(options) {
+    const keyBytes = toKey(options.key);
+    const chunks = [];
+    let totalLen = 0;
+    return new TS({
+        transform(chunk) {
+            chunks.push(chunk);
+            totalLen += chunk.length;
+        },
+        flush(controller) {
+            const ciphertext = new Uint8Array(totalLen);
+            let offset = 0;
+            for (const c of chunks) {
+                ciphertext.set(c, offset);
+                offset += c.length;
+            }
+            if (ciphertext.length < NONCE_LEN + 16) {
+                throw new Error("Ciphertext too short — missing nonce or auth tag");
+            }
+            const nonce = ciphertext.subarray(0, NONCE_LEN);
+            const encrypted = ciphertext.subarray(NONCE_LEN);
+            const cipher = (0, chacha_js_1.xchacha20poly1305)(keyBytes, nonce);
+            const plaintext = cipher.decrypt(encrypted);
+            controller.enqueue(plaintext);
+        },
+    });
+}
+function createHashStream(algorithm) {
+    const factory = hashFactories[algorithm];
+    if (!factory) {
+        throw new Error(`Unsupported hash algorithm: ${algorithm}`);
+    }
+    const hasher = factory();
+    return new TS({
+        transform(chunk) {
+            hasher.update(chunk);
+        },
+        flush(controller) {
+            const digest = Buffer.from(hasher.digest()).toString("hex");
+            controller.enqueue({ digest, algorithm });
+        },
+    });
+}
+//# sourceMappingURL=web-streams.js.map

package/dist/tokens/index.d.ts

@@ -0,0 +1,5 @@
+export { v4local, v4public, pae } from "./paseto";
+export type { PasetoLocalEncryptOptions, PasetoLocalDecryptOptions, PasetoPublicSignOptions, PasetoPublicVerifyOptions, PasetoToken, PasetoPayload, } from "./paseto";
+export { createKeyRing, rotateKey, findKeyByVersion, pruneExpiredKeys, encryptWithVersion, decryptWithVersion, } from "./key-rotation";
+export type { VersionedKey, KeyRing } from "./key-rotation";
+//# sourceMappingURL=index.d.ts.map

package/dist/tokens/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tokens/index.ts"],"names":[],"mappings":"AAcA,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAElD,YAAY,EACV,yBAAyB,EACzB,yBAAyB,EACzB,uBAAuB,EACvB,yBAAyB,EACzB,WAAW,EACX,aAAa,GACd,MAAM,UAAU,CAAC;AAElB,OAAO,EACL,aAAa,EACb,SAAS,EACT,gBAAgB,EAChB,gBAAgB,EAChB,kBAAkB,EAClB,kBAAkB,GACnB,MAAM,gBAAgB,CAAC;AAExB,YAAY,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/tokens/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decryptWithVersion = exports.encryptWithVersion = exports.pruneExpiredKeys = exports.findKeyByVersion = exports.rotateKey = exports.createKeyRing = exports.pae = exports.v4public = exports.v4local = void 0;
+var paseto_1 = require("./paseto");
+Object.defineProperty(exports, "v4local", { enumerable: true, get: function () { return paseto_1.v4local; } });
+Object.defineProperty(exports, "v4public", { enumerable: true, get: function () { return paseto_1.v4public; } });
+Object.defineProperty(exports, "pae", { enumerable: true, get: function () { return paseto_1.pae; } });
+var key_rotation_1 = require("./key-rotation");
+Object.defineProperty(exports, "createKeyRing", { enumerable: true, get: function () { return key_rotation_1.createKeyRing; } });
+Object.defineProperty(exports, "rotateKey", { enumerable: true, get: function () { return key_rotation_1.rotateKey; } });
+Object.defineProperty(exports, "findKeyByVersion", { enumerable: true, get: function () { return key_rotation_1.findKeyByVersion; } });
+Object.defineProperty(exports, "pruneExpiredKeys", { enumerable: true, get: function () { return key_rotation_1.pruneExpiredKeys; } });
+Object.defineProperty(exports, "encryptWithVersion", { enumerable: true, get: function () { return key_rotation_1.encryptWithVersion; } });
+Object.defineProperty(exports, "decryptWithVersion", { enumerable: true, get: function () { return key_rotation_1.decryptWithVersion; } });
+//# sourceMappingURL=index.js.map

package/dist/tokens/key-rotation.d.ts

@@ -0,0 +1,20 @@
+export interface VersionedKey {
+    version: string;
+    key: string;
+    activatedAt: Date;
+    expiresAt?: Date;
+}
+export interface KeyRing {
+    current: VersionedKey;
+    previous: VersionedKey[];
+}
+export declare function createKeyRing(current: VersionedKey): KeyRing;
+export declare function rotateKey(ring: KeyRing, newKey: VersionedKey): KeyRing;
+export declare function findKeyByVersion(ring: KeyRing, version: string): VersionedKey | undefined;
+export declare function pruneExpiredKeys(ring: KeyRing, now?: Date): KeyRing;
+export declare function encryptWithVersion(ring: KeyRing, plaintext: string): {
+    ciphertext: string;
+    version: string;
+};
+export declare function decryptWithVersion(ring: KeyRing, ciphertext: string, version: string): string;
+//# sourceMappingURL=key-rotation.d.ts.map

package/dist/tokens/key-rotation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"key-rotation.d.ts","sourceRoot":"","sources":["../../src/tokens/key-rotation.ts"],"names":[],"mappings":"AA8BA,MAAM,WAAW,YAAY;IAE3B,OAAO,EAAE,MAAM,CAAC;IAEhB,GAAG,EAAE,MAAM,CAAC;IAEZ,WAAW,EAAE,IAAI,CAAC;IAElB,SAAS,CAAC,EAAE,IAAI,CAAC;CAClB;AAMD,MAAM,WAAW,OAAO;IAEtB,OAAO,EAAE,YAAY,CAAC;IAEtB,QAAQ,EAAE,YAAY,EAAE,CAAC;CAC1B;AAaD,wBAAgB,aAAa,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAE5D;AAeD,wBAAgB,SAAS,CAAC,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,GAAG,OAAO,CAKtE;AAcD,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,OAAO,EACb,OAAO,EAAE,MAAM,GACd,YAAY,GAAG,SAAS,CAG1B;AAiBD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,OAAO,EAAE,GAAG,CAAC,EAAE,IAAI,GAAG,OAAO,CAMnE;AAeD,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,OAAO,EACb,SAAS,EAAE,MAAM,GAChB;IAED,UAAU,EAAE,MAAM,CAAC;IAEnB,OAAO,EAAE,MAAM,CAAC;CACjB,CAGA;AAgBD,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,OAAO,EACb,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,GACd,MAAM,CAOR"}

package/dist/tokens/key-rotation.js

@@ -0,0 +1,76 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createKeyRing = createKeyRing;
+exports.rotateKey = rotateKey;
+exports.findKeyByVersion = findKeyByVersion;
+exports.pruneExpiredKeys = pruneExpiredKeys;
+exports.encryptWithVersion = encryptWithVersion;
+exports.decryptWithVersion = decryptWithVersion;
+const secretbox = __importStar(require("../high-level/secretbox"));
+function createKeyRing(current) {
+    return { current, previous: [] };
+}
+function rotateKey(ring, newKey) {
+    return {
+        current: newKey,
+        previous: [...ring.previous, ring.current],
+    };
+}
+function findKeyByVersion(ring, version) {
+    if (ring.current.version === version)
+        return ring.current;
+    return ring.previous.find((k) => k.version === version);
+}
+function pruneExpiredKeys(ring, now) {
+    const ref = now ?? new Date();
+    return {
+        current: ring.current,
+        previous: ring.previous.filter((k) => !k.expiresAt || k.expiresAt > ref),
+    };
+}
+function encryptWithVersion(ring, plaintext) {
+    const { sealed } = secretbox.seal(ring.current.key, plaintext);
+    return { ciphertext: sealed, version: ring.current.version };
+}
+function decryptWithVersion(ring, ciphertext, version) {
+    const vk = findKeyByVersion(ring, version);
+    if (!vk) {
+        throw new Error(`Key version "${version}" not found in key ring`);
+    }
+    const pt = secretbox.open(vk.key, ciphertext);
+    return Buffer.from(pt).toString("utf8");
+}
+//# sourceMappingURL=key-rotation.js.map

package/dist/tokens/paseto.d.ts

@@ -0,0 +1,46 @@
+export interface PasetoLocalEncryptOptions {
+    key: string;
+    payload: Record<string, unknown>;
+    footer?: string;
+    implicit?: string;
+}
+export interface PasetoLocalDecryptOptions {
+    key: string;
+    token: string;
+    footer?: string;
+    implicit?: string;
+}
+export interface PasetoPublicSignOptions {
+    secretKey: string;
+    payload: Record<string, unknown>;
+    footer?: string;
+    implicit?: string;
+}
+export interface PasetoPublicVerifyOptions {
+    publicKey: string;
+    token: string;
+    footer?: string;
+    implicit?: string;
+}
+export interface PasetoToken {
+    token: string;
+}
+export interface PasetoPayload {
+    payload: Record<string, unknown>;
+    footer?: string;
+}
+export declare function pae(...pieces: Uint8Array[]): Uint8Array;
+declare function localEncrypt(opts: PasetoLocalEncryptOptions): PasetoToken;
+declare function localDecrypt(opts: PasetoLocalDecryptOptions): PasetoPayload;
+declare function publicSign(opts: PasetoPublicSignOptions): PasetoToken;
+declare function publicVerify(opts: PasetoPublicVerifyOptions): PasetoPayload;
+export declare const v4local: {
+    readonly encrypt: typeof localEncrypt;
+    readonly decrypt: typeof localDecrypt;
+};
+export declare const v4public: {
+    readonly sign: typeof publicSign;
+    readonly verify: typeof publicVerify;
+};
+export {};
+//# sourceMappingURL=paseto.d.ts.map

package/dist/tokens/paseto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paseto.d.ts","sourceRoot":"","sources":["../../src/tokens/paseto.ts"],"names":[],"mappings":"AAqDA,MAAM,WAAW,yBAAyB;IAExC,GAAG,EAAE,MAAM,CAAC;IAEZ,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAEjC,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAGD,MAAM,WAAW,yBAAyB;IAExC,GAAG,EAAE,MAAM,CAAC;IAEZ,KAAK,EAAE,MAAM,CAAC;IAEd,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAGD,MAAM,WAAW,uBAAuB;IAEtC,SAAS,EAAE,MAAM,CAAC;IAElB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAEjC,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAGD,MAAM,WAAW,yBAAyB;IAExC,SAAS,EAAE,MAAM,CAAC;IAElB,KAAK,EAAE,MAAM,CAAC;IAEd,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAGD,MAAM,WAAW,WAAW;IAE1B,KAAK,EAAE,MAAM,CAAC;CACf;AAGD,MAAM,WAAW,aAAa;IAE5B,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAEjC,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAkBD,wBAAgB,GAAG,CAAC,GAAG,MAAM,EAAE,UAAU,EAAE,GAAG,UAAU,CAoBvD;AAoCD,iBAAS,YAAY,CAAC,IAAI,EAAE,yBAAyB,GAAG,WAAW,CA+ClE;AAeD,iBAAS,YAAY,CAAC,IAAI,EAAE,yBAAyB,GAAG,aAAa,CA4DpE;AAiBD,iBAAS,UAAU,CAAC,IAAI,EAAE,uBAAuB,GAAG,WAAW,CA8B9D;AAcD,iBAAS,YAAY,CAAC,IAAI,EAAE,yBAAyB,GAAG,aAAa,CAkDpE;AAaD,eAAO,MAAM,OAAO;;;CAKV,CAAC;AAWX,eAAO,MAAM,QAAQ;;;CAKX,CAAC"}

package/dist/tokens/paseto.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.v4public = exports.v4local = void 0;
+exports.pae = pae;
+const chacha_js_1 = require("@noble/ciphers/chacha.js");
+const utils_js_1 = require("@noble/ciphers/utils.js");
+const ed25519_js_1 = require("@noble/curves/ed25519.js");
+const blake2_js_1 = require("@noble/hashes/blake2.js");
+const V4_LOCAL_HEADER = "v4.local.";
+const V4_PUBLIC_HEADER = "v4.public.";
+const NONCE_LEN = 32;
+const EK_LEN = 32;
+const N3_LEN = 24;
+const SIG_LEN = 64;
+const HEX_RE = /^[0-9a-fA-F]*$/;
+function pae(...pieces) {
+    const le64 = (n) => {
+        const buf = new Uint8Array(8);
+        const view = new DataView(buf.buffer);
+        view.setBigUint64(0, BigInt(n), true);
+        return buf;
+    };
+    const parts = [le64(pieces.length)];
+    for (const p of pieces) {
+        parts.push(le64(p.length));
+        parts.push(p);
+    }
+    const total = parts.reduce((s, p) => s + p.length, 0);
+    const result = new Uint8Array(total);
+    let offset = 0;
+    for (const p of parts) {
+        result.set(p, offset);
+        offset += p.length;
+    }
+    return result;
+}
+function hexToBytes(hex) {
+    if (!HEX_RE.test(hex))
+        throw new Error("Invalid hex string");
+    return Buffer.from(hex, "hex");
+}
+function toBase64url(buf) {
+    return Buffer.from(buf).toString("base64url");
+}
+function fromBase64url(s) {
+    const padded = s.replace(/-/g, "+").replace(/_/g, "/");
+    return Buffer.from(padded, "base64");
+}
+const encoder = new TextEncoder();
+function localEncrypt(opts) {
+    const { key, payload, footer = "", implicit = "" } = opts;
+    const keyBytes = hexToBytes(key);
+    if (keyBytes.length !== 32) {
+        throw new Error(`Key must be 32 bytes, got ${keyBytes.length}`);
+    }
+    const header = encoder.encode(V4_LOCAL_HEADER);
+    const message = encoder.encode(JSON.stringify(payload));
+    const footerBytes = encoder.encode(footer);
+    const implicitBytes = encoder.encode(implicit);
+    const randomN = (0, utils_js_1.randomBytes)(NONCE_LEN);
+    const nonce = (0, blake2_js_1.blake2b)(message, { key: randomN, dkLen: NONCE_LEN });
+    const ekInput = new Uint8Array(keyBytes.length + 16);
+    ekInput.set(keyBytes);
+    ekInput.set(nonce.subarray(0, 16), keyBytes.length);
+    const derived = (0, blake2_js_1.blake2b)(encoder.encode("paseto-encryption-key"), {
+        key: ekInput,
+        dkLen: EK_LEN + N3_LEN,
+    });
+    const ek = derived.subarray(0, EK_LEN);
+    const n3 = derived.subarray(EK_LEN, EK_LEN + N3_LEN);
+    const aad = pae(header, nonce, footerBytes, implicitBytes);
+    const cipher = (0, chacha_js_1.xchacha20poly1305)(ek, n3, aad);
+    const ciphertext = cipher.encrypt(message);
+    const body = new Uint8Array(NONCE_LEN + ciphertext.length);
+    body.set(nonce);
+    body.set(ciphertext, NONCE_LEN);
+    let token = V4_LOCAL_HEADER + toBase64url(body);
+    if (footer) {
+        token += "." + toBase64url(footerBytes);
+    }
+    return { token };
+}
+function localDecrypt(opts) {
+    const { key, token, footer = "", implicit = "" } = opts;
+    const keyBytes = hexToBytes(key);
+    if (keyBytes.length !== 32) {
+        throw new Error(`Key must be 32 bytes, got ${keyBytes.length}`);
+    }
+    if (!token.startsWith(V4_LOCAL_HEADER)) {
+        throw new Error(`Invalid token header: expected "${V4_LOCAL_HEADER}"`);
+    }
+    const withoutHeader = token.slice(V4_LOCAL_HEADER.length);
+    const parts = withoutHeader.split(".");
+    const bodyB64 = parts[0];
+    const footerB64 = parts[1] ?? "";
+    const footerBytes = encoder.encode(footer);
+    if (footerB64) {
+        const tokenFooter = fromBase64url(footerB64);
+        if (Buffer.from(tokenFooter).toString("utf8") !== footer) {
+            throw new Error("Footer mismatch");
+        }
+    }
+    else if (footer) {
+        throw new Error("Footer mismatch");
+    }
+    const body = fromBase64url(bodyB64);
+    if (body.length < NONCE_LEN + 16) {
+        throw new Error("Token body too short");
+    }
+    const header = encoder.encode(V4_LOCAL_HEADER);
+    const implicitBytes = encoder.encode(implicit);
+    const nonce = body.subarray(0, NONCE_LEN);
+    const ciphertext = body.subarray(NONCE_LEN);
+    const ekInput = new Uint8Array(keyBytes.length + 16);
+    ekInput.set(keyBytes);
+    ekInput.set(nonce.subarray(0, 16), keyBytes.length);
+    const derived = (0, blake2_js_1.blake2b)(encoder.encode("paseto-encryption-key"), {
+        key: ekInput,
+        dkLen: EK_LEN + N3_LEN,
+    });
+    const ek = derived.subarray(0, EK_LEN);
+    const n3 = derived.subarray(EK_LEN, EK_LEN + N3_LEN);
+    const aad = pae(header, nonce, footerBytes, implicitBytes);
+    const cipher = (0, chacha_js_1.xchacha20poly1305)(ek, n3, aad);
+    const plaintext = cipher.decrypt(ciphertext);
+    const payloadStr = Buffer.from(plaintext).toString("utf8");
+    const payload = JSON.parse(payloadStr);
+    return { payload, ...(footer ? { footer } : {}) };
+}
+function publicSign(opts) {
+    const { secretKey, payload, footer = "", implicit = "" } = opts;
+    const skBytes = hexToBytes(secretKey);
+    if (skBytes.length !== 64 && skBytes.length !== 32) {
+        throw new Error(`Secret key must be 32 or 64 bytes, got ${skBytes.length}`);
+    }
+    const header = encoder.encode(V4_PUBLIC_HEADER);
+    const message = encoder.encode(JSON.stringify(payload));
+    const footerBytes = encoder.encode(footer);
+    const implicitBytes = encoder.encode(implicit);
+    const m2 = pae(header, message, footerBytes, implicitBytes);
+    const seed = skBytes.length === 64 ? skBytes.subarray(0, 32) : skBytes;
+    const sig = ed25519_js_1.ed25519.sign(m2, seed);
+    const body = new Uint8Array(message.length + sig.length);
+    body.set(message);
+    body.set(sig, message.length);
+    let token = V4_PUBLIC_HEADER + toBase64url(body);
+    if (footer) {
+        token += "." + toBase64url(footerBytes);
+    }
+    return { token };
+}
+function publicVerify(opts) {
+    const { publicKey, token, footer = "", implicit = "" } = opts;
+    const pkBytes = hexToBytes(publicKey);
+    if (pkBytes.length !== 32) {
+        throw new Error(`Public key must be 32 bytes, got ${pkBytes.length}`);
+    }
+    if (!token.startsWith(V4_PUBLIC_HEADER)) {
+        throw new Error(`Invalid token header: expected "${V4_PUBLIC_HEADER}"`);
+    }
+    const withoutHeader = token.slice(V4_PUBLIC_HEADER.length);
+    const parts = withoutHeader.split(".");
+    const bodyB64 = parts[0];
+    const footerB64 = parts[1] ?? "";
+    const footerBytes = encoder.encode(footer);
+    if (footerB64) {
+        const tokenFooter = fromBase64url(footerB64);
+        if (Buffer.from(tokenFooter).toString("utf8") !== footer) {
+            throw new Error("Footer mismatch");
+        }
+    }
+    else if (footer) {
+        throw new Error("Footer mismatch");
+    }
+    const body = fromBase64url(bodyB64);
+    if (body.length < SIG_LEN) {
+        throw new Error("Token body too short");
+    }
+    const message = body.subarray(0, body.length - SIG_LEN);
+    const sig = body.subarray(body.length - SIG_LEN);
+    const header = encoder.encode(V4_PUBLIC_HEADER);
+    const implicitBytes = encoder.encode(implicit);
+    const m2 = pae(header, message, footerBytes, implicitBytes);
+    const valid = ed25519_js_1.ed25519.verify(sig, m2, pkBytes);
+    if (!valid) {
+        throw new Error("Invalid signature");
+    }
+    const payloadStr = Buffer.from(message).toString("utf8");
+    const payload = JSON.parse(payloadStr);
+    return { payload, ...(footer ? { footer } : {}) };
+}
+exports.v4local = {
+    encrypt: localEncrypt,
+    decrypt: localDecrypt,
+};
+exports.v4public = {
+    sign: publicSign,
+    verify: publicVerify,
+};
+//# sourceMappingURL=paseto.js.map

package/dist/types/types.d.ts

@@ -1 +1,58 @@
+import enums from "../enums";
+export interface UserID {
+    name: string;
+    email: string;
+}
+export type dataGenerate = {
+    date: Date;
+    name: string;
+    email: string;
+    userIDs: UserID[];
+    type: keyof typeof enums.type;
+    passphrase: string;
+    rsaBits: number;
+    curve: keyof typeof enums.curve;
+    keyExpirationTime: number;
+    format: keyof typeof enums.format;
+};
+export type dataRevoke = {
+    passphrase: string;
+    flag: number;
+    reason: string;
+};
+export type dataEncrypt = {
+    passphrase: string;
+    message: string;
+    publicKey: string;
+    privateKey?: string;
+};
+export type dataDecrypt = {
+    passphrase: string;
+    message: string;
+    publicKey: string;
+    privateKey?: string;
+};
+export type dataSign = {
+    message: string;
+    detached: boolean;
+    passphrase: string;
+};
+export type dataVerify = {
+    date: Date;
+    message: string;
+    verificationKeys: string | string[];
+};
+export type dataSessionKey = {
+    email: string;
+    name: string;
+    publicKey: string;
+};
+export type dataReformat = {
+    date: Date;
+    email: string;
+    expiration: number;
+    name: string;
+    passphrase: string;
+    publicKey: string;
+};
 //# sourceMappingURL=types.d.ts.map

package/dist/types/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types/types.ts"],"names":[],"mappings":""}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,UAAU,CAAC;AAK7B,MAAM,WAAW,MAAM;IAErB,IAAI,EAAE,MAAM,CAAC;IAEb,KAAK,EAAE,MAAM,CAAC;CACf;AAGD,MAAM,MAAM,YAAY,GAAG;IAEzB,IAAI,EAAE,IAAI,CAAC;IAEX,IAAI,EAAE,MAAM,CAAC;IAEb,KAAK,EAAE,MAAM,CAAC;IAEd,OAAO,EAAE,MAAM,EAAE,CAAC;IAElB,IAAI,EAAE,MAAM,OAAO,KAAK,CAAC,IAAI,CAAC;IAE9B,UAAU,EAAE,MAAM,CAAC;IAEnB,OAAO,EAAE,MAAM,CAAC;IAEhB,KAAK,EAAE,MAAM,OAAO,KAAK,CAAC,KAAK,CAAC;IAEhC,iBAAiB,EAAE,MAAM,CAAC;IAE1B,MAAM,EAAE,MAAM,OAAO,KAAK,CAAC,MAAM,CAAC;CACnC,CAAC;AAGF,MAAM,MAAM,UAAU,GAAG;IAEvB,UAAU,EAAE,MAAM,CAAC;IAEnB,IAAI,EAAE,MAAM,CAAC;IAEb,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAGF,MAAM,MAAM,WAAW,GAAG;IAExB,UAAU,EAAE,MAAM,CAAC;IAEnB,OAAO,EAAE,MAAM,CAAC;IAEhB,SAAS,EAAE,MAAM,CAAC;IAElB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAGF,MAAM,MAAM,WAAW,GAAG;IAExB,UAAU,EAAE,MAAM,CAAC;IAEnB,OAAO,EAAE,MAAM,CAAC;IAEhB,SAAS,EAAE,MAAM,CAAC;IAElB,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAGF,MAAM,MAAM,QAAQ,GAAG;IAErB,OAAO,EAAE,MAAM,CAAC;IAEhB,QAAQ,EAAE,OAAO,CAAC;IAElB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAGF,MAAM,MAAM,UAAU,GAAG;IAEvB,IAAI,EAAE,IAAI,CAAC;IAEX,OAAO,EAAE,MAAM,CAAC;IAEhB,gBAAgB,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;CACrC,CAAC;AAGF,MAAM,MAAM,cAAc,GAAG;IAE3B,KAAK,EAAE,MAAM,CAAC;IAEd,IAAI,EAAE,MAAM,CAAC;IAEb,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAGF,MAAM,MAAM,YAAY,GAAG;IAEzB,IAAI,EAAE,IAAI,CAAC;IAEX,KAAK,EAAE,MAAM,CAAC;IAEd,UAAU,EAAE,MAAM,CAAC;IAEnB,IAAI,EAAE,MAAM,CAAC;IAEb,UAAU,EAAE,MAAM,CAAC;IAEnB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC"}

package/dist/types/types.js

@@ -1,2 +1,3 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 //# sourceMappingURL=types.js.map

package/dist/utils.d.ts

@@ -0,0 +1,13 @@
+export declare function timingSafeEqual(a: Uint8Array, b: Uint8Array): boolean;
+export declare class SecureBuffer {
+    private buf;
+    private destroyed;
+    constructor(data: Uint8Array | string);
+    get length(): number;
+    get isDestroyed(): boolean;
+    expose(): Uint8Array;
+    toHex(): string;
+    destroy(): void;
+}
+export declare function wipeMemory(buffer: Uint8Array): void;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AA+BA,wBAAgB,eAAe,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,GAAG,OAAO,CAOrE;AAqBD,qBAAa,YAAY;IACvB,OAAO,CAAC,GAAG,CAAa;IACxB,OAAO,CAAC,SAAS,CAAS;gBAYd,IAAI,EAAE,UAAU,GAAG,MAAM;IASrC,IAAI,MAAM,IAAI,MAAM,CAEnB;IAGD,IAAI,WAAW,IAAI,OAAO,CAEzB;IAcD,MAAM,IAAI,UAAU;IAsBpB,KAAK,IAAI,MAAM;IAuBf,OAAO,IAAI,IAAI;CAMhB;AAiBD,wBAAgB,UAAU,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI,CAEnD"}

package/dist/utils.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SecureBuffer = void 0;
+exports.timingSafeEqual = timingSafeEqual;
+exports.wipeMemory = wipeMemory;
+const errors_1 = require("./errors");
+function timingSafeEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    let result = 0;
+    for (let i = 0; i < a.length; i++) {
+        result |= a[i] ^ b[i];
+    }
+    return result === 0;
+}
+class SecureBuffer {
+    buf;
+    destroyed = false;
+    constructor(data) {
+        if (typeof data === "string") {
+            this.buf = Buffer.from(data, "hex");
+        }
+        else {
+            this.buf = new Uint8Array(data);
+        }
+    }
+    get length() {
+        return this.buf.length;
+    }
+    get isDestroyed() {
+        return this.destroyed;
+    }
+    expose() {
+        if (this.destroyed) {
+            throw new errors_1.CryptoError("SecureBuffer has been destroyed", errors_1.CryptoErrorCode.BUFFER_DESTROYED);
+        }
+        return this.buf;
+    }
+    toHex() {
+        if (this.destroyed) {
+            throw new errors_1.CryptoError("SecureBuffer has been destroyed", errors_1.CryptoErrorCode.BUFFER_DESTROYED);
+        }
+        return Buffer.from(this.buf).toString("hex");
+    }
+    destroy() {
+        if (!this.destroyed) {
+            this.buf.fill(0);
+            this.destroyed = true;
+        }
+    }
+}
+exports.SecureBuffer = SecureBuffer;
+function wipeMemory(buffer) {
+    buffer.fill(0);
+}
+//# sourceMappingURL=utils.js.map