· 04/01/2026 ·

GPU remote attestation with Intel® Trust Authority

Intel and NVIDIA have collaborated to add NVIDIA* GPU TEE remote attestation to Intel® Trust Authority. It's now possible to attest a confidential virtual machine TEE and NVIDIA confidential-computing GPUs in one composite attestation workflow. This article provides an overview of the GPU attestation architecture, the Intel Trust Authority Python Client, CLI, and REST API that support GPU attestation, and examples of GPU and composite attestation JWTs.

Supported NVIDIA GPU architectures

Architecture GPU Notes
Hopper H100 Tensor Core* GPU Single-GPU and multi-GPU attestation.
Blackwell B200 Tensor Core* GPU Single-GPU and multi-GPU attestation.
Note

This release supports on-premises hardware and cloud-based GPU attestation from certain CSPs. Support GPU architectures are validated by Intel Trust Authority and its customers, additional architecture may also be supported but currently unverified by Intel Trust Authority.

The GPU as a TEE is a relatively new concept that extends the capabilities of a CPU TEE. Generative artificial intelligence (GAI) and other demanding workloads require hardware acceleration with a GPU to achieve acceptable performance. Many GAI models and parameters are themselves highly-valued intellectual property, and they often process sensitive data. The GPU TEE provides a secure execution environment for these workloads, helping to ensure that the data is protected from unauthorized access or tampering.

However, a GPU on its own is not a complete TEE for confidential computing. The GPU confidential compute solution relies on a confidential VM CPU TEE, enabled by Intel® Trust Domain Extensions (Intel® TDX) 1.x on Intel CPUs. The CPU TEE provides the measurements and attestations needed to establish trust in the GPU. The CPU TEE serves as an orchestrator for securely transferring information to the GPU. This is done through a fully encrypted process. The GPU and confidential VM exchange keys to create an encrypted communications channel.

The Intel Trust Authority Python Client, CLI for Intel TDX and NVIDIA GPU, and Intel Trust Authority REST API currently support two GPU attestation options (verfied by Intel Trust Authority and its customer), and each option is extended with multi-GPU (mGPU) batch attestation support.

  1. Composite CPU TEE + GPU TEE attestation. The Intel Trust Authority client collects separate evidence from the confidential VM TEE and the GPU driver. The evidence is combined and sent to Intel Trust Authority for verification. Intel Trust Authority verifies the CPU evidence, and the GPU quote is sent to NVIDIA Remote Attestation Service (NRAS) for verification. The resulting attestation JWT issued by Intel Trust Authority contains CPU TEE claims and GPU claims, and other claims from the Intel Trust Authority SaaS service. Composite attestation is the preferred method for confidential computing solutions that include a GPU TEE.

  2. GPU-only attestation using the Intel Trust Authority client. As described above, GPU-only attestation doesn't provide a complete confidential computing solution.

Both options support multi-GPU batch attestation, which allows a single attestation request to cover up to eight NVIDIA confidential-computing GPUs simultaneously. Multi-GPU attestation follows NRAS V3 token format that includes an overall attestation result and per-device claim details.

GPU attestation architecture

The following diagram is a high-level view of the GPU attestation architecture. The focus is on the relationship among the major components and actors (attester, verifier, & relying party).

Intel TDX and NVIDIA GPU attestation architecture diagram.

The attester comprises the confidential computing (CC) app and related software running in the TD, the Intel TDX-enabled host server, and an NVIDIA GPU (local or remote).

There are two independent verifiers: Intel Trust Authority SaaS service, and NVIDIA Remote Attestation Service (NRAS). NRAS verifies the GPU TEE by comparing the evidence collected from the driver with the so-called "golden measurements" stored in the NVIDIA Reference Integrity Manifest* (RIM) service.

GPU attestation begins when the Intel Trust Authority client GPU TEE adapter calls the NVIDIA SDK API to request evidence for the GPU. The GPU evidence is provided by the NVIDIA GPU driver running on the server where the GPU is installed. The GPU server can be local or remote, but the GPU driver must be running on the same server as the GPU.

When composite attestation (option 1 and 1a on the diagram) is requested, independent evidence is collected for both the Intel TDX TD and the NVIDIA confidential-computing GPU. When an attestation request is made, Intel Trust Authority SaaS verifies the Intel TDX quote as usual and forwards the GPU evidence to the NRAS GPU verification service.

Intel Trust Authority extracts the NRAS JWT from the NRAS API response body, verifies the NRAS JWT certificate, and returns the NRAS JWT embedded as a JSON sub object in the JWT. This method is called composite attestation because it relies on multiple verifiers and and the attestation result includes claims from more than one TEE or device.

Note

When composite attestation with a NVIDIA GPU is requested, the Intel Trust Authority service relies on NRAS to verify the GPU evidence and return a JWT. If NRAS is experiencing uneven performance, timeouts, or is unavailable, an error will occur and Intel Trust Authority won't return an attestation token. If service delay is lengthy, the verifier nonce may expire before an attestation request can be completed. It is recommended to include retry logic in the client application to handle these situations.

When GPU-only attestation (option 2 on the diagram) is requested, the Intel Trust Authority Python Client GPU adapter collects GPU evidence, generates a nonce in NVIDIA 32-byte Hex format, and then sends an attestation request to Intel Trust Authority. Intel Trust Authority's GPU verification sends a request to NVIDIA NRAS to verify the GPU evidence. The NRAS JWT cert is verified, and then the NRAS JWT claims are copied to the "nvgpu":{} section of the JWT issued by Intel Trust Authority.

Composite attestation of both the CPU TEE and the GPU TEE provides a more secure confidential computing solution than GPU-only attestation. The trust model of a GPU TEE relies on the CPU TEE to establish trust in the GPU, and to manage data flow and computations on the secure channel between the CPU and GPU.

Intel Trust Authority client support for GPU attestation

NVIDIA GPU attestation is supported by the Intel Trust Authority Python and Golang Client. The client includes a GPU adapter that collects evidence from the NVIDIA GPU driver (running on the server where the GPU is installed) and sends it to Intel Trust Authority for verification.

Note

Intel TDX and NVIDIA GPU attestation requires Ubuntu 24.04 LTS with Linux kernel 6.8 or later.

python client

The ITAConnector.get_token_v2 method supports both singular (Intel TDX or GPU) and composite (Intel TDX + NVIDIA H100/B200) attestation.

def get_token_v2(self, tdx_args: GetTokenArgs, gpu_args: GetTokenArgs) -> GetTokenResponse:

You must supply at least one of either tdx_args or gpu_args to get_token_v2. If both are supplied, the client will request a composite attestation.

An ITAConnector.get_token method is available for singular attestation of Intel TDX and Intel SGX. get_token doesn't support GPU or composite attestation.

Python CLI

Intel® Trust Authority Python CLI for Intel® Trust Domain Extensions (Intel® TDX) and NVIDIA GPU trustauthority-pycli provides a CLI to attest an Intel TDX trust domain (TD) and NVIDIA GPU with Intel Trust Authority.

trustauthority-pycli requires python-connector, python-intel-tdx, python-nvgpu, and NVIDIA Attestation SDK. A configuration file is required to be present in the trustauthority-pycli directory. See the README for details and more extensive documentation of the following commands.

trustauthority-pycli has three commands: attest, evidence, and verify.

Note

Root permissions are required to access the configfs-tsm device to collect evidence for Intel TDX attestation. You must run both attest and evidence commands as root. For example: sudo python3 trustauthority-pycli attest --attest_type tdx+nvgpu. GPU-only attestation doesn't require sudo.

The attest command collects evidence from the attester(s) and then forwards the evidence with an attestation request to Intel Trust Authority. attest requires an --attest_type parameter that can be one of tdx, nvgpu, or tdx+nvgpu. The tdx+nvgpu option is used for composite attestation of both the Intel TDX TD and the NVIDIA H100 GPU.

The evidence command is used to collect evidence from Intel TDX, the GPU driver or both, and optionally saving evidence to a file. evidence supports the background-check attestation model, and it's helpful for development and testing.

The verify command is used to verify an attestation token from Intel Trust Authority. verify takes a JWT as input, then checks the iss signing certs, CRL, and expiration date.

golang client

REST API updates

GPU and Intel TDX + GPU attestation uses the /appraisal/v2/attest endpoint of the Intel Trust Authority REST API.

Single-GPU attestation request fields

For single-GPU attestation, the request body contains the existing evidence, certificate, and gpu_nonce fields. These fields are mutually exclusive with evidence_list; you cannot use them together in the same request.

Multi-GPU attestation request fields

For multi-GPU (batch) attestation, the request body uses the evidence_list array field. evidence_list is mutually exclusive with the single-GPU evidence field. evidence_list contains json filed array encapsulating evidence and certificate from each invidividual GPU.

Note

The maximum number of GPUs in a single evidence_list request is 8. Submitting both evidence and evidence_list in the same request returns an error. However, evidence_list will take a evidence_list containing only one GPU field to support single-GPU attestation, noting the tokan claim format will be different in this case.

Multi-GPU attestation JWT (NRAS V3 token format)

When evidence_list is used for multi-GPU attestation, MRAS V3 token format will be returned. The top-level structure differs from the V1 single-GPU token in the following ways:

  • x-nvidia-overall-att-result — A single boolean that summarizes the attestation result across all GPUs in the request. This is the primary field to check in policy for a pass/fail result.
  • x-nvidia-ver — Identifies the EAT version (e.g., "EAT-24" for V4).
  • submods — NVIDIA sub-module metadata included in the V4 EAT.
  • claim_details — A JSON object that maps a per-device key (such as "GPU-0", "GPU-1") to an individual GPU claim details object. Each per-device entry mirrors the detailed attestation fields from the V1 single-GPU token (RIM validation results, driver and VBIOS versions, hardware model, and so on).

The per-device entry in claim_details contains the same detailed measurement and validation fields as the V1 single-GPU token, including:

  • x-nvidia-gpu-attestation-report-nonce-match
  • x-nvidia-gpu-attestation-report-parsed
  • x-nvidia-gpu-arch-check
  • x-nvidia-gpu-driver-rim-* and x-nvidia-gpu-vbios-rim-* results
  • hwmodel, secboot, dbgstat, oemid, ueid, measres
  • x-nvidia-gpu-driver-version, x-nvidia-gpu-vbios-version
Note

The V4 EAT claim_details structure replaces the flat top-level GPU claims of the V1 token. Existing single-GPU policies that reference input.nvgpu.<claim> directly are not affected; those policies apply only to single-GPU requests. For multi-GPU requests, write policies that access claims through input.nvgpu.claim_details[gpu_key].

GPU JWT example

The following sample shows a basic NVIDIA GPU attestation token as returned from NRAS.

{
  "sub": "NVIDIA-GPU-ATTESTATION",
  "x-nv-gpu-driver-version": "545.00",
  "iss": "https://nras.attestation.nvidia.com",
  "nonce": "1020ECB8F64DCFD50DABB760FC6A24210BA77D9F43A3A4DB170A1F560283566F",
  "x-nv-gpu-vbios-version": "96.00.5E.00.01",
  "aud": "HOPPER",
  "x-nv-attestation-type": "GPU",
  "x-nv-attestation-detailed-result": [
    {
      "nonceValidated": true,
      "evidenceParsed": true,
      "evidenceCertificateValidated": true,
      "evidenceSignatureVerified": true,
      "runtimeMeasurementCompared": true,
      "attestationResult": true,
      "mismatchIndexes": null,
      "mismatchMeasurementRecords": null
    }
  ],
  "exp": 1690892429,
  "iat": 1690888829,
  "x-nv-attestation-manufacturer": "NVIDIA Corporation",
  "x-nv-attestation-manufacturer-id": "5703",
  "jti": "b95ae8ce-889a-431c-b0ff-512face0a5e5",
  "x-nv-attestation-result": true
}

Composite JWT example

The following sample JWT is the result of a composite attestation with an Intel TDX TD and a NVIDIA H100 GPU. Notice that each of the embedded JWTs is a sub object that is identified with "intel_tee" and "nvidia_gpu".

Some claim values are truncated for readability, indicated with ellipsis (...).

{
  "appraisal": {
    "method": "default",
    "ver": 2
  },
  "eat_profile": "https://...intel.com/eat_profile.html",
  "intuse": "generic",
  "nvgpu": {
    "attester_type": "NVGPU",
    "dbgstat": "disabled",
    "eat_nonce": "A2B386E64B5595D25A52857...",
    "hwmodel": "GH100",
    "iss": "https://nras.attestation.nvidia.com",
    "measres": "comparison-successful",
    "oemid": "5703",
    "secboot": true,
    "sub": "NVIDIA-GPU-ATTESTATION",
    "ueid": "64161068116713415375430....",
    "verifier_instance_ids": [
      "e1e2fb60-bed9-45a8-950d-2e81520a7a1c",
      "ee53b2c0-f946-497e-8b84-8c249d79e010"
    ],
    "x-nvidia-attestation-detailed-result": {
      "x-nvidia-attestation-warning": null,
      "x-nvidia-gpu-arch-check": true,
      "x-nvidia-gpu-attestation-report-cert-chain-validated": true,
      "x-nvidia-gpu-attestation-report-parsed": true,
      "x-nvidia-gpu-attestation-report-signature-verified": true,
      "x-nvidia-gpu-driver-rim-cert-validated": true,
      "x-nvidia-gpu-driver-rim-driver-measurements-available": true,
      "x-nvidia-gpu-driver-rim-schema-fetched": true,
      "x-nvidia-gpu-driver-rim-schema-validated": true,
      "x-nvidia-gpu-driver-rim-signature-verified": true,
      "x-nvidia-gpu-measurements-match": true,
      "x-nvidia-gpu-nonce-match": true,
      "x-nvidia-gpu-vbios-rim-cert-validated": true,
      "x-nvidia-gpu-vbios-rim-measurements-available": true,
      "x-nvidia-gpu-vbios-rim-schema-fetched": true,
      "x-nvidia-gpu-vbios-rim-schema-validated": true,
      "x-nvidia-gpu-vbios-rim-signature-verified": true,
      "x-nvidia-mismatch-indexes": null,
      "x-nvidia-mismatch-measurement-records": null
    },
    "x-nvidia-attestation-type": "GPU",
    "x-nvidia-gpu-driver-version": "570.158.01",
    "x-nvidia-gpu-manufacturer": "NVIDIA Corporation",
    "x-nvidia-gpu-vbios-version": "96.00.74.00.1C",
    "x-nvidia-ver": "1.0"
  },
  "policy_ids_matched": [
    {
      "id": "3a0152e5-afc2-4502-9456-b449353b81cc",
      "version": "v1",
      "hash": "VVhCaVFiTnlFUHNCM3pKRjJwL2RNak...."
    },
    {
      "id": "66b3ca76-2b2a-4600-a296-4c454e3898a3",
      "version": "v1",
      "hash": "YmxvQXRBWmxFTDBLY0Fs..."
    },
    {
      "id": "f756764d-23ac-4174-a48c-e128024cd666",
      "version": "v1",
      "hash": "SjJTZUJhclZwODE3ays..."
    }
  ],
  "policy_ids_unmatched": [
    {
      "id": "8450bd7f-4499-44d9-bc5b-39f072540fca",
      "version": "v1",
      "hash": "MURxcjg2VmVrYTE2NFl..."
    },
    {
      "id": "1f92e45b-ddb2-4876-83cc-3a95cc5547db",
      "version": "v5",
      "hash": "VERxSTJEbmY3YnV0..."
    }
  ],
  "tdx": {
    "attester_tcb_date": "2026-02-11T00:00:00Z",
    "attester_tcb_status": "UpToDate",
    "attester_type": "TDX",
    "dbgstat": "disabled",
    "pce_svn": 13,
    "platform_instance_id": "82802b47fc...",
    "sgx_tcb_comp_svn": "04040202...",
    "tdx_collateral": {
      "fmspc": "90C06F000000",
      "qeidcerthash": "c550544e4442d9be583a5e...",
      "qeidcrlhash": "a275a88576a9d9d8a514f03...",
      "qeidhash": "9b3ff363d46fea6882f0a2dd59d...",
      "quotehash": "f39d47253f04d1fc019390c1b5f...",
      "tcbevaluationdatanumber": 21,
      "tcbinfocerthash": "c550544e4442d9be583a5...",
      "tcbinfocrlhash": "a275a88576a9d9d8a514f...",
      "tcbinfohash": "eb09df2e8626ef726d..."
    },
    "tdx_is_debuggable": false,
    "tdx_is_migratable": false,
    "tdx_mrconfigid": "00000000000000000000000000000000000000000000000000000...",
    "tdx_mrowner": "000000000000000000000000000000000000000000000000000000000000...",
    "tdx_mrownerconfig": "0000000000000000000000000000000000000000000000000...",
    "tdx_mrseam": "489e585f1c54bc5a02066c8c6ec21619ff0334ec6f2...",
    "tdx_mrsignerseam": "00000000000000000000000000000000000000000000000000...",
    "tdx_mrtd": "5fa1e03ac82c81049423456878a624582b8ca199aea6f9227c3f7a...",
    "tdx_report_data": "d61a6a8919bd434ff1f4c2e340a8f4fb6243732f1550393905c6b48a21a...",
    "tdx_rtmr0": "06e59a55c88c36d5e41b0bc146f33a21300b2caeff2bf7...",
    "tdx_rtmr1": "e6b2adf57939c1c7476a9e79e48b8c7dd4eff614c348ad...",
    "tdx_rtmr2": "f629c8341aae927f61d9cc0e0bee7ba34010f043058afb...",
    "tdx_rtmr3": "0000000000000000000000000000000000000000000000...",
    "tdx_seam_attributes": "0000000000000000",
    "tdx_seamsvn": 269,
    "tdx_td_attributes": "0000001000000000",
    "tdx_td_attributes_debug": false,
    "tdx_td_attributes_key_locker": false,
    "tdx_td_attributes_migratable": false,
    "tdx_td_attributes_perfmon": false,
    "tdx_td_attributes_protection_keys": false,
    "tdx_td_attributes_septve_disable": true,
    "tdx_tee_tcb_svn": "0d010400000000000000000000000000",
    "tdx_xfam": "e702060000000000"
  },
  "ver": "2.0.0",
  "verifier_instance_ids": [
    "2b913119-5847-4ea9-89a8-e0bd8f5936db",
    "63afdfb0-639c-49c7-a26a-2e912f010d0f",
    "d3b32e50-dc8b-4984-bb00-dff169845591",
    "e1e2fb60-bed9-45a8-950d-2e81520a7a1c",
    "ee53b2c0-f946-497e-8b84-8c249d79e010",
    "888581d7-ce5b-449f-ba90-a3bf487460bb",
    "98be93c5-4d5a-4756-8e5d-77bfbc281e37",
    "5dbb6d86-cb7a-4bbd-9efd-e7fdd61c1b79"
  ],
  "exp": 1773691508,
  "jti": "46f68935-1904-41eb-a317-d87310777efd",
  "iat": 1773691208,
  "iss": "https://...intel.com/",
  "nbf": 1773691208
}

Claims usable in policy

Not all claims in the JWT can be used in an appraisal policy. The following sample shows a NVIDIA GPU attestation token with claims that can be used in a policy. Claims not shown here are either informational or not intended for use in policy.

"nvgpu" : {

"sub": "NVIDIA-GPU-ATTESTATION",
"secboot": true,
"x-nvidia-gpu-manufacturer": "NVIDIA Corporation",
"x-nvidia-attestation-type": "GPU",
"x-nvidia-attestation-detailed-result": {
  "x-nvidia-gpu-driver-rim-schema-validated": true,
  "x-nvidia-gpu-vbios-rim-cert-validated": true,
  "x-nvidia-mismatch-measurement-records": [
    {
      "runtimeSize": 48,
      "index": 9,
      "goldenValue": "",
      "runtimeValue": "",
      "goldenSize": 48
    }
  ],
  "x-nvidia-gpu-attestation-report-cert-chain-validated": true,
  "x-nvidia-gpu-driver-rim-schema-fetched": true,
  "x-nvidia-gpu-attestation-report-parsed": true,
  "x-nvidia-gpu-nonce-match": true,
  "x-nvidia-gpu-vbios-rim-signature-verified": true,
  "x-nvidia-gpu-driver-rim-signature-verified": true,
  "x-nvidia-gpu-arch-check": true,
  "x-nvidia-attestation-warning": null,
  "x-nvidia-gpu-measurements-match": false,
  "x-nvidia-mismatch-indexes": [
    9
  ],
  "x-nvidia-gpu-attestation-report-signature-verified": true,
  "x-nvidia-gpu-vbios-rim-schema-validated": true,
  "x-nvidia-gpu-driver-rim-cert-validated": true,
  "x-nvidia-gpu-vbios-rim-schema-fetched": true,
  "x-nvidia-gpu-vbios-rim-measurements-available": true,
  "x-nvidia-gpu-driver-rim-driver-measurements-available": true
},
"x-nvidia-ver": "1.0",
"x-nvidia-gpu-driver-version": "535.104.05",
"hwmodel": "GH100 A01 GSP BROM",
"oemid": "5703",
"measres": "comparison-fail",
"x-nvidia-eat-ver": "EAT-21",
"ueid": "372...7941",
"x-nvidia-gpu-vbios-version": "96.00.5E.00.01"

}

This particular token shows a mixed result; the attestation report is valid, but the GPU measurements don't match. The mismatched measurements are identified in the x-nvidia-mismatch-measurement-records and x-nvidia-mismatch-indexes claims. A relying party can examine these claims to determine if the GPU is still within acceptable limits for use, or if it should be quarantined or taken offline.

Multi-GPU policy

Multi-GPU policies (for evidence_list requests) access claims through input.nvgpu.claim_details. The object_keys Rego built-in is supported and can be used to iterate over the per-device keys.

Check overall attestation result

Policy that checks the overall multi-GPU attestation result across all devices.

import rego.v1

default match := false

match if {
    input.nvgpu["x-nvidia-overall-att-result"] == true
}

Check every GPU's attestation result

Policy that requires every GPU in the batch request to have a valid attestation report with all measurements matched.

import rego.v1

default match := false

match if {
    input.nvgpu["x-nvidia-overall-att-result"] == true
    every gpu_key in object_keys(input.nvgpu.claim_details) {
        input.nvgpu.claim_details[gpu_key]["x-nvidia-gpu-attestation-report-parsed"] == true
        input.nvgpu.claim_details[gpu_key]["x-nvidia-gpu-attestation-report-signature-verified"] == true
    }
}

Check per-GPU RIM validation

Policy that requires every GPU to have both driver and VBIOS RIM validation pass.

import rego.v1

default match := false

match if {
    input.nvgpu["x-nvidia-overall-att-result"] == true
    every gpu_key in object_keys(input.nvgpu.claim_details) {
        input.nvgpu.claim_details[gpu_key]["x-nvidia-gpu-driver-rim-signature-verified"] == true
        input.nvgpu.claim_details[gpu_key]["x-nvidia-gpu-driver-rim-measurements-available"] == true
        input.nvgpu.claim_details[gpu_key]["x-nvidia-gpu-vbios-rim-signature-verified"] == true
        input.nvgpu.claim_details[gpu_key]["x-nvidia-gpu-vbios-rim-measurements-available"] == true
    }
}

Check per-GPU hardware identity

Policy that checks the hardware model and driver version for every GPU in the batch. Update the values to match your expected GPU configuration.

import rego.v1

default match := false

match if {
    input.nvgpu["x-nvidia-overall-att-result"] == true
    every gpu_key in object_keys(input.nvgpu.claim_details) {
        input.nvgpu.claim_details[gpu_key].hwmodel == "GH100 A01 GSP BROM"
        input.nvgpu.claim_details[gpu_key]["x-nvidia-gpu-driver-version"] == "535.104.05"
    }
}

Example appraisals

This section includes sample appraisal policies that can be used to verify the GPU attestation results. Most of these examples are really fragments meant to be combined for a complete GPU or composite policy. For more information about appraisal policies, see the Appraisal Policy V2 article.

Secure boot

Policy that checks whether Secure Boot* is enabled and all GPU measurements are matched


default match := false

match {
    input.nvgpu.secboot == true
    input.nvgpu["x-nvidia-attestation-detailed-result"]["x-nvidia-gpu-measurements-match"] == true
}

Validate attestation report

Policy that checks whether the attestation report is valid.

default match := false

match {
      input.nvgpu["x-nvidia-attestation-detailed-result"]["x-nvidia-gpu-attestation-report-cert-chain-validated"] == true
      input.nvgpu["x-nvidia-attestation-detailed-result"]["x-nvidia-gpu-attestation-report-parsed"] == true
      input.nvgpu["x-nvidia-attestation-detailed-result"]["x-nvidia-gpu-attestation-report-signature-verified"] == true
}

GPU driver RIM

Policy that checks whether the GPU driver RIM is available and valid.

default match := false

match {    
    input.nvgpu["x-nvidia-attestation-detailed-result"]["x-nvidia-gpu-driver-rim-schema-validated"] == true
    input.nvgpu["x-nvidia-attestation-detailed-result"]["x-nvidia-gpu-driver-rim-schema-fetched"] == true
    input.nvgpu["x-nvidia-attestation-detailed-result"]["x-nvidia-gpu-driver-rim-signature-verified"] == true
    input.nvgpu["x-nvidia-attestation-detailed-result"]["x-nvidia-gpu-driver-rim-cert-validated"] == true
    input.nvgpu["x-nvidia-attestation-detailed-result"]["x-nvidia-gpu-driver-rim-driver-measurements-available"] == true
}

GPU VBIOS RIM

Policy that checks whether the VBIOS RIM is available and valid.

default match := false

match {    
    input.nvgpu["x-nvidia-attestation-detailed-result"]['x-nvidia-gpu-vbios-rim-measurements-available'] == true
    input.nvgpu["x-nvidia-attestation-detailed-result"]['x-nvidia-gpu-vbios-rim-schema-fetched'] == true
    input.nvgpu["x-nvidia-attestation-detailed-result"]["x-nvidia-gpu-vbios-rim-cert-validated"] == true
    input.nvgpu["x-nvidia-attestation-detailed-result"]["x-nvidia-gpu-vbios-rim-schema-validated"] == true
    input.nvgpu["x-nvidia-attestation-detailed-result"]["x-nvidia-gpu-vbios-rim-signature-verified"] == true
}

GPU hardware info

Policy that checks the GPU HW information (e.g. Driver and VBIOS information). To use this, you need to know the specific values that apply to your GPU.

This example is written in policy v2 format; for more information, see Attestation Policies v2.


import rego.v1

default match := false

match if {    
    input.nvgpu["x-nvidia-gpu-driver-version"] == "535.104.05"
    input.nvgpu.hwmodel == "GH100 A01 GSP BROM"
    input.nvgpu[x-nvidia-gpu-vbios-version"] == "96.00.5E.00.01"
}



* Other names and brands may be claimed as the property of others.