Wenn der Zugriff auf Ihre geschützten Ressourcen nicht über das IAM von Google Cloudverwaltet wird (z. B. wenn die Ressourcen in einem anderen Cloud-Dienst, lokal oder auf einem lokalen Gerät wie einem Smartphone gespeichert sind), können Sie eine Arbeitslast für einen vertraulichen Bereich trotzdem auf dem Gerät authentifizieren, das Zugriff auf diese Ressourcen gewährt, auch als vertrauende Partei bezeichnet.
Dazu muss die vertrauende Partei ein Attestierungstoken vom Confidential Space-Attestierungsservice mit einer benutzerdefinierten Zielgruppe und optionalen Nonces anfordern. Wenn Sie ein Attestierungstoken anfordern, müssen Sie Ihre eigene Tokenbestätigung durchführen, bevor Sie Zugriff auf Ressourcen gewähren.
In der folgenden Dokumentation werden die Konzepte behandelt, die bei der Verwendung eines vertraulichen Gruppenbereichs mit Ressourcen außerhalb von Google Cloudeine Rolle spielen. Eine detaillierte Anleitung finden Sie im Codelab.
Ablauf für Attestierungstoken
Attestierungstokens werden von der Arbeitslast im Namen einer vertrauenden Partei angefordert und vom Attestierungsservice zurückgegeben. Je nach Bedarf können Sie eine benutzerdefinierte Zielgruppe definieren und optional Nonces angeben.
Unverschlüsselt
Um den Ablauf des Tokenabrufs besser nachvollziehen zu können, wird in diesem Flussdiagramm keine Verschlüsselung verwendet. In der Praxis empfehlen wir, die Kommunikation mit TLS zu verschlüsseln.
Das folgende Diagramm zeigt den Ablauf:
Die vertrauende Partei sendet eine Tokenanfrage an die Arbeitslast mit optionalen von ihr generierten Nonces.
Die Arbeitslast bestimmt die Zielgruppe, fügt sie der Anfrage hinzu und sendet die Anfrage an den Launcher für vertrauliche Gruppenbereiche.
Der Launcher sendet die Anfrage an den Attestierungsservice.
Der Attestierungsservice generiert ein Token, das die angegebene Zielgruppe und optionale Nonces enthält.
Der Attestierungsdienst gibt das Token an den Launcher zurück.
Der Launcher gibt das Token an die Arbeitslast zurück.
Die Arbeitslast gibt das Token an die vertrauende Partei zurück.
Die vertrauende Partei überprüft die Ansprüche, einschließlich der Zielgruppe und optionaler Nonces.
Mit TLS verschlüsselt
Ein unverschlüsselter Fluss macht die Anfrage anfällig für Man-in-the-Middle-Angriffe. Da ein Nonce nicht an die Datenausgabe oder eine TLS-Sitzung gebunden ist, kann ein Angreifer die Anfrage abfangen und sich als Arbeitslast ausgeben.
Um diese Art von Angriff zu verhindern, können Sie eine TLS-Sitzung zwischen der vertrauenden Partei und der Arbeitslast einrichten und das TLS-exportierte Schlüsselmaterial (EKM) als Nonce verwenden. Das von TLS exportierte Schlüsselmaterial bindet die Attestierung an die TLS-Sitzung und bestätigt, dass die Attestierungsanfrage über einen sicheren Kanal gesendet wurde. Dieser Vorgang wird auch als Kanalbindung bezeichnet.
Das folgende Diagramm zeigt den Ablauf mit Kanalbindung:
Die vertrauende Partei richtet eine sichere TLS-Sitzung mit der Confidential VM ein, auf der die Arbeitslast ausgeführt wird.
Die vertrauende Partei sendet eine Tokenanfrage über die sichere TLS-Sitzung.
Die Arbeitslast bestimmt die Zielgruppe und generiert eine Nonce mit dem über TLS exportierten Schlüsselmaterial.
Die Arbeitslast sendet die Anfrage an den Launcher für vertrauliche Bereiche.
Der Launcher sendet die Anfrage an den Attestierungsservice.
Der Attestierungsservice generiert ein Token, das die angegebene Zielgruppe und die Nonce enthält.
Der Attestierungsdienst gibt das Token an den Launcher zurück.
Der Launcher gibt das Token an die Arbeitslast zurück.
Die Arbeitslast gibt das Token an die vertrauende Partei zurück.
Die vertrauende Partei generiert den Nonce mit dem über TLS exportierten Schlüsselmaterial neu.
Die vertrauende Partei prüft die Ansprüche, einschließlich Zielgruppe und Nonce. Die Nonce im Token muss mit der Nonce übereinstimmen, die von der vertrauenden Partei neu generiert wird.
Struktur von Attestierungstokens
Attestationstokens sind JSON-Webtokens mit der folgenden Struktur:
Header: Beschreibt den Signaturalgorithmus. Bei PKI-Tokens wird die Zertifikatskette ebenfalls im Header im Feld
x5cgespeichert.Unterzeichnete JSON-Datennutzlast: Enthält Beanspruchungen zur Arbeitslast für die vertrauende Partei, z. B. Subjekt, Aussteller, Zielgruppe, Nonces und Ablaufzeit.
Signatur: Prüft, ob sich das Token während der Übertragung nicht geändert hat. Weitere Informationen zur Verwendung der Signatur finden Sie unter OpenID Connect-ID-Token prüfen.
Das folgende Codebeispiel ist ein Beispiel für ein codiertes Attestationstoken, das im vertraulichen Bereich 240500 generiert wurde. Neuere Bilder können zusätzliche Felder enthalten. Du kannst es mit https://jwt.io/ decodieren (die Signatur wird entfernt).
eyJhbGciOiJIUzI1NiIsImtpZCI6IjEyMzQ1IiwidHlwIjoiSldUIn0.eyJhdWQiOiJBVURJRU5DRV9OQU1FIiwiZGJnc3RhdCI6ImRpc2FibGVkLXNpbmNlLWJvb3QiLCJlYXRfbm9uY2UiOlsiTk9OQ0VfMSIsIk5PTkNFXzIiXSwiZWF0X3Byb2ZpbGUiOiJodHRwczovL2Nsb3VkLmdvb2dsZS5jb20vY29uZmlkZW50aWFsLWNvbXB1dGluZy9jb25maWRlbnRpYWwtc3BhY2UvZG9jcy9yZWZlcmVuY2UvdG9rZW4tY2xhaW1zIiwiZXhwIjoxNzIxMzMwMDc1LCJnb29nbGVfc2VydmljZV9hY2NvdW50cyI6WyJQUk9KRUNUX0lELWNvbXB1dGVAZGV2ZWxvcGVyLmdzZXJ2aWNlYWNjb3VudC5jb20iXSwiaHdtb2RlbCI6IkdDUF9BTURfU0VWIiwiaWF0IjoxNzIxMzI2NDc1LCJpc3MiOiJodHRwczovL2NvbmZpZGVudGlhbGNvbXB1dGluZy5nb29nbGVhcGlzLmNvbSIsIm5iZiI6MTcyMTMyNjQ3NSwib2VtaWQiOjExMTI5LCJzZWNib290Ijp0cnVlLCJzdWIiOiJodHRwczovL3d3dy5nb29nbGVhcGlzLmNvbS9jb21wdXRlL3YxL3Byb2plY3RzL1BST0pFQ1RfSUQvem9uZXMvdXMtY2VudHJhbDEtYS9pbnN0YW5jZXMvSU5TVEFOQ0VfTkFNRSIsInN1Ym1vZHMiOnsiY29uZmlkZW50aWFsX3NwYWNlIjp7Im1vbml0b3JpbmdfZW5hYmxlZCI6eyJtZW1vcnkiOmZhbHNlfSwic3VwcG9ydF9hdHRyaWJ1dGVzIjpbIkxBVEVTVCIsIlNUQUJMRSIsIlVTQUJMRSJdfSwiY29udGFpbmVyIjp7ImFyZ3MiOlsiL2N1c3RvbW5vbmNlIiwiL2RvY2tlci1lbnRyeXBvaW50LnNoIiwibmdpbngiLCItZyIsImRhZW1vbiBvZmY7Il0sImVudiI6eyJIT1NUTkFNRSI6IkhPU1RfTkFNRSIsIk5HSU5YX1ZFUlNJT04iOiIxLjI3LjAiLCJOSlNfUkVMRUFTRSI6IjJ-Ym9va3dvcm0iLCJOSlNfVkVSU0lPTiI6IjAuOC40IiwiUEFUSCI6Ii91c3IvbG9jYWwvc2JpbjovdXNyL2xvY2FsL2JpbjovdXNyL3NiaW46L3Vzci9iaW46L3NiaW46L2JpbiIsIlBLR19SRUxFQVNFIjoiMn5ib29rd29ybSJ9LCJpbWFnZV9kaWdlc3QiOiJzaGEyNTY6Njc2ODJiZGE3NjlmYWUxY2NmNTE4MzE5MmI4ZGFmMzdiNjRjYWU5OWM2YzMzMDI2NTBmNmY4YmY1ZjBmOTVkZiIsImltYWdlX2lkIjoic2hhMjU2OmZmZmZmYzkwZDM0M2NiY2IwMWE1MDMyZWRhYzg2ZGI1OTk4YzUzNmNkMGEzNjY1MTQxMjFhNDVjNjcyMzc2NWMiLCJpbWFnZV9yZWZlcmVuY2UiOiJkb2NrZXIuaW8vbGlicmFyeS9uZ2lueDpsYXRlc3QiLCJpbWFnZV9zaWduYXR1cmVzIjpbeyJrZXlfaWQiOiI8aGV4YWRlY2ltYWwtc2hhMjU2LWZpbmdlcnByaW50LXB1YmxpYy1rZXkxPiIsInNpZ25hdHVyZSI6IjxiYXNlNjQtZW5jb2RlZC1zaWduYXR1cmU-Iiwic2lnbmF0dXJlX2FsZ29yaXRobSI6IlJTQVNTQV9QU1NfU0hBMjU2In0seyJrZXlfaWQiOiI8aGV4YWRlY2ltYWwtc2hhMjU2LWZpbmdlcnByaW50LXB1YmxpYy1rZXkyPiIsInNpZ25hdHVyZSI6IjxiYXNlNjQtZW5jb2RlZC1zaWduYXR1cmU-Iiwic2lnbmF0dXJlX2FsZ29yaXRobSI6IlJTQVNTQV9QU1NfU0hBMjU2In0seyJrZXlfaWQiOiI8aGV4YWRlY2ltYWwtc2hhMjU2LWZpbmdlcnByaW50LXB1YmxpYy1rZXkzPiIsInNpZ25hdHVyZSI6IjxiYXNlNjQtZW5jb2RlZC1zaWduYXR1cmU-Iiwic2lnbmF0dXJlX2FsZ29yaXRobSI6IkVDRFNBX1AyNTZfU0hBMjU2In1dLCJyZXN0YXJ0X3BvbGljeSI6Ik5ldmVyIn0sImdjZSI6eyJpbnN0YW5jZV9pZCI6IklOU1RBTkNFX0lEIiwiaW5zdGFuY2VfbmFtZSI6IklOU1RBTkNFX05BTUUiLCJwcm9qZWN0X2lkIjoiUFJPSkVDVF9JRCIsInByb2plY3RfbnVtYmVyIjoiUFJPSkVDVF9OVU1CRVIiLCJ6b25lIjoidXMtY2VudHJhbDEtYSJ9fSwic3duYW1lIjoiQ09ORklERU5USUFMX1NQQUNFIiwic3d2ZXJzaW9uIjpbIjI0MDUwMCJdfQ.29V71ymnt7LY5Ny6OJFb9AClT4XNLPi0TIcddKDp5pk<SIGNATURE>
Hier ist die decodierte Version des vorherigen Beispiels:
{
"alg": "HS256",
"kid": "12345",
"typ": "JWT"
}.
{
"aud": "AUDIENCE_NAME",
"dbgstat": "disabled-since-boot",
"eat_nonce": [
"NONCE_1",
"NONCE_2"
],
"eat_profile": "https://cloud.google.com/confidential-computing/confidential-space/docs/reference/token-claims",
"exp": 1721330075,
"google_service_accounts": [
"PROJECT_ID-compute@developer.gserviceaccount.com"
],
"hwmodel": "GCP_AMD_SEV",
"iat": 1721326475,
"iss": "https://confidentialcomputing.googleapis.com",
"nbf": 1721326475,
"oemid": 11129,
"secboot": true,
"sub": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-central1-a/instances/INSTANCE_NAME",
"submods": {
"confidential_space": {
"monitoring_enabled": {
"memory": false
},
"support_attributes": [
"LATEST",
"STABLE",
"USABLE"
]
},
"container": {
"args": [
"/customnonce",
"/docker-entrypoint.sh",
"nginx",
"-g",
"daemon off;"
],
"env": {
"HOSTNAME": "HOST_NAME",
"NGINX_VERSION": "1.27.0",
"NJS_RELEASE": "2~bookworm",
"NJS_VERSION": "0.8.4",
"PATH": "/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
"PKG_RELEASE": "2~bookworm"
},
"image_digest": "sha256:67682bda769fae1ccf5183192b8daf37b64cae99c6c3302650f6f8bf5f0f95df",
"image_id": "sha256:fffffc90d343cbcb01a5032edac86db5998c536cd0a366514121a45c6723765c",
"image_reference": "docker.io/library/nginx:latest",
"image_signatures": [
{
"key_id": "<hexadecimal-sha256-fingerprint-public-key1>",
"signature": "<base64-encoded-signature>",
"signature_algorithm": "RSASSA_PSS_SHA256"
},
{
"key_id": "<hexadecimal-sha256-fingerprint-public-key2>",
"signature": "<base64-encoded-signature>",
"signature_algorithm": "RSASSA_PSS_SHA256"
},
{
"key_id": "<hexadecimal-sha256-fingerprint-public-key3>",
"signature": "<base64-encoded-signature>",
"signature_algorithm": "ECDSA_P256_SHA256"
}
],
"restart_policy": "Never"
},
"gce": {
"instance_id": "INSTANCE_ID",
"instance_name": "INSTANCE_NAME",
"project_id": "PROJECT_ID",
"project_number": "PROJECT_NUMBER",
"zone": "us-central1-a"
}
},
"swname": "CONFIDENTIAL_SPACE",
"swversion": [
"240500"
]
}
Eine ausführlichere Erläuterung der Felder für Attestierungstokens finden Sie unter Anspruchsfelder für Attestierungstokens.
Attestierungstokens abrufen
Führen Sie die folgenden Schritte aus, um Attestationstokens in Ihrer Confidential Space-Umgebung zu implementieren:
Richten Sie einen HTTP-Client in Ihrer Arbeitslast ein.
Verwenden Sie in Ihrer Arbeitslast den HTTP-Client, um über einen Unix-Domain-Socket eine HTTP-Anfrage an die wartende URL
http://localhost/v1/tokenzu senden. Die Socketdatei befindet sich unter/run/container_launcher/teeserver.sock.
Wenn eine Anfrage an die Auslieferungs-URL gesendet wird, verwaltet der Confidential Space-Launcher die Attestierungsnachweiserfassung, fordert ein Attestierungstoken vom Attestierungsservice an (übergibt alle benutzerdefinierten Parameter) und gibt das generierte Token dann an die Arbeitslast zurück.
Das folgende Codebeispiel in Go zeigt, wie Sie über IPC mit dem HTTP-Server des Launchers kommunizieren.
func getCustomTokenBytes(body string) ([]byte, error) {
httpClient := http.Client{
Transport: &http.Transport{
// Set the DialContext field to a function that creates
// a new network connection to a Unix domain socket
DialContext: func(_ context.Context, _, _ string) (net.Conn, error) {
return net.Dial("unix", "/run/container_launcher/teeserver.sock")
},
},
}
// Get the token from the IPC endpoint
url := "http://localhost/v1/token"
resp, err := httpClient.Post(url, "application/json", strings.NewReader(body))
if err != nil {
return nil, fmt.Errorf("failed to get raw token response: %w", err)
}
tokenbytes, err := io.ReadAll(resp.Body)
if err != nil {
return nil, fmt.Errorf("failed to read token body: %w", err)
}
fmt.Println(string(tokenbytes))
return tokenbytes, nil
}
Attestierungstoken mit benutzerdefinierter Zielgruppe anfordern
HTTP-Methode und URL:
POST http://localhost/v1/token
JSON-Text anfordern:
{
"audience": "AUDIENCE_NAME",
"token_type": "TOKEN_TYPE",
"nonces": [
"NONCE_1",
"NONCE_2",
...
]
}
Geben Sie folgende Werte an:
AUDIENCE_NAME: erforderlich. Der Zielgruppenwert, also der Name, den Sie der vertrauenden Partei gegeben haben. Dies wird von der Arbeitslast festgelegt.Für Tokens ohne benutzerdefinierte Zielgruppe wird standardmäßig
https://sts.google.comin dieses Feld eingetragen. Der Werthttps://sts.google.comkann nicht verwendet werden, wenn Sie eine benutzerdefinierte Zielgruppe festlegen. Die maximale Länge beträgt 512 Byte.Wenn eine benutzerdefinierte Zielgruppe in ein Token aufgenommen werden soll, muss die Arbeitslast – nicht die vertrauende Partei – sie der Attestierungstokenanfrage hinzufügen, bevor die Anfrage an den Attestierungsservice für vertrauliche Bereiche gesendet wird. So wird verhindert, dass die vertrauende Partei ein Token für eine geschützte Ressource anfordert, auf die sie keinen Zugriff haben sollte.
TOKEN_TYPE: erforderlich. Der Typ des Tokens, der zurückgegeben werden soll. Wählen Sie einen der folgenden Typen aus:OIDC: Diese Tokens werden am OIDC-Token-Validierungsendpunkt anhand eines öffentlichen Schlüssels validiert, der im Feldjwks_uriangegeben ist. Der öffentliche Schlüssel wird regelmäßig rotiert.PKI: Diese Tokens werden am PKI-Token-Validierungsendpunkt anhand eines Root-Zertifikats validiert, das im Feldroot_ca_uriangegeben ist. Sie müssen dieses Zertifikat selbst speichern. Das Zertifikat wird alle 10 Jahre rotiert.
Da für die Tokenvalidierung Zertifikate mit langer Gültigkeit anstelle von öffentlichen Schlüsseln mit kurzer Gültigkeit verwendet werden, werden Ihre IP-Adressen nicht so oft an Google-Server gesendet. Das bedeutet, dass PKI-Tokens einen höheren Datenschutz bieten als OIDC-Tokens.
Sie können den Fingerabdruck des Zertifikats mit OpenSSL validieren:
openssl x509 -fingerprint -in confidential_space_root.crtDer Fingerabdruck muss mit dem folgenden SHA-1-Digest übereinstimmen:
B9:51:20:74:2C:24:E3:AA:34:04:2E:1C:3B:A3:AA:D2:8B:21:23:21NONCE: Optional. Ein eindeutiger, zufälliger und nicht transparenter Wert, der dafür sorgt, dass ein Token nur einmal verwendet werden kann. Der Wert wird von der vertrauenden Partei festgelegt. Es sind bis zu sechs Nonces zulässig. Jede Nonce muss zwischen 10 und 74 Byte liegen.Wenn ein Nonce angegeben wird, muss die vertrauende Partei prüfen, ob die Nonces in der Attestierungstokenanfrage mit den Nonces im zurückgegebenen Token übereinstimmen. Wenn sie nicht übereinstimmen, muss die vertrauende Partei das Token ablehnen.
Attestierungstokens parsen und validieren
In den folgenden Codebeispielen in Go wird gezeigt, wie Attestationstokens validiert werden.
OIDC-Attestierungstokens
package main
import (
"context"
"crypto/rsa"
"encoding/base64"
"encoding/json"
"errors"
"fmt"
"io"
"math/big"
"net"
"net/http"
"strings"
"github.com/golang-jwt/jwt/v4"
)
const (
socketPath = "/run/container_launcher/teeserver.sock"
expectedIssuer = "https://confidentialcomputing.googleapis.com"
wellKnownPath = "/.well-known/openid-configuration"
)
type jwksFile struct {
Keys []jwk `json:"keys"`
}
type jwk struct {
N string `json:"n"` // "nMMTBwJ7H6Id8zUCZd-L7uoNyz9b7lvoyse9izD9l2rtOhWLWbiG-7pKeYJyHeEpilHP4KdQMfUo8JCwhd-OMW0be_XtEu3jXEFjuq2YnPSPFk326eTfENtUc6qJohyMnfKkcOcY_kTE11jM81-fsqtBKjO_KiSkcmAO4wJJb8pHOjue3JCP09ZANL1uN4TuxbM2ibcyf25ODt3WQn54SRQTV0wn098Y5VDU-dzyeKYBNfL14iP0LiXBRfHd4YtEaGV9SBUuVhXdhx1eF0efztCNNz0GSLS2AEPLQduVuFoUImP4s51YdO9TPeeQ3hI8aGpOdC0syxmZ7LsL0rHE1Q",
E string `json:"e"` // "AQAB" or 65537 as an int
Kid string `json:"kid"` // "1f12fa916c3a0ef585894b4b420ad17dc9d6cdf5",
// Unused fields:
// Alg string `json:"alg"` // "RS256",
// Kty string `json:"kty"` // "RSA",
// Use string `json:"use"` // "sig",
}
type wellKnown struct {
JwksURI string `json:"jwks_uri"` // "https://www.googleapis.com/service_accounts/v1/metadata/jwk/signer@confidentialspace-sign.iam.gserviceaccount.com"
// Unused fields:
// Iss string `json:"issuer"` // "https://confidentialcomputing.googleapis.com"
// Subject_types_supported string `json:"subject_types_supported"` // [ "public" ]
// Response_types_supported string `json:"response_types_supported"` // [ "id_token" ]
// Claims_supported string `json:"claims_supported"` // [ "sub", "aud", "exp", "iat", "iss", "jti", "nbf", "dbgstat", "eat_nonce", "google_service_accounts", "hwmodel", "oemid", "secboot", "submods", "swname", "swversion" ]
// Id_token_signing_alg_values_supported string `json:"id_token_signing_alg_values_supported"` // [ "RS256" ]
// Scopes_supported string `json:"scopes_supported"` // [ "openid" ]
}
func getWellKnownFile() (wellKnown, error) {
httpClient := http.Client{}
resp, err := httpClient.Get(expectedIssuer + wellKnownPath)
if err != nil {
return wellKnown{}, fmt.Errorf("failed to get raw .well-known response: %w", err)
}
wellKnownJSON, err := io.ReadAll(resp.Body)
if err != nil {
return wellKnown{}, fmt.Errorf("failed to read .well-known response: %w", err)
}
wk := wellKnown{}
json.Unmarshal(wellKnownJSON, &wk)
return wk, nil
}
func getJWKFile() (jwksFile, error) {
wk, err := getWellKnownFile()
if err != nil {
return jwksFile{}, fmt.Errorf("failed to get .well-known json: %w", err)
}
// Get JWK URI from .wellknown
uri := wk.JwksURI
fmt.Printf("jwks URI: %v\n", uri)
httpClient := http.Client{}
resp, err := httpClient.Get(uri)
if err != nil {
return jwksFile{}, fmt.Errorf("failed to get raw JWK response: %w", err)
}
jwkbytes, err := io.ReadAll(resp.Body)
if err != nil {
return jwksFile{}, fmt.Errorf("failed to read JWK body: %w", err)
}
file := jwksFile{}
err = json.Unmarshal(jwkbytes, &file)
if err != nil {
return jwksFile{}, fmt.Errorf("failed to unmarshall JWK content: %w", err)
}
return file, nil
}
// N and E are 'base64urlUInt' encoded: https://www.rfc-editor.org/rfc/rfc7518#section-6.3
func base64urlUIntDecode(s string) (*big.Int, error) {
b, err := base64.RawURLEncoding.DecodeString(s)
if err != nil {
return nil, err
}
z := new(big.Int)
z.SetBytes(b)
return z, nil
}
func getRSAPublicKeyFromJWKsFile(t *jwt.Token) (any, error) {
keysfile, err := getJWKFile()
if err != nil {
return nil, fmt.Errorf("failed to fetch the JWK file: %w", err)
}
// Multiple keys are present in this endpoint to allow for key rotation.
// This method finds the key that was used for signing to pass to the validator.
kid := t.Header["kid"]
for _, key := range keysfile.Keys {
if key.Kid != kid {
continue // Select the key used for signing
}
n, err := base64urlUIntDecode(key.N)
if err != nil {
return nil, fmt.Errorf("failed to decode key.N %w", err)
}
e, err := base64urlUIntDecode(key.E)
if err != nil {
return nil, fmt.Errorf("failed to decode key.E %w", err)
}
// The parser expects an rsa.PublicKey: https://github.com/golang-jwt/jwt/blob/main/rsa.go#L53
// or an array of keys. We chose to show passing a single key in this example as its possible
// not all validators accept multiple keys for validation.
return &rsa.PublicKey{
N: n,
E: int(e.Int64()),
}, nil
}
return nil, fmt.Errorf("failed to find key with kid '%v' from well-known endpoint", kid)
}
func decodeAndValidateToken(tokenBytes []byte, keyFunc func(t *jwt.Token) (any, error)) (*jwt.Token, error) {
var err error
fmt.Println("Unmarshalling token and checking its validity...")
token, err := jwt.NewParser().Parse(string(tokenBytes), keyFunc)
fmt.Printf("Token valid: %v", token.Valid)
if token.Valid {
return token, nil
}
if ve, ok := err.(*jwt.ValidationError); ok {
if ve.Errors&jwt.ValidationErrorMalformed != 0 {
return nil, fmt.Errorf("token format invalid. Please contact the Confidential Space team for assistance")
}
if ve.Errors&(jwt.ValidationErrorNotValidYet) != 0 {
// If device time is not synchronized with the Attestation Service you may need to account for that here.
return nil, errors.New("token is not active yet")
}
if ve.Errors&(jwt.ValidationErrorExpired) != 0 {
return nil, fmt.Errorf("token is expired")
}
return nil, fmt.Errorf("unknown validation error: %v", err)
}
return nil, fmt.Errorf("couldn't handle this token or couldn't read a validation error: %v", err)
}
func main() {
// Get a token from a workload running in Confidential Space
tokenbytes, err := getTokenBytesFromWorkload()
// Write a method to return a public key from the well-known endpoint
keyFunc := getRSAPublicKeyFromJWKsFile
// Verify properties of the original Confidential Space workload that generated the attestation
// using the token claims.
token, err := decodeAndValidateToken(tokenbytes, keyFunc)
if err != nil {
panic(err)
}
claimsString, err := json.MarshalIndent(token.Claims, "", " ")
if err != nil {
panic(err)
}
fmt.Println(string(claimsString))
}
PKI-Attestierungstokens
Um das Token zu validieren, muss die vertrauende Partei die folgenden Schritte ausführen:
Parse den Header des Tokens, um die Zertifikatskette zu erhalten.
Prüfen Sie die Zertifikatskette anhand des gespeicherten Stammzertifikats. Sie müssen das Stammzertifikat zuvor von der URL heruntergeladen haben, die im Feld
root_ca_uriangegeben ist, das am PKI-Token-Bestätigungsendpunkt zurückgegeben wird.Prüfen Sie die Gültigkeit des untergeordneten Zertifikats.
Verwende das untergeordnete Zertifikat, um die Tokensignatur mit dem Algorithmus zu validieren, der im
alg-Schlüssel im Header angegeben ist.
Nachdem das Token validiert wurde, kann die vertrauende Partei die Ansprüche des Tokens analysieren.
// This code is an example of how to validate a PKI token. This library is not an official library,
// nor is it endorsed by Google.
// ValidatePKIToken validates the PKI token returned from the attestation service is valid.
// Returns a valid jwt.Token or returns an error if invalid.
func ValidatePKIToken(storedRootCertificate x509.Certificate, attestationToken string) (jwt.Token, error) {
// IMPORTANT: The attestation token should be considered untrusted until the certificate chain and
// the signature is verified.
jwtHeaders, err := ExtractJWTHeaders(attestationToken)
if err != nil {
return jwt.Token{}, fmt.Errorf("ExtractJWTHeaders(token) returned error: %v", err)
}
if jwtHeaders["alg"] != "RS256" {
return jwt.Token{}, fmt.Errorf("ValidatePKIToken(string, *attestpb.Attestation, *v1mainpb.VerifyAttestationRequest) - got Alg: %v, want: %v", jwtHeaders["alg"], "RS256")
}
// Additional Check: Validate the ALG in the header matches the certificate SPKI.
// https://datatracker.ietf.org/doc/html/rfc5280#section-4.1.2.7
// This is included in golangs jwt.Parse function
x5cHeaders := jwtHeaders["x5c"].([]any)
certificates, err := ExtractCertificatesFromX5CHeader(x5cHeaders)
if err != nil {
return jwt.Token{}, fmt.Errorf("ExtractCertificatesFromX5CHeader(x5cHeaders) returned error: %v", err)
}
// Verify the leaf certificate signature algorithm is an RSA key
if certificates.LeafCert.SignatureAlgorithm != x509.SHA256WithRSA {
return jwt.Token{}, fmt.Errorf("leaf certificate signature algorithm is not SHA256WithRSA")
}
// Verify the leaf certificate public key algorithm is RSA
if certificates.LeafCert.PublicKeyAlgorithm != x509.RSA {
return jwt.Token{}, fmt.Errorf("leaf certificate public key algorithm is not RSA")
}
// Verify the storedRootCertificate is the same as the root certificate returned in the token.
// storedRootCertificate is downloaded from the confidential computing well known endpoint
// https://confidentialcomputing.googleapis.com/.well-known/attestation-pki-root
err = CompareCertificates(storedRootCertificate, *certificates.RootCert)
if err != nil {
return jwt.Token{}, fmt.Errorf("failed to verify certificate chain: %v", err)
}
err = VerifyCertificateChain(certificates)
if err != nil {
return jwt.Token{}, fmt.Errorf("VerifyCertificateChain(string, *attestpb.Attestation, *v1mainpb.VerifyAttestationRequest) - error verifying x5c chain: %v", err)
}
keyFunc := func(token *jwt.Token) (any, error) {
return certificates.LeafCert.PublicKey, nil
}
verifiedJWT, err := jwt.Parse(attestationToken, keyFunc)
return *verifiedJWT, err
}
// ExtractJWTHeaders parses the JWT and returns the headers.
func ExtractJWTHeaders(token string) (map[string]any, error) {
parser := &jwt.Parser{}
// The claims returned from the token are unverified at this point
// Do not use the claims until the algorithm, certificate chain verification and root certificate
// comparison is successful
unverifiedClaims := &jwt.MapClaims{}
parsedToken, _, err := parser.ParseUnverified(token, unverifiedClaims)
if err != nil {
return nil, fmt.Errorf("Failed to parse claims token: %v", err)
}
return parsedToken.Header, nil
}
// PKICertificates contains the certificates extracted from the x5c header.
type PKICertificates struct {
LeafCert *x509.Certificate
IntermediateCert *x509.Certificate
RootCert *x509.Certificate
}
// ExtractCertificatesFromX5CHeader extracts the certificates from the given x5c header.
func ExtractCertificatesFromX5CHeader(x5cHeaders []any) (PKICertificates, error) {
if x5cHeaders == nil {
return PKICertificates{}, fmt.Errorf("VerifyAttestation(string, *attestpb.Attestation, *v1mainpb.VerifyAttestationRequest) - x5c header not set")
}
x5c := []string{}
for _, header := range x5cHeaders {
x5c = append(x5c, header.(string))
}
// The PKI token x5c header should have 3 certificates - leaf, intermediate and root
if len(x5c) != 3 {
return PKICertificates{}, fmt.Errorf("incorrect number of certificates in x5c header, expected 3 certificates, but got %v", len(x5c))
}
leafCert, err := DecodeAndParseDERCertificate(x5c[0])
if err != nil {
return PKICertificates{}, fmt.Errorf("cannot parse leaf certificate: %v", err)
}
intermediateCert, err := DecodeAndParseDERCertificate(x5c[1])
if err != nil {
return PKICertificates{}, fmt.Errorf("cannot parse intermediate certificate: %v", err)
}
rootCert, err := DecodeAndParseDERCertificate(x5c[2])
if err != nil {
return PKICertificates{}, fmt.Errorf("cannot parse root certificate: %v", err)
}
certificates := PKICertificates{
LeafCert: leafCert,
IntermediateCert: intermediateCert,
RootCert: rootCert,
}
return certificates, nil
}
// DecodeAndParseDERCertificate decodes the given DER certificate string and parses it into an x509 certificate.
func DecodeAndParseDERCertificate(certificate string) (*x509.Certificate, error) {
bytes, _ := base64.StdEncoding.DecodeString(certificate)
cert, err := x509.ParseCertificate(bytes)
if err != nil {
return nil, fmt.Errorf("cannot parse certificate: %v", err)
}
return cert, nil
}
// DecodeAndParsePEMCertificate decodes the given PEM certificate string and parses it into an x509 certificate.
func DecodeAndParsePEMCertificate(certificate string) (*x509.Certificate, error) {
block, _ := pem.Decode([]byte(certificate))
if block == nil {
return nil, fmt.Errorf("cannot decode certificate")
}
cert, err := x509.ParseCertificate(block.Bytes)
if err != nil {
return nil, fmt.Errorf("cannot parse certificate: %v", err)
}
return cert, nil
}
// VerifyCertificateChain verifies the certificate chain from leaf to root.
// It also checks that all certificate lifetimes are valid.
func VerifyCertificateChain(certificates PKICertificates) error {
if isCertificateLifetimeValid(certificates.LeafCert) {
return fmt.Errorf("leaf certificate is not valid")
}
if isCertificateLifetimeValid(certificates.IntermediateCert) {
return fmt.Errorf("intermediate certificate is not valid")
}
interPool := x509.NewCertPool()
interPool.AddCert(certificates.IntermediateCert)
if isCertificateLifetimeValid(certificates.RootCert) {
return fmt.Errorf("root certificate is not valid")
}
rootPool := x509.NewCertPool()
rootPool.AddCert(certificates.RootCert)
_, err := certificates.LeafCert.Verify(x509.VerifyOptions{
Intermediates: interPool,
Roots: rootPool,
KeyUsages: []x509.ExtKeyUsage{x509.ExtKeyUsageAny},
})
if err != nil {
return fmt.Errorf("failed to verify certificate chain: %v", err)
}
return nil
}
func isCertificateLifetimeValid(certificate *x509.Certificate) bool {
currentTime := time.Now()
// check the current time is after the certificate NotBefore time
if !currentTime.After(certificate.NotBefore) {
return false
}
// check the current time is before the certificate NotAfter time
if currentTime.Before(certificate.NotAfter) {
return false
}
return true
}
// CompareCertificates compares two certificate fingerprints.
func CompareCertificates(cert1 x509.Certificate, cert2 x509.Certificate) error {
fingerprint1 := sha256.Sum256(cert1.Raw)
fingerprint2 := sha256.Sum256(cert2.Raw)
if fingerprint1 != fingerprint2 {
return fmt.Errorf("certificate fingerprint mismatch")
}
return nil
}