Todos os produtos
Search
Central de documentação

Elastic Compute Service:Proteção de Medição e Criptografia de Disco para Instâncias de Computação Confidencial

Última atualização: Jun 23, 2026

Este tópico descreve como usar o CryptPilot para proteger dados em repouso em instâncias de computação confidencial. O CryptPilot realiza medição confiável no sistema de arquivos raiz para impedir adulterações de software e criptografa os dados do disco para garantir a confidencialidade dos dados em repouso.

Instâncias de computação confidencial, como instâncias TDX e instâncias confidenciais heterogêneas, protegem dados em tempo de execução por meio de recursos de hardware como criptografia de registradores e criptografia de memória. No entanto, o código do programa e os dados processados geralmente ainda são armazenados em discos em nuvem e exigem mecanismos adicionais para proteção de dados em repouso. Este tópico descreve como usar o CryptPilot para implementar medição e proteção por criptografia de disco em instâncias de computação confidencial, com chaves de criptografia autogerenciadas para discos em nuvem.

Existem duas abordagens para proteção de disco em instâncias de computação confidencial. Elas podem ser usadas de forma independente ou em combinação:

  • Medição e criptografia do disco do sistema confidencial: Introduz a medição dm-verity durante a fase de criação da imagem do disco do sistema, com criptografia LUKS2 opcional. Durante a inicialização do sistema, o rootfs passa por verificação de integridade, e a chave de descriptografia é obtida do serviço de gerenciamento de confiança por meio de atestação remota. Essa abordagem é adequada para cenários que exigem medição confiável de todo o ambiente da máquina e também permite criptografar o disco do sistema.

  • Criptografia de disco de dados confidencial: Realiza criptografia LUKS2 em partições individuais de disco de dados em uma instância de computação confidencial em execução. Use essa abordagem quando você já possui instâncias de negócios e deseja criptografar apenas discos de dados específicos sem recriar a imagem.

Escolha a seção de acordo com o seu cenário: para criar uma imagem de sistema com inicialização confiável e mensurável para uma instância confidencial, consulte Medição e criptografia do disco do sistema confidencial; para criptografar apenas discos de dados específicos em uma instância em execução, consulte Criptografia de disco de dados confidencial.

Medição e criptografia do disco do sistema confidencial

Composição e proteção do disco do sistema confidencial

Um disco do sistema confidencial processado pelo CryptPilot é organizado por volume e contém dois volumes principais:

image
  • Volume rootfs: Um sistema de arquivos raiz somente leitura. Durante a inicialização, o mecanismo dm-verity do kernel Linux constrói uma árvore de hash completa para o volume rootfs. O valor do hash raiz é armazenado em memória segura e registrado no CC Eventlog da instância confidencial para verificar a integridade da cadeia de inicialização por meio de atestação remota. O kernel verifica o valor de hash de cada bloco de dados em relação ao valor de hash raiz pré-armazenado, camada por camada. Qualquer adulteração não autorizada é detectada em tempo real e impede a inicialização do sistema. Para manter a compatibilidade de negócios, uma camada de overlay gravável é colocada sobre o rootfs somente leitura, com o armazenamento de backend do overlay sustentado pelo volume delta. Gravações temporárias não afetam os resultados da medição.

    A criptografia desse volume é opcional. Quando ativada, a criptografia usa LUKS2 (AES-256). O dispositivo gera aleatoriamente uma Master Key para criptografia e descriptografia de dados. Uma Passphrase fornecida pelo usuário é processada por um algoritmo de derivação de chave para gerar uma KEK, que criptografa a Master Key e a armazena no cabeçalho do volume. Durante a inicialização, a KEK é obtida por atestação remota para descriptografar a Master Key. Todas as operações de criptografia e descriptografia são realizadas na memória segura da instância confidencial.

  • Volume delta: Um volume criptografado que ocupa o espaço restante do disco do sistema. Sempre é criptografado com LUKS2 e armazena os dados de backend para a camada de overlay gravável do rootfs. Todas as operações de gravação no rootfs são, por fim, criptografadas e armazenadas no volume delta.

Fluxo de uso

image

Etapa 1: Prepare um ambiente confiável

O ambiente confiável deve atender às seguintes condições:

  • Sistema operacional Alibaba Cloud Linux 3: A ferramenta CryptPilot para criação de discos do sistema confidenciais depende do Alibaba Cloud Linux 3.

  • IP público habilitado: A instância de computação confidencial precisa acessar o servidor Trustee para obter a chave de descriptografia durante a inicialização.

  • Espaço suficiente: O espaço necessário depende do tamanho do arquivo de imagem do disco do sistema que você deseja criar. Recomenda-se que o ambiente tenha mais de 40 GiB de espaço livre.

Etapa 2: Crie uma imagem de disco do sistema confidencial

  1. Prepare a imagem de disco de origem.

    Antes de criar um disco do sistema confidencial, você deve preparar um arquivo de imagem de disco com seu ambiente de negócios implantado. Obtenha essa imagem de uma das duas formas a seguir:

    Exportar uma imagem do sistema de uma instância ECS existente

    Implante e configure seu ambiente de negócios em uma instância Alibaba Cloud ECS existente e exporte a imagem do sistema da instância como um arquivo qcow2 pelo console ou pela API.

    Personalizar uma imagem base oficial

    Baixe a imagem base mais recente do Alibaba Cloud Linux 3 no site oficial do Alibaba Cloud e use a ferramenta virt-customize para personalizar o conteúdo da imagem (como instalar pacotes de software, configurar serviços e adicionar suas aplicações de negócios) para atender às suas necessidades.

    Acesse a página Alibaba Cloud Linux 3 On-premise Image para obter o link de download da distribuição mais recente. Por exemplo, execute o seguinte comando para baixar uma versão específica do arquivo de imagem QCOW2:

    curl -O -L -C - https://alinux3.oss-cn-hangzhou.aliyuncs.com/aliyun_3_x64_20G_nocloud_alibase_20250117.qcow2
    null
    • Apenas arquivos de imagem de disco do sistema operacional Alibaba Cloud Linux 3 nos formatos .qcow2 e .vhd são compatíveis.

    • Após uma imagem ser processada pelo cryptpilot-convert, seu conteúdo não pode mais ser modificado. Conclua todas as configurações e personalizações necessárias antes de processar a imagem.

  2. (Opcional) Fortaleça a imagem.

    Para instâncias que executam em um ambiente de computação confidencial, o fortalecimento da imagem reduz efetivamente a superfície de ataque e impede que serviços ou componentes desnecessários introduzam riscos de segurança, melhorando a segurança geral.

    Consulte a seção Fortalecimento de imagem abaixo para concluir as operações relevantes durante a fase de personalização da imagem, antes de realizar a criptografia.

  3. Instale o CryptPilot e prepare o arquivo de configuração.

    1. Instale o CryptPilot.

      Instale o pacote do host no ambiente de build confiável (que fornece ferramentas como cryptpilot-convert, cryptpilot-enhance e cryptpilot-fde-host para criar imagens de disco do sistema confidencial):

      sudo yum install -y cryptpilot-fde-host
    2. Verifique a versão do CryptPilot.

      cryptpilot-fde-host --version

      image

    3. Crie um diretório para os arquivos de configuração do CryptPilot.

      mkdir -p ./config_dir
    4. Escreva a configuração do disco do sistema.

      O CryptPilot permite configurar separadamente as definições de criptografia para o volume rootfs e o volume delta do disco do sistema confidencial. Escolha a configuração com base em duas dimensões: se o volume rootfs será criptografado e se os dados delta precisam ser persistidos. As quatro combinações a seguir estão disponíveis para o conteúdo de fde.toml. Escreva o conteúdo da opção selecionada em ./config_dir/fde.toml:

      Volume rootfs não criptografado + volume delta não persistente

      [rootfs]
      delta_location = "disk"
      
      [delta]
      integrity = true
      [delta.encrypt.otp]

      Volume rootfs não criptografado + volume delta persistente

      [rootfs]
      delta_location = "disk-persist"
      
      [delta]
      integrity = true
      [delta.encrypt.kbs]
      kbs_url = "http://<trustee-ip>:8081/api"
      key_uri = "kbs:///default/local-resources/delta"

      Volume rootfs criptografado + volume delta não persistente

      [rootfs]
      delta_location = "disk-persist"
      [rootfs.encrypt.kbs]
      kbs_url = "http://<trustee-ip>:8081/api"
      key_uri = "kbs:///default/local-resources/rootfs"
      
      [delta]
      integrity = true
      [delta.encrypt.otp]

      Volume rootfs criptografado + volume delta persistente

      [rootfs]
      delta_location = "disk-persist"
      [rootfs.encrypt.kbs]
      kbs_url = "http://<trustee-ip>:8081/api"
      key_uri = "kbs:///default/local-resources/rootfs"
      
      [delta]
      integrity = true
      [delta.encrypt.kbs]
      kbs_url = "http://<trustee-ip>:8081/api"
      key_uri = "kbs:///default/local-resources/delta"
      null
      • Ao usar OTP, o volume delta gera automaticamente uma nova chave aleatória a cada inicialização. Os dados são perdidos após o desligamento e nenhuma implantação de backend de chave é necessária. Para mais informações sobre OTP, consulte Senha de uso único (OTP).

      • Ao usar um backend de chave persistente como o Trustee, substitua <trustee-ip> na configuração pelo endereço IP público da instância onde você implantou o serviço Trustee (se você configurou acesso HTTPS para o Trustee, substitua http:// por https:// em kbs_url). Para a configuração detalhada de cada método de recuperação de chave, consulte Serviço de gerenciamento de confiança (Trustee).

  4. Crie o arquivo de imagem do disco do sistema confidencial.

    1. Crie o arquivo de imagem do disco do sistema confidencial.

      • Se sua configuração não criptografar o volume rootfs:

        sudo cryptpilot-convert --uki --in ./aliyun_3_x64_20G_nocloud_alibase_20250117.qcow2 --out ./confidential-disk.qcow2 --config-dir ./config_dir/ --rootfs-no-encryption
      • Se sua configuração criptografa o volume rootfs:

        sudo cryptpilot-convert --uki --in ./aliyun_3_x64_20G_nocloud_alibase_20250117.qcow2 --out ./confidential-disk.qcow2 --config-dir ./config_dir/ --rootfs-passphrase "<rootfs_volume_encryption_key>"
        null
        • <rootfs_volume_encryption_key> deve ser a mesma chave de criptografia carregada no backend de chaves para o volume rootfs.

        • Como o volume delta é criptografado durante a inicialização da instância, não é necessário especificar a senha do volume delta ao criar o arquivo de imagem de disco de sistema confidencial.

        • Se precisar instalar pacotes RPM adicionais no disco de sistema, use a opção --package para especificar o nome ou caminho do pacote RPM.

    2. Verifique a imagem gerada.

      A imagem de disco de sistema confidencial é criada em ./confidential-disk.qcow por padrão.

      file ./confidential-disk.qcow2

      image

Etapa 3: Importar a imagem personalizada e criar uma instância confidencial

  1. Carregue a imagem personalizada no OSS.

    Carregue o arquivo de imagem local no OSS e obtenha a URL do arquivo. Para mais informações, consulte Carregar arquivos.

  2. Importe a imagem personalizada.

    Ao importar a imagem personalizada, o Boot Mode deve ser definido como UEFI.

    image

  3. Após importar a imagem com êxito, acesse a página de detalhes da imagem e defina o driver NVMe como Enabled.

    image

Etapa 4: Usar a imagem personalizada importada para criar uma instância de computação confidencial

  1. Use a imagem personalizada importada para criar uma instância de computação confidencial TDX ou uma instância de computação confidencial heterogênea.

    Ao criar a instância, observe os seguintes parâmetros:

    • Image: Selecione a imagem personalizada importada e selecione Confidential VM.

      image

    • Public IP Address: Selecione Assign Public IPv4 Address para que a instância acesse o serviço Trustee e obtenha a chave via atestação remota.

    • Logon Credentials: Selecione Key Pair.

      Discos de sistema confidenciais criados com CryptPilot não oferecem suporte a logon por senha atualmente.

  2. (Opcional) Se você implantou o serviço Trustee, adicione uma regra de entrada no grupo de segurança da instância Trustee para permitir acesso à porta 8081 a partir do endereço IP público da instância confidencial.

    image

  3. Reinicie a instância de computação confidencial.

  4. Conecte-se à instância de computação confidencial pelo terminal Workbench.

    Se conseguir se conectar à instância, isso indica que ela acessa o serviço Trustee e obtém a chave via atestação remota com êxito.

Etapa 5: (Opcional) Registrar valores de referência no serviço Trustee

Se você configurou o Trustee como backend de armazenamento de chaves, a instância envia uma solicitação ao serviço Trustee durante a inicialização para obter a chave de descriptografia do disco. O serviço Trustee verifica o ambiente da instância via atestação remota para checar se ela está sendo executada em uma instância TEE. Além disso, se você quiser verificar também a imagem em execução, registre primeiro os valores de referência da imagem no Trustee.

  1. Use o CryptPilot para calcular os valores de referência da imagem de disco de sistema confidencial e salve-os em reference-value.json.

    sudo cryptpilot-fde-host show-reference-value --disk ./confidential-disk.qcow2 | tee ./reference-value.json

    Veja a seguir um exemplo de saída, em que 466713bf9b2dacca6cd15ff4acd050712e29b4164628e01bd2495411766f36d7ba4560f62537926cf16e08480f1c1804 é o valor de referência da imagem:image

  2. Importe os valores de referência no serviço Trustee.

    provenance=$(cat ./reference-value.json | base64 --wrap=0)
    cat << EOF > ./register-request.json
    {
        "version" : "0.1.0",
        "type": "sample",
        "payload": "$provenance"
    }
    EOF
    
    rvps-tool register --path ./register-request.json

Fortalecimento de imagem

Em um ambiente de computação confidencial, a configuração de segurança da imagem afeta diretamente a confiabilidade geral. Recomendamos fortalecer a imagem antes da criptografia:

  1. Minimização da superfície de ataque: Componentes de serviços de nuvem pré-instalados (como Cloud Assistant e agentes de monitoramento) ampliam a superfície de ataque em cenários de computação confidencial. Removê-los reduz o risco de exploração.

  2. Garantia de isolamento de dados: Serviços de gerenciamento não encerrados podem se tornar canais de vazamento de dados. O fortalecimento garante que apenas os serviços necessários estejam em execução.

  3. Controle de acesso: Desabilitar SSH e outros acessos remotos evita logons não autorizados e preserva o caráter fechado do ambiente de computação.

Descrição da ferramenta de fortalecimento

Para simplificar o processo de fortalecimento, disponibilizamos a ferramenta cryptpilot-enhance, que integra as melhores práticas de fortalecimento de segurança de imagens.

null

Se você usar uma imagem exportada de um snapshot de instância ECS em vez de uma imagem base do Alibaba Cloud Linux 3 obtida da fonte oficial, o Cloud Assistant ou o Security Center (Aegis) pode estar pré-instalado. A ferramenta cryptpilot-enhance detecta e desinstala esses componentes automaticamente.

null

Imagens geradas pelo cryptpilot-convert têm conteúdo finalizado e não podem ser modificadas. Por isso, execute o cryptpilot-enhance antes do cryptpilot-convert.

O cryptpilot-enhance oferece suporte a dois modos de fortalecimento:

  • full: Fortalecimento completo. Remove o serviço SSH e aplica o controle de acesso mais rigoroso.

  • partial: Fortalecimento parcial. Mantém o serviço SSH, mas exige autenticação por chave. Indicado para ambientes de produção que requerem manutenção remota.

O fortalecimento inclui os seguintes itens:

Modo de fortalecimento

Itens

Itens de fortalecimento comuns (executados em ambos os modos)

  • Desinstalar o Cloud Assistant

  • Desinstalar o Aegis

  • Desabilitar o serviço rpcbind

  • Remover o cloud-init

  • Limpeza de contas de usuário

  • Limpar o histórico do Bash

full mode

  • Desinstalar completamente o serviço SSH

partial mode

  • Fortalecimento de segurança do SSH:

    • Desabilitar logon por senha: PasswordAuthentication no

    • Habilitar autenticação por chave: PubkeyAuthentication yes

    • Restringir logon como root: PermitRootLogin prohibit-password

    • Desabilitar recursos de alto risco: X11Forwarding no, AllowTcpForwarding no

  • Se uma chave pública for fornecida, ela será injetada no arquivo root ~/.ssh/authorized_keys do usuário

Exemplos da ferramenta de fortalecimento

  • Execute o fortalecimento completo na imagem:

    cryptpilot-enhance \
      --mode full \
      --image ./os-disk.qcow2
  • Execute o fortalecimento parcial na imagem e injete uma chave pública SSH:

    cryptpilot-enhance \
      --mode partial \
      --image ./os-disk.qcow2 \
      --ssh-key ~/.ssh/id_rsa.pub

Criptografia confidencial de disco de dados

Em cenários de computação confidencial, além de proteger o disco de sistema completo, você também pode criptografar apenas partições específicas de disco de dados em uma instância confidencial em execução. Esta seção descreve como implementar a criptografia LUKS2 para discos de dados em uma instância de computação confidencial com chaves autogerenciadas.

Princípios de criptografia

Os discos em nuvem confidenciais são baseados na tecnologia LUKS2 da plataforma Linux, fornecendo proteção de criptografia de dados no nível de armazenamento em blocos. O processo inclui inicialização e abertura:

  • Inicialização: Selecione um dispositivo de bloco (como /dev/nvme1n1p1). Um algoritmo de números aleatórios seguro gera uma Master Key exclusiva do dispositivo para criptografia AES-256. A própria Master Key é criptografada por uma KEK derivada da Passphrase fornecida pelo usuário por meio de um algoritmo de derivação de chave e armazenada no cabeçalho do volume.

    null

    O processo de inicialização apaga os dados existentes no dispositivo de bloco. Prossiga com cautela para evitar perda acidental de dados.

  • Abertura: A KEK é derivada novamente da Passphrase fornecida pelo usuário para descriptografar a Master Key e desbloquear o volume. O sistema cria um dispositivo de bloco virtual no caminho /dev/mapper/<volume_name>. Todos os dados gravados nesse dispositivo são automaticamente criptografados antes de serem gravados no disco, e os dados são automaticamente descriptografados na leitura. A criptografia e a descriptografia são realizadas no kernel Linux, impedindo efetivamente que texto simples vaze para fora da instância.

image

A instância criptografada usa a aceleração de hardware AES integrada à CPU para reduzir a sobrecarga de criptografia e descriptografia. Os discos de dados confidenciais oferecem suporte à proteção de integridade por meio do modo de criptografia AEAD, que impede que invasores adulterem dados cifrados. Isso é adequado para cenários como armazenamento de pesos de grandes modelos de linguagem e armazenamento de conjuntos de dados de treinamento. A Passphrase usada para criptografia é gerenciada fora da instância e oferece suporte a múltiplos métodos de recuperação de chave. Para detalhes, consulte Apêndice: Métodos de recuperação de chave.

null
  • Somente discos de dados de instâncias TDX ou instâncias confidenciais heterogêneas são compatíveis com criptografia.

  • Quando um disco em nuvem é revertido, como a integridade e a confidencialidade dos dados não são comprometidas, a solução de disco em nuvem confidencial não consegue identificar tais ataques potenciais. Recomendamos realizar verificações de versão dos dados no nível da aplicação para tratar esse problema de acordo com seus requisitos de segurança.

Fluxo de uso

Etapa 1: Prepare o ambiente

  1. Crie uma instância de computação confidencial.

    Somente instâncias confidenciais TDX ou instâncias confidenciais heterogêneas são compatíveis.

  2. Conecte-se remotamente à instância de computação confidencial.

    Para mais informações, consulte Fazer login em uma instância Linux usando o Workbench.

  3. Instale o CryptPilot.

    sudo yum install -y cryptpilot-crypt

Etapa 2: Crie e monte um disco em nuvem

null

A criptografia de um disco em nuvem apaga os dados existentes no dispositivo de bloco. Recomendamos criar um novo disco de dados para esta operação.

  1. Crie um disco de dados vazio a ser criptografado.

  2. Anexe o disco de dados criado à instância ECS.

  3. Inicialize o disco de dados.

    Ao inicializar o disco de dados, crie apenas partições e sistemas de arquivos sem montar o sistema de arquivos. O sistema de arquivos deve ser montado após a criptografia.

  4. Visualize as informações do disco e das partições anexados.

  5. lsblk

    A saída mostra que a instância ECS atual tem dois discos em nuvem anexados:

    • /dev/nvme0n1: O disco de sistema existente.

    • /dev/nvme1n1: O disco de dados recém-adicionado, com 2 novas partições vazias (/dev/nvme1n1p1 e /dev/nvme1n1p2).

    image

Etapa 3: Crie um volume com sistema de arquivos ext4

  1. Primeiro, escreva um arquivo de configuração /etc/cryptpilot/volumes/data0.toml. Esse arquivo define um volume de dados chamado data0.

    null

    O arquivo de configuração usa o formato TOML. O nome do arquivo pode ser qualquer arquivo de texto com a extensão .toml e não precisa corresponder ao nome do volume.

    A seguir estão alguns exemplos de configuração típicos para diferentes cenários. Modifique os campos de configuração conforme necessário.

    Volume temporário

    # Volume configuration
    dev = "/dev/nvme1n1p1"    # Specify the block device, i.e., the empty partition of the cloud disk. In this example, /dev/nvme1n1p1 uses the first partition of the data disk.
    volume = "data0"          # Specify the volume name. In this example, it is named data0.
    auto_open = false         # true means the volume opens automatically on system startup; false means manual opening is required.
    makefs = "ext4"           # Specify the file system type to create. In this example, ext4.
    integrity = true          # true enables data integrity support; false disables it.
    
    # Key configuration
    [encrypt.otp]             # Specify the key storage type. Here, one-time password (OTP) is selected.

    Volume persistente (usando Trustee)

    # Volume configuration
    dev = "/dev/nvme1n1p2"        # Specify the block device, i.e., the empty partition of the cloud disk. In this example, /dev/nvme1n1p2 uses the second partition of the data disk.
    volume = "data0"              # Specify the volume name. In this example, it is named data0.
    auto_open = false             # true means the volume opens automatically on system startup; false means manual opening is required.
    makefs = "ext4"               # Specify the file system type to create. In this example, ext4.
    integrity = true              # true enables data integrity support; false disables it.
    
    # Key configuration (retrieved from Trustee KBS)
    [encrypt.kbs]
    kbs_url = "http://<trustee-ip>:8081/api"               # Replace <trustee-ip> with the public IP address of the Trustee instance
    key_uri = "kbs:///default/local-resources/data0"       # The resource URI for the data0 volume key stored in KBS

    Volume persistente (usando Alibaba Cloud KMS)

    # Volume configuration
    dev = "/dev/nvme1n1p2"        # Specify the block device, i.e., the empty partition of the cloud disk. In this example, /dev/nvme1n1p2 uses the first partition of the data disk.
    volume = "data0"              # Specify the volume name. In this example, it is named data0.
    auto_open = false             # true means the volume opens automatically on system startup; false means manual opening is required.
    makefs = "ext4"               # Specify the file system type to create. In this example, ext4.
    integrity = true              # true enables data integrity support; false disables it.
    
    # Key configuration
    [encrypt.kms]                 # Specify the key storage type. Here, Key Management Service (KMS) is selected.
    secret_name = "confidential_cloud_disk_passphrase"   # The name of the secret stored in the KMS instance, i.e., confidential_cloud_disk_passphrase in the example above.
    # Content of the application identity credential file (clientKey_****.json)
    client_key = '''
    {
      "KeyId": "KAAP.b183152a-c3bf-43ae-9399-a101607b****",
      "PrivateKeyData": "MIIJ0wIBAzCCCZ8GCSqGSIb3DQE****"
    }
    '''
    client_key_password = "258372e962f5204ce648bc66243f****"    # Content of the credential password file (clientKey_****_Password.txt)
    kms_instance_id = "kst-bjj67d004a85ykq80****"               # KMS instance ID
    # Content of the KMS instance CA certificate file (PrivateKmsCA_kst-******.pem)
    kms_cert_pem = """
    -----BEGIN CERTIFICATE-----
    MIIDuzCCAqOgAwIBAgIJALTKwWAjvbMiMA0GCSqGSIb3DQEBCwUAMH****
    -----END CERTIFICATE-----
    -----BEGIN CERTIFICATE-----
    MIID3zCCAsegAwIBAgIJAO8qnQyTy8/kMA0GCSqGSIb3DQEBCwUAMH****
    -----END CERTIFICATE-----
    """
  2. Visualize o status do volume.

    sudo cryptpilot-crypt show data0

    As informações de configuração do volume data0 são exibidas:

    • Coluna Initialized: Indica se o volume precisa de inicialização. Volumes temporários não precisam de inicialização, enquanto volumes persistentes precisam.

    • Coluna Opened: Indica que o volume não está aberto.

      image

  3. Inicialize o volume.

    sudo cryptpilot-crypt init data0
  4. Abra o volume.

    sudo cryptpilot-crypt open data0
  5. Verifique o dispositivo virtual do volume.

    sudo file -Ls /dev/mapper/data0

    Após abrir o volume, um dispositivo de bloco virtual é criado no caminho: /dev/mapper/<volume_name>.

    image

  1. Monte o sistema de arquivos e verifique o resultado da montagem.

    1. Monte o volume data0 no caminho /mnt/data0.

      sudo mkdir -p /mnt/data0
      sudo mount -t ext4 /dev/mapper/data0 /mnt/data0
    2. Verifique o resultado da montagem.

      mount | grep data0
      ls -la /mnt/data0/

      A saída a seguir indica que o volume foi montado com sucesso com um sistema de arquivos ext4 vazio.

      image

  2. Feche o volume.

    null
    • Este exemplo usa o modelo de senha de uso único (OTP). Após fechar o volume, os dados confidenciais armazenados nele são perdidos permanentemente.

    • Antes de fechar o volume, interrompa todos os processos de negócio que estejam lendo ou gravando no volume, desmonte o sistema de arquivos no volume e certifique-se de que o volume não está em uso.

    1. Desmonte o sistema de arquivos.

      sudo umount /mnt/data0
    2. Feche o volume.

      sudo cryptpilot-crypt close data0

      image

Etapa 4: Configurar o volume para abrir automaticamente na inicialização

  1. Modifique o arquivo de configuração.

    Para volumes que precisam abrir automaticamente, altere o valor do campo auto_open para true no arquivo de configuração.image

  2. (Condicional) Para volumes persistentes, execute manualmente sudo cryptpilot-crypt init <volume_name> para inicializar o volume antes que ele possa ser aberto automaticamente na inicialização.

  3. Inicie e ative o serviço cryptpilot para que ele seja iniciado no boot.

    null

    Após cada modificação da configuração do cryptpilot, inicie e ative o serviço cryptpilot para garantir que o recurso auto-open volume entre em vigor.

    sudo systemctl enable --now cryptpilot.service
  4. Reinicie a instância.

  5. Visualize o status do volume.

    sudo cryptpilot-crypt show

    A saída a seguir indica que o volume foi aberto automaticamente.image

Apêndice: Métodos de recuperação de chaves

O CryptPilot usa um mecanismo de Provider para integrar diferentes fontes de chaves, desacoplando "como criptografar/descriptografar o disco" de "onde obter a chave". Esta seção descreve os quatro métodos: OTP, Trustee (KBS), Alibaba Cloud KMS e programa externo (exec), referenciados nas seções de disco de sistema confidencial e disco de dados confidencial acima.

Método de recuperação de chave

Tipo de Provider

Persistência

Atestação remota necessária

Cenários típicos

OTP (Senha de uso único)

otp

Não (perdida no desligamento)

Não

Discos de dados temporários, partições de swap

Trustee

kbs

Sim

Sim (libera a chave com base na atestação remota do TEE)

Backend de chaves auto-hospedado com requisitos rigorosos de computação confiável

Alibaba Cloud KMS

kms

Sim

Não

Gerenciamento de chaves em nuvem gerenciada

exec (Programa externo)

exec

Depende do programa externo

Depende do programa externo

Usuários avançados com fluxos de trabalho personalizados de recuperação de chaves

Nos exemplos de configuração de volume acima, substitua a seção [encrypt.xxx] por uma das configurações de Provider descritas nesta seção, conforme suas necessidades.

Senha de uso único (OTP)

Escopo de aplicação

  • Disco de dados confidencial — volume temporário: Cada vez que o volume é reaberto, uma chave aleatória diferente é gerada. Os dados no volume são perdidos permanentemente após o desligamento. Indicado para discos de dados temporários ou partições de swap.

  • Não aplicável a discos de sistema confidenciais nem a volumes persistentes que precisam reter dados após o desligamento.

Exemplo de configuração

Adicione o seguinte à configuração toml do volume:

[encrypt.otp]

Nenhum parâmetro adicional é necessário. O CryptPilot gera automaticamente uma chave temporária segura ao abrir o volume para inicialização e descriptografia.

Serviço de gerenciamento de confiança (Trustee)

Trustee é um serviço de gerenciamento de confiança de código aberto composto pelo Attestation Service (AS), Reference Value Provider Service (RVPS) e Key Broker Service (KBS). Nessa abordagem, as chaves de criptografia são armazenadas no KBS. O CryptPilot recupera a chave do KBS ao abrir um volume. O KBS inicia a atestação remota da instância com base em políticas predefinidas e libera a chave somente após a atestação bem-sucedida.

O Trustee é adequado tanto para discos de sistema confidenciais (como backend de chaves recomendado em cenários com requisitos rigorosos de computação confiável) quanto para volumes persistentes de discos de dados confidenciais.

Etapa 1: Implantar o serviço Trustee

  1. Instale o pacote Trustee em um ambiente confiável (como uma instância ECS separada):

    sudo yum install -y trustee
  2. (Opcional) Configure o acesso HTTPS. Se o acesso HTTPS for necessário, edite /etc/trustee/gateway.yml e adicione a configuração do seu certificado TLS:

    server:
      insecure_http: false
      tls:
        cert_file: "<path_to_https_certificate.pem>"
        key_file: "<path_to_https_certificate_private_key>"
      # Other configurations...
  3. Em uma instância do Alibaba Cloud Linux 3, inicie o serviço Trustee pelo systemd:

    sudo systemctl restart trustee

    Após o Trustee estar em execução, ele escuta na porta 8081 na máquina local.

Etapa 2: Configurar a política de verificação de atestação remota

O Trustee inspeciona o ambiente de hardware TEE, o sistema de arquivos, os programas e as configurações da instância confidencial e produz os resultados da inspeção. Configure a política de liberação em /opt/trustee/kbs/policy.rego de acordo com seus requisitos de segurança.

  • Cenário de disco de sistema confidencial (recomendado: política estrita): Exige que os valores de confiabilidade das quatro dimensões (hardware, configuração, executáveis, sistema de arquivos) da atestação remota sejam <= 32. Para a política específica e a geração de valores de referência, consulte "Etapa 3: Criar uma imagem de disco de sistema confidencial" (registro de valores de referência no serviço Trustee) no fluxo de uso do disco de sistema confidencial acima.

  • Cenário de disco de dados confidencial (política mais simples: verificação somente de hardware): Para uso simplificado, verifique apenas a dimensão de hardware entre as quatro dimensões para confirmar se o ambiente é um ambiente de hardware TEE válido. Modifique /opt/trustee/kbs/policy.rego para a seguinte configuração padrão:

    Configuração padrão da política de atestação remota

    package policy
    
    import rego.v1
    
    default allow = false
    
    # ---------------------------
    # Resource path helpers
    # ---------------------------
    resource_path := data["resource-path"]
    path_parts := split(resource_path, "/")
    
    is_repo(name) if { count(path_parts) == 3; path_parts[0] == name }
    is_type(t)    if { count(path_parts) == 3; path_parts[1] == t }
    is_tag(tag)   if { count(path_parts) == 3; path_parts[2] == tag }
    
    # ---------------------------
    # Default decision
    # ---------------------------
    
    allow if {
            # cpu0 must exist
            s := input.submods["cpu0"]
            # cpu0 must carry a trustworthiness vector
            tv := s["ear.trustworthiness-vector"]
            # and it must pass the hardware check
            tv["hardware"] <= 32
    }
null

Para verificação multidimensional mais rigorosa, consulte /opt/trustee/attestation-service/policies/opa/default.rego e a documentação de configuração de valores de referência e a documentação de configuração de atestação remota para definir os valores de referência.

Etapa 3: Carregar as chaves de criptografia do volume no KBS

  1. Crie o diretório de armazenamento de chaves (o KBS usa /opt/trustee/kbs/repository/default/ por padrão):

    sudo mkdir -p /opt/trustee/kbs/repository/default/local-resources/
  2. Gere a chave de criptografia.

    sudo yum install -y openssl
    openssl rand -base64 40

    image

  3. Grave a chave aleatória gerada em um arquivo de recurso local. Por exemplo, para um volume chamado data0:

    sudo sh -c 'echo -n "<data0_volume_encryption_key>" > /opt/trustee/kbs/repository/default/local-resources/data0'

    Substitua <data0_volume_encryption_key> pela chave aleatória gerada anteriormente. O identificador de recurso KBS correspondente é kbs:///default/local-resources/data0, referenciado por esse URI na configuração de volume do CryptPilot.

Etapa 4: Referenciar o KBS na configuração do volume

[encrypt.kbs]
# HTTP(S) URL of the Trustee instance
kbs_url = "http://<trustee-ip>:8081/api"
# Resource URI in KBS, format: `kbs:///<repo>/<type>/<tag>`
key_uri = "kbs:///default/local-resources/data0"
# (Optional) Root certificate for KBS HTTPS access, PEM format; uses system root CA if not specified
kbs_root_cert = """
-----BEGIN CERTIFICATE-----
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
-----END CERTIFICATE-----
"""

Etapa 5: Instalar a dependência de atestação remota na instância confidencial

Para habilitar a atestação remota na instância confidencial e acessar o Trustee para recuperação de chaves, certifique-se de que o componente attestation-agent para o hardware correspondente esteja instalado na instância confidencial:

yum install -y attestation-agent

systemctl enable attestation-agent
systemctl start attestation-agent

Alibaba Cloud KMS

O Alibaba Cloud KMS é um serviço de gerenciamento de chaves baseado em nuvem, indicado para cenários em que você deseja hospedar chaves no Alibaba Cloud sem construir um backend de chaves próprio. Nessa abordagem, a chave de criptografia é armazenada como um "generic secret" no KMS. O CryptPilot recupera a chave da instância do KMS ao abrir um volume.

Etapa 1: Criar uma instância do Alibaba Cloud KMS e um generic secret

  1. Adquira e ative uma instância do KMS.

  2. null
    • Não há restrições quanto ao Key Management Type da instância do KMS para discos em nuvem confidenciais. Escolha conforme seus requisitos de segurança. Este exemplo utiliza uma instância do KMS do tipo Software Key Management.

    • A instância do KMS deve estar na mesma VPC que a instância do ECS.

  3. Crie uma chave de software.

  4. Crie um generic secret.

    • Secret Name: Preencha conforme sua instância. Neste exemplo, confidential_cloud_disk_passphrase.

    • Set Secret Value: Selecione texto simples e insira a chave aleatória gerada na etapa anterior.

    • Encryption Key: Selecione a chave de software criada na etapa anterior.

    image

  5. Crie um ponto de acesso para aplicação e obtenha o certificado CA da instância do KMS.

    Certifique-se de ter obtido os seguintes itens:

    • Conteúdo da credencial de identidade da aplicação (ClientKeyContent): o nome de arquivo padrão é clientKey_****.json.

    • Senha da credencial (ClientKeyPassword): o nome de arquivo padrão é clientKey_****_Password.txt.

    • Certificado CA da instância do KMS: o nome de arquivo padrão é PrivateKmsCA_kst-******.pem.

Etapa 2: Referenciar o KMS na configuração do volume

Modifique as informações de configuração no arquivo de configuração a seguir de acordo com sua configuração real.

[encrypt.kms]
# KMS instance ID
kms_instance_id = "kst-bjj67d004a85ykq80****"
# Name of the generic secret in the KMS instance
secret_name = "confidential_cloud_disk_passphrase"
# Content of the application identity credential file clientKey_****.json
client_key = '''
{
  "KeyId": "KAAP.XXXXXXXXX",
  "PrivateKeyData": "XXXXXXXXX"
}'''
# Content of the credential password file clientKey_****_Password.txt
client_key_password = "258372e962f5204ce648bc66243f****"
# Content of the KMS instance CA certificate PrivateKmsCA_kst-******.pem
kms_cert_pem = """
-----BEGIN CERTIFICATE-----
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
-----END CERTIFICATE-----
"""

Programa externo (exec)

O provedor exec permite que o CryptPilot chame qualquer programa externo ao abrir um volume e use a saída padrão desse programa como chave de descriptografia do volume. Este método é destinado a usuários avançados e pode ser utilizado para fluxos de trabalho personalizados de recuperação de chaves, como integração com HSMs corporativos, Vault, sistemas KMS customizados ou serviços de entrega remota de chaves.

null

Como a segurança da recuperação de chaves depende inteiramente do programa externo e de seu ambiente de execução, certifique-se de que o programa tenha controle de acesso adequado e seja proveniente de uma fonte confiável.

Exemplo de configuração

O exemplo a seguir usa o programa echo para gerar uma senha fixa, apenas para fins de demonstração. Não utilize senha fixa em ambientes de produção:

[rootfs]
delta_location = "disk"

[rootfs.encrypt.exec]
command = "echo"
args = ["-n", "AAAaaawewe222"]

[delta]
integrity = true

[delta.encrypt.exec]
command = "echo"
args = ["-n", "AAAaaawewe222"]

O CryptPilot executa o programa especificado em command (com os parâmetros de args) ao abrir um volume e usa a saída padrão como chave de descriptografia do volume.