このページは Cloud Translation API によって翻訳されました。

Confidential Virtual Machine での vTPM リモート認証

1. 概要

Confidential Virtual Machines（CVM）は、ハードウェアベースのメモリ暗号化を使用する Compute Engine 仮想マシンの一種です。これにより、使用中のデータとアプリケーションに対する読み取りや変更を防ぐことができます。この Codelab では、リモートパーティが CVM ノードを検証できるようにするリモート構成証明について説明します。また、詳細な監査のために Cloud Logging について学習します。

上の図に示すように、この Codelab では次の手順を行います。

CVM のセットアップとリモート構成証明
CVM リモート構成証明の Cloud Logging データ探索
シークレットリリースのウェブサーバーのセットアップ

上記の図のコンポーネントには、go-tpm ツールと Google Cloud 構成証明が含まれています。

go-tpm ツール: CVM の vTPM（仮想トラステッドプラットフォームモジュール）から構成証明証明書を取得し、Google Cloud 構成証明に送信して構成証明トークンを取得するオープンソースツール。
Google Cloud 構成証明: 受信した構成証明の証拠を確認して検証し、リクエスト元の CVM に関する事実を反映した構成証明トークンを返します。

学習内容

CVM で Confidential Computing API を使用してリモート構成証明を行う方法
Cloud Logging を使用して CVM リモート構成証明をモニタリングする方法

必要なもの

Google Cloud Platform プロジェクト
ブラウザ（Chrome、Firefox など）
Google Compute Engine、Confidential VM の基本的な知識

2. 設定と要件

必要な API を有効にするには、Cloud コンソールまたはローカル開発環境で次のコマンドを実行します。

gcloud auth login

gcloud services enable \
    cloudapis.googleapis.com \
    cloudshell.googleapis.com \
    confidentialcomputing.googleapis.com \
    compute.googleapis.com

3. CVM と vTPM のリモート構成証明の設定

このステップでは、CVM を作成し、vTPM リモート構成証明を実行して、CVM で構成証明トークン（OIDC トークン）を取得します。

Cloud コンソールまたはローカル開発環境に移動します。次のように CVM を作成します（Confidential VM インスタンスを作成する | Google Cloud を参照）。Confidential Computing API にアクセスするには、スコープが必要です。

gcloud config set project <project-id>

gcloud compute instances create cvm-attestation-codelab \
    --machine-type=n2d-standard-2 \
    --min-cpu-platform="AMD Milan" \
    --zone=us-central1-c \
    --confidential-compute \
    --image=ubuntu-2204-jammy-v20240228 \
    --image-project=ubuntu-os-cloud \
    --scopes https://www.googleapis.com/auth/cloud-platform

CVM のデフォルトのサービスアカウントに Confidential Computing API へのアクセスを許可します（CVM は、Confidential Computing API から構成証明トークンを取得するために、次の権限が必要です）。

1)。Confidential Computing API へのアクセスを許可するロールを作成します。

gcloud iam roles create Confidential_Computing_User --project=<project-id> \
    --title="CVM User" --description="Grants the ability to generate an attestation token in a CVM." \
 --permissions="confidentialcomputing.challenges.create,confidentialcomputing.challenges.verify,confidentialcomputing.locations.get,confidentialcomputing.locations.list" --stage=GA

次のように置き換えます。

project-id はプロジェクトの一意の識別子です。

2）。VM のデフォルトのサービスアカウントをロールに追加します。

gcloud projects add-iam-policy-binding <project-id> \
    --member serviceAccount:$(gcloud iam service-accounts list --filter="email ~ compute@developer.gserviceaccount.com$" --format='value(email)'
) \
    --role "projects/<project-id>/roles/Confidential_Computing_User"

次のように置き換えます。

project-id はプロジェクトの一意の識別子です。

3）CVM に接続し、Google Cloud 構成証明によって提供される Confidential Computing API から構成証明トークンを取得するための go-tpm ツールバイナリを設定します。

CVM に接続します。

gcloud compute ssh --zone us-central1-c cvm-attestation-codelab

Go 環境を設定します。

wget https://go.dev/dl/go1.22.0.linux-amd64.tar.gz
sudo tar -C /usr/local -xzf go1.22.0.linux-amd64.tar.gz
export PATH=$PATH:/usr/local/go/bin

go-tpm ツールのバイナリをビルドします。go-tpm ツールのバイナリは、CVM の vTPM から構成証明証拠を取得し、Google Cloud 構成証明に送信して構成証明トークンを取得します。

git clone https://github.com/google/go-tpm-tools.git --depth 1
cd go-tpm-tools/cmd/gotpm/
go build

go-tpm ツールコマンドは、vTPM から CVM の構成証明証拠を抽出し、Google Cloud 構成証明に送信します。Google Cloud 構成証明は、構成証明の証拠を検証し、構成証明トークンを返します。このコマンドを実行すると、attestation-token を含む attestation_token ファイルが作成されます。attestation-token は後でシークレットを取得するために使用します。jwt.io で構成証明トークンをデコードして、クレームを表示できます。

sudo ./gotpm token > attestation_token

（省略可）go-tpm ツールと Google Cloud 構成証明を使用してリモート構成証明を実行する代わりに、vTPM 構成証明の証拠を取得するコマンドを示します。これにより、Google Cloud 構成証明などのサービスを作成して、構成証明の証拠を確認して検証できます。

nonce=$(head -c 16 /dev/urandom | xxd -p)
sudo ./gotpm attest --nonce $nonce --format textproto --output quote.dat
sudo ./gotpm verify debug --nonce $nonce --format textproto --input quote.dat --output vtpm_report

vtpm_report には、検証済みのイベントログが含まれます。任意のエディタを使用して確認できます。verify コマンドは、オファーの構成証明鍵証明書をチェックしません。

4. Cloud Logging を有効にして、リモート構成証明ログを調べる

cvm-attestation-codelab CVM で次のコマンドを実行できます。今回は、Cloud Logging にアクティビティが記録されます。

sudo ./gotpm token --cloud-log --audience "https://api.cvm-attestation-codelab.com"

Cloud コンソールまたはローカル開発環境で cvm-attestation-codelab <instance-id> を取得します。

gcloud compute instances describe cvm-attestation-codelab --zone us-central1-c --format='value(id)'

Cloud Logging を確認するには、次の URL（https://console.cloud.google.com/logs）を開きます。クエリフィールドに次のクエリを入力します。

resource.type="gce_instance" resource.labels.zone="us-central1-c" resource.labels.instance_id=<instance-id> log_name="projects/<project-id>/logs/gotpm" severity>=DEFAULT

次のように置き換えます。

project-id はプロジェクトの一意の識別子です。
instance-id はインスタンスの一意の識別子です。

Google Cloud 構成証明に送信された構成証明トークン、そのクレーム、未加工の証拠、ノンスを確認できます。

5. シークレットリリースウェブサーバーをセットアップする

この手順では、前の SSH セッションを終了して別の VM を設定します。この VM で、シークレットリリースウェブサーバーを設定します。ウェブサーバーは、受信した構成証明トークンとそのクレームを検証します。検証が成功すると、リクエスト元にシークレットが解放されます。

1)。Cloud コンソールまたはローカル開発環境に移動します。仮想マシンを作成します。

gcloud config set project <project-id>

gcloud compute instances create cvm-attestation-codelab-web-server \
    --machine-type=n2d-standard-2 \
    --zone=us-central1-c \
    --image=ubuntu-2204-jammy-v20240228 \
    --image-project=ubuntu-os-cloud

次のように置き換えます。

project-id はプロジェクトの一意の識別子です。

2）。新しい VM に SSH で接続します。

gcloud compute ssh --zone us-central1-c cvm-attestation-codelab-web-server

3）Go 環境を設定します。

wget https://go.dev/dl/go1.22.0.linux-amd64.tar.gz
sudo tar -C /usr/local -xzf go1.22.0.linux-amd64.tar.gz
export PATH=$PATH:/usr/local/go/bin

4）。次の 2 つのファイルを作成して、シークレットリリースウェブサーバーのソースコードを保存します（nano でコピー/貼り付け）。

main.go

package main

import (
        "fmt"
        "net/http"
        "strings"
        "time"
        "log"

        "github.com/golang-jwt/jwt/v4"
)

const (
        theSecret = "This is the super secret information!"
)

func homePage(w http.ResponseWriter, r *http.Request) {
        tokenString := r.Header.Get("Authorization")
        if tokenString != "" {
                tokenString, err := extractToken(tokenString)
                if err != nil {
                        http.Error(w, err.Error(), http.StatusUnauthorized)
                }

                tokenBytes := []byte(tokenString)
                // A method to return a public key from the well-known endpoint
                keyFunc := getRSAPublicKeyFromJWKsFile

                token, err := decodeAndValidateToken(tokenBytes, keyFunc)
                if err != nil {
                        http.Error(w, "Invalid JWT Token", http.StatusUnauthorized)
                }

                if ok, err := isValid(token.Claims.(jwt.MapClaims)); ok {
                        fmt.Fprintln(w, theSecret)
                } else {
                        if err != nil {
                                http.Error(w, "Error validating JWT claims: "+err.Error(), http.StatusUnauthorized)
                        } else {
                                http.Error(w, "Invalid JWT token Claims", http.StatusUnauthorized)
                        }
                }
        } else {
                http.Error(w, "Authorization token required", http.StatusUnauthorized)
        }
}

func extractToken(tokenString string) (string, error) {
        if strings.HasPrefix(tokenString, "Bearer ") {
                return strings.TrimPrefix(tokenString, "Bearer "), nil
        }
        return "", fmt.Errorf("invalid token format")
}

func isValid(claims jwt.MapClaims) (bool, error) {
        // 1. Evaluating Standard Claims:
        subject, ok := claims["sub"].(string)
        if !ok {
                return false, fmt.Errorf("missing or invalid 'sub' claim")
        }
        fmt.Println("Subject:", subject)
        // e.g. "sub":"https://www.googleapis.com/compute/v1/projects/<project_id>/zones/<project_zone>/instances/<instance_name>"

        issuedAt, ok := claims["iat"].(float64)
        if !ok {
                return false, fmt.Errorf("missing or invalid 'iat' claim")
        }
        fmt.Println("Issued At:", time.Unix(int64(issuedAt), 0))

        // 2. Evaluating Remote Attestation Claims:
        hwModel, ok := claims["hwmodel"].(string)
        if !ok || hwModel != "GCP_AMD_SEV" {
                return false, fmt.Errorf("missing or invalid 'hwModel'")
        }
        fmt.Println("hwmodel:", hwModel)

        swName, ok := claims["swname"].(string)
        if !ok || swName != "GCE" {
                return false, fmt.Errorf("missing or invalid 'hwModel'")
        }
        fmt.Println("swname:", swName)

        return true, nil
}

func main() {
        http.HandleFunc("/", homePage)
        fmt.Println("Server listening on :8080")
        err := http.ListenAndServe(":8080", nil)
        if err != nil {
                log.Fatalf("Server failed to start: %v", err)
        }
}

helper.go

package main

import (
        "crypto/rsa"
        "encoding/base64"
        "encoding/json"
        "errors"
        "fmt"
        "io"
        "math/big"
        "net/http"

        "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\n", 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)
}

5）。次のコマンドを実行してウェブサーバーをビルドし、実行します。これにより、:8080 ポートでシークレットリリースウェブサーバーが起動します。

go mod init google.com/codelab
go mod tidy
go get github.com/golang-jwt/jwt/v4
go build
./codelab

トラブルシューティング: go mod tidy: を実行すると、次の警告が表示されることがあります。この警告は無視してかまいません。

go: finding module for package github.com/golang-jwt/jwt/v4
go: downloading github.com/golang-jwt/jwt v3.2.2+incompatible
go: downloading github.com/golang-jwt/jwt/v4 v4.5.0
go: found github.com/golang-jwt/jwt/v4 in github.com/golang-jwt/jwt/v4 v4.5.0
go: google.com/codelab/go/pkg/mod/github.com/golang-jwt/jwt@v3.2.2+incompatible: import path "google.com/codelab/go/pkg/mod/github.com/golang-jwt/jwt@v3.2.2+incompatible" should not have @version
go: google.com/codelab/go/pkg/mod/github.com/golang-jwt/jwt@v3.2.2+incompatible/cmd/jwt: import path "google.com/codelab/go/pkg/mod/github.com/golang-jwt/jwt@v3.2.2+incompatible/cmd/jwt" should not have @version
go: google.com/codelab/go/pkg/mod/github.com/golang-jwt/jwt@v3.2.2+incompatible/request: import path "google.com/codelab/go/pkg/mod/github.com/golang-jwt/jwt@v3.2.2+incompatible/request" should not have @version
go: google.com/codelab/go/pkg/mod/github.com/golang-jwt/jwt@v3.2.2+incompatible/test: import path "google.com/codelab/go/pkg/mod/github.com/golang-jwt/jwt@v3.2.2+incompatible/test" should not have @version

6）。別の Cloud コンソールタブまたはローカル開発環境セッションを開始して、次のコマンドを実行します。これにより、<cvm-attestation-codelab-web-server-internal-ip> が取得されます。

gcloud compute instances describe cvm-attestation-codelab-web-server --format='get(networkInterfaces[0].networkIP)' --zone=us-central1-c

7）。cvm-attestation-codelab VM インスタンスに SSH で接続します。

gcloud compute ssh --zone "us-central1-c" "cvm-attestation-codelab"

8）。次のコマンドは、前述で取得した attestation-token（~/go-tpm-tools/cmd/gotpm/ の下）を置き換えます。これにより、シークレットリリースウェブサーバーが保持するシークレットが取得されます。

cd ~/go-tpm-tools/cmd/gotpm/
curl http://<cvm-attestation-codelab-web-server-internal-ip>:8080 -H "Authorization: Bearer $(cat ./attestation_token)"

次のように置き換えます。

cvm-attestation-codelab-web-server-internal-ip は、cvm-attestation-codelab-web-server VM インスタンスの内部 IP です。

画面に「This is the super secret information!」と表示されます。

正しくない attestation-token または期限切れの attestation-token を指定すると、「curl: (52) Empty reply from server」と表示されます。また、cvm-attestation-codelab-web-server VM インスタンスのシークレットのリリースウェブサーバーログに「Token valid: false」と表示されます。

6. クリーンアップ

Cloud コンソールまたはローカル開発環境で次のコマンドを実行します。

# Delete the role binding
gcloud projects remove-iam-policy-binding <project-id> \
    --member serviceAccount:$(gcloud iam service-accounts list --filter="email ~ compute@developer.gserviceaccount.com$" --format='value(email)'
) \
    --role "projects/<project-id>/roles/Confidential_Computing_User"

# Delete the role
gcloud iam roles delete Confidential_Computing_User --project=<project-id>

# Delete the web server VM instance
gcloud compute instances delete cvm-attestation-codelab-web-server --zone=us-central1-c

# Delete the CVM instance
gcloud compute instances delete cvm-attestation-codelab --zone=us-central1-c

次のように置き換えます。

project-id はプロジェクトの一意の識別子です。

7. 次のステップ

詳しくは、Confidential VMs と Compute Engine をご覧ください。

Confidential Virtual Machine での vTPM リモート認証

1. 概要

学習内容

必要なもの

2. 設定と要件

3. CVM と vTPM のリモート構成証明の設定

4. Cloud Logging を有効にして、リモート構成証明ログを調べる

5. シークレット リリース ウェブサーバーをセットアップする

6. クリーンアップ

7. 次のステップ

5. シークレットリリースウェブサーバーをセットアップする