Usando assinaturas digitais para verificação de integridade de dados no Linux

Introdução

Uma das questões mais importantes no mundo de hoje é a questão da confiança nos dados recebidos. Por exemplo, o usuário À envia os dados D ao usuário B por e-mail. Como o usuário B pode ter certeza de que os dados recebidos são os mesmos dados que foram enviados pelo usuário A? Uma maneira possível de resolver esse problema é usar uma assinatura digital (DS). Os seguintes requisitos se aplicam a um DS:

• O conteúdo da assinatura deve depender da mensagem assinada;
  

• As informações exclusivas do remetente devem ser usadas em uma assinatura;
  

• Deve ser fácil criar uma assinatura;
  

• Deve ser impossível falsificar uma assinatura computacionalmente;
  

• A assinatura deve ser pequena.
  

Este artigo considera um exemplo de implementação de DS para verificação de integridade de arquivo binário no Linux (ELF de 64 bits). Usaremos um DS direto quando apenas um remetente e um destinatário estiverem se comunicando (sem um terceiro / árbitro). Precisamos de uma chave de criptografia privada e uma chave pública (certificado) para isso. O remetente cria ambas as chaves. O usuário A assina um arquivo executável e passa o certificado ao usuário B com a ajuda de meios de entrega seguros. Depois disso, o usuário A envia um arquivo assinado ao usuário B. O usuário B executa o arquivo recebido; se o arquivo binário estiver corrompido, o usuário B receberá uma mensagem informando que a verificação do DS falhou. Para implementar essa solução, precisaremos de um programa para assinar arquivos binários e um código que verifica os DSs.

Exemplo de implementação do DS

A implementação do DS inclui as seguintes etapas:

1. Geração de arquivo binário de origem MD5;
   

2. A criação de duas chaves:privada e pública (certificado).
   

3. Assinatura de arquivo binário (ELF):
   1 MD5 do arquivo binário é criptografado com a ajuda da chave privada;
   3.2 ​​O MD5 criptografado é gravado em um novo .sig seção do arquivo binário;
   3.3 O certificado é salvo na pasta ~ / .ssh.
   

Tudo isso pode ser implementado com a ajuda dos utilitários opensl, objcopy e md5sum do Linux. Abaixo você pode encontrar um exemplo de um script sign_elf.sh que assina arquivos binários ELF. (Observação:a fonte sem números de linha está incluída no final deste artigo.)

 001 #! / bin / bash002 003 KEY_DIR ="$ HOME / .ssh" 004 PRIVATE_KEY ="$ KEY_DIR / priv.key" 005 CERTIFICATE ="$ KEY_DIR / pub.crt" 006 SUBJECT ="/ C =RU / ST =Nizhni Novgorod / L =Nizhni Novgorod / O =Auriga / OU =DEV / CN =www.auriga.com "007 008 se [" $ # "=" 0 "]; then009 echo "Uso:sign_elfs.sh ..." 010 saída 1; 011 fi012 013 if [! -d "$ KEY_DIR"]; then014 # O controle entrará aqui se $ DIRECTORY não existir.015 mkdir "$ KEY_DIR" 016 fi017 018 # Criar chave privada e certificado019 openssl req -nodes -x509 -sha256 -newkey rsa:4096 -keyout "$ PRIVATE_KEY" -out " $ CERTIFICATE "-days 365 -subj" $ SUBJECT "020 021 para ELF_BIN em $ @; do022 ELF_BASE_NAME ="$ {ELF_BIN ## * /}" 023 # ELF_BIN_OLD ="$ ELF_BIN.old" 024 ELF_BIN_SIGNATURE ="$ ELF_BASE_NAME.sha256" 025 ELF_BIN_MD5 ="$ ELF_BASE_NAME.md5" 026 027 if [! -f "$ ELF_BIN"] || ["x $ ELF_BIN" ="x"]; then028 echo "Erro:arquivo inexistente $ ELF_BIN" 029 exit 1030 fi031 032 # Remove .sig section033 objcopy --remove-section =.sig "$ ELF_BIN" 034 035 # Add Seção de 512 bytes preenchida com zeros036 rm -f dummy.txt037 touch dummy.txt038 truncar --size =512 dummy.txt039 objcopy --add-section .sig =dummy.txt --set-section-flags .sig =noload, somente leitura "$ ELF_BIN" 040 041 # Criar MD5 hash042 md5sum "$ ELF_BIN" | awk '{print $ 1}'> "$ KEY_DIR / $ ELF_BIN_MD5" 043 044 # Criptografar hash MD5 usando chave privada045 openssl dgst -sha256 -sign "$ PRIVATE_KEY" -out "$ KEY_DIR / $ ELF_BIN_SIGNATURE" "$ KEY_DIR / $ ELF5" 046 047 # Validar hash MD5 criptografado usando certificate048 openssl dgst -sha256 -verify <(openssl x509 -in "$ CERTIFICATE" -pubkey -noout) -signature "$ KEY_DIR / $ ELF_BIN_SIGNATURE" "$ KEY_DIR / $ ELF_BIN_MD5 049 hash MD5 criptografado em binário ELF em .sig section051 echo "Adicionar seção .sig" 052 objcopy --update-section .sig ="$ KEY_DIR / $ ELF_BIN_SIGNATURE" --set-section-flags .sig =noload, somente leitura "$ ELF_BIN "" $ ELF_BIN "053 054 # Print .sig section055 echo" Verificar seção .sig "056 objdump -sj .sig" $ ELF_BIN "057 done058 059 rm -f dummy.txt060 061 ls -ls ~ / .ssh 

Figura 1. O processo de assinatura do binário ELF. (Fonte:Auriga)

Vamos explorar os detalhes do que esse script faz.

Linha 19:

openssl req -nodes -x509 -sha256 -newkey rsa:4096 -keyout “$ PRIVATE_KEY” -out “$ CERTIFICATE” -dias 365 -subj “$ SUBJECT”

req - solicitação de criação de certificado

-nodes - cria uma chave privada de texto simples

-x509 - saída - certificado autoassinado

-sha256 - algoritmo de criptografia

-newkey rsa:4096 - cria um novo certificado e chave privada RSA, número de bits - 4096

-keyout $ PRIVATE_KEY - o caminho para o arquivo onde a chave privada é gravada

-out $ CERTIFICATE - o caminho para o arquivo onde o certificado é gravado - dias 365 - número de dias para a confirmação do certificado

-subj $ SUBJECT - novo assunto do certificado (deve ter o formato de / type0 =value0 / type1 =value1 / type2 =…). Em nosso caso, é / C =RU / ST =Nizhni Novgorod / L =Nizhniy Novgorod / O =Auriga / OU =DEV / CN =www.auriga.com, onde
С - país
ST - estado, região, província
L - localização
O - organização
OU - departamento / unidade organizacional
CN - título básico / nome do contêiner

O assunto é descrito em detalhes no RFC-5280 (https://tools.ietf.org/html/rfc5280). Depois que esse comando for executado, uma chave privada será gerada, ~ / .ssh / priv.key e o certificado ~ / .ssh / pub.crt. A chave privada será usada para criptografar os dados e o certificado será usado para descriptografar os dados. Usando uma chave privada, é possível gerar vários certificados exclusivos para descriptografar dados que foram criptografados com essa chave privada.

Linha 21:

para ELF_BIN em $ @; faça

Início do loop para todos os arquivos binários adicionados ao script sign_elf.sh.

Linha 33:

objcopy –remove-section =.sig “$ ELF_BIN”

Remova o .sig seção de nosso arquivo binário. Isso precisa ser feito se o arquivo já foi assinado com nosso script e queremos assiná-lo novamente.

Linhas 36+:

rm -f dummy.txt
touch dummy.txt
truncar –size =512 dummy.txt
objcopy –add-section .sig =dummy.txt –set -section-flags .sig =noload, somente leitura “$ ELF_BIN

Crie um arquivo de texto de 512 bytes e adicione-o ao nosso arquivo binário não carregado no tempo de execução .sig seção apenas para leitura, que contém dados do arquivo dummy.txt.

Linha 42:

md5sum “$ ELF_BIN” | awk '{print $ 1}'> “$ KEY_DIR / $ ELF_BIN_MD5”

Calcule MD5 do arquivo binário (com .sig seção) e escrever o resultado em um arquivo de texto, binary_name.md5.

Linha 45:

openssl dgst -sha256 -sign “$ PRIVATE_KEY” -out “$ KEY_DIR / $ ELF_BIN_SIGNATURE” “$ KEY_DIR / $ ELF_BIN_MD5”

Este comando criptografa o arquivo com MD5 criado pela linha 42 com uma chave privada. Argumentos:

dgst - esta opção indica que queremos criptografar (assinar) dados;

-sha256 - algoritmo de criptografia;

-sign $ PRIVATE_KEY - criptografa o arquivo com a ajuda da chave privada $ PRIVATE_KEY;

-out $ KEY_DIR / $ ELF_BIN_SIGNATURE - os dados criptografados são salvos no arquivo $ KEY_DIR / $ ELF_BIN_SIGNATURE;

$ KEY_DIR / $ ELF_BIN_MD5 - arquivo de texto contendo dados a serem criptografados.

Linha 48:

openssl dgst -sha256 -verify <(openssl x509 -in "$ CERTIFICATE" -pubkey -noout) -signature "$ KEY_DIR / $ ELF_BIN_SIGNATURE" "$ KEY_DIR / $ ELF_BIN_MD5"

Verificação de arquivo assinado. Pode ser entendido por referência a esta linha que para verificação DS, precisamos de dados criptografados, um certificado que nos ajudará a realizar a verificação e verificação de dados. Ou seja, se

x - dados criptografados,
y - certificado,
z - dados de verificação,

então

f (x, y) =z

Linha 52:

objcopy –update-section .sig =”$ KEY_DIR / $ ELF_BIN_SIGNATURE” –set-section-flags .sig =noload, somente leitura “$ ELF_BIN” “$ ELF_BIN”

Remova o antigo .sig seção e adicione um novo ao arquivo $ ELF_BIN (binary_name). Como dados para o novo .sig seção, os dados do arquivo assinado $ KEY_DIR / $ ELF_BIN_SIGNATURE (~ / .ssh / binary_name.sha256) são usados.