@openwop/openwop-conformance 1.136.10 → 1.138.1

package/src/scenarios/webhook-receiver-adversarial.test.ts

@@ -17,7 +17,7 @@
  *      delivers body B'. Receiver MUST reject with
  *      `signature_mismatch`.
  *   2. Tampered HMAC — body is valid; adversary flips a byte of the
- *      v1=<hex> signature. Receiver MUST reject with
+ *      sha256=<hex> signature. Receiver MUST reject with
  *      `signature_mismatch`.
  *   3. Stale timestamp — body + HMAC are valid but timestamp is
  *      older than the default 5-minute window. Receiver MUST reject
@@ -42,6 +42,7 @@ import {
   createReceiverState,
   signPayload,
   verifyWebhookDelivery,
+  SIGNATURE_PREFIX,
 } from '../lib/webhook-receiver.js';
 
 describe('webhook-receiver-adversarial: receiver rejects five canonical attacks', () => {
@@ -93,8 +94,13 @@ describe('webhook-receiver-adversarial: receiver rejects five canonical attacks'
   it('case 2: tampered HMAC → signature_mismatch', () => {
     const state = createReceiverState();
     const { signatureHeader, timestampHeader, algorithmHeader } = signPayload(secret, ts, body);
-    // Flip one hex character of the v1=<hex> signature.
-    const flipIndex = 5;
+    // Flip one hex character of the `sha256=<hex>` signature. Derived from
+    // SIGNATURE_PREFIX rather than hard-coded: the literal `5` was inside the
+    // hex only while the prefix was the (non-spec) `v1=`, and silently moved
+    // INTO the prefix when it was corrected to `sha256=` — turning a
+    // tampered-HMAC case into a malformed-header one. The test caught it; the
+    // constant is what makes it stay caught.
+    const flipIndex = SIGNATURE_PREFIX.length + 2;
     const orig = signatureHeader[flipIndex]!;
     const replacement = orig === '0' ? '1' : '0';
     const tampered = signatureHeader.slice(0, flipIndex) + replacement + signatureHeader.slice(flipIndex + 1);

package/src/scenarios/webhook-signed-delivery.test.ts

@@ -7,7 +7,11 @@
  *   2. `X-openwop-Signature-Algorithm: v1` header is present.
  *   3. `X-openwop-Signature` is a valid HMAC-SHA256 of
  *      `${timestamp}.${rawBody}` under the subscription secret.
- *   4. `X-openwop-Subscription-Id` matches the returned subscription id.
+ *   4. `X-openwop-Webhook-Id` matches the returned `webhookId`.
+ *      (This line said `X-openwop-Subscription-Id` until 2026-08-19, two years
+ *      after the assertion below stopped checking that header — a docblock
+ *      asserting more than the code did, in the file that documents a
+ *      security-relevant contract.)
  *
  * Capability-gated: skips when the host does not advertise
  * `capabilities.webhooks.supported = true`.
@@ -122,10 +126,23 @@ describe('webhook-signed-delivery: end-to-end HMAC v1', () => {
 
     expect(reg.status, driver.describe(
       'webhooks.md §"Register"',
-      'POST /v1/webhooks MUST return 201 with subscriptionId + secret on success',
+      'POST /v1/webhooks MUST return 201 with webhookId + secret on success',
     )).toBe(201);
-    const sub = reg.json as { subscriptionId: string; secret: string };
-    expect(typeof sub.subscriptionId).toBe('string');
+    // `webhookId`, NOT `subscriptionId` (corrected 2026-08-19). `webhooks.md`
+    // §"Register" shows `{"webhookId": "wh_a3b9c2", ...}`, `api/openapi.yaml`
+    // declares the 201 body `required: [webhookId]` with no `subscriptionId`
+    // property at all, and the sibling `webhook-tenant-isolation.test.ts` reads
+    // `webhookId`. This file required a field the contract does not define, so a
+    // SPEC-CONFORMING host failed at the first assertion — the suite being
+    // different from the spec, which is worse than the stricter-than-spec case
+    // COMPATIBILITY.md §2.3 forbids. Reported by a tier-2 host emitting exactly
+    // what the spec shows. The postgres reference host returns both names, which
+    // is why nothing went red here.
+    const sub = reg.json as { webhookId: string; secret: string };
+    expect(typeof sub.webhookId, driver.describe(
+      'api/openapi.yaml registerWebhook 201',
+      'the 201 body MUST carry `webhookId` (required) — `subscriptionId` is not in the contract',
+    )).toBe('string');
     expect(typeof sub.secret).toBe('string');
     expect(sub.secret.length).toBeGreaterThan(0);
 
@@ -174,7 +191,7 @@ describe('webhook-signed-delivery: end-to-end HMAC v1', () => {
     expect(
       first.headers['x-openwop-webhook-id'],
       driver.describe('webhooks.md §"Delivery headers"', 'X-openwop-Webhook-Id MUST carry the subscription id'),
-    ).toBe(sub.subscriptionId);
+    ).toBe(sub.webhookId);
 
     const timestamp = first.headers['x-openwop-timestamp'];
     expect(
@@ -201,7 +218,7 @@ describe('webhook-signed-delivery: end-to-end HMAC v1', () => {
     expect(event.runId).toBe(runId);
 
     // Cleanup: unregister.
-    const del = await driver.delete(`/v1/webhooks/${encodeURIComponent(sub.subscriptionId)}`);
+    const del = await driver.delete(`/v1/webhooks/${encodeURIComponent(sub.webhookId)}`);
     expect(del.status).toBeGreaterThanOrEqual(200);
     expect(del.status).toBeLessThan(300);
   });

package/src/setup.ts

@@ -32,7 +32,7 @@ import { McpFakeServer, setMcpFakeServer } from './lib/mcp-fake-server.js';
 import { A2AFakePeer, setA2AFakePeer } from './lib/a2a-fake-peer.js';
 import { afterAll, afterEach, beforeAll, expect } from 'vitest';
 import { basename } from 'node:path';
-import { recordRequirement, journalLength, journalSince } from './lib/requirement-ledger.js';
+import { recordRequirement, hasRequirement, journalLength, journalSince } from './lib/requirement-ledger.js';
 import { requirementIdForFile, resolveFileRecord, type FileTestState } from './lib/scenario-disposition.js';
 import { softSkipDisposition } from './lib/soft-skip.js';
 import type { DiscoveryPayload } from './lib/profiles.js';
@@ -279,10 +279,29 @@ afterAll(({}, suite) => {
   // honest bundle row and the pressure to say why both survive. The rule is
   // `resolveFileRecord` (pinned by conformance-execution-witness.test.ts).
   const { disposition, detail } = resolveFileRecord(states, gateReason, assertionCount, softSkipDisposition(file));
-  try {
-    recordRequirement(requirementIdForFile(file), disposition, detail, { assertionCount });
-  } catch {
-    /* a scenario that recorded its own file id first wins; never fail the file for bookkeeping */
+  const fileRequirementId = requirementIdForFile(file);
+  // A scenario that classified ITSELF wins outright — including its `detail` and
+  // its `assertionCount`.
+  //
+  // The `catch` below has always made the explicit record win when the two
+  // DISAGREE (`recordRequirement` throws on a conflicting disposition). It did
+  // not when they AGREE: the automatic call then reached `ledger.set` and
+  // silently replaced the scenario's own detail and count with the file-level
+  // ones. Invisible until 2026-08-19, when `resolveFileRecord` started attaching
+  // a `partial-witness:` marker — a scenario that recorded `executed-pass` for a
+  // requirement it really did exercise, in a file whose LAST leg soft-skipped,
+  // would have been stamped "may not have witnessed this" over its own explicit
+  // finding. That would inject false positives into exactly the measurement the
+  // marker exists to produce.
+  //
+  // So the comment describing this line was true of half the cases. It is true
+  // of both now.
+  if (!hasRequirement(fileRequirementId)) {
+    try {
+      recordRequirement(fileRequirementId, disposition, detail, { assertionCount });
+    } catch {
+      /* never fail a file for bookkeeping */
+    }
   }
   _fileStates.delete(file);
   _fileAssertions.delete(file);