@askalf/dario 4.8.76 → 4.8.78

package/dist/cch.d.ts

@@ -0,0 +1,26 @@
+/** Verified per-release seeds, keyed on `major.minor.patch`. */
+export declare const CCH_SEEDS: Record<string, bigint>;
+/** Canonical xxHash64 of `data` with a 64-bit `seed`. */
+export declare function xxh64(data: Uint8Array, seed: bigint): bigint;
+/**
+ * Deterministic 5-hex cch for a serialized body under an EXPLICIT seed, or
+ * null if the body carries no `cch=XXXXX` token. Used by `scripts/cch-
+ * calibrate.mjs` to test candidate seeds against a live capture without going
+ * through the version table.
+ */
+export declare function cchWithSeed(bodyText: string, seed: bigint): string | null;
+/**
+ * Deterministic 5-hex `cch` for a serialized request body, or null when:
+ *  - `version` (major.minor.patch) has no known seed, or
+ *  - the body carries no `cch=XXXXX` billing token to stamp.
+ * A null return means the caller should keep its random placeholder.
+ */
+export declare function cchForBody(bodyText: string, version: string): string | null;
+/**
+ * Return `bodyText` with the billing-tag cch replaced in place by the
+ * deterministic value for `version`, or unchanged when the version has no
+ * known seed or the body has no billing token. The replacement is anchored to
+ * the billing tag (CCH_RE), so conversation content that quotes a cch is never
+ * touched. Used by the proxy at outbound-serialize time.
+ */
+export declare function stampCch(bodyText: string, version: string): string;

package/dist/cch.js

@@ -0,0 +1,161 @@
+// Deterministic Claude Code request-integrity hash (`cch`) — dario#528.
+//
+// Claude Code stamps each /v1/messages request with a 5-hex `cch` token inside
+// the `x-anthropic-billing-header` system block. It is NOT random: it is an
+// xxHash64 over a canonical PROJECTION of the request body, masked to 20 bits.
+// Reverse-engineered by lwsh123k (dario#528) and verified here against live
+// captures on Claude Code 2.1.177:
+//
+//   material = the serialized body, transformed by:
+//     1. reset the `cch=XXXXX` token to `cch=00000`
+//     2. blank the "model" VALUE (keep the key)
+//     3. delete "fallbacks", "fallback_credit_token", "max_tokens"
+//     4. re-serialize as compact JSON (JSON.stringify)
+//   cch = ( xxHash64(material, SEED[version]) & 0xFFFFF ) as zero-padded 5-hex
+//
+// The excluded fields are exactly the ones a routing proxy rewrites (model,
+// fallbacks, max_tokens), so the value is STABLE across dario's rewrites — the
+// upstream re-derives the same projection from whatever we send and recomputes
+// the identical hash. dario therefore only has to hash its own final body.
+//
+// The seed rotates per Claude Code release and is keyed on major.minor.patch
+// (the build-tag suffix, e.g. ".e2d" vs ".dd9", does NOT change it — verified
+// against two captures with different suffixes, same 2.1.177 seed). An unknown
+// version returns null so the caller falls back to a random value (the
+// pre-dario#528 behavior) rather than emitting a confident-but-wrong hash that
+// a validating server could single out.
+/** Verified per-release seeds, keyed on `major.minor.patch`. */
+export const CCH_SEEDS = {
+    '2.1.177': 0x4d659218e32a3268n,
+};
+const MASK = 0xfffffn;
+const U64 = (1n << 64n) - 1n;
+// xxHash64 primes.
+const P1 = 0x9e3779b185ebca87n;
+const P2 = 0xc2b2ae3d27d4eb4fn;
+const P3 = 0x165667b19e3779f9n;
+const P4 = 0x85ebca77c2b2ae63n;
+const P5 = 0x27d4eb2f165667c5n;
+const rotl = (x, r) => ((x << r) | (x >> (64n - r))) & U64;
+function round(acc, input) {
+    acc = (acc + input * P2) & U64;
+    acc = rotl(acc, 31n);
+    return (acc * P1) & U64;
+}
+function mergeRound(acc, val) {
+    const r = round(0n, val);
+    acc = (acc ^ r) & U64;
+    return (acc * P1 + P4) & U64;
+}
+/** Canonical xxHash64 of `data` with a 64-bit `seed`. */
+export function xxh64(data, seed) {
+    const len = data.length;
+    const dv = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    let h;
+    let i = 0;
+    if (len >= 32) {
+        let v1 = (seed + P1 + P2) & U64;
+        let v2 = (seed + P2) & U64;
+        let v3 = seed & U64;
+        let v4 = (seed - P1) & U64;
+        const limit = len - 32;
+        while (i <= limit) {
+            v1 = round(v1, dv.getBigUint64(i, true));
+            i += 8;
+            v2 = round(v2, dv.getBigUint64(i, true));
+            i += 8;
+            v3 = round(v3, dv.getBigUint64(i, true));
+            i += 8;
+            v4 = round(v4, dv.getBigUint64(i, true));
+            i += 8;
+        }
+        h = (rotl(v1, 1n) + rotl(v2, 7n) + rotl(v3, 12n) + rotl(v4, 18n)) & U64;
+        h = mergeRound(h, v1);
+        h = mergeRound(h, v2);
+        h = mergeRound(h, v3);
+        h = mergeRound(h, v4);
+    }
+    else {
+        h = (seed + P5) & U64;
+    }
+    h = (h + BigInt(len)) & U64;
+    while (i + 8 <= len) {
+        const k1 = round(0n, dv.getBigUint64(i, true));
+        h = (h ^ k1) & U64;
+        h = (rotl(h, 27n) * P1 + P4) & U64;
+        i += 8;
+    }
+    if (i + 4 <= len) {
+        h = (h ^ ((BigInt(dv.getUint32(i, true)) * P1) & U64)) & U64;
+        h = (rotl(h, 23n) * P2 + P3) & U64;
+        i += 4;
+    }
+    while (i < len) {
+        h = (h ^ ((BigInt(data[i]) * P5) & U64)) & U64;
+        h = (rotl(h, 11n) * P1) & U64;
+        i += 1;
+    }
+    h = (h ^ (h >> 33n)) & U64;
+    h = (h * P2) & U64;
+    h = (h ^ (h >> 29n)) & U64;
+    h = (h * P3) & U64;
+    h = (h ^ (h >> 32n)) & U64;
+    return h;
+}
+// Match the cch token INSIDE the billing tag specifically — never a stray
+// `cch=#####` quoted in conversation content (which sorts before `system` in
+// the body, so a naive first-match would grab it, mis-hash, AND silently
+// rewrite the user's text at stamp time — dario#528). Anchor on the
+// `cc_entrypoint=<value>; cch=` that immediately precedes it in the billing
+// header. The entrypoint value is BOUNDED ({1,32}) so the match stays linear
+// on a 10 MB body — an unbounded `[^"]*?` span here is O(n^2) when the anchor
+// repeats (CodeQL js/polynomial-redos). Anchoring is also what real CC must
+// do, so this matches upstream behavior, not just our own correctness.
+const CCH_RE = /(cc_entrypoint=[a-z0-9-]{1,32}; cch=)[0-9a-fA-F]{5}(?=;)/;
+/** Build the canonical cch pre-image bytes from a serialized request body. */
+function cchMaterial(bodyText) {
+    const zeroed = bodyText.replace(CCH_RE, (_m, prefix) => `${prefix}00000`);
+    const body = JSON.parse(zeroed);
+    body.model = '';
+    delete body.fallbacks;
+    delete body.fallback_credit_token;
+    delete body.max_tokens;
+    return new TextEncoder().encode(JSON.stringify(body));
+}
+/**
+ * Deterministic 5-hex cch for a serialized body under an EXPLICIT seed, or
+ * null if the body carries no `cch=XXXXX` token. Used by `scripts/cch-
+ * calibrate.mjs` to test candidate seeds against a live capture without going
+ * through the version table.
+ */
+export function cchWithSeed(bodyText, seed) {
+    if (!CCH_RE.test(bodyText))
+        return null;
+    const h = xxh64(cchMaterial(bodyText), seed) & MASK;
+    return h.toString(16).padStart(5, '0');
+}
+/**
+ * Deterministic 5-hex `cch` for a serialized request body, or null when:
+ *  - `version` (major.minor.patch) has no known seed, or
+ *  - the body carries no `cch=XXXXX` billing token to stamp.
+ * A null return means the caller should keep its random placeholder.
+ */
+export function cchForBody(bodyText, version) {
+    const seed = CCH_SEEDS[version];
+    if (seed === undefined)
+        return null;
+    return cchWithSeed(bodyText, seed);
+}
+/**
+ * Return `bodyText` with the billing-tag cch replaced in place by the
+ * deterministic value for `version`, or unchanged when the version has no
+ * known seed or the body has no billing token. The replacement is anchored to
+ * the billing tag (CCH_RE), so conversation content that quotes a cch is never
+ * touched. Used by the proxy at outbound-serialize time.
+ */
+export function stampCch(bodyText, version) {
+    const cch = cchForBody(bodyText, version);
+    if (cch === null)
+        return bodyText;
+    return bodyText.replace(CCH_RE, (_m, prefix) => `${prefix}${cch}`);
+}

package/dist/live-fingerprint.d.ts

@@ -282,7 +282,7 @@ export declare function _resetInstalledVersionProbeForTest(): void;
  */
 export declare const SUPPORTED_CC_RANGE: {
     readonly min: "1.0.0";
-    readonly maxTested: "2.1.177";
+    readonly maxTested: "2.1.178";
 };
 /**
  * Compare two dotted-numeric version strings. Returns negative if `a<b`,

package/dist/live-fingerprint.js

@@ -786,7 +786,7 @@ export function _resetInstalledVersionProbeForTest() {
  */
 export const SUPPORTED_CC_RANGE = {
     min: '1.0.0',
-    maxTested: '2.1.177',
+    maxTested: '2.1.178',
 };
 /**
  * Compare two dotted-numeric version strings. Returns negative if `a<b`,

package/dist/proxy.js

@@ -9,6 +9,7 @@ import { arch, platform } from 'node:process';
 import { getAccessToken, getStatus } from './oauth.js';
 import { buildHealthResponse } from './health-response.js';
 import { buildCCRequest, applyCcPromptCaching, parseEffortSuffix, reverseMapResponse, createStreamingReverseMapper, orderHeadersForOutbound, CC_TEMPLATE } from './cc-template.js';
+import { stampCch } from './cch.js';
 import { describeTemplate, detectDrift, checkCCCompat } from './live-fingerprint.js';
 import { AccountPool, computeStickyKey, parseRateLimits, modelFamily, isInAuthCooldown, authCooldownMs } from './pool.js';
 import { Analytics, billingBucketFromClaim } from './analytics.js';
@@ -44,19 +45,16 @@ function computeBuildTag(userMessage, version) {
     const chars = [4, 7, 20].map(i => userMessage[i] || '0').join('');
     return createHash('sha256').update(`${BILLING_SEED}${chars}${version}`).digest('hex').slice(0, 3);
 }
-// Per-request cch. NOTE: real Claude Code does NOT randomise this — it's a
-// deterministic xxHash64 integrity hash over the serialized request body,
-// written in place over a `cch=00000` placeholder inside the billing-tag
-// system block (reverse-engineered on cc_version=2.1.37; see dario#528).
-//
-// We emit a random 5-hex value on purpose. The published seed
-// (0x6E52736AC806831E) + scope do NOT reproduce the cch on current CC
-// (falsified against a live 2.1.177 capture), and the seed/scope appear to
-// rotate between releases. A deterministic-but-wrong value is no better than
-// random against a server that recomputes — and a cleaner tell — whereas a
-// random value keeps the right shape (5 lowercase hex) and varies per request
-// like the real one. Revisit only if Anthropic starts rejecting on cch, which
-// would require re-RE'ing the current binary for the live seed + pre-image.
+// Per-request cch PLACEHOLDER. Claude Code's cch is a deterministic xxHash64
+// over a projection of the request body (see src/cch.ts, dario#528). We can
+// only compute the real value once the final body is assembled, so we seed the
+// billing tag with a random 5-hex token here and overwrite it in place with the
+// deterministic value at serialize time (the `cchForBody` call near the
+// JSON.stringify of the outbound body). For Claude Code versions whose seed we
+// haven't reverse-engineered, `cchForBody` returns null and this random value
+// is what ships — same behavior as before dario#528, and a better tell than a
+// confident-but-wrong deterministic hash. Operators can force the random path
+// on every request with DARIO_CCH=random.
 function computeCch() {
     return randomBytes(3).toString('hex').slice(0, 5);
 }
@@ -1768,7 +1766,20 @@ export async function startProxy(opts = {}) {
                             oc.effort = bestSupportedEffort(supportedEfforts);
                         }
                     }
-                    finalBody = Buffer.from(JSON.stringify(r));
+                    // dario#528: overwrite the random cch placeholder with the real
+                    // deterministic value for Claude Code versions whose seed we've
+                    // reverse-engineered. stampCch hashes a projection of THIS final body
+                    // (so it must run after every mutation above) and replaces the cch
+                    // anchored to the billing tag — never a cch quoted in conversation
+                    // content. No-op for unknown versions (keep the random placeholder).
+                    // Only the template-replay path is stamped — passthrough /
+                    // count_tokens forward the client's body (and its own cch) verbatim.
+                    // Reversible kill-switch: DARIO_CCH=random.
+                    let outboundText = JSON.stringify(r);
+                    if (!passthrough && !isCountTokens && process.env.DARIO_CCH !== 'random') {
+                        outboundText = stampCch(outboundText, cliVersion);
+                    }
+                    finalBody = Buffer.from(outboundText);
                 }
                 catch { /* not JSON, send as-is */ }
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askalf/dario",
-  "version": "4.8.76",
+  "version": "4.8.78",
   "description": "Use your Claude Pro/Max subscription in any tool — Cursor, Cline, Aider, the Agent SDK, your scripts — at subscription pricing, not per-token API bills. One local Anthropic + OpenAI-compatible endpoint.",
   "type": "module",
   "bin": {
@@ -32,6 +32,7 @@
     "compat": "node test/compat.mjs",
     "lint:pkg": "node scripts/check-package-json.mjs",
     "drift:sdk": "node scripts/check-sdk-drift.mjs",
+    "cch:calibrate": "node scripts/cch-calibrate.mjs",
     "fix:pkg": "node -e \"const fs=require('fs');fs.writeFileSync('package.json',JSON.stringify(JSON.parse(fs.readFileSync('package.json','utf-8')),null,2)+'\\n')\""
   },
   "keywords": [