Skip to content

Linux Attitude

Le libre est un état d'esprit

Archive

Archives pour mars, 2009

Niveau : Star Star Star Star Empty
Résumé :

Après avoir vu il y a longtemps comment créer le certificat d'une autorité de certification personnelle et comment l'installer là où c'est nécessaire, nous allons voir les méthodes pour gérer une autorité de certification.

Une fois l'autorité créée, l'activité principale d'une autorité est de signer des certificats. Et plutôt que de taper tous les paramètres à la main, il est plus simple de disposer d'une configuration, ce qu'openssl nous propose. De plus, openssl dispose d'une commande permettant une gestion simplifiée d'une autorité.

Passons en revue la configuration (reprise du fichier par défaut /etc/ssl/openssl.cnf). Parlons directement de la section gérant l'autorité elle-même :

# Section pour la commande ca
[ ca ]
# Autorité par défaut (pour en gérer plusieurs)
default_ca      = Peck_authority 

# Section spécifique à mon autorité
[ Peck_authority ]

# Tous les répertoires de base
dir             = /srv/Authority        # Where everything is kept
crl_dir         = $dir/crl              # Where the issued crl are kept
database        = $dir/index.txt        # database index file.
new_certs_dir   = $dir/newcerts         # default place for new certs.

certificate     = $dir/cacert.pem       # The CA certificate
serial          = $dir/serial           # The current serial number
crlnumber       = $dir/crlnumber        # the current crl number
                                        # must be commented out to leave a V1 CRL
private_key     = $dir/private/cakey.pem# The private key
RANDFILE        = $dir/private/.rand    # private random number file

Ensuite les options spécifiques :

# Mettre à no pour permettre à une entité de disposer de plusieurs certificats
#unique_subject = no

# Section contenant les extensions à utiliser
x509_extensions = usr_cert              # The extentions to add to the cert

# Format d'affichage des données en ligne de commande
name_opt        = ca_default            # Subject Name options
cert_opt        = ca_default            # Certificate field options

# Ne pas utiliser sauf à faire infiniment confiance aux demandeurs (ou tout vérifier à la main)
# copy_extensions = copy

# Durée de validité des certificats émis
default_days    = 365
# Fonction de hashage à utiliser (ne pas utiliser md5 :-)
default_md      = sha1
# Réécrire le DN passé par le demandeur
preserve        = no

# Politique à utiliser pour la vérification de la demande
policy          = policy_match

Et maintenant les sous-sections.

La politique de vérification des demandes est simpliste, elle ne sert qu'à vérifier que la demande est valide, rien de plus. C'est à l'humain / le script / la PKI de vérifier que la demande est la bonne et que le demandeur est bien celui qu'il prétend.

# Liste des champs présents dans la demande et inclus dans le certificats (les autres seront supprimés).
# match = doit être la même que cette de l'AC
# supplied = obligatoire
# optional = optionnel
[ policy_match ]
countryName             = match
stateOrProvinceName     = match
organizationName        = supplied
organizationalUnitName  = optional
commonName              = supplied
emailAddress            = optional

Une sous-section pour définir les extensions des certificats générés :

[ usr_cert ]
# Le certificat ne peut pas servir d'autorité 
basicConstraints=CA:FALSE

# Usage autorisé du certificat (selon Netscape)
# client, server, email, objsign, reserved, sslCA, emailCA, objCA
nsCertType                    = client, email

# Usage autorisé du certificat (selon PKIX)
# digitalSignature, nonRepudiation, keyEncipherment, dataEncipherment, keyAgreement, keyCertSign, cRLSign, encipherOnly, decipherOnly
keyUsage = digitalSignature

# Commentaire inclu dans le certificat
nsComment                       = "Certificate from Peck"

# Génération automatique de l'identifiant du certificat
subjectKeyIdentifier=hash
# Génération de l'identifiant de la clé de signature
authorityKeyIdentifier=keyid,issuer

# ... 

Il existe une foultitude d'autres extensions, principalement les extensions définies par Netscape et celles définies par PKIX (groupe de travail sur le x509) dans le RFC 5280 (§4.2). PKIX dispose d'une liste d'extensions (id-pe) mais leur documentation doit être recherchée dans les divers documents du groupe de travail.

Ces extensions sont à utiliser lorsque vous avez des besoins spécifiques à une application. Notez qu'une extension peut toujours être préfixée de "critical" qui indique à l'utilisateur du certificat qu'il doit le refuser s'il ne comprend pas le sens de l'extension en question (sinon elle est ignorée). Faites attention, l'usage de critical peut se retourner contre vous.

Une fois la configuration prête, créez votre autorité :

$ mkdir /srv/Authority
$ cd /srv/Authority
$ mkdir newcerts private
$ echo "00" > serial
$ touch index.txt

Placez-y votre certificat d'autorité et sa clé :

$ cp ca.crt /srv/Authority/cacert.pem
$ cp ca.key /srv/Authority/private/cakey.pem

Et voila, votre autorité est prête à être utilisée. Pour exemple, comme d'hab le client crée une demande de certificat :

# Il se débrouille pour générer une requête au bon format avec l'outil qu'il veut
$ openssl req -new

Et vous le signez après en avoir vérifié le contenu et l'auteur :

# Lecture de la demande
$ openssl req -in client.csr -text
#Signature de la demande
$ openssl ca -config openssl.cnf -in client.csr

Et le certificat signé à renvoyer au client est dans le répertoire newcerts sous le nom <serial>.pem

Vous verrez que des sauvegardes de fichier sont conservées pour permettre d'annuler la dernière opération.

PKI

mar 26

Niveau : Star Star Star Empty Empty
Résumé : PKI ; IGC

Une PKI (Public Key Infrastructure), en français IGC (Infrastructure de Gestion des Clés) est un système permettant de gérer des clés publiques. Il s'agit en général de gérer des certificats x509. Elle établit un réseau de confiance entre utilisateurs, lequel passe nécessairement par l'autorité de certification.

Ces certificats peuvent servir selon leur contenu à :

Disposer d'une PKI signifie qu'on est capable de créer, pour chacun de ses utilisateurs, des certificats qui nous permettront par la suite de lui faire confiance. Pour cela une PKI offre plusieurs services :

  • Un service d'enregistrement qui vérifie l'identité des "utilisateurs"
  • Un service de signature de demande de certificats
  • Un service de renouvellement de certificats
  • Un service de publication des certificats
  • Un service de révocation des certificats
  • Un service de publication des révocations
  • Parfois un service de création de clés

Ces fonctionnalités sont généralement regroupées dans des entités séparées pour des raisons de sécurité. En effet, une PKI une fois en place devient rapidement un élément critique puisqu'elle permet de se faire passer pour une entité digne de confiance (pensez social engineering mais sans le social) . C'est pourquoi un certain nombre de fonctionnalités peuvent être installés dans un équipement dédié (un HSM, hardware security module). Du coté utilisateur, on peut faire pareil, sauf qu'on appel cet appareil dédié une carte à puce.

Mettre en place une PKI est une chose assez lourde. Mais elle devient intéressante à partir du moment où on se retrouve à gérer un grand nombre de certificats (beaucoup de serveurs ou beaucoup d'utilisateurs). Vous n'avez pas envie d'installer une PKI pour vous authentifier sur un seul serveur. Mais si vous avez 200 000 employés et que vous voulez que tout le monde signe ses mail en x509, il est temps d'en installer une.

Je voudrais attirer votre attention sur le fait qu'il ne s'agit pas seulement de créer des certificats et de les signer. La confiance se fait sur toute une chaîne, et il faut pouvoir garantir que l'autorité n'a pas été compromise (AC séparée). Il faut pouvoir garantir cette confiance dans le temps (renouvellement), il faut pouvoir se prémunir des erreurs, des vols ou des changements d'organisation (révocation). C'est pourquoi il est nécessaire de prendre son temps avant de l'installer pour bien comprendre le fonctionnement de chaque élément.

Il existe plusieurs PKI open source dont EJBCA ou NewPKI. Je parlerai d'OpenSSL, la PKI du pauvre, dans mes prochains articles. Principalement pour pouvoir mettre les mains dans le cambouis, ne pensez pas à l'utiliser tel quel comme PKI.

Deux ans !

mar 23

C'est la fête, ce site a deux ans passés ! J'en profite pour m'autocongratuler, des articles réguliers et un rythme presque soutenu !

Et pour fêter ça je vous propose de tout relire. Ceux qui sont arrivés en cours de route n'ont forcément pas tout lu. Et comme ça fait un bon paquet d'articles, je vous propose de les lire progressivement. Je ferai de même, je les relirai progressivement pour relever les fautes qui restent nécessairement, voire intégrerai les commentaires pertinents dans l'article..

C'est pourquoi j'ai fait une home page rétro (pas pour le look, mais pour le contenu). Elle s'appelle home2ans et contient tous les articles d'il y a 2 ans. Vous pourrez donc tout relire sans devoir passer tout le site d'un coup. Devinez-quoi ! Il y a un même un flux des articles datant de 720 jours exactement, disponible en RSS ou en Atom.

Pour ceux qui les ont déjà lus, n'hésitez pas à relire, il y a probablement des articles que vous avez oubliés, des astuces que vous auriez voulu mettre en place mais que vous n'avez pas eu le temps. Prenez donc votre temps et retournez dans un passé pas si lointain.

Enfin, quelques stats pour les curieux :

  • presque 300 articles
  • environ 300 visiteurs par jour
  • environ un article tous les 2.5 jours
  • 67% d'utilisateurs de firefox
  • 13% d'utilisateurs d'IE (dont presque 40% d'ie6 bouh)
  • et merci aux nombreux commentateurs

Rendez-vous dans deux ans, en espérant être toujours aussi productif !

Niveau : Star Star Empty Empty Empty
Résumé : shutdown -[fF] ; /forcefsck ; /fastboot ; shift-g ; sudo !! ; VAR=""""

Désolé pour le peu d'articles poussés, j'ai manqué un peu de temps récemment.

Forcer le fsck au prochain boot (explication dans /etc/init.d/checkfs)

$ touch /forcefsck
# ou
$ shutdown -F

Empecher le fsck au prochain boot (explication dans /etc/init.d/checkfs)

$ touch /fastboot
# ou
$ shutdown -f

Mettre des retours à la ligne dans une variable bash :

$ VAR=$'ligne1\nligne2'
$ echo "$VAR"

Concaténer 2 chaines en bash (attention, pas d'espaces) :

$ VAR="chaine1""chaine2"$CHAINE3'chaine4'
$ echo "$VAR"

Aller à la fin d'un fichier dans less :

shift-g

Relancer la dernière commande mais en root :

$ sudo !!

Niveau : Star Empty Empty Empty Empty
Résumé :

Après les "top of mind" qui prouvent qu'il existe toujours une solution pour vous dans le libre, voici des alternatives. Ces nouveaux choix ne sont pas moins bons, il sont même meilleurs dans biens des cas. Il est juste moins fréquent de les indiquer à un nouveau venu, tout simplement parce qu'il faut bien faire le premier choix pour lui. Mais il ne faut pas oublier que le monde du libre est le monde de la variété, l'utilisateur a toujours la possibilité de choisit une alternative.

Cette liste est là simplement pour donner des idées à tous ceux qui veulent choisir. Pour chaque section, une recherche sur google vous en ressortira bien d'autres.

Serveurs :
Administration :
Clients :
Divers
Et les protocoles:
  • Transfert de fichier : ftp http
  • Serveur de fichier : webdav ssh ocfs smb
  • Réception de mails : pop imap uucp
  • Gestion d'utilisateurs : passwd nis

... liste très loin d'être exhaustive ...

Niveau : Star Empty Empty Empty Empty
Résumé :

Aujourd'hui une petite liste de logiciels à connaître et à conseiller. Attention, s'ils sont là, c'est parce qu'ils sont "top of mind", ils ont les fonctionnalités les plus larges et conviendront au plus grand nombre. C'est pourquoi il est bon de les conseiller à ceux qui ne savent pas quoi choisir. Cela ne veut pas dire qu'il n'existe pas pour autant d'alternatives fiables, voire meilleures.

Avant d'avoir le choix, il faut avoir une base à partir de laquelle choisir, donc on commence par un choix par défaut, puis on adapte en fonction des besoins. Apache est un bon serveur web, mais dans certains cas on préfèrera lighthttpd, ces cas étant plus rares on commence par apache.

Serveurs :
Administration :
Clients :
Divers
Et les protocoles:
  • Transfert de fichier : sftp
  • Serveur de fichier : nfs
  • Réception de mails : imaps
  • Gestion d'utilisateurs : ldap

... liste non exhaustive ...

Niveau : Star Star Star Star Empty
Résumé : SSH et certificats x509

Vous avez une ferme de serveurs ? Vous avez une ferme d'utilisateurs ? Vous avez déjà une infrastructure de gestion de clés pour des certificats x509 (ssl) ?

Si vous répondez oui à deux de ces points alors cet article va vous intéresser.

Sachez qu'il est possible d'utiliser des certificats x509 avec ssh. Quel intérêt ? Tout simplement vous pouvez réutiliser votre PKI si vous en avez déjà une en x509. Ensuite les certificats fonctionnent par un système de signature hiérarchisée, donc il n'est plus nécessaire de mettre en place un système de distribution des clés des utilisateurs sur les machines. Et inversement, les utilisateurs n'auront plus à se reposer sur leur pifomètre pour accepter les clés des serveurs à leur première connexion.

Maintenant qu'on sait qu'on va pouvoir vendre de la sécurité à notre boss tout en évitant de se farcir des systèmes de synchronisation, on va pouvoir se lancer dans les choses sérieuses.

Compilation

Tout d'abord il nous faut une version de ssh qui supporte ce mode de fonctionnement. On la trouvez chez un certain Roumen Petrov. Bon, petite déception, il ne fournit que des patchs. A nous d'en faire un vrai ssh compilé. Pour une fois, ça va être une peu plus difficile pour les debianistes. Pour ceux qui recompilent leur ssh directement :

# à adapter à vos besoins et à votre version
$ wget http://www.roumenpetrov.info/openssh/x509-6.1.1/openssh-5.1p1+x509-6.1.1.diff.gz
$ cd openssh-source
$ zcat ../openssh-5.1p1+x509-6.1.1.diff.gz | patch -p1
$ ./configure
$ make
$ make install

Pour ceux qui sont sur debian, il serait quand même plus sympa de se refaire un paquet. Le problème est que le patch de Roumen Petrov s'applique mal sur des sources debian. Il y a donc 3 rejets à appliquer avant de pouvoir lancer la compilation :

# récupération des sources debian
$ apt-get source openssh
# récupération du patch
$ wget http://www.roumenpetrov.info/openssh/x509-6.1.1/openssh-5.1p1+x509-6.1.1.diff.gz
$ cd openssh-5.1p1
$ zcat ../openssh-5.1p1+x509-6.1.1.diff.gz | patch -p1

# ICI relisez les fichiers .rej et appliquez à la main, c'est assez simple

# recompilation
$ dpkg-buildpackage -rfakeroot -b
# installation
$ cd ..
$ su
$ dpkg -i openssh-client*.deb openssh-server*.deb

Pour ceux qui sont toujours en etch vous pouvez soit upgrader ssh en récupérant le paquet source de lenny soit utiliser la version etch avec une version plus ancienne du patch.

Pour la méthode upgrade avec etch, modifiez le fichier debian/control qui se trouve dans le répertoire source ssh et supprimez les versions de libssl et lsb-base indiquées dans les dépendances avant de compiler. Cela marche très bien.

Pour ceux qui voudraient rester en ssh4.1, appliquez le patch de Roumen Petrov et forcez l'application du patch avec les erreurs. Ensuite listez les fichier .rej (ils sont tous à la racine) et appliquez les à la main (retrouver la bonne ligne, ajouter ...). C'est un peu plus long.

Utilisation

Ça y est le nouveau ssh est installé sur le serveur et sur le client. Maintenant utilisons un certificat pour se connecter au serveur et prouver que ça marche.

Tout d'abord il nous faut une autorité de certification, c'est à dire un certificat qui a le droit de signer d'autres certificats et que nous installerons partout (l'article explique comment la créer et l'utiliser). Avec cette autorité, il faut générer deux paires de clés : une paire pour le serveur, une paire pour le client. Rien n'oblige à avoir la même autorité pour les deux, mais cela simplifie les exemples, c'est donc ce que je vais faire.

On a donc :

  • ca.crt : le certificat de l'autorité
  • server.crt et server.key : le certificat et la clé à utiliser sur le serveur ssh
  • client.crt et client.key : le certificat et la clé à utiliser sur le client ssh

Authentification du serveur

Commençons par configurer l'authentification du serveur par le client. Le client sera sûr que le serveur est reconnue par une autorité.

Côté serveur

Installons le certificat sur le serveur ssh. On place la clé dans un nouveau fichier pour le serveur :

$ cat server.key server.crt > /etc/ssh/ssh_host_x509_key
$ chmod 600 /etc/ssh/ssh_host_x509_key
# mise à jour de la clé publique pour la forme
$ ssh-keygen -y -f /etc/ssh/ssh_host_x509_key > /etc/ssh/ssh_host_x509_key.pub

Et on ajoute cette clé à celle que le serveur envoie au client pour authentification en ajoutant une ligne/etc/ssh/sshd_config :

HostKey /etc/ssh/ssh_host_x509_key

Vous pouvez même commenter les anciennes lignes HostKey si vous voulez forcer l'utilisation de x509, mais je ne pense pas que ce soit judicieux (par contre ça permet d'être sur de ce qu'on teste). Et hop on relance le serveur.

# n'ayez pas peur cela ne coupe pas les connexions existantes
$ /etc/init.d/ssh restart

Côté client

Maintenant il faut que le client accepte cette clé. On va lui dire qu'il peut accepter tout ce qui a été signé par notre autorité. Pour cela, il suffit de copier le certificat de l'autorité dans /etc/ssh/ca/ca-bundle.crt (vous pouvez mettre toutes les autorités que vous voulez dans ce fichier) :

$ cp ca.crt /etc/ssh/ca/ca-bundle.crt

Attention : ssh vérifie que le certificat est bien signé par une autorité valide mais cela ne veut pas dire qu'il accepte directement la clé. Il passe toujours par une vérification utilisateur comme expliqué dans un autre article. Attention : ssh refuse les clés mal signées mais autorise les clés sans certificat. A l'utilisateur d'accepter ou refuser la clé. Attention : ssh vérifie la chaine de certification, mais ne vérifie pas que le cn correspond au nom du serveur.

A noter qu'il est dommage que la vérification de la chaine de certification se fasse après l'acceptation par le client.

Authentification du client

Cette fois c'est le serveur qui va vérifier que le client dispose d'un certificat vérifié par une autorité.

Côté client

Pour utiliser notre certificat comme identité, on le copie sur le client :

$ cat client.key client.crt > ~/.ssh/id_x509
$ chmod 600 ~/.ssh/id_x509
# on met a jour la clé publique
$ ssh-keygen -y -f ~/.ssh/id_x509 > ~/.ssh/id_x509.pub

Et on configure le client pour qu'il l'utilise (au choix dans /etc/ssh/ssh_config ou dans ~/.ssh/config) :

Host *
        IdentityFile ~/.ssh/id_x509

Côté serveur

Maintenant il faut que le serveur accepte cette clé. On va lui dire qu'il peut accepter tout ce qui a été signé par notre autorité. Pour cela, il suffit de copier le certificat de l'autorité dans /etc/ssh/ca/ca-bundle.crt (vous pouvez mettre toutes les autorités que vous voulez dans ce fichier) :

$ cp ca.crt /etc/ssh/ca/ca-bundle.crt

Et on adapte l'authorized_keys sur le serveur. Pour cela deux solutions, la première est de copier tel quel le fichier id_x509.pub généré précédemment. Ça marche, mais ce n'est pas très intéressant. Puisqu'on a des certificats qui sont vérifiés autant en profiter et ne donner que le DN ce qui nous permettra de le changer.

# on réutilise le certificat pour sortir le dn au bon format
$ openssl x509 -noout -subject -in client.crt -nameopt RFC2253 >> ~/.ssh/authorized_keys

Attention : ssh refuse les clés mal signées mais autorise les clés sans certificat. A l'utilisateur de remplir son authorized_keys correctement

Conclusion

Cet article commence à être long, je vais donc m'arrêter ici. Vous voyez qu'il est possible de mettre en place des certificats pour ssh sans trop se forcer. Le patch de Roumen Petrov est bien fait puisqu'il ajoute beaucoup d'options (je les ai laissé ici à leur valeur par défaut pour simplifier l'article) et surtout, elles sont toutes documentées dans les pages de manuel. De plus le support de x509 est étendu à tous les outils ssh, c'est à dire le client, le serveur, mais aussi ssh-keygen et ssh-agent. En dehors du man, la meilleure documentation c'est le README.

Tout cela est bien pratique mais seul un usage basique a été couvert ici. Un des gros avantages de l'utilisation des certificats est de pouvoir gérer des listes de révocation pour interdire automatiquement des certificat qui ne sont plus valides (l'utilisateur est parti, la clé est trop vieille ...). Nous en parlerons surement dans un prochain article.