Todo o conceito de inicialização segura no Ubuntu exige que exista uma cadeia de confiança, desde a primeira coisa carregada pelo hardware (o código do firmware), até as últimas coisas carregadas pelo sistema operacional como parte do kernel: os módulos . Em outras palavras, não apenas o firmware e o bootloader requerem assinaturas, o Kernel e os módulos também. As pessoas geralmente não mudam tanto o firmware ou o bootloader, mas e quanto a reconstruir um kernel ou adicionar módulos extras fornecidos pelos fabricantes de hardware?
Assinatura de inicialização segura no UBUNTU
A história de inicialização segura no Ubuntu inclui o fato de que você pode querer construir seu próprio kernel (mas esperamos que você possa apenas usar o kernel genérico que enviamos no arquivo), e que você pode instalar seus próprios módulos de kernel. Isso significa assinar binários UEFI e módulos do kernel, o que pode ser feito com seu próprio conjunto de ferramentas.
Mas, primeiro, mais informações sobre a cadeia de confiança usada para inicialização segura.
Certificados em shim
Para começar a assinar coisas para UEFI Secure Boot, você precisa criar um certificado X509 que pode ser importado no firmware; diretamente através do firmware do fabricante, ou mais facilmente, por meio de Shim.
Criar um certificado para uso em UEFI Secure Boot é relativamente simples. O openssl pode fazer isso executando alguns comandos SSL. Agora, precisamos criar um certificado SSL para assinatura de módulo …
Primeiro, vamos criar algumas configurações para permitir que o openssl saiba o que queremos criar (vamos chamá-lo de ‘openssl.cnf’):
Atualize os valores em “[req_distinguished_name]” ou livre-se dessa seção completamente (junto com o campo “distinguished_name”) e remova o campo “prompt”. Em seguida, o openssl solicitará os valores que você deseja definir para a identificação do certificado.
A identificação em si não importa muito, mas alguns dos valores posteriores são importantes: por exemplo, queremos ter certeza de que “1.3.6.1.4.1.2312.16.1.2” está incluído em extendedKeyUsage, e é esse OID que vai dizer shim é um certificado de assinatura de módulo.
Então, podemos começar a parte divertida: criar as chaves privadas e públicas.
Este comando criará a parte privada e pública do certificado para assinar coisas. Você precisa de ambos os arquivos para assinar; e apenas a parte pública (MOK.der) para registrar a chave no shim.
Registrando a chave
Dando continuidade ao processo de inicialização segura no Ubuntu, agora para garantir a inicialzação segurno no Ubuntu, vamos registrar a chave que acabamos de criar no shim. Isso faz com que seja aceito como uma chave de assinatura válida para qualquer módulo que o kernel deseja carregar, bem como uma chave válida se você quiser construir seu próprio gerenciador de inicialização ou kernels (desde que você não inclua isso ‘1.3. 6.1.4.1.2312.16.1.2 ‘OID discutido anteriormente).
Para registrar uma chave, use o comando mokutil:
Siga as instruções para inserir uma senha que será usada para garantir que você realmente deseja registrar a chave em um minuto.
Feito isso, reinicie. Antes de carregar o GRUB, o shim mostrará uma tela azul (que na verdade é outra parte do projeto do shim chamada “MokManager”). use essa tela para selecionar “Inscrever MOK” e siga os menus para concluir o processo de inscrição. Você também pode ver algumas das propriedades da chave que está tentando adicionar, apenas para ter certeza de que é realmente a correta usando “Exibir chave”. O MokManager pedirá a senha que digitamos antes ao executar o mokutil; e salvará a chave e reiniciaremos novamente.
Vamos assinar coisas
Antes de assinarmos, vamos ter certeza de que a chave que adicionamos realmente é vista pelo kernel. Para fazer isso, podemos examinar / proc / keys:
Apenas certifique-se de que existe uma chave com os atributos (commonName, etc.) que você inseriu anteriormente
Para assinar módulos do kernel, podemos usar o comando kmodsign:
module.ko
deve ser o nome do arquivo de um módulo do kernel que você deseja assinar. A assinatura será anexada a ela pelo kmodsign, mas se você preferir manter a assinatura separada e concatená-la no módulo você mesmo, pode fazer isso também (consulte ‘kmosign –help’).
Você pode validar se o módulo está assinado verificando se ele inclui a string ‘~ Module signature appended ~’:
Você também pode usar o hexdump dessa forma para verificar se a chave de assinatura é a que você criou.
E quanto aos kernels e bootloaders?
Para assinar um kernel customizado ou qualquer outro binário EFI que você deseja carregar por shim, você precisará usar um comando diferente: sbsign. Infelizmente, precisaremos do certificado em um formato diferente neste caso.
Vamos converter o certificado que criamos anteriormente em PEM:
Agora, podemos usar isso para assinar nosso binário EFI:
Contanto que a chave de assinatura esteja registrada no shim e não contenha o OID anterior (já que isso limita o uso da chave para a assinatura do módulo do kernel), o binário deve ser carregado perfeitamente pelo shim.
Fazendo assinaturas fora do shim
Se você não quiser usar shim para lidar com chaves (mas eu recomendo que você use), você precisará criar certificados diferentes; sendo um deles o PK (Platform Key) do sistema, que você pode registrar no firmware diretamente via KeyTool ou alguma ferramenta de firmware fornecida com seu sistema.
Dando continuidade ao processo de inicialização segura no Ubuntu, não iremos elaborar os passos para cadastrar as chaves no firmware, pois tende a variar de sistema para sistema, mas a ideia principal é colocar o sistema em “Modo de Configuração” de Boot Seguro; execute o KeyTool (que é seu próprio binário EFI que você mesmo pode construir e executar) e registrar as chaves – primeiro instalando as chaves KEK e DB e finalizando com o PK. Esses arquivos precisam estar disponíveis em alguma partição FAT.
Eu tenho esse script para gerar os certificados e arquivos corretos; que posso compartilhar (e ele mesmo é copiado de algum lugar, não me lembro):
A mesma lógica aplica-se anteriormente: assine coisas usando sbsign ou kmodsign conforme necessário (use os arquivos .crt com sbsign e os arquivos .cer com kmodsign); e, desde que as chaves estejam devidamente registradas no firmware ou no shim, elas serão carregadas com sucesso.
O que está por vir para a inicialização segura no Ubuntu
Assinar coisas é complexo – você precisa criar certificados SSL, inscrevê-los no firmware ou shim … Você precisa ter um bom conhecimento prévio de como a inicialização segura funciona e quais comandos são usados. É bastante óbvio que isso não está ao alcance de todos e, em primeiro lugar, é uma experiência um tanto ruim. Por esse motivo, estamos trabalhando para tornar mais fácil a criação, inscrição e assinaturas de chaves ao instalar os módulos DKMS.
update-secureboot-policy logo deverá permitir que você gere e registre uma chave; e o DKMS será capaz de assinar coisas sozinho usando essa chave.
Conclusão
Como pode ser observado neste tutorial, o uso do certificado digital está a cada dia mais presente de modo a ampliar a segurança dos UBUNTU e demais sistemas operacionais LINUX, Bem como dar segurança desde boot até o carregamento dos módulos do Kernel.
Fonte: UBUNTU
Segue abaixo mais alguns artigos sobre os temas abordados nesta matéria.
Lançado Linux Lite 5.2 baseado no Ubuntu 20.04.1 LTS
LINUX – conheça comandos básicos e mais úteis
Gerencie a expiração dos certificados de SSL
O post Assinatura de inicialização segura no UBUNTU apareceu primeiro em SempreUPdate.
