Criar e conceder acesso a recursos confidenciais

Os colaboradores de dados precisam configurar os seguintes recursos para que os dados confidenciais fiquem acessíveis para uma carga de trabalho:

Além disso, os colaboradores de dados precisam escolher onde os resultados da carga de trabalho do Confidential Space são armazenados e se esses resultados são exclusivos para cada colaborador ou compartilhados. Por exemplo, é possível enviar o mesmo resultado para vários buckets do Cloud Storage que pertencem a cada colaborador de dados.

Armazenar seus dados criptografados

É possível usar qualquer serviço do Google Cloud que armazene dados para hospedar seus dados confidenciais. Por exemplo, é possível usar um dos seguintes serviços:

Verifique se esses dados estão criptografados em repouso, seja usando recursos integrados ou algo como o Cloud Key Management Service (Cloud KMS).

Autorizar a carga de trabalho com um WIP

Um WIP é o mecanismo que o Confidential Space usa para permitir que uma carga de trabalho externa acesse e trabalhe com seus dados confidenciais como uma identidade federada. Uma identidade federada é uma entidade externa tratada como se fosse um principal no seu próprio projeto, permitindo que você conceda papéis do IAM a ela para dar acesso a recursos específicos ou personificar contas de serviço para fazer o mesmo.

Como colaborador de dados, você configura um provedor dentro de um WIP que define as regras para entidades que se autenticam como uma identidade federada. Para o Confidential Space, é preciso definir o seguinte em um provedor:

  • Um serviço de atestado: esse serviço verifica se a carga de trabalho é uma instância de VM confidencial e, por fim, retorna um token de atestado do OpenID Connect (OIDC) ao provedor do WIP. O operador de carga de trabalho define o serviço de atestado usado, que precisa corresponder ao serviço de atestado adicionado ao provedor de WIP para que o acesso seja concedido.

  • Mapeamentos de atributos: atributos em tokens de acesso do Security Token Service que são mapeados para declarações feitas pela entidade de autenticação. Nesse caso, a instância de VM que está executando a carga de trabalho. As declarações são feitas pela própria instância de VM, pela imagem do Confidential Space e pelo contêiner de carga de trabalho, e transmitidas ao provedor de WIP pela carga de trabalho. Esses atributos são usados para itens como trilhas de auditoria no Cloud Logging e para conceder papéis pelo IAM com base em declarações de entidade de autenticação, como resumos de contêineres de imagem de carga de trabalho. Leia mais sobre mapeamentos de atributos.

  • Uma política de atestado: uma série de condições que as entidades de autenticação precisam transmitir para receber acesso, com base nas declarações que fazem.

Quando uma carga de trabalho é iniciada, o Confidential Space Launcher envia o relatório de atestação para um serviço de atestação definido pelo operador da carga de trabalho, que verifica a instância de VM confidencial e retorna um token de atestação OIDC. Esse token dura uma hora e é atualizado automaticamente.

O token de atestação é transmitido ao provedor do WIP pela carga de trabalho, e o provedor o usa para verificar se as declarações passam na política de atestação definida no provedor. Se isso acontecer, a carga de trabalho poderá acessar os recursos confidenciais.

Acesso a cargas de trabalho externas

Antes de configurar um WIP e um provedor, é preciso escolher como a carga de trabalho vai acessar seus recursos: acesso direto a recursos ou identidade temporária de conta de serviço.

Acesso direto a recursos

Recomendamos o método de acesso direto a recursos para cargas de trabalho.

Esse método envolve a configuração de uma identidade federada em um provedor de WIP vinculado às declarações de uma entidade de autenticação. Dessa forma, uma carga de trabalho pode ser autorizada a acessar recursos diretamente por meio de vinculações do IAM, com base em atributos como o resumo da imagem do contêiner da carga de trabalho.

O acesso direto a recursos tem as seguintes vantagens:

  • A configuração de um ambiente do Confidential Space requer menos etapas, já que os colaboradores de dados não precisam configurar contas de serviço para que uma conta de serviço de carga de trabalho as represente.

  • A carga de trabalho só pode acessar recursos específicos, conforme determinado pelo IAM. Esse método é mais seguro do que a identidade temporária de conta de serviço, em que contas de serviço com permissões excessivas ou direitos de identidade temporária podem fornecer a um usuário malicioso mais acesso do que o pretendido.

  • Cada acesso a recursos é registrado com uma identidade federada da instância de VM de carga de trabalho, em vez de uma identidade de conta de serviço representada que pode ser compartilhada por várias cargas de trabalho. A identidade de uma instância de VM de carga de trabalho pode incluir detalhes como o resumo da imagem de um contêiner, o número do projeto em que a carga de trabalho está operando e o ID da instância de VM que executa a carga de trabalho, fornecendo uma trilha de auditoria mais detalhada.

  • Não é necessário mapear a propriedade selfLink da instância de VM para o atributo google.subject em um provedor de WIP. Valores muito longos de selfLink podem exceder o limite de 127 bytes desse atributo, fazendo com que a autenticação do provedor de WIP falhe.

Identidade temporária de conta de serviço

O método de identidade temporária de conta de serviço envolve cada colaborador de dados configurando uma conta de serviço para descriptografar os dados particulares e, em seguida, anexando essa conta de serviço ao próprio WIP. Eles também especificam a conta de serviço da carga de trabalho no provedor de WIP, o que permite que ela represente as contas de serviço dos colaboradores de dados para recuperar e operar os dados confidenciais deles.

A identidade temporária de conta de serviço só deve ser usada nos seguintes cenários:

O método de identidade temporária de conta de serviço pode falhar ao autenticar em um provedor de WIP se uma instância de VM tiver uma propriedade selfLink muito longa. Isso ocorre porque a declaração sub no token de atestado, que é definida como o valor selfLink, é mapeada no provedor WIP para o atributo google.subject, que tem um limite de 127 bytes.

Para valores de selfLink de instância de VM que excedem 127 bytes, renomeie as instâncias de VM para encurtar o selfLink ou use o método de acesso direto a recursos.

Configurar um WIP e um provedor

As etapas para configurar um provedor mudam dependendo se você usa o acesso direto a recursos ou a identidade temporária de conta de serviço.

Acesso direto a recursos

O método de acesso direto a recursos envolve a configuração de um WIP e de um provedor, além da configuração de papéis do IAM com base em um resumo de imagem do contêiner de carga de trabalho específico.

Configurar um WIP e um provedor

Para configurar um WIP e um provedor, siga estas instruções:

  1. Crie o WIP:

    gcloud iam workload-identity-pools create DATA_COLLABORATOR_POOL_NAME \
        --location=global
    
  2. Crie um provedor OIDC no WIP:

    gcloud iam workload-identity-pools providers create-oidc attestation-verifier \
        --location=global \
        --workload-identity-pool=DATA_COLLABORATOR_POOL_NAME \
        --issuer-uri="ISSUER_URI" \
        --allowed-audiences="https://sts.googleapis.com" \
        --attribute-mapping="google.subject=\"gcpcs::\"+assertion.submods.container.image_digest+\"::\"+assertion.submods.gce.project_number+\"::\"+assertion.submods.gce.instance_id,attribute.image_digest=assertion.submods.container.image_digest" \
        --attribute-condition="assertion.swname == 'CONFIDENTIAL_SPACE' \
            && 'STABLE' in assertion.submods.confidential_space.support_attributes"
    

    Este exemplo usa os seguintes valores:

    • Um issuer-uri que corresponde ao serviço de atestação que você está usando:

      • Google Cloud Attestation: https://confidentialcomputing.googleapis.com

      • Intel Trust Authority: https://portal.trustauthority.intel.com

    • Um allowed-audiences de https://sts.googleapis.com. Esse é o Security Token Service do Google, que troca credenciais por tokens de acesso.

    • Um attribute-mapping de google.subject, com o seguinte valor:

      \"gcpcs::\"+assertion.submods.container.image_digest+\"::\"+assertion.submods.gce.project_number+\"::\"+assertion.submods.gce.instance_id,attribute.image_digest=assertion.submods.container.image_digest
      

      Esse valor é construído usando a Common Expression Language (CEL). Os valores a seguir são atribuídos ao atributo gcpcs e aparecem no Cloud Logging sempre que a carga de trabalho acessa recursos:

      • assertion.submods.container.image_digest: o resumo da imagem do contêiner da carga de trabalho.

      • assertion.submods.gce.project_number: o número do projeto da instância de VM.

      • assertion.submods.gce.instance_id: o ID da instância de VM.

      Além disso, attribute.image_digest é definido como assertion.submods.container.image_digest, o resumo da imagem do contêiner da carga de trabalho. Esse atributo é mapeado para que você possa conceder os papéis do IAM de identidade federada com base em um resumo de imagem específico.

      É possível mapear qualquer uma das declarações de carga de trabalho disponíveis, desde que o tamanho total do valor google.subject seja menor que 127 bytes.

    • Os attribute-conditions a seguir, que formam uma política de atestado. Se essas condições corresponderem às declarações da carga de trabalho, ela poderá acessar os recursos confidenciais como uma identidade federada:

      • assertion.swname == 'CONFIDENTIAL_SPACE': verifica se o Confidential Space é o software em execução na VM, com todas as garantias de segurança integradas.

      • 'STABLE' in assertion.submods.confidential_space.support_attributes: verifica se a imagem de produção do Confidential Space está sendo usada e tem o atributo de suporte STABLE.

      Para mais condições de atributo que podem ser usadas, consulte Criar uma política de atestado.

Conceder os papéis do IAM de identidade federada

Depois de criar um provedor de WIP, é possível conceder à identidade federada um papel do IAM com base em se o resumo do contêiner de imagem da carga de trabalho da identidade corresponde a um valor esperado.

O exemplo a seguir demonstra como conceder a uma identidade federada a capacidade de descriptografar uma chave específica do Cloud Key Management Service:

gcloud kms keys add-iam-policy-binding \
    projects/DATA_COLLABORATOR_PROJECT_ID/locations/global/keyRings/DATA_COLLABORATOR_KEYRING_NAME/cryptoKeys/DATA_COLLABORATOR_KEY_NAME \
    --member="principalSet://iam.googleapis.com/projects/DATA_COLLABORATOR_PROJECT_NUMBER/locations/global/workloadIdentityPools/DATA_COLLABORATOR_POOL_NAME/attribute.image_digest/WORKLOAD_CONTAINER_IMAGE_DIGEST" \
    --role=roles/cloudkms.cryptoKeyDecrypter

Identidade temporária de conta de serviço

O método de identidade temporária de conta de serviço envolve o seguinte:

  1. Criar contas de serviço em cada um dos projetos de colaboradores de dados e conceder a elas permissão para descriptografar os dados confidenciais.

  2. Criar WIPs em cada um dos projetos de colaboradores de dados e, em seguida, anexar a conta de serviço recém-criada de cada projeto ao WIP.

  3. Criar provedores de WIP em cada WIP, que especificam a conta de serviço da carga de trabalho como a conta que tem permissão para representar as contas de serviço do colaborador de dados.

Configurar contas de serviço para descriptografar dados confidenciais

  1. Crie as contas de serviço nos projetos de colaborador de dados:

    gcloud iam service-accounts create DATA_COLLABORATOR_SERVICE_ACCOUNT_NAME
    

    Conceda às contas de serviço as permissões necessárias para descriptografar os dados confidenciais. Por exemplo, é possível criptografar arquivos confidenciais no Cloud Storage com o Cloud KMS. Portanto, é necessário conceder à conta de serviço permissão para descriptografar esses dados:

    gcloud kms keys add-iam-policy-binding \
        projects/DATA_COLLABORATOR_PROJECT_ID/locations/global/keyRings/DATA_COLLABORATOR_KEYRING_NAME/cryptoKeys/DATA_COLLABORATOR_KEY_NAME \
        --member=serviceAccount:DATA_COLLABORATOR_SERVICE_ACCOUNT_NAME@DATA_COLLABORATOR_PROJECT_ID.iam.gserviceaccount.com \
        --role=roles/cloudkms.cryptoKeyDecrypter
    

Configurar um WIP e um provedor

Para configurar um WIP e um provedor, siga estas instruções em cada projeto de colaborador de dados:

  1. Crie o WIP:

    gcloud iam workload-identity-pools create DATA_COLLABORATOR_POOL_NAME \
        --location=global
    
  2. Anexe a conta de serviço que será personificada ao WIP, com o papel roles/iam.workloadIdentityUser:

    gcloud iam service-accounts add-iam-policy-binding \
        DATA_COLLABORATOR_SERVICE_ACCOUNT_NAME@DATA_COLLABORATOR_PROJECT_ID.iam.gserviceaccount.com \
        --member="principalSet://iam.googleapis.com/projects/DATA_COLLABORATOR_PROJECT_NUMBER/locations/global/workloadIdentityPools/DATA_COLLABORATOR_POOL_NAME/*" \
        --role=roles/iam.workloadIdentityUser
    
  3. Crie um provedor OIDC no WIP e defina a conta de serviço da carga de trabalho nele para que ela possa personificar a conta de serviço do colaborador de dados:

    gcloud iam workload-identity-pools providers create-oidc attestation-verifier \
        --location=global \
        --workload-identity-pool=DATA_COLLABORATOR_POOL_NAME \
        --issuer-uri="https://confidentialcomputing.googleapis.com/" \
        --allowed-audiences="https://sts.googleapis.com" \
        --attribute-mapping="google.subject=assertion.sub" \
        --attribute-condition="assertion.submods.container.image_digest == 'WORKLOAD_CONTAINER_IMAGE_DIGEST' \
    && 'WORKLOAD_SERVICE_ACCOUNT_NAME@WORKLOAD_OPERATOR_PROJECT_ID.iam.gserviceaccount.com' in assertion.google_service_accounts \
    && assertion.swname == 'CONFIDENTIAL_SPACE' \
    && 'STABLE' in assertion.submods.confidential_space.support_attributes"
    

    Este exemplo usa os seguintes valores:

    • Um issuer-uri de https://confidentialcomputing.googleapis.com/, o que significa que o Google Cloud Attestation é usado como o serviço de atestação.

    • Um allowed-audiences de https://sts.googleapis.com. Esse é o Security Token Service do Google, que troca credenciais por tokens de acesso.

    • Um attribute-mapping de google.subject, com o valor assertion.sub. Esse é o selfLink da instância de VM, conforme definido na declaração sub no token de atestado.

      A instância de VM selfLink aparece no Cloud Logging sempre que a carga de trabalho acessa recursos.

    • Os attribute-conditions a seguir, que formam uma política de atestado. Se essas condições corresponderem às declarações da carga de trabalho, ela poderá acessar recursos como uma identidade federada:

      • assertion.submods.container.image_digest == 'WORKLOAD_CONTAINER_IMAGE_DIGEST': verifica se o resumo da imagem do contêiner da carga de trabalho corresponde ao valor esperado.

      • 'WORKLOAD_SERVICE_ACCOUNT_NAME@WORKLOAD_PROJECT_ID.iam.gserviceaccount.com' in assertion.google_service_accounts: verifica se a conta de serviço anexada à carga de trabalho corresponde à conta de serviço esperada e a usa para representar a conta de serviço do colaborador de dados.

      • assertion.swname == 'CONFIDENTIAL_SPACE': verifica se o Confidential Space é o software em execução na VM, com todas as garantias de segurança integradas.

      • 'STABLE' in assertion.submods.confidential_space.support_attributes: verifica se a imagem de produção do Confidential Space está sendo usada e tem o atributo de suporte STABLE.

      Para mais condições de atributo que podem ser usadas, consulte Criar uma política de atestado.

Criar uma política de atestado

Como parte da criação de um WIP, você precisa criar uma política de atestado. As declarações de uma entidade de autenticação precisam corresponder à sua política para que ela possa acessar seus dados.

As políticas são escritas em Common Expression Language (CEL) e são compostas por uma série de instruções que podem ser encadeadas com o operador &&.

As instruções usam declarações da imagem do Confidential Space, da imagem do contêiner de carga de trabalho ou da instância de VM como variáveis, e o valor especificado como a expressão. Por exemplo, veja uma política que impõe que a carga de trabalho use o Confidential Space, use uma imagem do Confidential Space STABLE e que a zona em que a instância de VM da carga de trabalho está em execução seja us-central1-a:

assertion.swname == 'CONFIDENTIAL_SPACE' \
&& 'STABLE' in assertion.submods.confidential_space.support_attributes" \
&& assertion.submods.gce.zone == "us-central1-a"

Consulte declarações de atestado para mais informações.

Declarações de atestado

As declarações disponíveis para criar uma política de atestado são detalhadas na tabela a seguir. As políticas podem validar declarações feitas pela imagem do Confidential Space, pelo contêiner de carga de trabalho e pela instância de VM.

Declarações de imagem

Declaração Tipo Descrição

assertion.dbgstat

Interage com:

Enumeração

Verifica se a imagem do Confidential Space é a versão de depuração ou produção.

Os valores válidos são os seguintes:

  • enable: verifique se a imagem de depuração está sendo usada.
  • disabled-since-boot: verifique se a imagem de produção está sendo usada.
Exemplos

O código a seguir verifica se a versão de depuração da imagem do Confidential Space está sendo usada:

assertion.dbgstat == "enable"

O código a seguir verifica se a versão de produção da imagem do Confidential Space está sendo usada:

assertion.dbgstat == "disabled-since-boot"
assertion.submods.confidential_space.support_attributes Matriz de strings

Verifica se a versão de segurança do TEE é uma imagem de produção do Confidential Space. As imagens de depuração do Confidential Space não têm um atributo de suporte definido.

A tabela a seguir descreve os atributos de suporte encontrados nas imagens de produção do Confidential Space.

Atributo de suporte Descrição

LATEST

As imagens LATEST também têm os seguintes atributos de suporte:

  • STABLE
  • USABLE

Ciclo de vida da imagem: aproximadamente um mês. Depois disso, o atributo de suporte LATEST é removido.

Essa é a versão mais recente da imagem do Confidential Space, além de ser suportada e monitorada em busca de vulnerabilidades.

Para cargas de trabalho de longa duração, recomendamos que você não especifique LATEST como parte da política de atestado. Isso ocorre porque a imagem do Confidential Space pode ser atualizada enquanto a carga de trabalho está em execução, fazendo com que a imagem do Confidential Space que você está usando não seja mais LATEST e fazendo com que a carga de trabalho falhe na atestação quando o token padrão do Confidential Space for atualizado em seguida.

STABLE

As imagens STABLE também têm os seguintes atributos de suporte:

  • USABLE

Ciclo de vida da imagem: aproximadamente seis meses. A partir de 1º de abril de 2027, o atributo de suporte STABLE será removido após o término da vida útil da imagem.

As imagens com o atributo STABLE são compatíveis e monitoradas em busca de vulnerabilidades por um período de seis meses. Recomendamos que você escreva uma política de atestado com base no atributo STABLE.

Em casos raros, o atributo STABLE pode ser removido durante o período normal de suporte de seis meses, como quando vulnerabilidades críticas são descobertas.

USABLE

As imagens com apenas o atributo USABLE ainda estão disponíveis para uso, mas são consideradas descontinuadas. As imagens descontinuadas não são compatíveis e têm mais de seis meses. Use por sua conta e risco.

As imagens USABLE têm uma propriedade deprecated.deprecated. O valor é o carimbo de data/hora de quando a imagem será descontinuada. As propriedades de uma imagem podem ser visualizadas com o comando gcloud compute images describe ou com o método REST images.get. Exemplo:

gcloud compute images describe confidential-space-240800 \
    --format=json \
    --project=confidential-space-images
EXPERIMENTAL

As imagens que têm apenas esse atributo usam recursos em fase de pré-lançamento. As imagens EXPERIMENTAL são apenas para fins de teste e nunca devem ser usadas na produção.

Uma imagem EXPERIMENTAL nunca tem os atributos LATEST, STABLE ou USABLE.

Recomendamos manter a imagem do Confidential Space atualizada. Para saber como atualizar sua imagem do Confidential Space, consulte Atualizar imagens do Confidential Space.

Exemplo

O código a seguir verifica se uma versão estável da imagem do Confidential Space está sendo usada:

"STABLE" in assertion.submods.confidential_space.support_attributes
assertion.swname Enumeração

Verifica o software em execução na entidade de atestado. O valor sempre é CONFIDENTIAL_SPACE.

Exemplo
assertion.swname == "CONFIDENTIAL_SPACE"
assertion.swversion Matriz de strings

Verifica a versão do software da imagem do Confidential Space. Recomendamos usar assertion.submods.confidential_space.support_attributes para acessar a versão mais recente de uma imagem.

Exemplo
int(assertion.swversion[0]) == 230103

Declarações de contêiner

Declaração Tipo Descrição

assertion.submods.container.cmd_override

Interage com:

  • Autor da carga de trabalho: a política de lançamento allow_cmd_override.
  • Operador de carga de trabalho: a variável de metadados tee-cmd.
Matriz de strings

Verifica os comandos e parâmetros do CMD usados na imagem da carga de trabalho.

Exemplos

O código a seguir verifica se o CMD da imagem da carga de trabalho não foi substituído:

size(assertion.submods.container.cmd_override) == 0

O código a seguir verifica se program é o único conteúdo nas substituições do CMD:

assertion.submods.container.cmd_override == ['program']

assertion.submods.container.env

Interage com:

objeto JSON

Verifica se as variáveis de ambiente e os respectivos valores foram transmitidos explicitamente para o contêiner.

Exemplo

O código a seguir verifica se a variável de ambiente example-env-1 está definida como value-1 e example-env-2 está definida como value-2.

assertion.submods.container.env == {"example-env-1": "value-1", "example-env-2": "value-2"}

assertion.submods.container.env_override

Interage com:

String

Verifica se o operador de carga de trabalho substituiu as variáveis de ambiente no contêiner.

Exemplos

O código a seguir verifica se o operador de carga de trabalho não substituiu a variável de ambiente example:

!has(assertion.submods.container.env_override.example)

O código a seguir verifica se o operador da carga de trabalho não substituiu nenhuma variável de ambiente:

size(assertion.submods.container.env_override) == 0
assertion.submods.container.image_digest String

Verifica o resumo da imagem do contêiner da carga de trabalho. Especificar essa condição permite que várias partes concordem com uma carga de trabalho autorizada que tenha permissão para acessar os dados delas.

Exemplo
assertion.submods.container.image_digest == "sha256:837ccb607e312b170fac7383d7ccfd61fa5072793f19a25e75fbacb56539b86b"
assertion.submods.container.image_id String

Verifica o ID da imagem do contêiner da carga de trabalho.

Exemplo
assertion.submods.container.image_id == "sha256:652a44b0e911271ba07cf2915cd700fdfa50abd62a98f87a57fdebc59843d93f"

assertion.submods.container.image_reference

Interage com:

String

Verifica o local do contêiner de carga de trabalho em execução sobre a imagem do Confidential Space.

Exemplo
assertion.submods.container.image_reference == "us-docker.pkg.dev/PROJECT_ID/WORKLOAD_CONTAINER:latest"

assertion.submods.container.image_signatures

Interage com:

objeto JSON

Verifica se a imagem tem uma determinada assinatura ou se é assinada por uma chave pública e um algoritmo de assinatura. Especificar essa condição permite que várias partes concordem com uma carga de trabalho autorizada que tenha permissão para acessar os dados delas.

A declaração pode incluir os seguintes elementos:

  • key_id: a impressão digital hexadecimal da chave pública. Para encontrar a impressão digital, execute o seguinte comando:

    openssl pkey -pubin -in public_key.pem -outform DER | openssl sha256

    Em que public_key.pem é sua chave pública no formato PEM.

  • signature: a assinatura de um payload associado ao contêiner assinado e que segue o formato de assinatura simples.
  • signature_algorithm: o algoritmo usado para assinar a chave. Opções:

    • RSASSA_PSS_SHA256 (RSASSA-PSS com um resumo SHA-256)
    • RSASSA_PKCS1V15_SHA256 (RSASSA-PKCS1 v1_5 com um resumo SHA-256)
    • ECDSA_P256_SHA256 (ECDSA na curva P-256 com um resumo SHA-256)
Exemplo
['ECDSA_P256_SHA256:PUBLIC_KEY_FINGERPRINT'].exists(fingerprint, fingerprint in assertion.submods.container.image_signatures.map(sig, sig.signature_algorithm+':'+sig.key_id))

assertion.submods.container.restart_policy

Interage com:

Enumeração

Verifica a política de reinicialização do inicializador do contêiner para quando a carga de trabalho é interrompida.

Os valores válidos são os seguintes:

  • Never (padrão)
  • Always
  • OnFailure
Exemplo
assertion.submods.container.restart_policy == "Never"

Declarações de VM

Declaração Tipo Descrição

assertion.google_service_accounts

Interage com:

Matriz de strings

Verifica se uma conta de serviço especificada está conectada à VM que está executando a carga de trabalho ou se foi listada usando tee-impersonate-service-accounts nos metadados da VM.

Exemplo
workload-service-account@my-project.iam.gserviceaccount.com in assertion.google_service_accounts
assertion.hwmodel String

Verifica a tecnologia de Computação Confidencial. As plataformas compatíveis são as seguintes:

  • GCP_AMD_SEV
  • INTEL_TDX
Exemplo
assertion.hwmodel == "GCP_AMD_SEV"

assertion.submods.confidential_space.monitoring_enabled

Interage com:

Booleano

Verifica o estado de monitoramento na entidade de atestado.

Exemplo
assertion.submods.confidential_space.monitoring_enabled.memory == true
assertion.submods.gce.instance_id String

Verifica o ID da instância de VM.

Exemplo
assertion.submods.gce.instance_id == "0000000000000000000"
assertion.submods.gce.instance_name String

Verifica o nome da instância de VM.

Exemplo
assertion.submods.gce.instance_name == "workload-vm"
assertion.submods.gce.project_id String

Verifica se a VM está executando um projeto do Google Cloud com o ID do projeto especificado.

Exemplo
assertion.submods.gce.project_id == "project-id"
assertion.submods.gce.project_number String

Verifica se a VM está em execução em um projeto do Google Cloud com o número de projeto especificado.

Exemplo
assertion.submods.gce.project_number == "00000000000"

assertion.submods.gce.zone

Interage com:

  • Operador de carga de trabalho: o valor --zone.
String

Verifica se a VM está em execução na zona especificada.

Exemplo
assertion.submods.gce.zone == "us-central1-a"

assertion.submods.nvidia_gpu.cc_feature

Interage com:

Enumeração

Verifica os recursos de Computação Confidencial compatíveis com uma GPU NVIDIA. Somente o modo de passagem de GPU única (SPT, na sigla em inglês) é compatível com o Confidential Space. Portanto, o valor é sempre SPT.

Para mais informações sobre o suporte à Computação Confidencial da NVIDIA, consulte Soluções de computação confiável da NVIDIA (PDF).

Exemplo
assertion.submods.nvidia_gpu.cc_feature == "SPT"

assertion.submods.nvidia_gpu.cc_mode

Interage com:

Enumeração

Verifica o status do driver de Computação Confidencial da NVIDIA. Os valores válidos são os seguintes:

  • OFF: nenhum dos recursos de computação confidencial da NVIDIA está ativo.
  • ON: o hardware, o firmware e o software da NVIDIA H100 ativaram totalmente os recursos de computação confidencial.
  • DEVTOOLS: a GPU está em um modo de computação confidencial parcial que corresponde aos fluxos de trabalho do modo ON, mas desativa as proteções de segurança.
Exemplo
assertion.submods.nvidia_gpu.cc_mode == "ON"

assertion.submods.nvidia_gpu.gpus

Interage com:

Matriz de objetos

Verifica as declarações de cada GPU NVIDIA atestada. O Confidential Space aceita apenas uma declaração de GPU.

Um objeto gpus é semelhante ao seguinte:

{
  "hwmodel": "GCP_NVIDIA_H100",
  "ueid": "490457405999046854973671575630853621547794591064",
  "l4_serial_number": "1216669666319372030078",
  "driver_version": "570.00",
  "vbios_version": "96.00.9F.00.01"
}
Exemplos

O código a seguir verifica se o primeiro modelo de hardware de GPU é uma NVIDIA H100 em execução no Google Cloud:

assertion.submods.nvidia_gpu.gpus[0].hwmodel == "GCP_NVIDIA_H100"

O código a seguir verifica se a declaração de atestado tem declarações relacionadas à GPU:

has(assertion.submods.nvidia_gpu.gpus)