Exécutables signés sous Linux

Je me rends compte que c'est une question ancienne mais je viens de la trouver.

J'ai écrit un support exécutable signé pour le noyau Linux (autour de la version 2.4.3) il y a quelque temps, et j'ai mis en place toute la chaîne d'outils pour signer les exécutables, vérifier les signatures au moment execve(2), mettre en cache les informations de validation de signature (effacer la validation lorsque le fichier a été ouvert Il a introduit certains des pénalités de performance lors de la première exécution de chaque programme (parce que le noyau devait charger dans le fichier entier, plutôt que de simplement demander les pages nécessaires) mais une fois que le système était en état stable, cela fonctionnait bien.

Mais nous avons décidé d'arrêter de le poursuivre parce qu'il faisait face à plusieurs problèmes qui étaient trop importants pour justifier la complexité:

• Nous n'avions pas encore construit un soutien pour signé bibliothèques. Les bibliothèques signées nécessiteraient également la modification le chargeur ld.so et le mécanisme dlopen(3). Ce n'était pas impossible mais compliquait l'interface: faut-il que le chargeur demande au noyau de valider une signature ou que le calcul se fasse entièrement dans l'espace utilisateur? Comment se protéger contre un processus strace(2)d si cette partie de la validation est effectuée dans l'espace utilisateur? Serions-nous obligés d'interdire strace(2) entièrement sur un tel système?

  Que ferions-nous au sujet des programmes qui fournissent leur propre chargeur?

• Un grand nombre de programmes sont écrits dans des langages qui ne compilent pas D'objets ELF. Nous aurions besoin de fournir spécifiques à la langue modifications bash, perl, python, java, awk, sed, et ainsi de suite, pour chacun des interprètes pour être en mesure de aussi valider les signatures. Étant donné que la plupart de ces programmes sont en texte brut au format libre, ils n'ont pas la structure qui a rendu l'intégration des signatures numériques dans les fichiers objets ELF si facile. Où serait le les signatures sont stockées? Dans les scripts? Dans les attributs étendus? Dans une base de données externe de signatures?

• De nombreux interprètes sont très ouverts sur ce qu'ils permettent; bash(1) peut communiquer avec des systèmes distants tout seul en utilisant echo et /dev/tcp, et peut facilement être trompé pour exécuter tout ce qu'un attaquant doit faire. Signé ou non, vous ne pouviez pas leur faire confiance une fois qu'ils étaient sous le contrôle d'un pirate informatique.

• Le premier facteur de motivation pour les le support des exécutables signés provient de rootkits remplaçant le système fourni /bin/ps, /bin/ps, /bin/kill, et ainsi de suite. Oui, il existe d'autres raisons utiles d'avoir signé des exécutables. Cependant, les rootkits sont devenus beaucoup plus impressionnants au fil du temps, beaucoup s'appuyant sur kernel hacks pour cacher leurs activités aux administrateurs. Une fois que le noyau a été piraté, Tout le jeu est terminé. En raison de la sophistication des rootkits les outils que nous espérions empêcher d'être utilisés tombaient hors de faveur dans la communauté de piratage.

• L'interface de chargement du module du noyau était grande ouverte. Une fois qu'un processus a le privilège root, Il était facile d'injecter un module noyau sans aucune vérification. Nous aurions aussi pu écrire un autre vérificateur pour les modules du noyau, mais l'infrastructure du noyau autour des modules était très primitive.

Le modèle GNU / Linux / FOSS encourage en fait la falsification -- d'une sorte. Les utilisateurs et les fabricants de distribution doivent être libres de modifier (altérer) le logiciel en fonction de leurs besoins. Même simplement recompiler le logiciel (sans changer de code source) pour la personnalisation est quelque chose qui se fait assez souvent, mais qui casserait la signature de code binaire. Par conséquent, le modèle de signature de code binaire n'est pas particulièrement adapté à GNU/Linux/FOSS.

Au Lieu de cela, ce type de logiciel repose davantage sur la génération signatures et / ou hachages sécurisés des paquets source. En combinaison avec un modèle de distribution de paquets fiable et fiable, cela peut être rendu aussi sûr (sinon plus, vis-à-vis de la transparence dans le code source) que la signature de code binaire.

Jetez un oeil à ceci: http://linux-ima.sourceforge.net/

Il ne signe pas encore, mais il active toujours la vérification.

Jetez un oeil à Medusa DS9 . J'ai joué avec lui il y a longtemps (long), mais si je me souviens bien, vous pourriez enregistrer des binaires spécifiques et toute modification n'était pas autorisée au niveau du noyau. Bien sûr, il peut être remplacé par un accès local à la machine, mais ce n'était pas vraiment facile. Il y a un démon intelligent, appelé constable, qui vérifie tout ce qui se passe sur la machine et si quelque chose d'inhabituel se produit, il commence à crier.

Je ne l'ai jamais essayé, mais jetez un oeil à: http://blog.codenoise.com/signelf-digitally-signing-elf-binaries . la solution fonctionne sans avoir besoin du support du noyau, et semble être prête à partir.

Le code du signataire se trouve à http://sourceforge.net/projects/signelf/

Il ne résout pas la question "exécuter uniquement du code de confiance sur linux", mais il résout partiellement le problème en permettant au programme de se détecter un possible falsification / corruption

Je peux répondre à la question d'un point de vue Solaris 10 & 11 OS, tous les binaires sont signés. Pour vérifier la signature, utilisez 'elfsign'...

$ elfsign verify -v /usr/bin/bash
elfsign: verification of /usr/bin/bash passed.
format: rsa_sha1.
signer: O=Oracle Corporation, OU=Corporate Object Signing, OU=Solaris Signed Execution, CN=Solaris 11.
signed on: Fri Oct 04 17:06:13 2013.

Oracle a récemment ajouté un processus de démarrage vérifié pour Solaris 11, pour plus de détails, voir - Solaris Verified Boot Introduction

Il y a quelques fourches de qualité de production du code OpenSolaris, trois méritent d'être étudiées sont Illumos, SmartOS et OmniOS.

Http://en.wikipedia.org/wiki/PKCS

Utilisez un signe PKCS7 (S / MIME). Générez votre propre paire cert / clé privée, signez automatiquement le cert, puis signez votre fichier avec la clé privée et le cert En utilisant PKCS7. Il y attachera le cert, puis il pourra se vérifier à l'exécution en utilisant la commande openssl (man smime ou simplement faire de l'aide openssl). Ceci est inviolable car même si la clé publique est dans les fichiers que vous donnez, la signature S / MIME pour cette clé publique ne peut être généré avec la clé privée que vous ne distribuerez pas. Donc, si le fichier est signé par votre cert, il doit avoir été signé par quelqu'un avec la clé privée et puisque vous n'avez donné la clé privée à personne, il doit provenir de vous.

Voici comment faire le certificat auto-signé.

Http://www.akadia.com/services/ssh_test_certificate.html

Vous devrez convaincre openssl de faire confiance à votre cert En tant que racine d'autorité (- CAfile), puis le vérifier avec cela comme la racine, et aussi vérifier le cert sur le fichier est à vous (hachez le cert) et vérifiez le hachage. Notez que bien qu'il ne soit pas documenté, l'état de sortie d'openssl reflète la validité du signe que vous vérifiez lors d'une vérification smime. C'est 0 s'il correspond, non-zéro si ce n'est pas le cas.

Notez que tout cela n'est pas sûr, car si le chèque est dans votre code, il suffit d'ôter les vérifier s'ils veulent vous battre. La seule façon sûre de le faire serait d'avoir l'outil dans le système d'exploitation et vérifier votre binaire et de refuser de l'exécuter si elle n'est pas signé. Mais comme il n'y a pas de vérificateur dans le système d'exploitation et linux peut être modifié pour le supprimer/le contourner de toute façon... Ce qui est vraiment bon pour est juste de détecter les fichiers corrompus plus que d'essayer d'empêcher les gens de vous contourner.