SignetGate is a security control, so this page states what it defends, what it assumes, and what it does not cover. It points at the detailed records rather than restating them. Where this page and the published list of limitations disagree, that list is right.
The bypass our pre-pilot integration audit found in some configurations, and its fix, are register entry 34; what stays with the integrator, including keeping payment credentials out of the agent’s reach, is entry 6.
Read these two first
Two entries in the register are launch blockers: they must close before this build is used beyond a scoped pilot. Neither is closed, and no work on this build has closed them.
A scoped pilot is one where the exposure is bounded: shadow mode, where the gated tool records an approval but moves no money; a test account; or a payment ceiling, enforced by the customer’s own payment system, low enough that the exposure is acceptable to them. A ceiling-capped pilot does move real money, which is why the entries below name the pilot as the exception rather than leaving it to be inferred.
1. Reviewer credentials are a development stand-in
A reviewer signs in with an account id and a password. There is no second factor and no
device binding, and that session is the only source of the verifierId written into every
receipt. So a receipt shows that some holder of that credential approved a payment; it does
not show which person did.
Production refuses to boot on password auth unless the operator records, in configuration, that they accept this specific risk, which is a deliberate, self-documenting acceptance rather than a default.
Outside a scoped pilot, do not deploy against real payment rails before SSO with enforced MFA. Full entry: entry 1 in the published limitations.
2. Only the server, not the reviewer’s own machine, binds what is shown to what is signed
The receipt binds a fingerprint of the payment. The review screen renders values derived from that same payload, by one shared implementation, and the server refuses to serve or to certify a payment whose stored bytes no longer hash to their stored hash.
All of that is enforced on our server. The reviewer’s browser does not recompute the fingerprint, so a modified client is outside what any of it reaches. Checking without relying on our server is what the offline checker is for, and it happens after the fact.
What closes it: the console recomputing that fingerprint from the payment it renders, refusing to arm approval unless it matches, and sending it with the decision so the server refuses to sign unless it matches the payment it is signing. That covers divergence between what is displayed and what is signed. It does not cover a modified client or a compromised server, which stay where they are today: with the offline checker, after the fact. Full entry: entry 2 in the published limitations.
Threat model
Four adversaries, in the order the design addresses them.
| # | Adversary | Principal mitigations |
|---|---|---|
| 1 | Compromised or prompt-injected agent: submits a fraudulent payee with a matching doctored invoice | Server-side document capture; the comparison of the invoice data with what the agent extracted, which is a real defence only where the invoice data comes from the finance system (STRUCTURED_FEED) and the payment from the agent’s own tool arguments (register entries 3, 4 and 35) |
| 2 | Fatigued reviewer: approves reflexively | Dwell thresholds and a typed challenge; synthetic payments with planted defects, measured per reviewer |
| 3 | Insider reviewer: approves a payment and later denies it | Identity derived from the authenticated session and never from a request; asymmetric signing; revocable sessions, and accounts disabled when removed from the configuration. Bounded by entry 1 |
| 4 | Post-hoc disputant: contests what was approved or shown | The receipt binds payloadHash and documentSha256; the offline checker answers whether a genuine receipt covers a given payment |
The agent is the untrusted party throughout. It supplies the payload, the document URL and the invoice ground truth, and its self-reported gate configuration is labelled as self-reported everywhere it is displayed.
Cryptographic assumptions
| Purpose | Primitive | Reference |
|---|---|---|
| Receipt signatures | Ed25519, pure (no prehash) | RFC 8032 §5.1 |
| Bytes that get signed | JSON Canonicalization Scheme | RFC 8785 |
| Payload and document fingerprints | SHA-256 | FIPS 180-4 |
| Reviewer password storage | scrypt | RFC 7914 |
| Session cookie integrity | HMAC-SHA-256 | RFC 2104 |
What these give:
Signatures are existentially unforgeable under chosen-message attack. That is a claim about producing a signature without the private key. It is not a claim that a receipt is about the payment in front of you: a receipt can be authentic, unaltered and about something else, which is why the checking tools compare a payment instruction against it and report
PAYLOAD_MISMATCHas a distinct verdict.Signature-string uniqueness is not claimed. Ed25519 malleability is a property of each implementation that checks signatures, and this repository runs three (Node, browser WebCrypto, the offline page). Nothing here depends on a signature being the only valid one for a message: receipts are identified by
receiptId, with a uniqueness constraint per verification, and are never keyed by signature.The auditor tools do not leave key and encoding edge cases to the engine. Browsers accept a signature under a small-order public key for any message; Node refuses it. So the offline page,
verify.jsand the repository’s command-line checker, by the same rules:- refuse small-order and non-canonical keys before any crypto runs, any key or signature R outside Ed25519’s prime-order subgroup, and a signature whose R is the identity point, about which engines disagree;
- accept only the signature form the signer writes (unpadded base64url, no stray bits);
- refuse a receipt file with a repeated field, a field outside the signed set, or a value the receipt schema does not allow, whoever signed it;
- read a receipt file as UTF-8, strictly, removing one byte-order mark and nothing else, and name it by the fingerprint of its bytes;
- judge the one unsigned field, the certificate link, by a fixed pattern rather than by the engine’s URL parser;
- accept a public key only as one PEM block labelled
PUBLIC KEYholding an Ed25519 key, so a private key, a certificate or a second block is refused.
The same file gets the same answer from all three. That is measured, in Node, Chromium and Firefox, on the published Ed25519 test vectors (Wycheproof and ed25519-speccheck) and on our own edge cases. Safari is not part of that measurement; the current build was checked in Safari by hand (register entry 11). The SDK and the review console read receipts and keys by the same rules, and check that the key they hold is the one the receipt names. A private key pinned in the SDK stops it starting.
Canonicalisation is a narrowing of RFC 8785, deliberately. Non-integer numbers and lone surrogates are rejected rather than serialised, so the cross-language reproducibility claim stays cheap to honour. A second encoder, for the raw tool arguments, has weaker guarantees by design and is kept out of every hashing and signing path by a source-level allowlist. Unicode is not normalised, and agreement with other JCS implementations depends on that.
HMAC for session cookies is not a substitute for asymmetric signing. A cookie is issued and verified by the same server and is never handed to anyone as evidence. Receipts are third-party-verifiable and use Ed25519.
The offline checker uses the browser’s own Ed25519 and bundles no crypto library, so
there is no opaque blob to trust. It self-tests against RFC 8032’s published vector before
judging anything, including confirming that it refuses a signature it should refuse, and
reports CANNOT_CHECK rather than a verdict where the algorithm is unavailable.
The checker’s own hashes are published here, away from the bundle. Register entry 11 tells an
auditor to compare the file against a hash obtained separately from it, and SHA256SUMS.txt
travels with the file it describes, so this page is the separate copy. A mismatch means the
copy changed after publication: get a fresh one.
| File | SHA-256 |
|---|---|
signetgate-verifier.html |
1dc365170f22e4a1ebd06887448fb83935074df9943cc418edfa7e92e67457a0 |
verify.js |
cceaf6cdf9b2c1214253723b8337a1231248079f6b484f8867ebb48d9e5e0737 |
A pilot gets four files from each release: SignetGate’s three packages, the SDK, its core
library and the onboarding self-check, as tarballs, and the pilot pack, a .zip of the README,
the pilot runbook, the pilot quick start and the shadow-mode starter. The SHA-256 of each is
published here for the same reason. Check the pilot pack against this page before you open it,
and each tarball before you install it, and use none of them if any differs.
No release has been published yet. Its values appear here when it is.
Trust boundaries
| Boundary | What crosses it | How it is treated |
|---|---|---|
| Agent → API | Payload, raw tool args, ground truth, document URL, gate attestation | Authenticated by API key; agentId derived from the key and refused in a body. Validated with strict schemas. Two free-text fields are restricted to a character class, to single spaces between words and to Unicode normalisation form C, so displayed text matches hashed text |
invoiceDocumentUrl → vault |
Attacker-supplied URL | Fetched server-side behind a host allowlist, with DNS resolution checked against private, loopback, link-local, metadata and special-purpose ranges, in every spelling of an address (including the IPv4-mapped, IPv4-compatible, NAT64 and 6to4 IPv6 forms, which are classified by the IPv4 address they carry; three other forms are not, register entry 31), the connection pinned to the validated address, every redirect hop re-checked, size and type capped and magic-byte sniffed |
| Vault → browser | Attacker-supplied document bytes | Parsed by pdf.js inside a hidden, opaque-origin sandbox with no allow-same-origin. The page sets that sandbox in its own policy and may be framed only by the console, so it holds however the page is opened. Only an ImageBitmap and integers return; nothing from the frame is rendered as text or markup |
| Browser → API | Decisions, claims, telemetry | Session cookie derived identity; client-reported telemetry recorded as claims, with the enforced quantities measured server-side |
| Receipt → auditor | Signed evidence | Verifiable offline against the public key the customer recorded, with no network and no dependency on this repository |
Sandbox containment rests on three independent layers: the sandbox’s own connect-src, the
session cookie’s SameSite, and an Origin allowlist on state-changing routes. Because
three mechanisms prevent one outcome, that outcome is not evidence for any of them, so each
is asserted separately.
The offline checker carries default-src 'none', so the page cannot fetch, load or connect
to anything, and its policy names the SHA-256 of the one script it ships. An altered copy
refuses to run rather than running altered. That catches alteration of the script alone, not
someone who rewrites the pin along with it, which is what the published SHA-256 is for
(register entry 11).
The console’s PDF sandbox is a different policy, for a different reason: 'strict-dynamic'
was measured there letting an injected inline script run, so it names an explicit origin
instead.
Reporting a vulnerability
Email security@signetry.co.uk. This address is for vulnerability reports only. For pilots and other enquiries, use pilot@signetry.co.uk.
Please report privately rather than opening a public issue. Include what you did, what you observed, and what you expected. A proof of concept helps; a working exploit is welcome and not required.
We aim to acknowledge within 3 working days and to give an assessment within 10. There is no bug bounty.
In scope: SignetGate’s software (the SDK, the backend API, the verifier console, the canonicaliser and the offline checker) and signetry.co.uk.
Pilot deployments: we operate each pilot deployment for a customer, and it holds that customer’s data, so it is in scope only with written permission from both us and that customer.
Rules of engagement:
- Test only a deployment you operate, or one you have written permission to test.
- Do not use real customer or payment data. If you come across personal or customer data, stop, keep no copy, and tell us.
- Stop once you have a proof of concept, rather than going further.
- No load or denial-of-service testing, no social engineering of our staff or our customers’ staff, no physical access, and no automated scanning that degrades a live service.
Out of scope, because they are already documented: anything in the published list of limitations. Reports naming an entry there are read with interest where they show the exposure is larger than the entry claims, and that is a useful report. A report that restates an entry is not a finding.
Also out of scope: the seeded development credentials in .env.example, the self-signed TLS
fixture used by our own tests (generated for tests, never served), and the
development-only mock invoice routes, which exist only when the server is started with
NODE_ENV=development or test. An unset NODE_ENV runs as production, and the server says
at boot which mode it resolved.
Known limitations
Every one is written up in the register: what could go wrong and what to do, what it is, what it doesn’t affect, what limits the damage today, what would close it, and any earlier findings that are now fixed. They are not restated here.
- 1. The reviewer credential model is a development stand-in (launch blocker)
- 2. Only the server, not the reviewer’s own machine, binds what is shown to what is signed (launch blocker)
- 3. Rendering deception is unmitigated
- 4. OCR-sourced ground truth is not independent of the document it is compared against
- 5. The render-failure signal is client-reported and can be suppressed
- 6. Shadow detection cannot see settings-file allow rules
- 7.
PreToolUsehook precedence is documented, not measured - 8. Confirmation of Payee is simulated
- 9. A single reviewer can approve any payment
- 10. Coverage is not uniform: some paths are tested only against stubs
- 11. The offline checker moves the auditor’s trust, it does not remove it
- 12. Payee names that differ only in accented letters collide in the fingerprint
- 13. Two duty-of-care checks rest on what the server cannot verify, and the release check lives in our client
- 14. A review can outlive the call it was opened for
- 15. The Claude Code version floor rests on what the host reports
- 16. The same payment awaiting review twice is not flagged, and another agent’s decisions are not consulted (known defect; fix deferred until after the shadow pilots start)
- 17. Whoever runs the server can weaken every control, and nothing records it
- 18. There is no key rotation or compromise procedure
- 19. An SDK without pinned keys trusts the server that signs its receipts
- 20. A payee approved once counts as seen, for every agent and for good
- 21. Fixed: production started with the repository’s published example secrets
- 22. The SDK leaks a listener on every call made with a reused abort signal (defect)
- 23. The SDK accepts a plain-HTTP address and a review window it did not ask for (defect)
- 24. A slow document host can hold every capture slot, and payments are refused (defect)
- 25. Failed sign-ins can fill the server’s disk (defect)
- 26. After one lockout, a single wrong password locks a reviewer out again (defect)
- 27. Responses carrying payment details are not marked uncacheable (defect)
- 28. Fixed: invoice data was shown without isolating its text direction
- 29. Only submitting, withdrawing, signing in and the readiness check are rate-limited
- 30. The server’s clock decides dwell and the deadline, and a step in it counts
- 31. The address classifier treats three IPv6 forms as public (defect)
- 32. A reviewer’s refusal reason can look like a system refusal (defect)
- 33. A receipt’s certificate link is not signed
- 34. Fixed: the gate could be bypassed in some integration configurations
- 35. The comparison is only as independent as the integration builds it
- 36. A restore from backup, or a crash of the host, can lose decisions already answered
- 37. Nothing in the SDK tells a shadow integration from a paying one
- 38. An integration that sets its own idempotency key can release two calls on one approval (defect)
- 39. One person operates every pilot
Two are easy to assume away, so they are stated here as well:
- Homoglyphs are not detected. The character class on vendor names admits any Unicode
letter, deliberately, so that a legitimate non-Latin supplier is not refused. A Cyrillic
оin a Latin name passes it. What limits the exposure depends on where the invoice data came from. Compared against the finance system’s own name, such a name gives a CoPNO_MATCHand a mismatch, and the payment is elevated. Compared against the agent’s own invoice data, it matches, and it is elevated only as a new payee, until a payment to that payee has been approved. A payment to an account the same agent had refused within the look-back window (90 days by default, which the operator can change) is flagged as previously refused under any name, if the refusal judged the payee. A system refusal, or a reviewer’s because the document was missing or unreadable, the payment had already been made, or the payment is held to confirm with the supplier, is remembered only for the same payment. Register entries 2 and 16 have the measurements and the rule. - Confirmation of Payee is simulated in this version, and every surface showing a result carries a label saying it is simulated and not a live CoP response. Configuring a live check throws at boot rather than degrading quietly.