# UEFI Secure Boot para instâncias do Amazon EC2
O UEFI Secure Boot baseia-se no longo processo de inicialização segura do Amazon EC2, e fornece mais proteção abrangente que ajuda os clientes a proteger o software de ameaças que persistem durante as reinicializações. Ele garante que a instância inicialize apenas o software assinado com chaves criptográficas. As chaves são armazenadas no banco de dados de chaves do [armazenamento de variáveis não voláteis UEFI](uefi-variables.md). O UEFI Secure Boot impede a modificação não autorizada do fluxo de inicialização da instância.
**Topics**
+ [Como o UEFI Secure Boot funciona com instâncias do Amazon EC2](how-uefi-secure-boot-works.md)
+ [Requisitos para o UEFI Secure Boot no Amazon EC2](launch-instance-with-uefi-sb.md)
+ [Verificar se uma instância do Amazon EC2 está habilitada para o UEFI Secure Boot](verify-uefi-secure-boot.md)
+ [Criar uma AMI do Linux com chaves personalizadas do UEFI Secure Boot](create-ami-with-uefi-secure-boot.md)
+ [Crie o blob binário da AWS para o UEFI Secure Boot](aws-binary-blob-creation.md)
# Como o UEFI Secure Boot funciona com instâncias do Amazon EC2
O UEFI Secure Boot é um recurso especificado na UEFI que fornece verificação sobre o estado da cadeia de inicialização. Ele é projetado para garantir que apenas binários UEFI verificados criptograficamente sejam executados após a autoinicialização do firmware. Esses binários incluem drivers de UEFI e o carregador de inicialização principal, bem como componentes carregados em cadeia.
O UEFI Secure Boot especifica quatro bancos de dados principais que são usados em uma cadeia de confiança. Os bancos de dados são armazenados no armazenamento de variáveis UEFI.
A cadeia de confiança é a seguinte:
**Banco de dados de chave de plataforma (PK**
O banco de dados de PK é a raiz de confiança. Ele contém uma única chave PK pública usada na cadeia de confiança para atualizar o banco de dados de chaves de troca de chave (KEK).
Para alterar o banco de dados de PK, você deve ter a chave PK privada para assinar uma solicitação de atualização. Isso inclui excluir o banco de dados de PK escrevendo uma chave PK vazia.
**Banco de dados de chaves de troca de chave (KEK**
O banco de dados de KEK é uma lista de chaves KEK públicas que são usadas na cadeia de confiança para atualizar os bancos de dados de assinaturas (db) e de lista de negação (dbx).
Para alterar o banco de dados de KEK público, você deve ter a chave PK privada para assinar uma solicitação de atualização.
**Banco de dados de assinaturas (db**
O banco de dados db é uma lista de chaves públicas e hashes que são usados na cadeia de confiança para validar todos os binários de inicialização UEFI.
Para alterar o banco de dados db, você deve ter a chave PK privada ou qualquer uma das chaves KEK privadas para assinar uma solicitação de atualização.
**Banco de dados de lista de negação de assinatura (dbx**
O banco de dados dbx é uma lista de chaves públicas e hashes binários que não são confiáveis e são usados na cadeia de confiança como um arquivo de revogação.
O banco de dados dbx sempre tem precedência sobre todos os outros bancos de dados de chaves.
Para alterar o banco de dados dbx, você deve ter a chave PK privada ou qualquer uma das chaves KEK privadas para assinar uma solicitação de atualização.
O Fórum UEFI mantém um dbx disponível publicamente para muitos binários e certificados conhecidamente ruins em [https://uefi.org/revocationlistfile](https://uefi.org/revocationlistfile).
**Importante**
O UEFI Secure Boot impõe a validação da assinatura em qualquer binário UEFI. Para permitir a execução de um binário UEFI no UEFI Secure Boot, você o assina com qualquer uma das chaves db privadas descritas acima.
Por padrão, o UEFI Secure Boot é desabilitado e o sistema está no `SetupMode`. Quando o sistema estiver no `SetupMode`, todas as variáveis principais podem ser atualizadas sem uma assinatura criptográfica. Quando a PK está definida, o UEFI Secure Boot é habilitado e o SetupMode é encerrado.
# Requisitos para o UEFI Secure Boot no Amazon EC2
Quando você [executar uma instância do Amazon EC2](LaunchingAndUsingInstances.md)com uma AMI e um tipo de instância compatíveis, essa instância validará automaticamente os binários de inicialização da UEFI em relação ao banco de dados do UEFI Secure Boot. Não é exigida nenhuma configuração adicional. Você também pode configurar o UEFI Secure Boot em uma instância após o início.
**nota**
O UEFI Secure Boot protege sua instância e seu sistema operacional contra modificações no fluxo de inicialização. Se você criar uma nova AMI a partir de uma AMI de origem com a Inicialização Segura UEFI habilitada e modificar determinados parâmetros durante o processo de cópia, como alterar os `UefiData` na AMI, poderá desabilitar a Inicialização Segura UEFI.
**Topics**
+ [AMIs compatíveis](#uefi-amis)
+ [Tipos de instâncias compatíveis](#uefi-instance)
## AMIs compatíveis
**AMIs do Linux**
Para iniciar uma instância Linux, a AMI Linux deve ter o UEFI Secure Boot habilitado.
O Amazon Linux oferece suporte ao UEFI Secure Boot a partir do AL2023 versão 2023.1. No entanto, o UEFI Secure Boot não está habilitado nas AMIs padrão. Para obter mais informações, consulte [UEFI Secure Boot](https://docs.aws.amazon.com/linux/al2023/ug/uefi-secure-boot.html) no *Guia do usuário do AL2023*. As versões mais antigas das AMIs do Amazon Linux não estão habilitadas para o UEFI Secure Boot. Para usar uma AMI compatível, é necessário executar várias etapas de configuração em sua própria AMI do Linux. Para obter mais informações, consulte [Criar uma AMI do Linux com chaves personalizadas do UEFI Secure Boot](create-ami-with-uefi-secure-boot.md).
**AMIs Windows**
Para iniciar uma instância Windows, a AMI Windows deve ter o UEFI Secure Boot habilitado. Para encontrar uma AMI do AWS Windows pré-configurada para UEFI Secure Boot com chaves da Microsoft, consulte [Encontrar AMIs do Windows Server configuradas com NitroTPM e UEFI Secure Boot](https://docs.aws.amazon.com/ec2/latest/windows-ami-reference/ami-windows-tpm.html#ami-windows-tpm-find) na *Referência de AMIs do AWS Windows*.
Atualmente, não oferecemos suporte à importação do Windows com o UEFI Secure Boot o comando [import-image](https://docs.aws.amazon.com/cli/latest/reference/ec2/import-image.html).
## Tipos de instâncias compatíveis
Todos os tipos de instâncias virtualizadas que são compatíveis com a UEFI também são compatíveis com o UEFI Secure Boot. Para ver os tipos de instância compatíveis com o UEFI Secure Boot, consulte [Requisitos para o modo de inicialização da UEFI](launch-instance-boot-mode.md).
**nota**
Os tipos de instância bare metal não oferecem suporte ao UEFI Secure Boot.
# Verificar se uma instância do Amazon EC2 está habilitada para o UEFI Secure Boot
É possível usar os procedimentos a seguir para determinar se um Amazon EC2 está habilitado para o UEFI Secure Boot.
## Instâncias do Linux
É possível usar o utilitário `mokutil` para verificar se uma instância do Linux está habilitada para o UEFI Secure Boot. Se o `mokutil` não estiver instalado em sua instância, você precisará instalá-lo. Para obter as instruções de instalação do Amazon Linux 2, consulte [Find and install software packages on an Amazon Linux 2 instance](https://docs.aws.amazon.com/linux/al2/ug/find-install-software.html). Para outras distribuições do Linux, consulte a documentação específica.
**Verificar se uma instância do Linux está habilitada para o UEFI Secure Boot**
Conecte-se à instância e execute o comando a seguir como `root` na janela de terminal.
```
mokutil --sb-state
```
O seguinte é um exemplo de saída.
+ Se o UEFI Secure Boot estiver habilitado, a saída conterá `SecureBoot enabled`.
+ Se o UEFI Secure Boot não estiver habilitado, a saída conterá `SecureBoot disabled` ou `Failed to read SecureBoot`.
## Instâncias do Windows
**Para verificar se uma instância do Windows está habilitada para o UEFI Secure Boot**
1. Conecte-se à sua instância.
1. Abra a ferramenta msinfo32.
1. Verifique o campo **Secure Boot State** (Estado do Secure Boot). Se o UEFI Secure Boot estiver habilitado, o valor será **Compatível**, conforme mostrado na imagem a seguir.
![\[Estado de inicialização segura nas informações do sistema.\]](http://docs.aws.amazon.com/pt_br/AWSEC2/latest/UserGuide/images/secure-boot-state-win.png)
Você também pode usar o cmdlet `Confirm-SecureBootUEFI` do Windows PowerShell para verificar o status da Secure Boot. Para obter mais informações sobre o cmdlet, consulte [Confirm-SecureBootUEFI](https://learn.microsoft.com/en-us/powershell/module/secureboot/confirm-securebootuefi) na documentação da Microsoft.
# Criar uma AMI do Linux com chaves personalizadas do UEFI Secure Boot
Estas instruções mostram como criar uma AMI do Linux com o UEFI Secure Boot e chaves privadas personalizadas. O Amazon Linux oferece suporte ao UEFI Secure Boot a partir do AL2023 versão 2023.1. Para obter mais informações, consulte [UEFI Secure Boot on AL2023](https://docs.aws.amazon.com/linux/al2023/ug/uefi-secure-boot.html) no *Guia do usuário do Amazon Linux 2023*.
**Importante**
O procedimento a seguir destina-se **somente a usuários avançados**. Você deve ter conhecimento suficiente de SSL e do fluxo de inicialização da distribuição do Linux para usar esses procedimentos.
**Pré-requisitos**
+ As seguintes ferramentas serão usadas:
+ OpenSSL: [https://www.openssl.org/](https://www.openssl.org/)
+ efivar: [https://github.com/rhboot/efivar](https://github.com/rhboot/efivar)
+ efitools: [https://git.kernel.org/pub/scm/linux/kernel/git/jejb/efitools.git/](https://git.kernel.org/pub/scm/linux/kernel/git/jejb/efitools.git/)
+ Comando [get-instance-uefi-data](https://docs.aws.amazon.com/cli/latest/reference/ec2/get-instance-uefi-data.html)
+ Sua instância do Linux deve ter sido iniciada com uma AMI do Linux com suporte para o modo de inicialização UEFI e ter dados não voláteis presentes.
Instâncias recém-criadas sem chaves do UEFI Secure Boot são criadas em `SetupMode`, o que permite que você inscreva suas próprias chaves. Algumas AMIs vêm pré-configuradas com o UEFI Secure Boot, e você não pode alterar as chaves existentes. Se você desejar alterar as chaves, deve criar uma nova AMI com base na AMI original.
Você tem duas maneiras de propagar as chaves no armazenamento de variáveis, descritas na Opção A e na Opção B a seguir. A opção A descreve como fazer isso de dentro da instância, imitando o fluxo de hardware real. A opção B descreve como criar um blob binário, que será então passado como um arquivo codificado em base64 quando você criar a AMI. Para ambas as opções, você deve primeiro criar os três pares de chaves, que são usados para a cadeia de confiança.
**Topics**
+ [Tarefa 1: criar pares de chaves](#uefi-secure-boot-create-three-key-pairs)
+ [Tarefa 2: opção A: adicionar chaves ao armazenamento de variáveis de dentro da instância](#uefi-secure-boot-optionA)
+ [Tarefa 2: opção B: criar um blob binário contendo um armazenamento de variáveis pré-preenchido](#uefi-secure-boot-optionB)
## Tarefa 1: criar pares de chaves
O UEFI Secure Boot é baseado nos três seguintes bancos de dados de chaves, que são usados em uma cadeia de confiança: a chave de plataforma (PK), a chave de troca de chaves (KEK) e o banco de dados de assinatura (db).¹
Você cria cada chave na instância. Para preparar as chaves públicas em um formato válido para o padrão UEFI Secure Boot, você cria um certificado para cada chave. `DER` define o formato SSL (codificação binária de um formato). Em seguida, você converte cada certificado em uma lista de assinaturas UEFI, que é o formato binário entendido pelo UEFI Secure Boot. E, finalmente, você assina cada certificado com a chave relevante.
**Topics**
+ [Preparar para criar os pares de chaves](#uefisb-prepare-to-create-key-pairs)
+ [Par de chaves 1: criar a chave da plataforma (PK)](#uefisb-create-key-pair-1)
+ [Par de chaves 2: criar a chave de troca de chaves (KEK)](#uefisb-create-key-pair-2)
+ [Par de chaves 3: criar o banco de dados de assinaturas (db)](#uefisb-create-key-pair-3)
+ [Assine a imagem de inicialização (kernel) com a chave privada](#uefi-secure-boot-sign-kernel)
### Preparar para criar os pares de chaves
Antes de criar os pares de chaves, crie um identificador exclusivo globalmente (GUID) para ser usado na geração de chaves.
1. [Conecte-se à instância](connect.md).
1. Execute o comando a seguir em um prompt de shell.
```
uuidgen --random > GUID.txt
```
### Par de chaves 1: criar a chave da plataforma (PK)
A PK é a raiz da confiança para instâncias UEFI Secure Boot. A PK privada é usado para atualizar a KEK, que por sua vez pode ser usada para adicionar chaves autorizadas ao banco de dados de assinaturas (db).
O padrão X.509 é usado para criar o par de chaves. Para obter informações sobre o padrão, consulte [X.509](https://en.wikipedia.org/wiki/X.509) na *Wikipédia*.
**Para criar o PK**
1. Crie a chave. Você deve nomear a variável `PK`.
```
openssl req -newkey rsa:4096 -nodes -keyout PK.key -new -x509 -sha256 -days 3650 -subj "/CN=Platform key/" -out PK.crt
```
Os seguintes parâmetros são especificados:
+ `-keyout PK.key`: o arquivo da chave privada.
+ `-days 3650`: o número de dias em que o certificado é válido.
+ `-out PK.crt`: o certificado usado para criar a variável UEFI.
+ `CN=Platform key`: o nome comum (CN) para a chave. É possível inserir o nome da sua própria organização em vez de *Chave da plataforma*.
1. Crie o certificado.
```
openssl x509 -outform DER -in PK.crt -out PK.cer
```
1. Converta o certificado em uma lista de assinaturas UEFI.
```
cert-to-efi-sig-list -g "$(< GUID.txt)" PK.crt PK.esl
```
1. Assine a lista de assinaturas UEFI com a PK privada (autoassinada).
```
sign-efi-sig-list -g "$(< GUID.txt)" -k PK.key -c PK.crt PK PK.esl PK.auth
```
### Par de chaves 2: criar a chave de troca de chaves (KEK)
A KEK privada é usada para adicionar chaves ao db, que é a lista de assinaturas autorizadas a inicializar no sistema.
**Para criar a KEK**
1. Crie a chave.
```
openssl req -newkey rsa:4096 -nodes -keyout KEK.key -new -x509 -sha256 -days 3650 -subj "/CN=Key Exchange Key/" -out KEK.crt
```
1. Crie o certificado.
```
openssl x509 -outform DER -in KEK.crt -out KEK.cer
```
1. Converta o certificado em uma lista de assinaturas UEFI.
```
cert-to-efi-sig-list -g "$(< GUID.txt)" KEK.crt KEK.esl
```
1. Assine a lista de assinaturas com a PK privada.
```
sign-efi-sig-list -g "$(< GUID.txt)" -k PK.key -c PK.crt KEK KEK.esl KEK.auth
```
### Par de chaves 3: criar o banco de dados de assinaturas (db)
A lista db contém chaves autorizadas que estão autorizadas a ser inicializadas no sistema. Para modificar a lista, é necessária a KEK privada. As imagens de inicialização serão assinadas com a chave privada criada nesta etapa.
**Para criar o db**
1. Crie a chave.
```
openssl req -newkey rsa:4096 -nodes -keyout db.key -new -x509 -sha256 -days 3650 -subj "/CN=Signature Database key/" -out db.crt
```
1. Crie o certificado.
```
openssl x509 -outform DER -in db.crt -out db.cer
```
1. Converta o certificado em uma lista de assinaturas UEFI.
```
cert-to-efi-sig-list -g "$(< GUID.txt)" db.crt db.esl
```
1. Assine a lista de assinaturas com a KEK privada.
```
sign-efi-sig-list -g "$(< GUID.txt)" -k KEK.key -c KEK.crt db db.esl db.auth
```
### Assine a imagem de inicialização (kernel) com a chave privada
Para o Ubuntu 22.04, as imagens a seguir exigem assinaturas.
```
/boot/efi/EFI/ubuntu/shimx64.efi
/boot/efi/EFI/ubuntu/mmx64.efi
/boot/efi/EFI/ubuntu/grubx64.efi
/boot/vmlinuz
```
**Para assinar uma imagem**
Utilize uma sintaxe semelhante à seguinte.
```
sbsign --key db.key --cert db.crt --output /boot/vmlinuz /boot/vmlinuz
```
**nota**
Você deve assinar todos os novos kernels. *`/boot/vmlinuz`* geralmente será um link simbólico para o último kernel instalado.
Consulte a documentação da sua distribuição para saber sobre sua cadeia de inicialização e as imagens necessárias.
¹ Nossos agradecimentos à comunidade ArchWiki por todo o trabalho que eles fizeram. Os comandos para criar a PK, criar a KEK, criar o DB e assinar a imagem são de [Criação de chaves](https://wiki.archlinux.org/title/Unified_Extensible_Firmware_Interface/Secure_Boot#Creating_keys), de autoria da Equipe de Manutenção do ArchWiki e/ou dos colaboradores do ArchWiki.
## Tarefa 2: opção A: adicionar chaves ao armazenamento de variáveis de dentro da instância
Depois de criar os [três pares de chaves](#uefi-secure-boot-create-three-key-pairs), é possível se conectar à sua instância e adicionar as chaves ao armazenamento de variáveis de dentro da instância, concluindo as etapas a seguir. Como alternativa, conclua as etapas em [Tarefa 2: opção B: criar um blob binário contendo um armazenamento de variáveis pré-preenchido](#uefi-secure-boot-optionB).
**Topics**
+ [Etapa 1: iniciar uma instância que ofereça suporte ao UEFI Secure Boot](#step1-launch-uefi-sb)
+ [Etapa 2: configurar uma instância para oferecer suporte ao UEFI Secure Boot](#step2-launch-uefi-sb)
+ [Etapa 3: criar uma AMI da instância](#step3-launch-uefi-sb)
### Etapa 1: iniciar uma instância que ofereça suporte ao UEFI Secure Boot
Quando você [iniciar uma instância](LaunchingAndUsingInstances.md) com os pré-requisitos a seguir, a instância estará pronta para ser configurada para oferecer suporte ao UEFI Secure Boot. Você só pode habilitar o suporte ao UEFI Secure Boot em uma instância na inicialização; não será possível habilitá-lo mais tarde.
**Pré-requisitos**
+ **AMI**: a AMI do Linux deve oferecer suporte ao modo de inicialização UEFI. Para verificar se a AMI oferece suporte ao modo de inicialização UEFI, o parâmetro do modo de inicialização da AMI deve ser **UEFI**. Para obter mais informações, consulte [Determinar o parâmetro do modo de inicialização de uma AMI do Amazon EC2](ami-boot-mode.md).
Observe que fornece a AWS só fornece AMIs do Linux configuradas para compatibilidade com UEFI para tipos de instância baseados no Graviton. A AWS atualmente não fornece AMIs do Linux x86\$164 que sejam compatíveis com o modo de inicialização UEFI. É possível configurar a AMI para compatibilidade com o modo de inicialização UEFI para todas as arquiteturas. Para configurar sua própria AMI para compatibilidade com o modo de inicialização UEFI, é necessário realizar várias etapas de configuração em sua própria AMI. Para obter mais informações, consulte [Definir o modo de inicialização de uma AMI do Amazon EC2](set-ami-boot-mode.md).
+ **Tipo de instância**: todos os tipos de instâncias virtualizadas com suporte a UEFI também oferecem suporte a UEFI Secure Boot. Os tipos de instância bare metal não oferecem suporte ao UEFI Secure Boot. Para ver os tipos de instância compatíveis com o UEFI Secure Boot, consulte [Requisitos para o modo de inicialização da UEFI](launch-instance-boot-mode.md).
+ Inicie sua instância após o lançamento do UEFI Secure Boot. Somente instâncias iniciadas após 10 de maio de 2022 (quando o UEFI Secure Boot foi lançado) podem oferecer suporte ao UEFI Secure Boot.
Depois de iniciar sua instância, é possível verificar se ela está pronta para ser configurada para oferecer suporte à UEFI Secure Boot (em outras palavras, é possível prosseguir para a [Etapa 2](#step2-launch-uefi-sb)) verificando se os dados da UEFI estão presentes. A presença de dados de UEFI indica que dados não voláteis são persistidos.
**Para verificar se sua instância está pronta para a Etapa 2**
Use o comando [https://docs.aws.amazon.com/cli/latest/reference/ec2/get-instance-uefi-data.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/get-instance-uefi-data.html) e especifique o ID da instância.
```
aws ec2 get-instance-uefi-data --instance-id i-1234567890abcdef0
```
A instância estará pronta para a Etapa 2 se os dados da UEFI estiverem presentes na saída. Se a saída estiver vazia, a instância não poderá ser configurada para oferecer suporte ao UEFI Secure Boot. Isso pode acontecer se sua instância tiver sido iniciada antes que o suporte ao UEFI Secure Boot fique disponível. Inicie uma nova instância e tente novamente.
### Etapa 2: configurar uma instância para oferecer suporte ao UEFI Secure Boot
#### Registre os pares de chaves no armazenamento de variáveis UEFI na instância
**Atenção**
Você deve assinar suas imagens de inicialização *depois* de registrar as chaves, caso contrário, não poderá inicializar sua instância.
Depois que você criar as listas de assinaturas UEFI assinadas (`PK`, `KEK`, e `db`), elas devem ser registradas no firmware do UEFI.
A gravação na variável `PK` só será possível se:
+ Ainda não houver PK registrada, o que será indicado se a variável `SetupMode` for `1`. Verifique isso usando o comando a seguir. A saída for `1` ou `0`.
```
efivar -d -n 8be4df61-93ca-11d2-aa0d-00e098032b8c-SetupMode
```
+ A nova PK for assinada pela chave privada da PK existente.
**Para registrar as chaves no seu armazenamento de variáveis UEFI**
Os comandos a seguir devem ser executados na instância.
Se SetupMode estiver habilitado (o valor será `1`), as chaves podem ser registradas executando os seguintes comandos na instância:
```
[ec2-user ~]$ efi-updatevar -f db.auth db
```
```
[ec2-user ~]$ efi-updatevar -f KEK.auth KEK
```
```
[ec2-user ~]$ efi-updatevar -f PK.auth PK
```
**Para verificar se o UEFI Secure Boot está habilitado**
Para verificar se o UEFI Secure Boot está habilitado, siga as etapas em [Verificar se uma instância do Amazon EC2 está habilitada para o UEFI Secure Boot](verify-uefi-secure-boot.md).
Agora é possível exportar seu armazenamento de variáveis UEFI com o comando [https://docs.aws.amazon.com/cli/latest/reference/ec2/get-instance-uefi-data.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/get-instance-uefi-data.html) da CLI, ou prosseguir para a próxima etapa e assinar suas imagens de inicialização para reinicializar em uma instância habilitada para o UEFI Secure Boot.
### Etapa 3: criar uma AMI da instância
Para criar uma AMI a partir da instância, é possível usar o console ou a API `CreateImage`, a CLI ou SDKs. Para obter instruções sobre o console, consulte [Criação de uma AMI baseada no Amazon EBS](creating-an-ami-ebs.md). Para obter instruções sobre a API, consulte [CreateImage](https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_CreateImage.html).
**nota**
A API `CreateImage` copia automaticamente o armazenamento de variáveis UEFI da instância para a AMI. O console usa a API `CreateImage`. Depois de executar instâncias usando essa AMI, as instâncias terão o mesmo armazenamento de variáveis UEFI.
## Tarefa 2: opção B: criar um blob binário contendo um armazenamento de variáveis pré-preenchido
Depois de criar os [três pares de chaves](#uefi-secure-boot-create-three-key-pairs), é possível criar um blob binário contendo um armazenamento de variáveis pré-preenchido contendo as chaves do UEFI Secure Boot. Como alternativa, conclua as etapas em [Tarefa 2: opção A: adicionar chaves ao armazenamento de variáveis de dentro da instância](#uefi-secure-boot-optionA).
**Atenção**
Você deverá assinar suas imagens de inicialização *antes* de registrar as chaves, caso contrário, não poderá inicializar sua instância.
**Topics**
+ [Etapa 1: criar um novo armazenamento de variáveis ou atualizar um existente](#uefi-secure-boot-create-or-update-variable)
+ [Etapa 2: carregar o blob binário na criação da AMI](#uefi-secure-boot-upload-binary-blob-on-ami-creation)
### Etapa 1: criar um novo armazenamento de variáveis ou atualizar um existente
É possível criar o armazenamento de variáveis *offline*, sem uma instância em execução, usando a ferramenta python-uefivars. A ferramenta pode criar um novo armazenamento de variáveis a partir de suas chaves. O script atualmente oferece suporte ao formato EDK2, ao formato AWS e a uma representação JSON que é mais fácil de editar com ferramentas de nível superior.
**Para criar o armazenamento de variáveis offline sem uma instância em execução**
1. Baixe a ferramenta no link a seguir.
```
https://github.com/awslabs/python-uefivars
```
1. Crie um novo armazenamento de variáveis a partir de suas chaves executando o comando a seguir. Isso criará um blob binário codificado em base64 em *your\$1binary\$1blob*.bin. A ferramenta também suporta a atualização de um blob binário através do parâmetro `-I`.
```
./uefivars.py -i none -o aws -O your_binary_blob.bin -P PK.esl -K KEK.esl --db db.esl --dbx dbx.esl
```
### Etapa 2: carregar o blob binário na criação da AMI
Use [https://docs.aws.amazon.com/cli/latest/reference/ec2/register-image.html](https://docs.aws.amazon.com/cli/latest/reference/ec2/register-image.html) para passar seus dados de armazenamento de variáveis UEFI. Para o parâmetro `--uefi-data`, especifique seu blob binário e para o parâmetro `--boot-mode`, especifique `uefi`.
```
aws ec2 register-image \
--name uefi_sb_tpm_register_image_test \
--uefi-data $(cat your_binary_blob.bin) \
--block-device-mappings "DeviceName=/dev/sda1,Ebs= {SnapshotId=snap-0123456789example,DeleteOnTermination=true}" \
--architecture x86_64 \
--root-device-name /dev/sda1 \
--virtualization-type hvm \
--ena-support \
--boot-mode uefi
```
# Crie o blob binário da AWS para o UEFI Secure Boot
É possível usar as seguintes etapas para personalizar as variáveis do UEFI Secure Boot durante a criação da AMI. A KEK usado nessas etapas está atual desde de setembro de 2021. Se a Microsoft atualizar a KEK, você deverá usar a KEK mais recente.
**Para criar o blob binário da AWS**
1. Crie uma lista de assinaturas PK vazia.
```
touch empty_key.crt
cert-to-efi-sig-list empty_key.crt PK.esl
```
1. Baixe os certificados de KEK.
```
https://go.microsoft.com/fwlink/?LinkId=321185
```
1. Empacote os certificados de KEK em uma lista de assinaturas UEFI (`siglist`).
```
sbsiglist --owner 77fa9abd-0359-4d32-bd60-28f4e78f784b --type x509 --output MS_Win_KEK.esl MicCorKEKCA2011_2011-06-24.crt
```
1. Baixe os certificados de db da Microsoft.
```
https://www.microsoft.com/pkiops/certs/MicWinProPCA2011_2011-10-19.crt
https://www.microsoft.com/pkiops/certs/MicCorUEFCA2011_2011-06-27.crt
```
1. Gere a lista de assinaturas db.
```
sbsiglist --owner 77fa9abd-0359-4d32-bd60-28f4e78f784b --type x509 --output MS_Win_db.esl MicWinProPCA2011_2011-10-19.crt
sbsiglist --owner 77fa9abd-0359-4d32-bd60-28f4e78f784b --type x509 --output MS_UEFI_db.esl MicCorUEFCA2011_2011-06-27.crt
cat MS_Win_db.esl MS_UEFI_db.esl > MS_db.esl
```
1. O Unified Extensible Firmware Interface Forum não fornece mais os arquivos DBX. Eles agora são fornecidos pela Microsoft no GitHub. Baixe a atualização mais recente do DBX do repositório de atualizações do Microsoft Secure Boot em [https://github.com/microsoft/secureboot\$1objects](https://github.com/microsoft/secureboot_objects).
1. Descompacte o binário de atualização assinado.
Crie `SplitDbxContent.ps1` com o conteúdo do script abaixo. Como alternativa, você pode instalar o script da [Galeria do PowerShell](https://www.powershellgallery.com/packages/SplitDbxContent/1.0) usando `Install-Script -Name SplitDbxContent`.
```
<#PSScriptInfo
.VERSION 1.0
.GUID ec45a3fc-5e87-4d90-b55e-bdea083f732d
.AUTHOR Microsoft Secure Boot Team
.COMPANYNAME Microsoft
.COPYRIGHT Microsoft
.TAGS Windows Security
.LICENSEURI
.PROJECTURI
.ICONURI
.EXTERNALMODULEDEPENDENCIES
.REQUIREDSCRIPTS
.EXTERNALSCRIPTDEPENDENCIES
.RELEASENOTES
Version 1.0: Original published version.
#>
<#
.DESCRIPTION
Splits a DBX update package into the new DBX variable contents and the signature authorizing the change.
To apply an update using the output files of this script, try:
Set-SecureBootUefi -Name dbx -ContentFilePath .\content.bin -SignedFilePath .\signature.p7 -Time 2010-03-06T19:17:21Z -AppendWrite'
.EXAMPLE
.\SplitDbxAuthInfo.ps1 DbxUpdate_x64.bin
#>
# Get file from script input
$file = Get-Content -Encoding Byte $args[0]
# Identify file signature
$chop = $file[40..($file.Length - 1)]
if (($chop[0] -ne 0x30) -or ($chop[1] -ne 0x82 )) {
Write-Error "Cannot find signature"
exit 1
}
# Signature is known to be ASN size plus header of 4 bytes
$sig_length = ($chop[2] * 256) + $chop[3] + 4
$sig = $chop[0..($sig_length - 1)]
if ($sig_length -gt ($file.Length + 40)) {
Write-Error "Signature longer than file size!"
exit 1
}
# Content is everything else
$content = $file[0..39] + $chop[$sig_length..($chop.Length - 1)]
# Write signature and content to files
Set-Content -Encoding Byte signature.p7 $sig
Set-Content -Encoding Byte content.bin $content
```
Use o script para descompactar os arquivos DBX assinados.
```
PS C:\Windows\system32> SplitDbxContent.ps1 .\dbx.bin
```
Isso produz dois arquivos: `signature.p7` e `content.bin`. Use `content.bin` na próxima etapa.
1. Construa um armazenamento de variáveis UEFI usando o script `uefivars.py`.
```
./uefivars.py -i none -o aws -O uefiblob-microsoft-keys-empty-pk.bin -P ~/PK.esl -K ~/MS_Win_KEK.esl --db ~/MS_db.esl --dbx ~/content.bin
```
1. Verifique o blob binário e o armazenamento de variáveis UEFI.
```
./uefivars.py -i aws -I uefiblob-microsoft-keys-empty-pk.bin -o json | less
```
1. É possível atualizar o blob passando-o para a mesma ferramenta novamente.
```
./uefivars.py -i aws -I uefiblob-microsoft-keys-empty-pk.bin -o aws -O uefiblob-microsoft-keys-empty-pk.bin -P ~/PK.esl -K ~/MS_Win_KEK.esl --db ~/MS_db.esl --dbx ~/content.bin
```
Saída esperada
```
Replacing PK
Replacing KEK
Replacing db
Replacing dbx
```