Utiliser les signatures numériques pour vérifier l'intégrité des fichiers binaires sous Linux

Introduction

Dans un monde où les données peuvent être interceptées ou altérées, la confiance dans l'authenticité des fichiers reçus est primordiale. Par exemple, si l'utilisateur A envoie un fichier binaire à l'utilisateur B par email, comment B peut-il être certain que le fichier n'a pas été modifié ? Les signatures numériques (DS) fournissent une solution fiable en liant les données aux identifiants uniques de l'expéditeur.

• La signature doit être dérivée du message signé.
• Elle doit incorporer l'information unique de l'expéditeur.
• Sa création doit être simple.
• Il doit être calculatoirement impossible à forger.
• La taille de la signature doit rester petite.

Cet article démontre une implémentation pratique de DS pour vérifier l'intégrité de binaires ELF 64 bits sous Linux. L'approche utilise un schéma de signature direct (sans tiers arbitre) et repose sur une clé privée pour la signature et un certificat public pour la vérification.

Exemple d'implémentation DS

L'implémentation de la signature implique les étapes suivantes :

1. Générer un hash MD5 du binaire source.
2. Créer une clé privée et un certificat public auto-signé.
3. Signer le binaire :
   • Chiffrer le hash MD5 avec la clé privée.
   • Stocker le hash chiffré dans une nouvelle section .sig du fichier ELF.
   • Sauvegarder le certificat dans ~/.ssh pour vérification ultérieure.

Tout le processus peut être scripté avec openssl, objcopy et md5sum. Ci-dessous un exemple de script, sign_elf.sh, qui automatise la signature de binaires ELF. (Le code source sans numéros de ligne apparaît à la fin de l'article.)

#!/bin/bash
KEY_DIR="$HOME/.ssh"
PRIVATE_KEY="$KEY_DIR/priv.key"
CERTIFICATE="$KEY_DIR/pub.crt"
SUBJECT="/C=RU/ST=Nizhni Novgorod/L=Nizhniy Novgorod/O=Auriga/OU=DEV/CN=www.auriga.com"
if [ "$#" = "0" ]; then
 echo "Usage: sign_elfs.sh [ELF files]"
 exit 1
fi
[ ! -d "$KEY_DIR" ] && mkdir "$KEY_DIR"
# Générer clé privée et certificat
openssl req -nodes -x509 -sha256 -newkey rsa:4096 -keyout "$PRIVATE_KEY" -out "$CERTIFICATE" -days 365 -subj "$SUBJECT"
for ELF_BIN in "$@"; do
 ELF_BASE_NAME="${ELF_BIN##*/}"
 ELF_BIN_SIGNATURE="$ELF_BASE_NAME.sha256"
 ELF_BIN_MD5="$ELF_BASE_NAME.md5"
 if [ ! -f "$ELF_BIN" ]; then
 echo "Error: no such file $ELF_BIN"
 exit 103
 fi
 # Supprimer section .sig existante
 objcopy --remove-section=.sig "$ELF_BIN"
 # Ajouter section .sig de 512 octets remplie de zéros
 rm -f dummy.txt
 touch dummy.txt
 truncate --size=512 dummy.txt
 objcopy --add-section .sig=dummy.txt --set-section-flags .sig=noload,readonly "$ELF_BIN"
 # Calculer hash MD5 du binaire (avec section .sig)
 md5sum "$ELF_BIN" | awk '{ print $1 }' > "$KEY_DIR/$ELF_BIN_MD5"
 # Signer le hash MD5 avec la clé privée
 openssl dgst -sha256 -sign "$PRIVATE_KEY" -out "$KEY_DIR/$ELF_BIN_SIGNATURE" "$KEY_DIR/$ELF_BIN_MD5"
 # Vérifier la signature immédiatement (optionnel)
 openssl dgst -sha256 -verify <(openssl x509 -in "$CERTIFICATE" -pubkey -noout) -signature "$KEY_DIR/$ELF_BIN_SIGNATURE" "$KEY_DIR/$ELF_BIN_MD5"
 # Embarquer le hash chiffré dans la section .sig
 objcopy --update-section .sig="$KEY_DIR/$ELF_BIN_SIGNATURE" --set-section-flags .sig=noload,readonly "$ELF_BIN"
 # Afficher le contenu de la section .sig pour inspection
 objdump -sj .sig "$ELF_BIN"
done
rm -f dummy.txt
ls -ls ~/.ssh

Détail des étapes du script

Ligne 19 – Génération du certificat

openssl req -nodes -x509 -sha256 -newkey rsa:4096 -keyout "$PRIVATE_KEY" -out "$CERTIFICATE" -days 365 -subj "$SUBJECT"

• req crée une demande de signature de certificat.
• -nodes produit une clé privée en texte clair.
• -x509 sort un certificat auto-signé.
• -sha256 sélectionne SHA-256 pour le hachage.
• -newkey rsa:4096 génère une clé RSA 4096 bits.
• Le champ SUBJECT suit le format RFC 5280, ex: /C=RU/ST=…/CN=….

Après cette étape, ~/.ssh/priv.key contient la clé privée et ~/.ssh/pub.crt le certificat. La clé privée chiffre les données ; le certificat contient la clé publique nécessaire à la vérification.

Boucle sur les fichiers ELF (Ligne 21)

Chaque binaire spécifié en ligne de commande est traité séquentiellement. Le script s'assure que toute section .sig préexistante est supprimée avant de signer à nouveau.

Gestion des sections (Lignes 33–40)

• La section .sig existante est supprimée avec objcopy --remove-section=.sig.
• Un fichier placeholder de 512 octets est créé et ajouté comme section .sig en lecture seule, non chargeable.

Calcul du hash (Ligne 42)

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

Le MD5 est calculé sur le binaire, y compris la section .sig placeholder, et stocké dans nom_binaire.md5.

Signature du hash (Ligne 45)

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

Le hash MD5 est chiffré avec la clé privée, produisant un fichier de signature (ex: nom_binaire.sha256).

Vérification (optionnelle) (Ligne 48)

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

Cette étape confirme que la signature correspond au hash en utilisant la clé publique extraite du certificat.

Intégration de la signature (Ligne 52)

objcopy --update-section .sig="$KEY_DIR/$ELF_BIN_SIGNATURE" --set-section-flags .sig=noload,readonly "$ELF_BIN"

Le hash chiffré remplace le placeholder, finalisant le binaire ELF signé.

L'exécution du script sur un ensemble de fichiers ELF produira des binaires signés qui peuvent être distribués en toute sécurité. Le destinataire peut vérifier l'intégrité en extrayant la section .sig, la déchiffrant avec le certificat public, et comparant le hash résultant à un hash fraîchement calculé du fichier reçu.