@alikhalilll/nuxt-crypto 1.0.3 → 1.2.1

package/README.md

@@ -7,6 +7,7 @@ Symmetric encryption for Nuxt 3 / 4, built on the native **Web Crypto API**. Def
 - **Pluggable algorithms** — swap the default AES-GCM implementation for your own `CryptoAlgorithm` without touching the payload envelope.
 - **Versioned payload format** — `v1.{salt}.{iv}.{cipher}` with clean forward compatibility.
 - **Server-only mode** — opt into registering the plugin only on the server so the passphrase never ships to the browser bundle.
+- **Device fingerprint** _(new)_ — bind a payload to the browser that created it via an HttpOnly cookie. Survives IP changes (Wi-Fi ↔ 4G, VPN rotation) while still blocking copy-paste to another browser or device.
 - **Strong types** — `CryptoService`, `CryptoServiceConfig`, and `CryptoAlgorithm` all exported.
 
 ---
@@ -16,21 +17,22 @@ Symmetric encryption for Nuxt 3 / 4, built on the native **Web Crypto API**. Def
 1. [Install](#install)
 2. [Register the module](#register-the-module)
 3. [Usage](#usage)
-    - [Basic round-trip](#basic-round-trip)
-    - [Encrypt / decrypt a JSON object](#encrypt--decrypt-a-json-object)
-    - [Encrypt / decrypt an arbitrary value](#encrypt--decrypt-an-arbitrary-value)
-    - [Persist a ciphertext in a cookie](#persist-a-ciphertext-in-a-cookie)
-    - [Bulk encrypt / decrypt (key cache benefits)](#bulk-encrypt--decrypt-key-cache-benefits)
-    - [Clear the key cache](#clear-the-key-cache)
-    - [Error handling](#error-handling)
+   - [Basic round-trip](#basic-round-trip)
+   - [Encrypt / decrypt a JSON object](#encrypt--decrypt-a-json-object)
+   - [Encrypt / decrypt an arbitrary value](#encrypt--decrypt-an-arbitrary-value)
+   - [Persist a ciphertext in a cookie](#persist-a-ciphertext-in-a-cookie)
+   - [Bulk encrypt / decrypt (key cache benefits)](#bulk-encrypt--decrypt-key-cache-benefits)
+   - [Clear the key cache](#clear-the-key-cache)
+   - [Error handling](#error-handling)
 4. [Server-only mode](#server-only-mode)
 5. [Nitro / API routes](#nitro--api-routes)
-6. [Framework-agnostic core](#framework-agnostic-core)
-7. [Custom algorithm](#custom-algorithm)
-8. [Rotating the passphrase (re-encryption)](#rotating-the-passphrase-re-encryption)
-9. [Payload format](#payload-format)
-10. [Module options reference](#module-options-reference)
-11. [Exported types](#exported-types)
+6. [Device fingerprint](#device-fingerprint)
+7. [Framework-agnostic core](#framework-agnostic-core)
+8. [Custom algorithm](#custom-algorithm)
+9. [Rotating the passphrase (re-encryption)](#rotating-the-passphrase-re-encryption)
+10. [Payload format](#payload-format)
+11. [Module options reference](#module-options-reference)
+12. [Exported types](#exported-types)
 
 ---
 
@@ -49,7 +51,7 @@ export default defineNuxtConfig({
   crypto: {
     // Always wire this from an env var. Never commit the passphrase.
     passphrase: process.env.NUXT_ENCRYPTION_PASSPHRASE ?? '',
-    provideName: '$crypto',  // leading "$" optional
+    provideName: '$crypto', // leading "$" optional
     iterations: 100_000,
     keyCacheSize: 64,
     serverOnly: false,
@@ -148,6 +150,7 @@ $crypto.clearKeyCache();
 ```
 
 Useful when:
+
 - You rotate the passphrase (the cache would still hold old keys).
 - You want to force re-derivation in a security-audit test.
 
@@ -164,13 +167,13 @@ try {
 
 Errors you can see:
 
-| Scenario                                      | Message |
-|-----------------------------------------------|---------|
-| Payload isn't `a.b.c.d`                       | `Invalid payload format — expected 4 dot-separated segments.` |
-| A segment is empty                            | `Invalid payload format — one or more segments were empty.`   |
-| Algorithm version mismatch                    | `Unsupported payload version: v2 (algorithm expects v1).`     |
-| Wrong passphrase / tampered ciphertext        | Native `OperationError` from Web Crypto.                      |
-| Passphrase not set in module config           | `[nuxt-crypto] passphrase is required.`                       |
+| Scenario                               | Message                                                       |
+| -------------------------------------- | ------------------------------------------------------------- |
+| Payload isn't `a.b.c.d`                | `Invalid payload format — expected 4 dot-separated segments.` |
+| A segment is empty                     | `Invalid payload format — one or more segments were empty.`   |
+| Algorithm version mismatch             | `Unsupported payload version: v2 (algorithm expects v1).`     |
+| Wrong passphrase / tampered ciphertext | Native `OperationError` from Web Crypto.                      |
+| Passphrase not set in module config    | `[nuxt-crypto] passphrase is required.`                       |
 
 ## Server-only mode
 
@@ -184,30 +187,120 @@ crypto: {
 ```
 
 With this enabled, `$crypto` is `undefined` on the client. Use it only in:
+
 - Nitro server routes (`server/api/*.ts`)
 - Server-only plugins
 - `<script setup>` blocks guarded by `import.meta.server`
 
 ## Nitro / API routes
 
+Nitro event handlers run outside the Nuxt app context, so `useNuxtApp()` — and therefore `$crypto` — isn't available there. Use the framework-agnostic core directly. A tiny server utility keeps the service cached across requests:
+
+```ts
+// server/utils/crypto.ts
+import { createCryptoService } from '@alikhalilll/nuxt-crypto/core';
+
+let servicePromise: ReturnType<typeof createCryptoService> | null = null;
+
+export function useServerCrypto() {
+  if (!servicePromise) {
+    servicePromise = createCryptoService({
+      passphrase: process.env.NUXT_ENCRYPTION_PASSPHRASE!,
+      iterations: 100_000,
+    });
+  }
+  return servicePromise;
+}
+```
+
 Encrypt data before sending it to the browser, decrypt it when it comes back:
 
 ```ts
 // server/api/session/encode.post.ts
 export default defineEventHandler(async (event) => {
   const body = await readBody(event);
-  const { $crypto } = useNuxtApp();
-  return { token: await $crypto.encrypt(JSON.stringify(body)) };
+  const crypto = await useServerCrypto();
+  return { token: await crypto.encrypt(JSON.stringify(body)) };
 });
 
 // server/api/session/decode.post.ts
 export default defineEventHandler(async (event) => {
   const { token } = await readBody(event);
-  const { $crypto } = useNuxtApp();
-  return JSON.parse(await $crypto.decrypt(token));
+  const crypto = await useServerCrypto();
+  return JSON.parse(await crypto.decrypt(token));
 });
 ```
 
+## Device fingerprint
+
+Bind a payload to the browser that created it, so a copy of the ciphertext in another browser or on another device won't decrypt. Useful for short-lived CSRF tokens, magic links, and anti-replay nonces.
+
+The fingerprint is built from an **HttpOnly device-ID cookie** — not the client IP — so it survives Wi-Fi → 4G switches, cell handoffs, VPN rotations, and residential IP rotation while still blocking copy-paste to another origin.
+
+### Setup
+
+```ts
+// nuxt.config.ts
+export default defineNuxtConfig({
+  runtimeConfig: {
+    // Server-side pepper. Keep this secret; never expose to the client.
+    cryptoFingerprintSalt: process.env.NUXT_CRYPTO_FINGERPRINT_SALT ?? '',
+  },
+});
+```
+
+```
+# .env
+NUXT_CRYPTO_FINGERPRINT_SALT=<64 random hex chars>
+```
+
+### Encrypt / decrypt with a fingerprint
+
+```ts
+// server/api/session.post.ts
+import { getClientFingerprint } from '@alikhalilll/nuxt-crypto/server';
+
+export default defineEventHandler(async (event) => {
+  const body = await readBody(event);
+  const crypto = await useServerCrypto(); // see "Nitro / API routes" above
+
+  const fingerprint = await getClientFingerprint(event, {
+    salt: useRuntimeConfig().cryptoFingerprintSalt,
+  });
+
+  return {
+    token: await crypto.encrypt(JSON.stringify(body), { fingerprint }),
+  };
+});
+```
+
+The first call sets an HttpOnly cookie (`__nuxt_crypto_device`) with a random 32-byte ID; subsequent calls reuse it. Pass the same `{ fingerprint }` to `crypto.decrypt` on the server to round-trip.
+
+### What this protects against
+
+| Scenario                                  | Decrypts?                            |
+| ----------------------------------------- | ------------------------------------ |
+| Wi-Fi → 4G on the same device             | ✅ yes — cookie travels with browser |
+| VPN exit node or ISP IP rotation          | ✅ yes                               |
+| Copy token to another browser on same box | ❌ no — no cookie in that browser    |
+| XSS-exfiltrated token to an attacker      | ❌ no — HttpOnly cookie unreachable  |
+| User clears cookies                       | ❌ no — permanently unrecoverable    |
+
+### `deriveFingerprint` — bring your own device ID
+
+If you already manage per-device identity (session table, signed JWT, etc.), skip the cookie helper:
+
+```ts
+import { deriveFingerprint } from '@alikhalilll/nuxt-crypto/server';
+
+const fingerprint = await deriveFingerprint({
+  deviceId: session.id,
+  salt: useRuntimeConfig().cryptoFingerprintSalt,
+});
+```
+
+> **Warning** — a fingerprinted payload becomes undecryptable if the device cookie is cleared or the session rotates. Use only for tokens the user can afford to lose (short sessions, magic links, one-shot nonces), never for long-lived data.
+
 ## Framework-agnostic core
 
 Everything the Nuxt plugin wraps is available as a plain factory:
@@ -238,9 +331,15 @@ import type { CryptoAlgorithm } from '@alikhalilll/nuxt-crypto/types';
 
 const myAlgo: CryptoAlgorithm = {
   version: 'v2',
-  async deriveKey({ subtle, passphrase, salt, iterations }) { /* ... */ },
-  async encrypt({ subtle, key, plainText })                  { /* ... */ },
-  async decrypt({ subtle, key, cipher, iv })                 { /* ... */ },
+  async deriveKey({ subtle, passphrase, salt, iterations }) {
+    /* ... */
+  },
+  async encrypt({ subtle, key, plainText }) {
+    /* ... */
+  },
+  async decrypt({ subtle, key, cipher, iv }) {
+    /* ... */
+  },
 };
 
 const service = await createCryptoService({
@@ -271,22 +370,22 @@ Run `rotate` over your stored ciphertexts during a background migration. Clear t
 
 `v1.{saltB64}.{ivB64}.{cipherB64}` — four dot-separated segments, each standard base64:
 
-| Segment | Bytes | Notes |
-|---------|-------|-------|
-| `v1`    | —     | Algorithm / version tag. |
-| salt    | 16    | Per-encryption PBKDF2 salt. |
-| iv      | 12    | AES-GCM initialization vector. |
+| Segment | Bytes | Notes                              |
+| ------- | ----- | ---------------------------------- |
+| `v1`    | —     | Algorithm / version tag.           |
+| salt    | 16    | Per-encryption PBKDF2 salt.        |
+| iv      | 12    | AES-GCM initialization vector.     |
 | cipher  | N     | Ciphertext + 16-byte GCM auth tag. |
 
 ## Module options reference
 
-| Option         | Type     | Default    | Purpose                                                              |
-|----------------|----------|------------|----------------------------------------------------------------------|
-| `passphrase`   | `string` | `''`       | Passphrase to derive the AES key from. Throws at use if empty.       |
-| `provideName`  | `string` | `'$crypto'`| Injected under `$<name>`. Leading `$` is stripped.                   |
-| `iterations`   | `number` | `100_000`  | PBKDF2 iteration count.                                              |
-| `keyCacheSize` | `number` | `64`       | Max derived keys kept in memory. Set to 0 to disable caching.        |
-| `serverOnly`   | `boolean`| `false`    | When true, plugin runs only on the server.                           |
+| Option         | Type      | Default     | Purpose                                                        |
+| -------------- | --------- | ----------- | -------------------------------------------------------------- |
+| `passphrase`   | `string`  | `''`        | Passphrase to derive the AES key from. Throws at use if empty. |
+| `provideName`  | `string`  | `'$crypto'` | Injected under `$<name>`. Leading `$` is stripped.             |
+| `iterations`   | `number`  | `100_000`   | PBKDF2 iteration count.                                        |
+| `keyCacheSize` | `number`  | `64`        | Max derived keys kept in memory. Set to 0 to disable caching.  |
+| `serverOnly`   | `boolean` | `false`     | When true, plugin runs only on the server.                     |
 
 ## Exported types
 
@@ -294,11 +393,16 @@ Run `rotate` over your stored ciphertexts during a background migration. Clear t
 import type {
   CryptoService,
   CryptoServiceConfig,
+  CryptoOperationOptions,
   CryptoAlgorithm,
   CryptoModuleOptions,
   Bytes,
   ParsedPayload,
 } from '@alikhalilll/nuxt-crypto/types';
+
+// Server subpath (Nitro / H3 only)
+import type { ClientFingerprintOptions, FingerprintParts } from '@alikhalilll/nuxt-crypto/server';
+import { getClientFingerprint, deriveFingerprint } from '@alikhalilll/nuxt-crypto/server';
 ```
 
 ## License

package/dist/{chunk-HNTEUBQ7.mjs → chunk-FKHKOTFR.mjs}

@@ -1,10 +1,18 @@
+import {
+  fromBase64,
+  getRandomBytes,
+  getSubtle,
+  toBase64
+} from "./chunk-FKXZ7VYW.mjs";
+
 // src/core/algorithms/aes-gcm.ts
 var aesGcmPbkdf2 = {
   version: "v1",
-  async deriveKey({ subtle, passphrase, salt, iterations }) {
+  async deriveKey({ subtle, passphrase, fingerprint, salt, iterations }) {
+    const material = fingerprint ? `${passphrase}\0${fingerprint}` : passphrase;
     const keyMaterial = await subtle.importKey(
       "raw",
-      new TextEncoder().encode(passphrase),
+      new TextEncoder().encode(material),
       { name: "PBKDF2" },
       false,
       ["deriveKey"]
@@ -33,31 +41,6 @@ var aesGcmPbkdf2 = {
   }
 };
 
-// src/core/base64.ts
-function toBase64(data) {
-  if (typeof btoa === "function") {
-    let binary = "";
-    const CHUNK = 32768;
-    for (let i = 0; i < data.length; i += CHUNK) {
-      binary += String.fromCharCode(...data.subarray(i, i + CHUNK));
-    }
-    return btoa(binary);
-  }
-  return Buffer.from(data).toString("base64");
-}
-function fromBase64(input) {
-  if (typeof atob === "function") {
-    const binary = atob(input);
-    const out2 = new Uint8Array(binary.length);
-    for (let i = 0; i < binary.length; i++) out2[i] = binary.charCodeAt(i);
-    return out2;
-  }
-  const buf = Buffer.from(input, "base64");
-  const out = new Uint8Array(buf.length);
-  out.set(buf);
-  return out;
-}
-
 // src/core/key-cache.ts
 var KeyCache = class {
   constructor(capacity) {
@@ -65,8 +48,8 @@ var KeyCache = class {
   }
   capacity;
   map = /* @__PURE__ */ new Map();
-  static key(salt, iterations) {
-    return `${iterations}.${toBase64(salt)}`;
+  static key(salt, iterations, fingerprint) {
+    return `${iterations}.${fingerprint ?? ""}.${toBase64(salt)}`;
   }
   get(key) {
     const value = this.map.get(key);
@@ -112,24 +95,6 @@ function parsePayload(payload) {
   };
 }
 
-// src/core/subtle.ts
-async function getSubtle() {
-  if (globalThis.crypto?.subtle) return globalThis.crypto.subtle;
-  const { webcrypto } = await import("crypto");
-  return webcrypto.subtle;
-}
-function getRandomBytes(length) {
-  const out = new Uint8Array(length);
-  const c = globalThis.crypto;
-  if (c?.getRandomValues) {
-    c.getRandomValues(out);
-    return out;
-  }
-  throw new Error(
-    "[nuxt-crypto] globalThis.crypto.getRandomValues is not available. Upgrade your runtime."
-  );
-}
-
 // src/core/create-service.ts
 var DEFAULT_ITERATIONS = 1e5;
 var DEFAULT_CACHE = 64;
@@ -145,32 +110,32 @@ async function createCryptoService(config) {
   const passphrase = String(config.passphrase).trim();
   const encoder = new TextEncoder();
   const decoder = new TextDecoder();
-  async function getDerivedKey(salt) {
-    const key = KeyCache.key(salt, iterations);
+  async function getDerivedKey(salt, fingerprint) {
+    const key = KeyCache.key(salt, iterations, fingerprint);
     const cached = cache.get(key);
     if (cached) return cached;
-    const pending = algorithm.deriveKey({ subtle, passphrase, salt, iterations });
+    const pending = algorithm.deriveKey({ subtle, passphrase, fingerprint, salt, iterations });
     cache.set(key, pending);
     return pending;
   }
   return {
-    async encrypt(plainText) {
+    async encrypt(plainText, options) {
       const salt = getRandomBytes(SALT_BYTES);
-      const key = await getDerivedKey(salt);
+      const key = await getDerivedKey(salt, options?.fingerprint);
       const encoded = encoder.encode(plainText);
       const plainBytes = new Uint8Array(new ArrayBuffer(encoded.byteLength));
       plainBytes.set(encoded);
       const { cipher, iv } = await algorithm.encrypt({ subtle, key, plainText: plainBytes });
       return encodePayload({ version: algorithm.version, salt, iv, cipher });
     },
-    async decrypt(payload) {
+    async decrypt(payload, options) {
       const parsed = parsePayload(payload);
       if (parsed.version !== algorithm.version) {
         throw new Error(
           `[nuxt-crypto] Unsupported payload version: ${parsed.version} (algorithm expects ${algorithm.version}).`
         );
       }
-      const key = await getDerivedKey(parsed.salt);
+      const key = await getDerivedKey(parsed.salt, options?.fingerprint);
       const plainBytes = await algorithm.decrypt({
         subtle,
         key,
@@ -187,13 +152,9 @@ async function createCryptoService(config) {
 
 export {
   aesGcmPbkdf2,
-  toBase64,
-  fromBase64,
   KeyCache,
   encodePayload,
   parsePayload,
-  getSubtle,
-  getRandomBytes,
   createCryptoService
 };
-//# sourceMappingURL=chunk-HNTEUBQ7.mjs.map
+//# sourceMappingURL=chunk-FKHKOTFR.mjs.map

package/dist/chunk-FKHKOTFR.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/algorithms/aes-gcm.ts","../src/core/key-cache.ts","../src/core/payload.ts","../src/core/create-service.ts"],"sourcesContent":["import type { CryptoAlgorithm } from '../types';\n\n/**\n * AES-256-GCM with PBKDF2-SHA256 key derivation. This is the default and\n * currently the only built-in algorithm; pluggable via `CryptoServiceConfig.algorithm`.\n */\nexport const aesGcmPbkdf2: CryptoAlgorithm = {\n  version: 'v1',\n\n  async deriveKey({ subtle, passphrase, fingerprint, salt, iterations }) {\n    // NUL separator prevents `\"ab\" + \"cd\"` and `\"abc\" + \"d\"` from colliding.\n    const material = fingerprint ? `${passphrase}\\x00${fingerprint}` : passphrase;\n    const keyMaterial = await subtle.importKey(\n      'raw',\n      new TextEncoder().encode(material),\n      { name: 'PBKDF2' },\n      false,\n      ['deriveKey']\n    );\n\n    return subtle.deriveKey(\n      { name: 'PBKDF2', salt, iterations, hash: 'SHA-256' },\n      keyMaterial,\n      { name: 'AES-GCM', length: 256 },\n      false,\n      ['encrypt', 'decrypt']\n    );\n  },\n\n  async encrypt({ subtle, key, plainText }) {\n    const iv = new Uint8Array(new ArrayBuffer(12));\n    globalThis.crypto.getRandomValues(iv);\n    const buf = await subtle.encrypt({ name: 'AES-GCM', iv }, key, plainText);\n    const cipher = new Uint8Array(new ArrayBuffer(buf.byteLength));\n    cipher.set(new Uint8Array(buf));\n    return { cipher, iv };\n  },\n\n  async decrypt({ subtle, key, cipher, iv }) {\n    const buf = await subtle.decrypt({ name: 'AES-GCM', iv }, key, cipher);\n    const out = new Uint8Array(new ArrayBuffer(buf.byteLength));\n    out.set(new Uint8Array(buf));\n    return out;\n  },\n};\n","import type { Bytes } from './types';\nimport { toBase64 } from './base64';\n\n/**\n * A tiny LRU-ish cache for derived `CryptoKey` values, keyed on the salt.\n * When capacity is exceeded the oldest entry is evicted. Derived key\n * material is expensive (PBKDF2 is designed to be slow), so caching has\n * a big impact when decrypting many payloads in a row.\n */\nexport class KeyCache {\n  private readonly map = new Map<string, Promise<CryptoKey>>();\n  constructor(private readonly capacity: number) {}\n\n  static key(salt: Bytes, iterations: number, fingerprint?: string): string {\n    // `.` separates the fields; iterations and base64 can't contain one,\n    // so the joined key is unambiguous even when fingerprint is empty.\n    return `${iterations}.${fingerprint ?? ''}.${toBase64(salt)}`;\n  }\n\n  get(key: string): Promise<CryptoKey> | undefined {\n    const value = this.map.get(key);\n    if (!value) return undefined;\n    // Refresh recency by re-inserting.\n    this.map.delete(key);\n    this.map.set(key, value);\n    return value;\n  }\n\n  set(key: string, value: Promise<CryptoKey>): void {\n    if (this.capacity <= 0) return;\n    this.map.set(key, value);\n    while (this.map.size > this.capacity) {\n      const oldest = this.map.keys().next().value;\n      if (oldest === undefined) break;\n      this.map.delete(oldest);\n    }\n  }\n\n  clear(): void {\n    this.map.clear();\n  }\n}\n","import { fromBase64, toBase64 } from './base64';\nimport type { Bytes } from './types';\n\n/**\n * Payload serialisation format (v1): `${version}.${saltB64}.${ivB64}.${cipherB64}`.\n *\n * Each part is URL-safe base64, all joined with `.`. The version tag is\n * always the first segment so consumers can route to the correct algorithm\n * during decrypt.\n */\nexport interface ParsedPayload {\n  version: string;\n  salt: Bytes;\n  iv: Bytes;\n  cipher: Bytes;\n}\n\nexport function encodePayload(parts: ParsedPayload): string {\n  return [parts.version, toBase64(parts.salt), toBase64(parts.iv), toBase64(parts.cipher)].join(\n    '.'\n  );\n}\n\nexport function parsePayload(payload: string): ParsedPayload {\n  const segments = payload.split('.');\n  if (segments.length !== 4) {\n    throw new Error('[nuxt-crypto] Invalid payload format — expected 4 dot-separated segments.');\n  }\n  const [version, saltB64, ivB64, cipherB64] = segments;\n  if (!version || !saltB64 || !ivB64 || !cipherB64) {\n    throw new Error('[nuxt-crypto] Invalid payload format — one or more segments were empty.');\n  }\n  return {\n    version,\n    salt: fromBase64(saltB64),\n    iv: fromBase64(ivB64),\n    cipher: fromBase64(cipherB64),\n  };\n}\n","import { aesGcmPbkdf2 } from './algorithms/aes-gcm';\nimport { KeyCache } from './key-cache';\nimport { encodePayload, parsePayload } from './payload';\nimport { getRandomBytes, getSubtle } from './subtle';\nimport type { CryptoAlgorithm, CryptoService, CryptoServiceConfig } from './types';\n\nconst DEFAULT_ITERATIONS = 100_000;\nconst DEFAULT_CACHE = 64;\nconst SALT_BYTES = 16;\n\n/**\n * Create a framework-agnostic `CryptoService` from a passphrase.\n *\n * Uses AES-256-GCM with PBKDF2-SHA256 (100k iterations by default). Pass a\n * different `algorithm` to plug in another cipher while preserving the same\n * versioned payload envelope.\n */\nexport async function createCryptoService(config: CryptoServiceConfig): Promise<CryptoService> {\n  if (!config.passphrase) {\n    throw new Error('[nuxt-crypto] passphrase is required.');\n  }\n\n  const iterations = config.iterations ?? DEFAULT_ITERATIONS;\n  const algorithm: CryptoAlgorithm = config.algorithm ?? aesGcmPbkdf2;\n  const subtle = config.subtle ?? (await getSubtle());\n  const cache = new KeyCache(config.keyCacheSize ?? DEFAULT_CACHE);\n  const passphrase = String(config.passphrase).trim();\n  const encoder = new TextEncoder();\n  const decoder = new TextDecoder();\n\n  async function getDerivedKey(\n    salt: Uint8Array<ArrayBuffer>,\n    fingerprint?: string\n  ): Promise<CryptoKey> {\n    const key = KeyCache.key(salt, iterations, fingerprint);\n    const cached = cache.get(key);\n    if (cached) return cached;\n    const pending = algorithm.deriveKey({ subtle, passphrase, fingerprint, salt, iterations });\n    cache.set(key, pending);\n    return pending;\n  }\n\n  return {\n    async encrypt(plainText, options) {\n      const salt = getRandomBytes(SALT_BYTES);\n      const key = await getDerivedKey(salt, options?.fingerprint);\n      const encoded = encoder.encode(plainText);\n      const plainBytes = new Uint8Array(new ArrayBuffer(encoded.byteLength));\n      plainBytes.set(encoded);\n      const { cipher, iv } = await algorithm.encrypt({ subtle, key, plainText: plainBytes });\n      return encodePayload({ version: algorithm.version, salt, iv, cipher });\n    },\n\n    async decrypt(payload, options) {\n      const parsed = parsePayload(payload);\n      if (parsed.version !== algorithm.version) {\n        throw new Error(\n          `[nuxt-crypto] Unsupported payload version: ${parsed.version} (algorithm expects ${algorithm.version}).`\n        );\n      }\n      const key = await getDerivedKey(parsed.salt, options?.fingerprint);\n      const plainBytes = await algorithm.decrypt({\n        subtle,\n        key,\n        cipher: parsed.cipher,\n        iv: parsed.iv,\n      });\n      return decoder.decode(plainBytes);\n    },\n\n    clearKeyCache(): void {\n      cache.clear();\n    },\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-FKXZ7VYW.mjs

@@ -0,0 +1,50 @@
+// src/core/base64.ts
+function toBase64(data) {
+  if (typeof btoa === "function") {
+    let binary = "";
+    const CHUNK = 32768;
+    for (let i = 0; i < data.length; i += CHUNK) {
+      binary += String.fromCharCode(...data.subarray(i, i + CHUNK));
+    }
+    return btoa(binary);
+  }
+  return Buffer.from(data).toString("base64");
+}
+function fromBase64(input) {
+  if (typeof atob === "function") {
+    const binary = atob(input);
+    const out2 = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) out2[i] = binary.charCodeAt(i);
+    return out2;
+  }
+  const buf = Buffer.from(input, "base64");
+  const out = new Uint8Array(buf.length);
+  out.set(buf);
+  return out;
+}
+
+// src/core/subtle.ts
+async function getSubtle() {
+  if (globalThis.crypto?.subtle) return globalThis.crypto.subtle;
+  const { webcrypto } = await import("crypto");
+  return webcrypto.subtle;
+}
+function getRandomBytes(length) {
+  const out = new Uint8Array(length);
+  const c = globalThis.crypto;
+  if (c?.getRandomValues) {
+    c.getRandomValues(out);
+    return out;
+  }
+  throw new Error(
+    "[nuxt-crypto] globalThis.crypto.getRandomValues is not available. Upgrade your runtime."
+  );
+}
+
+export {
+  toBase64,
+  fromBase64,
+  getSubtle,
+  getRandomBytes
+};
+//# sourceMappingURL=chunk-FKXZ7VYW.mjs.map

package/dist/chunk-FKXZ7VYW.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/base64.ts","../src/core/subtle.ts"],"sourcesContent":["import type { Bytes } from './types';\n\n/** Encode bytes to standard base64. Works in browser and Node. */\nexport function toBase64(data: Bytes): string {\n  if (typeof btoa === 'function') {\n    let binary = '';\n    const CHUNK = 0x8000;\n    for (let i = 0; i < data.length; i += CHUNK) {\n      binary += String.fromCharCode(...data.subarray(i, i + CHUNK));\n    }\n    return btoa(binary);\n  }\n  // Node fallback — Buffer is globally available in Node.\n  return Buffer.from(data).toString('base64');\n}\n\n/** Decode a base64 string back to bytes. Works in browser and Node. */\nexport function fromBase64(input: string): Bytes {\n  if (typeof atob === 'function') {\n    const binary = atob(input);\n    const out = new Uint8Array(binary.length);\n    for (let i = 0; i < binary.length; i++) out[i] = binary.charCodeAt(i);\n    return out;\n  }\n  const buf = Buffer.from(input, 'base64');\n  const out = new Uint8Array(buf.length);\n  out.set(buf);\n  return out;\n}\n","/**\n * Resolve a SubtleCrypto implementation across environments:\n *\n * - Browser / Deno / Bun / Node 20+: `globalThis.crypto.subtle` is available.\n * - Older Node: fall back to `node:crypto`'s `webcrypto`.\n */\nexport async function getSubtle(): Promise<SubtleCrypto> {\n  if (globalThis.crypto?.subtle) return globalThis.crypto.subtle;\n  const { webcrypto } = await import('node:crypto');\n  return webcrypto.subtle as unknown as SubtleCrypto;\n}\n\n/** Fill the given buffer with cryptographically strong random bytes. */\nexport function getRandomBytes(length: number): Uint8Array<ArrayBuffer> {\n  const out = new Uint8Array(length);\n  const c = globalThis.crypto;\n  if (c?.getRandomValues) {\n    c.getRandomValues(out);\n    return out;\n  }\n  throw new Error(\n    '[nuxt-crypto] globalThis.crypto.getRandomValues is not available. Upgrade your runtime.'\n  );\n}\n"],"mappings":";AAGO,SAAS,SAAS,MAAqB;AAC5C,MAAI,OAAO,SAAS,YAAY;AAC9B,QAAI,SAAS;AACb,UAAM,QAAQ;AACd,aAAS,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK,OAAO;AAC3C,gBAAU,OAAO,aAAa,GAAG,KAAK,SAAS,GAAG,IAAI,KAAK,CAAC;AAAA,IAC9D;AACA,WAAO,KAAK,MAAM;AAAA,EACpB;AAEA,SAAO,OAAO,KAAK,IAAI,EAAE,SAAS,QAAQ;AAC5C;AAGO,SAAS,WAAW,OAAsB;AAC/C,MAAI,OAAO,SAAS,YAAY;AAC9B,UAAM,SAAS,KAAK,KAAK;AACzB,UAAMA,OAAM,IAAI,WAAW,OAAO,MAAM;AACxC,aAAS,IAAI,GAAG,IAAI,OAAO,QAAQ,IAAK,CAAAA,KAAI,CAAC,IAAI,OAAO,WAAW,CAAC;AACpE,WAAOA;AAAA,EACT;AACA,QAAM,MAAM,OAAO,KAAK,OAAO,QAAQ;AACvC,QAAM,MAAM,IAAI,WAAW,IAAI,MAAM;AACrC,MAAI,IAAI,GAAG;AACX,SAAO;AACT;;;ACtBA,eAAsB,YAAmC;AACvD,MAAI,WAAW,QAAQ,OAAQ,QAAO,WAAW,OAAO;AACxD,QAAM,EAAE,UAAU,IAAI,MAAM,OAAO,QAAa;AAChD,SAAO,UAAU;AACnB;AAGO,SAAS,eAAe,QAAyC;AACtE,QAAM,MAAM,IAAI,WAAW,MAAM;AACjC,QAAM,IAAI,WAAW;AACrB,MAAI,GAAG,iBAAiB;AACtB,MAAE,gBAAgB,GAAG;AACrB,WAAO;AAAA,EACT;AACA,QAAM,IAAI;AAAA,IACR;AAAA,EACF;AACF;","names":["out"]}

package/dist/core/index.d.ts

@@ -1,5 +1,5 @@
-import { b as CryptoServiceConfig, a as CryptoService, C as CryptoAlgorithm, B as Bytes } from '../payload-Cht5Ar0K.js';
-export { P as ParsedPayload, e as encodePayload, p as parsePayload } from '../payload-Cht5Ar0K.js';
+import { c as CryptoServiceConfig, b as CryptoService, C as CryptoAlgorithm, B as Bytes } from '../payload-BOueSWcI.js';
+export { a as CryptoOperationOptions, P as ParsedPayload, e as encodePayload, p as parsePayload } from '../payload-BOueSWcI.js';
 
 /**
  * Create a framework-agnostic `CryptoService` from a passphrase.
@@ -41,7 +41,7 @@ declare class KeyCache {
     private readonly capacity;
     private readonly map;
     constructor(capacity: number);
-    static key(salt: Bytes, iterations: number): string;
+    static key(salt: Bytes, iterations: number, fingerprint?: string): string;
     get(key: string): Promise<CryptoKey> | undefined;
     set(key: string, value: Promise<CryptoKey>): void;
     clear(): void;

package/dist/core/index.mjs

@@ -3,12 +3,14 @@ import {
   aesGcmPbkdf2,
   createCryptoService,
   encodePayload,
+  parsePayload
+} from "../chunk-FKHKOTFR.mjs";
+import {
   fromBase64,
   getRandomBytes,
   getSubtle,
-  parsePayload,
   toBase64
-} from "../chunk-HNTEUBQ7.mjs";
+} from "../chunk-FKXZ7VYW.mjs";
 export {
   KeyCache,
   aesGcmPbkdf2,

package/dist/module.d.ts

@@ -1,6 +1,6 @@
 import { NuxtModule } from '@nuxt/schema';
 import { CryptoModuleOptions } from './types/index.js';
-export { B as Bytes, C as CryptoAlgorithm, a as CryptoService, b as CryptoServiceConfig, P as ParsedPayload } from './payload-Cht5Ar0K.js';
+export { B as Bytes, C as CryptoAlgorithm, a as CryptoOperationOptions, b as CryptoService, c as CryptoServiceConfig, P as ParsedPayload } from './payload-BOueSWcI.js';
 
 declare const cryptoModule: NuxtModule<CryptoModuleOptions>;
 

package/dist/{payload-Cht5Ar0K.d.ts → payload-BOueSWcI.d.ts}

@@ -1,5 +1,23 @@
 /** Shorthand for the `Uint8Array` we use everywhere in the crypto package. */
 type Bytes = Uint8Array<ArrayBuffer>;
+/**
+ * Options accepted by `encrypt` / `decrypt`. Both calls must receive the
+ * same `fingerprint` value to round-trip; passing different fingerprints
+ * produces undecryptable ciphertext.
+ */
+interface CryptoOperationOptions {
+    /**
+     * Optional extra key material mixed into the PBKDF2 input. Typically a
+     * device fingerprint produced server-side from an HttpOnly device-ID
+     * cookie via `getClientFingerprint()` from `@alikhalilll/nuxt-crypto/server`.
+     *
+     * ⚠️ Binding ciphertext to a fingerprint means the payload becomes
+     * undecryptable the moment the device cookie is cleared. Use only for
+     * ephemeral tokens (short-lived session cookies, one-time links), never
+     * for long-lived user data.
+     */
+    fingerprint?: string;
+}
 /**
  * A CryptoService encrypts plaintext to a serialisable string payload and
  * decrypts it back. Every operation is async because it hits the Web Crypto
@@ -7,9 +25,9 @@ type Bytes = Uint8Array<ArrayBuffer>;
  */
 interface CryptoService {
     /** Encrypt a UTF-8 string to a versioned, base64-encoded payload. */
-    encrypt(plainText: string): Promise<string>;
-    /** Decrypt a payload produced by `encrypt`. */
-    decrypt(payload: string): Promise<string>;
+    encrypt(plainText: string, options?: CryptoOperationOptions): Promise<string>;
+    /** Decrypt a payload produced by `encrypt`. Pass the same `fingerprint` used at encrypt time, if any. */
+    decrypt(payload: string, options?: CryptoOperationOptions): Promise<string>;
     /** Clear any cached derived keys. Safe to call at any time. */
     clearKeyCache(): void;
 }
@@ -41,10 +59,15 @@ interface CryptoServiceConfig {
 interface CryptoAlgorithm {
     /** Short identifier stored as the first segment of every payload (e.g. `'v1'`). */
     readonly version: string;
-    /** Derive a CryptoKey from a passphrase + salt pair. Expected to be idempotent. */
+    /**
+     * Derive a CryptoKey from a passphrase + salt pair. Expected to be idempotent.
+     * When `fingerprint` is provided it is mixed into the key-derivation input
+     * (alongside the passphrase) so ciphertext becomes bound to that fingerprint.
+     */
     deriveKey(args: {
         subtle: SubtleCrypto;
         passphrase: string;
+        fingerprint?: string;
         salt: Bytes;
         iterations: number;
     }): Promise<CryptoKey>;
@@ -82,4 +105,4 @@ interface ParsedPayload {
 declare function encodePayload(parts: ParsedPayload): string;
 declare function parsePayload(payload: string): ParsedPayload;
 
-export { type Bytes as B, type CryptoAlgorithm as C, type ParsedPayload as P, type CryptoService as a, type CryptoServiceConfig as b, encodePayload as e, parsePayload as p };
+export { type Bytes as B, type CryptoAlgorithm as C, type ParsedPayload as P, type CryptoOperationOptions as a, type CryptoService as b, type CryptoServiceConfig as c, encodePayload as e, parsePayload as p };

package/dist/runtime/plugin.mjs

@@ -1,6 +1,7 @@
 import {
   createCryptoService
-} from "../chunk-HNTEUBQ7.mjs";
+} from "../chunk-FKHKOTFR.mjs";
+import "../chunk-FKXZ7VYW.mjs";
 
 // src/runtime/plugin.ts
 import { defineNuxtPlugin } from "#app";

package/dist/runtime/plugin.mjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/runtime/plugin.ts"],"sourcesContent":["import { defineNuxtPlugin } from '#app';\nimport config from '#build/crypto-config.mjs';\n\nimport { createCryptoService } from '../core/create-service';\n\nexport default defineNuxtPlugin(async () => {\n  const { passphrase, iterations, keyCacheSize, provideName } = config;\n\n  if (!passphrase && (import.meta as ImportMeta & { dev?: boolean }).dev) {\n    // eslint-disable-next-line no-console\n    console.warn(\n      `[@alikhalilll/nuxt-crypto] Missing passphrase — $${provideName} will throw when used.`\n    );\n  }\n\n  const service = await createCryptoService({\n    passphrase: String(passphrase).trim(),\n    iterations,\n    keyCacheSize,\n  });\n\n  return {\n    provide: {\n      [provideName]: service,\n    },\n  };\n});\n"],"mappings":";;;;;AAAA,SAAS,wBAAwB;AACjC,OAAO,YAAY;AAInB,IAAO,iBAAQ,iBAAiB,YAAY;AAC1C,QAAM,EAAE,YAAY,YAAY,cAAc,YAAY,IAAI;AAE9D,MAAI,CAAC,cAAe,YAA+C,KAAK;AAEtE,YAAQ;AAAA,MACN,yDAAoD,WAAW;AAAA,IACjE;AAAA,EACF;AAEA,QAAM,UAAU,MAAM,oBAAoB;AAAA,IACxC,YAAY,OAAO,UAAU,EAAE,KAAK;AAAA,IACpC;AAAA,IACA;AAAA,EACF,CAAC;AAED,SAAO;AAAA,IACL,SAAS;AAAA,MACP,CAAC,WAAW,GAAG;AAAA,IACjB;AAAA,EACF;AACF,CAAC;","names":[]}
+{"version":3,"sources":["../../src/runtime/plugin.ts"],"sourcesContent":["import { defineNuxtPlugin } from '#app';\nimport config from '#build/crypto-config.mjs';\n\nimport { createCryptoService } from '../core/create-service';\n\nexport default defineNuxtPlugin(async () => {\n  const { passphrase, iterations, keyCacheSize, provideName } = config;\n\n  if (!passphrase && (import.meta as ImportMeta & { dev?: boolean }).dev) {\n    // eslint-disable-next-line no-console\n    console.warn(\n      `[@alikhalilll/nuxt-crypto] Missing passphrase — $${provideName} will throw when used.`\n    );\n  }\n\n  const service = await createCryptoService({\n    passphrase: String(passphrase).trim(),\n    iterations,\n    keyCacheSize,\n  });\n\n  return {\n    provide: {\n      [provideName]: service,\n    },\n  };\n});\n"],"mappings":";;;;;;AAAA,SAAS,wBAAwB;AACjC,OAAO,YAAY;AAInB,IAAO,iBAAQ,iBAAiB,YAAY;AAC1C,QAAM,EAAE,YAAY,YAAY,cAAc,YAAY,IAAI;AAE9D,MAAI,CAAC,cAAe,YAA+C,KAAK;AAEtE,YAAQ;AAAA,MACN,yDAAoD,WAAW;AAAA,IACjE;AAAA,EACF;AAEA,QAAM,UAAU,MAAM,oBAAoB;AAAA,IACxC,YAAY,OAAO,UAAU,EAAE,KAAK;AAAA,IACpC;AAAA,IACA;AAAA,EACF,CAAC;AAED,SAAO;AAAA,IACL,SAAS;AAAA,MACP,CAAC,WAAW,GAAG;AAAA,IACjB;AAAA,EACF;AACF,CAAC;","names":[]}

package/dist/server/index.d.ts

@@ -0,0 +1,76 @@
+import { setCookie, H3Event } from 'h3';
+
+type CookieSerializeOptions = NonNullable<Parameters<typeof setCookie>[3]>;
+/**
+ * Options for {@link getClientFingerprint}.
+ */
+interface ClientFingerprintOptions {
+    /**
+     * Per-app pepper. Stored in a runtime-config secret (e.g.
+     * `NUXT_CRYPTO_FINGERPRINT_SALT`) — keeping it off the client means the
+     * fingerprint can't be reproduced from a leaked device cookie alone.
+     */
+    salt: string;
+    /** Cookie name holding the device ID. Default `__nuxt_crypto_device`. */
+    cookieName?: string;
+    /** Cookie lifetime in seconds. Default 1 year. */
+    cookieMaxAge?: number;
+    /**
+     * Override individual cookie flags. Sensible defaults apply (`httpOnly: true`,
+     * `sameSite: 'lax'`, `path: '/'`, and `secure` auto-detected from the request
+     * protocol).
+     */
+    cookieOptions?: Partial<CookieSerializeOptions>;
+}
+/**
+ * Pure inputs accepted by {@link deriveFingerprint}. Use this if you already
+ * manage the device identity yourself (e.g. an existing session-cookie system
+ * or a signed JWT) and want to plug a fingerprint into `crypto.encrypt`.
+ */
+interface FingerprintParts {
+    /** Opaque, stable per-device identifier. 16+ random bytes recommended. */
+    deviceId: string;
+    /** Per-app pepper. Required. */
+    salt: string;
+}
+/**
+ * Compute a fingerprint string from explicit parts. SHA-256 → base64.
+ *
+ * The fingerprint is deterministic — call it twice with the same inputs and
+ * you get the same output. That's what lets `crypto.decrypt` succeed on a
+ * payload encrypted earlier with the same device ID.
+ */
+declare function deriveFingerprint(parts: FingerprintParts): Promise<string>;
+/**
+ * Ensure the client has a persistent HttpOnly device-ID cookie, then derive a
+ * fingerprint from it. Call this from Nitro route handlers or server
+ * middleware before encrypting / decrypting.
+ *
+ * Why an HttpOnly cookie (and not the client IP)?
+ *   - **Survives network changes.** The cookie travels with the browser, so
+ *     Wi-Fi ↔ 4G handoffs, cell-tower roaming, VPN rotations, and residential
+ *     IP rotation don't invalidate the fingerprint.
+ *   - **Anti-theft.** The cookie is HttpOnly, so XSS-exfiltrated ciphertext
+ *     stored in localStorage can't be decrypted — the attacker can't read the
+ *     cookie.
+ *   - **Per-device / per-browser.** A token copied to another browser or
+ *     device finds no device cookie there, so it won't decrypt.
+ *
+ * @example
+ * ```ts
+ * // server/api/session.post.ts
+ * import { getClientFingerprint } from '@alikhalilll/nuxt-crypto/server';
+ *
+ * export default defineEventHandler(async (event) => {
+ *   const body = await readBody(event);
+ *   const { $crypto } = useNuxtApp();
+ *   const fingerprint = await getClientFingerprint(event, {
+ *     salt: useRuntimeConfig().cryptoFingerprintSalt,
+ *   });
+ *   return { token: await $crypto.encrypt(JSON.stringify(body), { fingerprint }) };
+ * });
+ * ```
+ */
+declare function getClientFingerprint(event: H3Event, options: ClientFingerprintOptions): Promise<string>;
+
+export { type ClientFingerprintOptions, type FingerprintParts, deriveFingerprint, getClientFingerprint };

package/dist/server/index.mjs

@@ -0,0 +1,42 @@
+import {
+  getRandomBytes,
+  getSubtle,
+  toBase64
+} from "../chunk-FKXZ7VYW.mjs";
+
+// src/server/index.ts
+import { getCookie, getRequestProtocol, setCookie } from "h3";
+var DEFAULT_COOKIE_NAME = "__nuxt_crypto_device";
+var DEFAULT_COOKIE_MAX_AGE = 60 * 60 * 24 * 365;
+var DEVICE_ID_BYTES = 32;
+async function deriveFingerprint(parts) {
+  const material = `${parts.deviceId}\0${parts.salt}`;
+  const subtle = await getSubtle();
+  const hash = await subtle.digest("SHA-256", new TextEncoder().encode(material));
+  return toBase64(new Uint8Array(hash));
+}
+async function getClientFingerprint(event, options) {
+  if (!options.salt) {
+    throw new Error("[nuxt-crypto] getClientFingerprint: `salt` is required.");
+  }
+  const cookieName = options.cookieName ?? DEFAULT_COOKIE_NAME;
+  let deviceId = getCookie(event, cookieName);
+  if (!deviceId) {
+    deviceId = toBase64(getRandomBytes(DEVICE_ID_BYTES));
+    const isSecure = options.cookieOptions?.secure ?? getRequestProtocol(event, { xForwardedProto: true }) === "https";
+    setCookie(event, cookieName, deviceId, {
+      httpOnly: true,
+      sameSite: "lax",
+      path: "/",
+      maxAge: options.cookieMaxAge ?? DEFAULT_COOKIE_MAX_AGE,
+      ...options.cookieOptions,
+      secure: isSecure
+    });
+  }
+  return deriveFingerprint({ deviceId, salt: options.salt });
+}
+export {
+  deriveFingerprint,
+  getClientFingerprint
+};
+//# sourceMappingURL=index.mjs.map

package/dist/server/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/server/index.ts"],"sourcesContent":["import type { H3Event } from 'h3';\nimport { getCookie, getRequestProtocol, setCookie } from 'h3';\n\nimport { toBase64 } from '../core/base64';\nimport { getRandomBytes, getSubtle } from '../core/subtle';\n\n// h3 doesn't re-export its cookie-options type, so derive it from setCookie.\ntype CookieSerializeOptions = NonNullable<Parameters<typeof setCookie>[3]>;\n\nconst DEFAULT_COOKIE_NAME = '__nuxt_crypto_device';\nconst DEFAULT_COOKIE_MAX_AGE = 60 * 60 * 24 * 365; // one year\nconst DEVICE_ID_BYTES = 32;\n\n/**\n * Options for {@link getClientFingerprint}.\n */\nexport interface ClientFingerprintOptions {\n  /**\n   * Per-app pepper. Stored in a runtime-config secret (e.g.\n   * `NUXT_CRYPTO_FINGERPRINT_SALT`) — keeping it off the client means the\n   * fingerprint can't be reproduced from a leaked device cookie alone.\n   */\n  salt: string;\n  /** Cookie name holding the device ID. Default `__nuxt_crypto_device`. */\n  cookieName?: string;\n  /** Cookie lifetime in seconds. Default 1 year. */\n  cookieMaxAge?: number;\n  /**\n   * Override individual cookie flags. Sensible defaults apply (`httpOnly: true`,\n   * `sameSite: 'lax'`, `path: '/'`, and `secure` auto-detected from the request\n   * protocol).\n   */\n  cookieOptions?: Partial<CookieSerializeOptions>;\n}\n\n/**\n * Pure inputs accepted by {@link deriveFingerprint}. Use this if you already\n * manage the device identity yourself (e.g. an existing session-cookie system\n * or a signed JWT) and want to plug a fingerprint into `crypto.encrypt`.\n */\nexport interface FingerprintParts {\n  /** Opaque, stable per-device identifier. 16+ random bytes recommended. */\n  deviceId: string;\n  /** Per-app pepper. Required. */\n  salt: string;\n}\n\n/**\n * Compute a fingerprint string from explicit parts. SHA-256 → base64.\n *\n * The fingerprint is deterministic — call it twice with the same inputs and\n * you get the same output. That's what lets `crypto.decrypt` succeed on a\n * payload encrypted earlier with the same device ID.\n */\nexport async function deriveFingerprint(parts: FingerprintParts): Promise<string> {\n  // NUL separator prevents `\"abc\" + \"d\"` vs `\"ab\" + \"cd\"` collisions.\n  const material = `${parts.deviceId}\\x00${parts.salt}`;\n  const subtle = await getSubtle();\n  const hash = await subtle.digest('SHA-256', new TextEncoder().encode(material));\n  return toBase64(new Uint8Array(hash));\n}\n\n/**\n * Ensure the client has a persistent HttpOnly device-ID cookie, then derive a\n * fingerprint from it. Call this from Nitro route handlers or server\n * middleware before encrypting / decrypting.\n *\n * Why an HttpOnly cookie (and not the client IP)?\n *   - **Survives network changes.** The cookie travels with the browser, so\n *     Wi-Fi ↔ 4G handoffs, cell-tower roaming, VPN rotations, and residential\n *     IP rotation don't invalidate the fingerprint.\n *   - **Anti-theft.** The cookie is HttpOnly, so XSS-exfiltrated ciphertext\n *     stored in localStorage can't be decrypted — the attacker can't read the\n *     cookie.\n *   - **Per-device / per-browser.** A token copied to another browser or\n *     device finds no device cookie there, so it won't decrypt.\n *\n * @example\n * ```ts\n * // server/api/session.post.ts\n * import { getClientFingerprint } from '@alikhalilll/nuxt-crypto/server';\n *\n * export default defineEventHandler(async (event) => {\n *   const body = await readBody(event);\n *   const { $crypto } = useNuxtApp();\n *   const fingerprint = await getClientFingerprint(event, {\n *     salt: useRuntimeConfig().cryptoFingerprintSalt,\n *   });\n *   return { token: await $crypto.encrypt(JSON.stringify(body), { fingerprint }) };\n * });\n * ```\n */\nexport async function getClientFingerprint(\n  event: H3Event,\n  options: ClientFingerprintOptions\n): Promise<string> {\n  if (!options.salt) {\n    throw new Error('[nuxt-crypto] getClientFingerprint: `salt` is required.');\n  }\n\n  const cookieName = options.cookieName ?? DEFAULT_COOKIE_NAME;\n  let deviceId = getCookie(event, cookieName);\n\n  if (!deviceId) {\n    deviceId = toBase64(getRandomBytes(DEVICE_ID_BYTES));\n    const isSecure =\n      options.cookieOptions?.secure ??\n      getRequestProtocol(event, { xForwardedProto: true }) === 'https';\n    setCookie(event, cookieName, deviceId, {\n      httpOnly: true,\n      sameSite: 'lax',\n      path: '/',\n      maxAge: options.cookieMaxAge ?? DEFAULT_COOKIE_MAX_AGE,\n      ...options.cookieOptions,\n      secure: isSecure,\n    });\n  }\n\n  return deriveFingerprint({ deviceId, salt: options.salt });\n}\n"],"mappings":";;;;;;;AACA,SAAS,WAAW,oBAAoB,iBAAiB;AAQzD,IAAM,sBAAsB;AAC5B,IAAM,yBAAyB,KAAK,KAAK,KAAK;AAC9C,IAAM,kBAAkB;AA2CxB,eAAsB,kBAAkB,OAA0C;AAEhF,QAAM,WAAW,GAAG,MAAM,QAAQ,KAAO,MAAM,IAAI;AACnD,QAAM,SAAS,MAAM,UAAU;AAC/B,QAAM,OAAO,MAAM,OAAO,OAAO,WAAW,IAAI,YAAY,EAAE,OAAO,QAAQ,CAAC;AAC9E,SAAO,SAAS,IAAI,WAAW,IAAI,CAAC;AACtC;AAgCA,eAAsB,qBACpB,OACA,SACiB;AACjB,MAAI,CAAC,QAAQ,MAAM;AACjB,UAAM,IAAI,MAAM,yDAAyD;AAAA,EAC3E;AAEA,QAAM,aAAa,QAAQ,cAAc;AACzC,MAAI,WAAW,UAAU,OAAO,UAAU;AAE1C,MAAI,CAAC,UAAU;AACb,eAAW,SAAS,eAAe,eAAe,CAAC;AACnD,UAAM,WACJ,QAAQ,eAAe,UACvB,mBAAmB,OAAO,EAAE,iBAAiB,KAAK,CAAC,MAAM;AAC3D,cAAU,OAAO,YAAY,UAAU;AAAA,MACrC,UAAU;AAAA,MACV,UAAU;AAAA,MACV,MAAM;AAAA,MACN,QAAQ,QAAQ,gBAAgB;AAAA,MAChC,GAAG,QAAQ;AAAA,MACX,QAAQ;AAAA,IACV,CAAC;AAAA,EACH;AAEA,SAAO,kBAAkB,EAAE,UAAU,MAAM,QAAQ,KAAK,CAAC;AAC3D;","names":[]}

package/dist/types/index.d.ts

@@ -1,4 +1,4 @@
-export { B as Bytes, C as CryptoAlgorithm, a as CryptoService, b as CryptoServiceConfig, P as ParsedPayload } from '../payload-Cht5Ar0K.js';
+export { B as Bytes, C as CryptoAlgorithm, a as CryptoOperationOptions, b as CryptoService, c as CryptoServiceConfig, P as ParsedPayload } from '../payload-BOueSWcI.js';
 
 interface CryptoModuleOptions {
     /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@alikhalilll/nuxt-crypto",
-  "version": "1.0.3",
-  "description": "Symmetric Web Crypto service for Nuxt 3/4. AES-256-GCM + PBKDF2 with key caching and pluggable algorithms.",
+  "version": "1.2.1",
+  "description": "Symmetric Web Crypto service for Nuxt 3/4. AES-256-GCM + PBKDF2 with key caching, pluggable algorithms, and optional device-fingerprint binding.",
   "license": "MIT",
   "author": "alikhalilll",
   "repository": {
@@ -9,7 +9,7 @@
     "url": "git+https://github.com/alikhalilll/ali-nuxt-toolkit.git",
     "directory": "packages/crypto"
   },
-  "homepage": "https://github.com/alikhalilll/ali-nuxt-toolkit#readme",
+  "homepage": "https://alikhalilll.github.io/ali-nuxt-toolkit/crypto",
   "bugs": {
     "url": "https://github.com/alikhalilll/ali-nuxt-toolkit/issues"
   },
@@ -25,7 +25,8 @@
     "encryption",
     "aes-gcm",
     "web-crypto",
-    "pbkdf2"
+    "pbkdf2",
+    "fingerprint"
   ],
   "exports": {
     ".": {
@@ -36,6 +37,10 @@
       "types": "./dist/core/index.d.ts",
       "import": "./dist/core/index.mjs"
     },
+    "./server": {
+      "types": "./dist/server/index.d.ts",
+      "import": "./dist/server/index.mjs"
+    },
     "./types": {
       "types": "./dist/types/index.d.ts",
       "import": "./dist/types/index.mjs"
@@ -51,6 +56,9 @@
       "core": [
         "./dist/core/index.d.ts"
       ],
+      "server": [
+        "./dist/server/index.d.ts"
+      ],
       "types": [
         "./dist/types/index.d.ts"
       ]
@@ -65,17 +73,22 @@
     "node": ">=18"
   },
   "peerDependencies": {
-    "@nuxt/kit": "^3.0.0 || ^4.0.0"
+    "@nuxt/kit": "^3.0.0 || ^4.0.0",
+    "h3": "^1.0.0 || ^2.0.0"
   },
   "peerDependenciesMeta": {
     "@nuxt/kit": {
       "optional": true
+    },
+    "h3": {
+      "optional": true
     }
   },
   "devDependencies": {
     "@nuxt/kit": "^4.0.0",
     "@nuxt/schema": "^4.0.0",
     "@types/node": "^22.13.0",
+    "h3": "^1.13.0",
     "rimraf": "^6.0.1",
     "tsup": "^8.5.0",
     "typescript": "^5.9.2"

package/dist/chunk-HNTEUBQ7.mjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/core/algorithms/aes-gcm.ts","../src/core/base64.ts","../src/core/key-cache.ts","../src/core/payload.ts","../src/core/subtle.ts","../src/core/create-service.ts"],"sourcesContent":["import type { CryptoAlgorithm } from '../types';\n\n/**\n * AES-256-GCM with PBKDF2-SHA256 key derivation. This is the default and\n * currently the only built-in algorithm; pluggable via `CryptoServiceConfig.algorithm`.\n */\nexport const aesGcmPbkdf2: CryptoAlgorithm = {\n  version: 'v1',\n\n  async deriveKey({ subtle, passphrase, salt, iterations }) {\n    const keyMaterial = await subtle.importKey(\n      'raw',\n      new TextEncoder().encode(passphrase),\n      { name: 'PBKDF2' },\n      false,\n      ['deriveKey']\n    );\n\n    return subtle.deriveKey(\n      { name: 'PBKDF2', salt, iterations, hash: 'SHA-256' },\n      keyMaterial,\n      { name: 'AES-GCM', length: 256 },\n      false,\n      ['encrypt', 'decrypt']\n    );\n  },\n\n  async encrypt({ subtle, key, plainText }) {\n    const iv = new Uint8Array(new ArrayBuffer(12));\n    globalThis.crypto.getRandomValues(iv);\n    const buf = await subtle.encrypt({ name: 'AES-GCM', iv }, key, plainText);\n    const cipher = new Uint8Array(new ArrayBuffer(buf.byteLength));\n    cipher.set(new Uint8Array(buf));\n    return { cipher, iv };\n  },\n\n  async decrypt({ subtle, key, cipher, iv }) {\n    const buf = await subtle.decrypt({ name: 'AES-GCM', iv }, key, cipher);\n    const out = new Uint8Array(new ArrayBuffer(buf.byteLength));\n    out.set(new Uint8Array(buf));\n    return out;\n  },\n};\n","import type { Bytes } from './types';\n\n/** Encode bytes to standard base64. Works in browser and Node. */\nexport function toBase64(data: Bytes): string {\n  if (typeof btoa === 'function') {\n    let binary = '';\n    const CHUNK = 0x8000;\n    for (let i = 0; i < data.length; i += CHUNK) {\n      binary += String.fromCharCode(...data.subarray(i, i + CHUNK));\n    }\n    return btoa(binary);\n  }\n  // Node fallback — Buffer is globally available in Node.\n  return Buffer.from(data).toString('base64');\n}\n\n/** Decode a base64 string back to bytes. Works in browser and Node. */\nexport function fromBase64(input: string): Bytes {\n  if (typeof atob === 'function') {\n    const binary = atob(input);\n    const out = new Uint8Array(binary.length);\n    for (let i = 0; i < binary.length; i++) out[i] = binary.charCodeAt(i);\n    return out;\n  }\n  const buf = Buffer.from(input, 'base64');\n  const out = new Uint8Array(buf.length);\n  out.set(buf);\n  return out;\n}\n","import type { Bytes } from './types';\nimport { toBase64 } from './base64';\n\n/**\n * A tiny LRU-ish cache for derived `CryptoKey` values, keyed on the salt.\n * When capacity is exceeded the oldest entry is evicted. Derived key\n * material is expensive (PBKDF2 is designed to be slow), so caching has\n * a big impact when decrypting many payloads in a row.\n */\nexport class KeyCache {\n  private readonly map = new Map<string, Promise<CryptoKey>>();\n  constructor(private readonly capacity: number) {}\n\n  static key(salt: Bytes, iterations: number): string {\n    return `${iterations}.${toBase64(salt)}`;\n  }\n\n  get(key: string): Promise<CryptoKey> | undefined {\n    const value = this.map.get(key);\n    if (!value) return undefined;\n    // Refresh recency by re-inserting.\n    this.map.delete(key);\n    this.map.set(key, value);\n    return value;\n  }\n\n  set(key: string, value: Promise<CryptoKey>): void {\n    if (this.capacity <= 0) return;\n    this.map.set(key, value);\n    while (this.map.size > this.capacity) {\n      const oldest = this.map.keys().next().value;\n      if (oldest === undefined) break;\n      this.map.delete(oldest);\n    }\n  }\n\n  clear(): void {\n    this.map.clear();\n  }\n}\n","import { fromBase64, toBase64 } from './base64';\nimport type { Bytes } from './types';\n\n/**\n * Payload serialisation format (v1): `${version}.${saltB64}.${ivB64}.${cipherB64}`.\n *\n * Each part is URL-safe base64, all joined with `.`. The version tag is\n * always the first segment so consumers can route to the correct algorithm\n * during decrypt.\n */\nexport interface ParsedPayload {\n  version: string;\n  salt: Bytes;\n  iv: Bytes;\n  cipher: Bytes;\n}\n\nexport function encodePayload(parts: ParsedPayload): string {\n  return [parts.version, toBase64(parts.salt), toBase64(parts.iv), toBase64(parts.cipher)].join(\n    '.'\n  );\n}\n\nexport function parsePayload(payload: string): ParsedPayload {\n  const segments = payload.split('.');\n  if (segments.length !== 4) {\n    throw new Error('[nuxt-crypto] Invalid payload format — expected 4 dot-separated segments.');\n  }\n  const [version, saltB64, ivB64, cipherB64] = segments;\n  if (!version || !saltB64 || !ivB64 || !cipherB64) {\n    throw new Error('[nuxt-crypto] Invalid payload format — one or more segments were empty.');\n  }\n  return {\n    version,\n    salt: fromBase64(saltB64),\n    iv: fromBase64(ivB64),\n    cipher: fromBase64(cipherB64),\n  };\n}\n","/**\n * Resolve a SubtleCrypto implementation across environments:\n *\n * - Browser / Deno / Bun / Node 20+: `globalThis.crypto.subtle` is available.\n * - Older Node: fall back to `node:crypto`'s `webcrypto`.\n */\nexport async function getSubtle(): Promise<SubtleCrypto> {\n  if (globalThis.crypto?.subtle) return globalThis.crypto.subtle;\n  const { webcrypto } = await import('node:crypto');\n  return webcrypto.subtle as unknown as SubtleCrypto;\n}\n\n/** Fill the given buffer with cryptographically strong random bytes. */\nexport function getRandomBytes(length: number): Uint8Array<ArrayBuffer> {\n  const out = new Uint8Array(length);\n  const c = globalThis.crypto;\n  if (c?.getRandomValues) {\n    c.getRandomValues(out);\n    return out;\n  }\n  throw new Error(\n    '[nuxt-crypto] globalThis.crypto.getRandomValues is not available. Upgrade your runtime.'\n  );\n}\n","import { aesGcmPbkdf2 } from './algorithms/aes-gcm';\nimport { KeyCache } from './key-cache';\nimport { encodePayload, parsePayload } from './payload';\nimport { getRandomBytes, getSubtle } from './subtle';\nimport type { CryptoAlgorithm, CryptoService, CryptoServiceConfig } from './types';\n\nconst DEFAULT_ITERATIONS = 100_000;\nconst DEFAULT_CACHE = 64;\nconst SALT_BYTES = 16;\n\n/**\n * Create a framework-agnostic `CryptoService` from a passphrase.\n *\n * Uses AES-256-GCM with PBKDF2-SHA256 (100k iterations by default). Pass a\n * different `algorithm` to plug in another cipher while preserving the same\n * versioned payload envelope.\n */\nexport async function createCryptoService(config: CryptoServiceConfig): Promise<CryptoService> {\n  if (!config.passphrase) {\n    throw new Error('[nuxt-crypto] passphrase is required.');\n  }\n\n  const iterations = config.iterations ?? DEFAULT_ITERATIONS;\n  const algorithm: CryptoAlgorithm = config.algorithm ?? aesGcmPbkdf2;\n  const subtle = config.subtle ?? (await getSubtle());\n  const cache = new KeyCache(config.keyCacheSize ?? DEFAULT_CACHE);\n  const passphrase = String(config.passphrase).trim();\n  const encoder = new TextEncoder();\n  const decoder = new TextDecoder();\n\n  async function getDerivedKey(salt: Uint8Array<ArrayBuffer>): Promise<CryptoKey> {\n    const key = KeyCache.key(salt, iterations);\n    const cached = cache.get(key);\n    if (cached) return cached;\n    const pending = algorithm.deriveKey({ subtle, passphrase, salt, iterations });\n    cache.set(key, pending);\n    return pending;\n  }\n\n  return {\n    async encrypt(plainText: string): Promise<string> {\n      const salt = getRandomBytes(SALT_BYTES);\n      const key = await getDerivedKey(salt);\n      const encoded = encoder.encode(plainText);\n      const plainBytes = new Uint8Array(new ArrayBuffer(encoded.byteLength));\n      plainBytes.set(encoded);\n      const { cipher, iv } = await algorithm.encrypt({ subtle, key, plainText: plainBytes });\n      return encodePayload({ version: algorithm.version, salt, iv, cipher });\n    },\n\n    async decrypt(payload: string): Promise<string> {\n      const parsed = parsePayload(payload);\n      if (parsed.version !== algorithm.version) {\n        throw new Error(\n          `[nuxt-crypto] Unsupported payload version: ${parsed.version} (algorithm expects ${algorithm.version}).`\n        );\n      }\n      const key = await getDerivedKey(parsed.salt);\n      const plainBytes = await algorithm.decrypt({\n        subtle,\n        key,\n        cipher: parsed.cipher,\n        iv: parsed.iv,\n      });\n      return decoder.decode(plainBytes);\n    },\n\n    clearKeyCache(): void {\n      cache.clear();\n    },\n  };\n}\n"],"mappings":"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","names":["out"]}