Verify us.
Don't trust us.

Every model we deliver to a puck is cryptographically signed. The puck trusts exactly one thing: bytes that verify against our public key. Here is that key — and its hash — so you can check it yourself.

Match the hash yourself

Thirty seconds, no tools of ours required. Hash the published public key and confirm it equals the value above:

# Python — hash the raw public key
python3 - <<'EOF'
import hashlib
raw = bytes.fromhex("06e86c3a3434ab20005657d89e09b833625a6c8b9ed70c1d1dc6d8010e880df6")
print(hashlib.sha256(raw).hexdigest())
EOF
# -> 811f732421c51647a97d58d2535eaeacd1b49402a0d755a7116758d8bbc1f7c7

Verify a signed pack

Given any model pack and its .sig, verification uses only this public key — exactly what the puck does. A tampered or unsigned pack simply fails:

# Python — verify a pack against the published key
python3 - <<'EOF'
from cryptography.hazmat.primitives.serialization import load_pem_public_key
from cryptography.exceptions import InvalidSignature
pub = load_pem_public_key(open("model_signing.pub","rb").read())
data = open("pack.bin","rb").read(); sig = open("pack.bin.sig","rb").read()
try: pub.verify(sig, data); print("VALID - chains to AuraVision's root")
except InvalidSignature: print("INVALID - refused")
EOF

Silicon root — expected fuse values

The hardware layer anchors secure boot in one-time-programmable fuses. We publish the expected values before the silicon is burned — so the commitment is public before any unit exists, and we cannot quietly swap it. When you hold a puck, read its fuses and match them against these.

Match the fuse value yourself

Recompute the expected fuse value from the published public key, using NVIDIA's own tool from the public Jetson BSP — you don't take our word for the hash:

# NVIDIA tegrasign (public Jetson BSP) — hash the published PKC public key
python3 tegrasign_v3.py --pubkeyhash pub.key pub.sha --key pkc_rsa.pub
# -> tegra-fuse format (big-endian): 0x2af81016ec9ab994a64194564d864b59daacd18c9c5a94d61c...3c88

Verify it on your own silicon

A published number is only worth something if you can read the fuse yourself. You can — through the SoC's immutable on-die BootROM, in recovery, with Continuum OS never loaded, so no AuraVision code can sit in the path:

# 1. Put your puck into NVIDIA Force Recovery (RCM).
#    The unit-specific entry ships in your box (not posted publicly, for obvious reasons).
# 2. From your OWN host, using the public NVIDIA Jetson BSP (Linux_for_Tegra):
sudo ./odmfuseread.sh -i 0x23 <your-board>
# 3. It reads the fuse values directly via the on-die BootROM — Continuum never runs.
#    Match the PKC_PUBKEY_HASH it prints to the value published above.
# PKC_PUBKEY_HASH -> 0x2af81016ec9ab994a64194564d864b59daacd18c9c5a94d61c417f2719d7efa9...3c88

Nothing of ours runs during that read: it is NVIDIA's silicon BootROM and your host. And we published the expected value before the fuse was burned, so we cannot have back-fit it to whatever a unit happens to report. Read it, match it — trust nothing we say. That is the whole loop: a value committed in public ahead of the silicon, read back through immutable hardware you control.

Two layers, stated plainly

This is what "privacy by construction" has to mean to be worth anything: not a promise, a value you can check. The cloud asks you to trust a policy. We publish the key.