Custinel

Independent machine-state verification

Know what your machines actually booted. Verify it outside the machine.

Custinel checks the booted state of a machine against its published reference, and it belongs neither to the machine it checks nor to the vendor who built it.

Each machine provides evidence of its measured state, signed by its TPM. Custinel checks the signature and the device, compares the state with the reference, rejects evidence it has already accepted, and records the verdict with its reason. In the terms of RFC 9334, it is the Verifier.

How it works

The machine provides signed evidence. Someone else decides.

A machine's report about itself is worth little if the machine is in question. Custinel moves the decision off the machine.

01

Measure

As the machine boots, its firmware, kernel and system are measured into TPM registers.

02

Sign

An open-source prover asks the TPM for a quote of those registers and binds it to an envelope with a counter that only grows.

03

Appraise

Custinel checks the quote and the device, compares the state with the reference, and rejects evidence it has already accepted.

04

Record

The verdict and its reason are recorded. Any third party can re-check the same evidence with the open tools.

Freshness is established through a TPM-protected monotonic counter. The verifier tracks the highest counter it has accepted for each device and rejects anything at or below it. No online nonce exchange with the verifier and no synchronized clock are required, which is why the evidence can also travel by USB from a site without a connection.

What exactly is verified

A precise claim, with its edges marked.

An independent verifier is only as useful as the claim it makes. This is ours.

What Custinel verifies

  • The TPM quote is genuine and signed by a registered device key.
  • The submitted envelope is bound to that quote.
  • The measured boot state matches the published reference.
  • The evidence is newer than anything already accepted from that device.
  • The device is known and registered.

What it does not prove

  • That the software has no vulnerabilities.
  • That nothing was compromised at runtime after boot.
  • That the applications behave correctly.
  • That the device is physically intact.
  • That the reference itself is right. An independent verifier does not turn a wrong reference into a correct one.

What a machine needs: Linux with a TPM 2.0, a measured-boot chain that records the components we compare, a published reference for that chain, and a registered device key. The prover is open source and builds on standard Linux; the machine does not need to run our operating system.

Two modes, one verifier

Fleet assurance, and independent inspection.

Both run the same verifier on a separate device. They serve different buyers: the owner of a fleet, and the party that checks someone else's.

Bench-verified

Stationary: fleet assurance

For operators of their own fleets

Are my machines still running the state I approved?

  • Sits next to the machines it checks, inside the operator's physical perimeter.
  • Appraises every node's evidence as it arrives.
  • Shows what each machine actually booted, not what it reports.

Value: continuous detection of drift from the approved state.

In development

Portable: independent inspection

For auditors, certification bodies and buyers of equipment

What did these machines boot on the day I checked, and can I prove it later?

  • Brought to the site by the inspecting party, with its own keys.
  • The site being checked is treated as a possible adversary.
  • The result leaves with the inspector. The site cannot rewrite it, because the device is not theirs.

Value: an independent result the inspector takes away. The unit is being assembled; its first run will be published here.

Where it applies

Linux devices with TPM 2.0 and a measured-boot chain.

The first bench run was an EV charging station. The same verifier is meant for the other classes below; each new class gets its own dated run before we call it demonstrated.

EV charging stations

A signed firmware update proves where a package came from. Custinel shows which measured state the station booted, against a reference the supplier does not control. Bench-verified.

Servers running AI workloads

Show the tenant, the regulator or the chip supplier which state the machines booted, with evidence the operator did not write. Next run.

Industrial devices

Devices at remote sites inside an operator-controlled perimeter, often without an online connection to the verifier. Planned.

Bench verification

2026-11-18

EV charging station, verified from outside.

An EVerest charging stack on TactiQ OS (Radxa ROCK 5A, Infineon SLB9670 TPM) sends its attestation envelope over OCPP 2.0.1 DataTransfer to a test CSMS on the bench. Custinel, outside the station, appraises each envelope against the reference published with the build.

21consecutive valid envelopes accepted in the bench run
PCR 0-9matched the reference published with the build, in full
5deliberately modified or replayed test cases rejected, each for its own reason
Test caseCustinel's answer
The station as built and publishedACCEPT
The station boots an image other than the published oneUnrecognizedState
The envelope altered under a valid TPM quoteQuoteBindingFail
The TPM quote itself alteredSignatureFail
An already accepted envelope sent againStale
An envelope from a device with no registered keyUnknownDevice

The rejection cases were run as tests on genuine envelopes taken from the board.

Limits of this run

  • One station, one board, one operating system. Third-party operating systems and server hardware are the next runs.
  • The CSMS was a test stub on the bench, not a production charging network.
  • The reference came from our own reproducible build, and TactiQ AI also makes Custinel. Anyone can rebuild the image and get the same reference, but in a customer deployment the reference should come from the customer's own build or signing root. For firmware nobody can rebuild, the reference has to come from the platform's event log; that path is not yet demonstrated.
  • Not yet demonstrated: anchoring the verifier's own state in its TPM, and mutual attestation between two Custinel units.
  • The evidence bundle for this run (envelopes, reference, verdicts, versions and the commands to repeat it) is being prepared for publication.

Open and paid

Checking one piece of evidence is open. Keeping state across a fleet over time is Custinel.

The line follows what needs memory. A single envelope can be checked by anyone, without us. Knowing that it is the newest one requires remembering what came before for every device, and that is the work Custinel does.

Open source

tactiq-attest · Apache-2.0

Is this evidence genuine, and was the state in the reference?

  • Evidence format
  • Prover
  • Signature and quote verification
  • Reference comparison
  • Single-envelope appraisal, offline tools that also build for the browser

Custinel

verifier device and annual subscription

Is this the state now, and was the machine not swapped or rolled back?

  • Device identity and registration
  • Persistent counter tracking per device
  • Record of verdicts over time
  • Continuous appraisal across the fleet
  • References per machine model, rebuilt for each signed release
  • The verifier device itself

The open single-envelope check cannot tell on its own whether evidence is the newest from its device: that needs the state Custinel keeps. We say so plainly rather than imply the open check offers the same replay protection.

Where Custinel does not fit

  • It is not monitoring or a SOC. It verifies booted state, it does not hunt incidents.
  • It is not a vulnerability scanner. It probes nothing and exploits nothing.
  • It is not an HSM. Its TPM serves its own identity, not your keys.
  • It is not vendor self-reporting. The party that built or runs the machine does not write the verdict.

Built on

  • The RATS architecture, RFC 9334: Attester, Verifier, Relying Party
  • TPM 2.0 quotes and its monotonic NV counter
  • tactiq-attest: the open evidence format, prover and single-envelope check
  • TactiQ OS: the open, measured operating system used in the bench run

Design partners

Bring us a device. We will show you what it actually booted.

We are open to operators and hardware makers who want to run an independent verification exercise on real equipment. Three steps:

01

Establish a reference for an existing device.

02

Verify the device against that reference with Custinel.

03

Deliberately change it and check that Custinel rejects the change.

Operators of server fleets and charging networks, makers of charging stations and industrial devices, and inspection, audit and certification bodies. Nothing from your equipment is published without your consent.

Write to lazarev@tactiqedge.com