On 10/27/26 12:36 PM, Jason Gunthorpe wrote:
On Tue, Oct 27, 2026 at 11:43:04AM -0700, Dave Jiang wrote:
quoted
I built a proof of concept on your wip_attestation_all_1 branch with help of LLM
for TDX Connect device attestation to see how it holds up, and wanted to share
what I found.
Nice!
quoted
What I built:
- A ctlv-attestation-spdm family. As you proposed, the sysfs lock creates the
assigned-TDI attestation instance; in my version unlock removes it.
EVIDENCE_GET, EVIDENCE_ACCEPT, DEVSEC_STATE_GET and DEVSEC_RUN all go through
your ops.
quoted
- A provider (a 'struct attestation_provider') that sits on top of PCI/TSM, so
any backend can use it. It serves the evidence PCI/TSM already publishes, and
asks the backend for a refresh when EVIDENCE_GET carries a challenge.
I ran it in QEMU with the devsec sample TSM, and in a TDX Connect guest on real
hardware with a real device. Both worked: lock, EVIDENCE_GET, DEVSEC_RUN
refusing a device without a verdict, RUN, and unlock. My tree has out of tree
code for TDX Connect to get things working.
The model works well for device attestation. A few things came up that I think
worth a look.
1. EVIDENCE_ACCEPT and DEVSEC_RUN take any evidence generation since the last
device change (attestation_evidence_validate()). Ranges would narrow that,
but they need measurement registers (attestation_ranges_required()), and a
device has none. So a verdict survives a refresh. In QEMU with the devsec
sample:
EVIDENCE_GET, empty challenge -> evidence generation 1
EVIDENCE_GET, challenge c1 -> generation 2, measurements changed
EVIDENCE_ACCEPT generation 1 -> ok
EVIDENCE_GET, challenge c2 -> generation 3, measurements changed
DEVSEC_RUN generation 1 -> ok, device in RUN
Any process that can issue EVIDENCE_GET can do this between the appraisal and
DEVSEC_RUN, and the device runs on evidence nobody looked at.
We don't care about freshness of measurements. What we care about is
that the device has remained continuously locked while we are doing
this.
Generation should not have anything to do with the # of evidence
collected, it should be tied to the lock event. We do a lock and we
get a generation number. That number remains fixed and could be passed
into run as a minor sanity check.
However the real security work is in the kernel driver which is
required to actively detect/prevent any host tampering with LOCKED.
RMM does this with a trio of sequences counters maintained by the
kernel driver: lock_seq, meas_seq, report_seq
If the host tampers with things then the sequences computed by the
driver will not match those computed by the RMM and it will fail.
So, I don't care if we lock the device and then collect three
evidences for some reason. It is not the APIs problem to make sure
they are all the same, or that the one used for attestation is
"freshest".
While locked the device is not supposed to change its measurements,
allowing that turns locked into complete security nonsense. How do you
know when the measurements stop changing to actually measure it?
The only point here is to collect some evidence that represents the
start time of a continuous period of exclusive guest control.
Have I got this wrong somehow?
You have it mostly right. The devsec sample has no real measurements. Its
refresh only puts the new nonce into a fake request, so the "measurements
changed" lines just reflect the nonce. I'm dropping the
attestation_evidence_replaced() idea.
There are two issues for TDX Connect. One, the device info is collected at
SPDM connect (TDH.SPDM.CONNECT), not at lock. TDH.TDI.BIND only returns the
interface report. So the measurements a TD sees at lock can be from well
before the lock. To get measurements taken after the bind, the TD has to
ask the VMM for a recollection with its own nonce.
Second, a device may take a runtime firmware update of equal or higher SVN
while its TDIs stay locked, unless the lock sets NO_FW_UPDATE. The TD isn't
told when that happens. The VMM picks the lock flags, and INTERFACE_INFO
bit 0 in the interface report tells the TD whether updates are permitted
while locked. Currently our host passes no lock flags and nothing in the
guest checks that bit.
With NO_FW_UPDATE set and the evidence collected after the bind, tying the
generation to the lock works for me.
On the RMM sequence counters, I don't think TDX has an equivalent set. What it
has is a bind session ID. The TD reads it after the bind, and TDG.TDI.START
only succeeds with that same ID. Before START the TD checks the device info and
report against the TDX Module's digests. After START it relies on the state the
TDX Module tracks, which can lag as I mentioned.
quoted
2. TDX Connect (maybe others) does not raise an event when a device drops out of
RUN. The provider only finds out when it asks, and on TDX even that answer
can lag. The guest reads the state the TDX Module last saw in a TDISP
response. A function level reset, for example, moves a locked TDI to ERROR,
but the guest keeps reading CONFIG_LOCKED until the TDX Module sees another
TDISP response, such as when the host asks the device for its state.
Yeah, I bet this is common.
quoted
Could the core add a version of attestation_state_changed() that a provider
can call while the op already holds the lock? Or let the provider flag the
change, and have the core send the notification once the op drops the lock?
Sounds right to me
quoted
3. Jason asked on 14/20 whether anyone needs a variable-length challenge. I
don't think devices need a range. A plain read sends an empty challenge, and
an SPDM GET_MEASUREMENTS nonce is "NL = 32 or 0". Your TDX provider always
takes 64 (attestation_tdx_evidence_caps).
quoted
A device needs exactly two lengths: 0 for a plain read and 32 for a refresh.
struct attestation_evidence_caps only holds a single min/max range. It's
checked on every request in attestation_evidence_request_decode(), and any
range that allows both 0 and 32 also allows everything in between.
To work around that, my provider declares 0-64 and PCI/TSM rejects any length
other than the backend's nonce size, 32 for both backends I ran. Could the
caps give one exact challenge length instead of a range, plus a flag that
also allows an empty challenge? A device provider would set 32 with the flag,
and your TDX provider 64 without it.
I'd expect to be able to learn the exact nonce sice that the challenge
can support. It should probably be a list not a range, then you could
include 0 for SPDM..
A list works for me. It covers 0 and 32 for a device, 64 for TDX, and other
sizes later.
And maybe other lens if we do crypto agility here or something.
The challenge is formed into the returned token so it is a kind of
ABI and we don't want things like transparent 0 pad or something, so
userspace does have to know..
quoted
4. EVIDENCE_GET rejects any buffer smaller than max_length
(attestation_evidence_decode_objects()), so userspace has to allocate for the
worst case. Aneesh's provider declares 16M per certificate chain, so every
read needs a 16M buffer. Could EVIDENCE_GET take a smaller buffer and return
the length it needs, or offer a way to ask for the size?
Makes sense, this is also where someday having the memfd as an option
might be nice since it could be dynamicaly sized by the kernel
quoted
5. evidence.challenge is a required attr of evidence-request, so a plain read
has to send an empty one ("hex:" in Aneesh's example). Could it be optional?
I'm a bit puzzled by this optional challenge concept, I haven't tried
to read SPDM spec yet, but it really has a way to omit the challenge
from the reply? It doesn't just replace it with 0 or something?
SPDM puts the requester's nonce in the GET_MEASUREMENTS request, and only when
the request asks for a signature. The MEASUREMENTS response always carries the
responder's own nonce, and the signature covers the request too. An unsigned
request has no nonce and gets an unsigned response.
The empty challenge in my provider means something else though: don't
recollect, return the evidence collected earlier. So it's less "omit the
nonce" and more "no new collection". Maybe that's better as an explicit flag
than an empty challenge?
quoted
6. tdx_attestation_test's discovery_and_construction_fields expects an
inheritance chain of 4, but the TDX family inherits ctlv-attestation
directly, which gives 3. In a real TDX guest it fails with
"Expected 4 (4) == ctlv_chain_len(self->dev) (3)".
I would have naively guessed this should inherent from some SPDM family?
The TDX family is the TD's own attestation (TD report, Quote and RTMRs), with
no device or SPDM in it. In wip_attestation_all_1 it inherits ctlv-attestation
directly, so I think the test's 4 is what's stale. Jiri would know for sure.
DJ