sécurité

Hadoop, doop, doop, doop…

par guiguiabloc le 12 nov., 2009, sous architecture, linux, sécurité

Un billet qui propose même une version musicale : http://www.youtube.com/watch?v=LUm19zKdASY

Bon ok , je sors…

Vous me direz, j’aurais pu faire pire et vous proposer une nouvelle version de “Oh chéri, chéri” de Karen Cheryl (désolé Fred… )

Pour être franc avec vous, j’ai longuement hésité avant de me lancer dans l’écriture de ce billet.

Le sujet est tellement vaste et les possibilités d’utilisation si nombreuses qu’il m’aurait fallu des pages et des pages pour en faire le tour (en plus je suis certain d’avoir un retour amusé de certaines personnes de mon entourage sur ce billet :-D)

Mais après tout, pourquoi pas ? Donc je vais l’aborder sans plonger dans les détails mais suffisamment, je pense, pour pouvoir vous amuser (c’est bien le but, non ? )

Hadoop, quoi que c’est ?

Pour citer Wikipédia :

“Hadoop est un framework java libre destiné aux applications distribués et à la gestion intensive des données. Il permet aux applications de travailler avec des milliers de nœuds et des pétaoctets de données. Hadoop a été inspiré par les publications MapReduce, GoogleFS et BigTable de Google.”

Parmi les éléments composant Hadoop, nous allons retrouver principalement:

- HDFS (Hadoop Distributed File System), le système de fichiers distribués

- MAPREDUCE , un framework pour les calculs parallèles et distribués

- HBASE , la base de données distribuées

- ZOOKEEPER , un service de centralisation pour coordonner les systèmes distribués

- PIG , plateforme pour l’analyse d’un grand nombre de données

Vous l’avez compris, Hadoop sert principalement au traitement de gros volumes de données.

A cet effet, je vous invite à regarder la vidéo d’Olivier Grisel lors de sa présentation d’Hadoop et MapReduce a l’Open Source Developers Conference 2009 (vous retrouverez cette présentation ICI ).

Vous me direz “Oui mais bon, en quoi ça me concerne moi ???”.

Tsss, petit scarabée, il n’y a pas si longtemps, dans une galaxie lointaine, vous stockiez l’intégralité de vos photos de vacances de votre vie sur un disque de 10 Go….

Aujourd’hui où le moindre APN bas de gamme prend une photo de 5 Mo, je vous laisse imaginer la volumétrie nécessaire pour stocker l’intégralité de vos clichés de vacances avec Tata Simone et surtout la cousine Juliette…

Bref, vous l’avez compris, la capacité des disques augmentent mais les vitesses de transfert, elles ne suivent pas.

En 1990, sur un disque de 1,4Go, avec un taux de transfert de 4,4 Mo/s, il vous fallait environ 5 minutes pour le lire entièrement. De nos jours, pour un disque d’1To, avec un taux de transfert de 100 Mo/sec, il vous faut presque 2h30 pour la même opération…

Diviser ces données sur 100 disques et, par cette lecture parallèle, toutes les données peuvent être lues en moins de 2 minutes.

Ceux qui utilisent le système RAID doivent comprendre

Pour de plus amples détails, je vous invite a parcourir le Wiki Hadoop ou vous plonger dans l’excellent “Hadoop, The definitive Guide” chez O’Reilly .

Pour bien comprendre le fonctionnement d’Hadoop, comme toujours, un joli dessin pour tenter de conceptualiser le bouzin.

Il faut discerner tout d’abord la partie HDFS qui est le système de fichier distribué d’Hadoop, composé d’un serveur maître, le NameNode et de serveurs détenant les données proprement dites, les Datanodes.

Quand une application cliente a besoin d’accéder a une information, elle interroge le NameNode qui lui indique les Datanodes sur lesquels se trouve ces informations. Une fois en possession de cette liste, l’application cliente va directement interroger le(s) Datanodes.

Dans une architecture HDFS, un fichier est découpé en un ou plusieurs blocs et réparti sur les datanodes du cluster. De plus, chaque bloc est répliqué suivant le facteur de réplication que vous avez spécifié dans votre configuration.

Je ne vais pas vous expliquer en détails la façon dont est architecturé HDFS, je vous invite à lire cette page pour bien comprendre la structure :

http://hadoop.apache.org/common/docs/current/hdfs_design.html

Ensuite, par dessus HDFS, nous avons la partie moteur MAP/REDUCE avec un JobTracker, genre de centralisateur de tâches, et des TaskTracker qui se chargent d’executer les travaux demandés.

Le Client soumet la requète de travail au JobTracker qui va les transmettre au(x) TaskTracker concerné(s) en s’efforcant d’être au plus proche de la donnée.

Concernant MapReduce, son rôle consiste à diviser le traitement en 2 étapes :

la première phase (Map) est une étape d’ingestion et de transformation des données sous la forme de paires clé/valeur
la seconde phase (Reduce) est une étape de fusion des enregistrements par clé pour former le résultat final

Source : InternetCollaboratif
, sinon je vous invite à vous rendre sur cette page de Wikipédia qui vous donnera un peu plus d’explication sur son fonctionnement (inutile que je vous raconte la même chose )

Sachez enfin qu’Hadoop est utilisé chez Yahoo!, Facebook, le New York Times, Last.fm etc… Bref, déjà bien éprouvé en production…

Bien, trêve de bavardage, attaquons nous a tout cela.

La société Cloudera propose sur son site une installation automatisée d’Hadoop, permettant de monter son cluster Hadoop en trois clics et configurable à souhait.

Excellente initiative qui mérite d’être saluée.

Mais bon, nous, on n’a pas peur, on est même plutôt “couillu” donc on va se la faire en mode installation a la mimine.

Pré-requis :

- Un JAVA 1.6 sur les serveurs : http://java.sun.com/javase/downloads/index.jsp

- Un utilisateur “hadoop” par exemple

- une paire de clés ssh privé/publique pour cet utilisateur afin de contrôler les noeuds du cluster

Téléchargez les sources sur : http://hadoop.apache.org/core/releases.html

tar xzvf hadoop-0.20.1.tar.gz
 
chown -R hadoop:hadoop hadoop-0.20.1
su - hadoop
ssh-keygen -t dsa -P '' -f ~/.ssh/id_dsa
ssh localhost (et sur les autres noeuds également)

Il existe 3 modes d’installation d’Hadoop :

Mode StandAlone (local)
Mode Pseudo-Distributed(chaque démon Hadoop est lancé dans un process Java indépendant)
Mode Fully-Distributed (Cluster)

Bien évidemment, nous, même pas peur, on va se faire l’installation “Cluster”.

Pour ce billet, je vais partir sur un cluster de 4 machines comme décris dans le schéma plus haut.

Pour faciliter les tests, le NameNode sera également DataNode.

Un petit dessin reprenant le nom des machines et leurs rôles pour la suite :

Les fichiers de configurations se trouve dans.. conf.

Voici les principaux :

hadoop-env.sh         Variables d’environment utilisées par Hadoop
core-site.xml    Configuration principal (comme les paramètres I/O pour HDFS et MapReduce
hdfs-site.xml            Configuration des démons HDFS
mapred-site.xml      Configuration pour le démon MapReduce (jobtracker et les tasktrackers)
masters                   Liste des machines qui sont NameNode secondaire
slaves                      Liste des machines qui sont datanodes et tasktracker
Vous n’avez pas à spécifier le NameNode et le JobTracker dans le fichier “masters”.

Pour la partie HDFS, c’est en lançant le script start-dfs.sh sur la machine qu’elle va être désignée NameNode et executer le démarrage des datanodes listées dans le fichier “slaves”.

Idem pour la partie MapReduce et le script stop-mapred.sh.

Le premier a modifier est celui de l’environnement, puis le core-site.xml et le hdfs-site.xml pour la partie HDFS, enfin le maprep.xml pour la partie Mapreduce.

hadoop-env.sh

export JAVA_HOME=/opt/jdk1.6.0_16
 
# Taille mémoire allouée à chaque démon (ici 2Go)
 
export HADOOP_HEAPSIZE=2000
 
export HADOOP_LOG_DIR=/tmp

Il existe d’autres options que vous pouvez affiner.

core-site.xml

On définit l’URI du NameNode

 
fs.default.name
hdfs://guiguiabloc-namenode/

hdfs-site.xml (HDFS)

 
<!--  ici le chemin local du filesystem où le NameNode stocke ses données -->
dfs.name.dir
/data/hdfs
 
<!--  ici le chemin local du filesystem où le DataNode stocke ses données -->
dfs.data.dir
/data/hdfs2

mapred-site.xml (MAPREDUCE)

Ici on spécifie le répertoire local qui servira a MapReduce pour écrire ses données temporaires.

Puis le répertoire système proprement dit (dans le filesystem HDFS)

 
mapred.job.tracker
guiguiabloc-jobtracker:8021
 
mapred.local.dir
/opt/mapred
 
mapred.system.dir
/hdfs/mapred/system
 
mapred.tasktracker.map.tasks.maximum
4

slaves

Ici nous spécifions tout les noeuds datanodes/tasktrackers

guiguiabloc-namenode
guiguiabloc-datanode-a
guiguiabloc-datanode-b

Commencons les joyeusetés :

On “formate” notre HDFS (sur guiguiabloc-namenode)

guiguiabloc-namenode:~$ bin/hadoop namenode -format
09/11/12 14:38:31 INFO namenode.NameNode: STARTUP_MSG:
/************************************************************
STARTUP_MSG: Starting NameNode
STARTUP_MSG:   host = guiguiabloc-namenode/127.0.1.1
STARTUP_MSG:   args = [-format]
STARTUP_MSG:   version = 0.20.1
STARTUP_MSG:   build = http://svn.apache.org/repos/asf/hadoop/common/tags/release-0.20.1-rc1 -r 810220; compiled by 'oom' on Tue Sep  1 20:55:56 UTC 2009
************************************************************/
Re-format filesystem in /data/hdfs ? (Y or N) Y
09/11/12 14:38:33 INFO namenode.FSNamesystem: fsOwner=hadoop,hadoop
09/11/12 14:38:33 INFO namenode.FSNamesystem: supergroup=supergroup
09/11/12 14:38:33 INFO namenode.FSNamesystem: isPermissionEnabled=true
09/11/12 14:38:33 INFO common.Storage: Image file of size 96 saved in 0 seconds.
09/11/12 14:38:34 INFO common.Storage: Storage directory /data/hdfs has been successfully formatted.
09/11/12 14:38:34 INFO namenode.NameNode: SHUTDOWN_MSG:
/************************************************************
SHUTDOWN_MSG: Shutting down NameNode at guiguiabloc-namenode/127.0.1.1
************************************************************/

Puis on démarre le Namenode (qui se chargera de démarrer les datanodes)

$ bin/start-dfs.sh
starting namenode, logging to /tmp/hadoop-hadoop-namenode-guiguiabloc-namenode.out
guiguiabloc-namenode: starting datanode, logging to /tmp/hadoop-hadoop-datanode-guiguiabloc-namenode.out
guiguiabloc-datanode-b: starting datanode, logging to /tmp/hadoop-hadoop-datanode-guiguiabloc-datanode-b.out
guiguiabloc-datanode-a: starting datanode, logging to /tmp/hadoop-hadoop-datanode-guiguiabloc-datanode-a.out
localhost: starting secondarynamenode, logging to /tmp/hadoop-hadoop-secondarynamenode-guiguiabloc-namenode.out

Si tout se déroule correctement, vous devriez voir les noeuds esclaves démarrés :

2009-11-12 16:14:38,974 INFO org.apache.hadoop.hdfs.server.datanode.DataNode: STARTUP_MSG:
/************************************************************
STARTUP_MSG: Starting DataNode
STARTUP_MSG:   host = guiguiabloc-datanode-a/91.xx.xx.xx
STARTUP_MSG:   args = []
STARTUP_MSG:   version = 0.20.1
STARTUP_MSG:   build = http://svn.apache.org/repos/asf/hadoop/common/tags/release-0.20.1-rc1 -r 810220; compiled by 'oom' on Tue Sep  1 20:55:56 UTC 2009
************************************************************/
2009-11-12 16:14:39,297 INFO org.apache.hadoop.hdfs.server.common.Storage: Storage directory /data/hdfs is not formatted.
2009-11-12 16:14:39,297 INFO org.apache.hadoop.hdfs.server.common.Storage: Formatting ...
2009-11-12 16:14:40,062 INFO org.apache.hadoop.hdfs.server.datanode.DataNode: Registered FSDatasetStatusMBean
2009-11-12 16:14:40,065 INFO org.apache.hadoop.hdfs.server.datanode.DataNode: Opened info server at 50010
2009-11-12 16:14:40,068 INFO org.apache.hadoop.hdfs.server.datanode.DataNode: Balancing bandwith is 1048576 bytes/s
...

Il ne vous reste qu’a vous connecter sur l’interface http://guiguiabloc-namenode:50070 pour voir l’état de votrte cluster

Maintenant démarrons la partie MapReduce.

hadoop@guiguiabloc-jobtracker:~$ bin/start-mapred.sh
starting jobtracker, logging to /tmp/hadoop-hadoop-jobtracker-guiguiabloc-jobtracker.out
guiguiabloc-namenode: starting tasktracker, logging to /tmp/hadoop-hadoop-tasktracker-guiguiabloc-namenode.out
guiguiabloc-datanode-a: starting tasktracker, logging to /tmp/hadoop-hadoop-tasktracker-guiguiabloc-datanode-a.out
guiguiabloc-datanode-b: starting tasktracker, logging to /tmp/hadoop-hadoop-tasktracker-guiguiabloc-datanode-b.out

Idem les noeuds tasktracker démarrent également :

2009-11-12 16:58:09,822 INFO org.apache.hadoop.mapred.TaskTracker: STARTUP_MSG:
/************************************************************
STARTUP_MSG: Starting TaskTracker
STARTUP_MSG:   host = guiguiabloc-datanode-b/91.xx.xx.xx
STARTUP_MSG:   args = []
STARTUP_MSG:   version = 0.20.1
STARTUP_MSG:   build = http://svn.apache.org/repos/asf/hadoop/common/tags/release-0.20.1-rc1 -r 810220; compiled by 'oom' on Tue Sep  1 20:55:56 UTC 2009
************************************************************/
...
2009-11-12 16:58:47,185 INFO org.apache.hadoop.ipc.Server: IPC Server handler 6 on 43676: starting
2009-11-12 16:58:47,185 INFO org.apache.hadoop.mapred.TaskTracker: TaskTracker up at: localhost/127.0.0.1:43676
2009-11-12 16:58:47,186 INFO org.apache.hadoop.mapred.TaskTracker: Starting tracker tracker_guiguiabloc-datanode-b:localhost/127.0.0.1:43676
2009-11-12 16:58:47,230 INFO org.apache.hadoop.ipc.Server: IPC Server handler 7 on 43676: starting
2009-11-12 16:58:47,238 INFO org.apache.hadoop.mapred.TaskTracker:  Using MemoryCalculatorPlugin : org.apache.hadoop.util.LinuxMemoryCalculatorPlugin@1af33d6
2009-11-12 16:58:47,241 WARN org.apache.hadoop.mapred.TaskTracker: TaskTracker's totalMemoryAllottedForTasks is -1. TaskMemoryManager is disabled.
2009-11-12 16:58:47,242 INFO org.apache.hadoop.mapred.IndexCache: IndexCache created with max memory = 10485760
2009-11-12 16:58:47,243 INFO org.apache.hadoop.mapred.TaskTracker: Starting thread: Map-events fetcher for all reduce tasks on tracker_guiguiabloc-datanode-b:localhost/127.0.0.1:43676

Vous pouvez vérifier l’état de l’ensemble en vous connectant sur http://guiguiabloc-jobtracker:50030

Une fois tout bien démarrer, il ne vous reste qu’a créer les accès pour les utilisateurs :

$ bin/hadoop fs -mkdir /user/username
$ bin/hadoop fs -chown username:username /user/username

Pour appliquer un quota d’ 1To a un user par exemple :

$ bin/hadoop dfsadmin -setSpaceQuota 1t /user/username

Des outils de Benchmark sont fournis avec, vous permettant de tester votre cluster :

Par exemple pour tester l’écriture de 10 fichiers de 1G

$ bin/hadoop jar /opt/hadoop/hadoop-0.20.1-test.jar TestDFSIO -write -nrFiles 10 -filesize 1000

Idem pour les Mapreduces

$ bin/hadoop jar /opt/hadoop/hadoop-0.20.1-examples.jar randomwriter random-data
$ bin/hadoop jar /opt/hadoop/hadoop-0.20.1-examples.jar sort random-data sorted-data
Running on 3 nodes to sort from hdfs://guiguiabloc-namenode/user/hadoop/random-data into hdfs://guiguiabloc-namenode/user/hadoop/sorted-data with 5 reduces.
Job started: Thu Nov 12 16:47:41 CET 2009

Dans votre interface d’administration, les Jobs s’afficheront avec le résultat.

Vous voilà désormais à la tête d’un joli cluster Hadoop qu’il est grand temps de mettre à contribution.

Je vous invite a lire les nombreux tuto qui existent sur le site d’Hadoop (http://hadoop.apache.org/common/docs/current/mapred_tutorial.html par exemple).

Voila pour cette première approche d’Hadoop, en espérant que cela à titiller votre envie d’en savoir plus sur cette architecture.

Bien évidemment, je n’ai fait qu’approcher le sujet, j’y reviendrais peut-être dans d’autres billets maitenant que notre architecture Hadoop est en place afin de vous montrer la formidable puissance de cet environnement.

Amusez-vous bien

3 Commentaires :hadoop, hdfs, mapreduce suite...

Scans web, engluer les requètes automatisées

par guiguiabloc le 16 juil., 2009, sous linux, sécurité

Aujourd’hui un petit billet pour s’amuser un peu avec les scripts kiddies.

Si vous hébergez votre propre serveur web, vous avez sûrement remarqué l’accès indésirable à votre serveur http par des requêtes plus ou moins automatisées dans le but de découvrir une faille potentielle.

Dans le genre :

[Sun Jul 12 06:26:57 2009] [error] [client 1.2.3.4] File does not
exist: /var/www/phpmyadmin
[Sun Jul 12 06:26:58 2009] [error] [client 1.2.3.4] File does not
exist: /var/www/phpMyAdmin

Bien entendu, en bon admin que vous êtes, vous avez greffé ModSecurity sur votre Apache préféré, ce qui limite grandement la casse et renvoi le petit merdeux bonhomme dans sa chaumière avec un joli code 400 :

[Wed Jul 15 19:30:36 2009] [error] [client 87.229.108.30] ModSecurity: Warning. Operator EQ match: 0. [id "960009"] [msg "Request Missing a User Agent Header"] [severity "WARNING"] [hostname "1.2.3.4"] [uri "/phpMyAdmin/main.php"] [unique_id "6cDOIV4XBY0AABEgIhMAAAAD"]
[Wed Jul 15 19:30:36 2009] [error] [client 87.229.108.30] ModSecurity: Access denied with code 400 (phase 2). Pattern match "^[\\\\d\\\\.]+$" at REQUEST_HEADERS:Host. [id "960017"] [msg "Host header is a numeric IP address"] [severity "CRITICAL"] [hostname "1.2.3.4"] [uri "/phpMyAdmin/main.php"] [unique_id "6cDOIV4XBY0AABEgIhMAAAAD"]

Et bien sûr couplé également à un fail2ban ou un ossec dans les règles :

/var/ossec/active-response/ossec-hids-responses.log
Wed Jul 15 19:30:36 CET 2009
/var/ossec/active-response/bin/firewall-drop.sh add - 87.229.108.30

Pan, gant Mapa, gravier et bonjour chez toi…

C’est bien mais moi, qu’on vienne m’embêter, je n’aime pas ça et sadique comme je sais l’être, je suis assez fervent de rendre la monnaie de leur pièces a ces “cliqueurs-de-truc-ki-marche-tout-seul-pour-hack”

Donc j’ai chercher un moyen de m’amuser avec eux et surtout, ce qui est le pire pour un spammeur/script-kiddies, leur faire perdre du temps.

Cette technique d’engluage, appelée aussi “sticky honeypot”, est déjà utilisée pour ralentir les vers, bots, etc… grâce à l’excellent LaBrea.

Ce programme est ce que l’on appele un “tarpit“. Un service réseau dont le seul but est de ralentir la connexion a ce service aussi longtemps que possible.

En effet, un spammeur pour qui l’envoi de masse et la rapidité sont primordiaux, si le serveur de mail en face met 10 secondes a lui répondre au lieu de 1 seconde, vous comprendrez qu’il a de quoi enrager…

Bref, je vous invite à lire les différents articles sur les liens données ci-dessus si vous voulez jouer avec cette technique (il y a même un patch Tarpit pour iptables )

ModSecurity, la solution qui va bien

Je cherchais une solution plutôt simple et rapide à mettre en oeuvre (après tout, ce n’est qu’un Proof of Concept ), et utilisant déjà ModSecurity, il devait exister un moyen de combiner tout cela.

Après avoir fouillé la documentation et effectué quelques recherches sur le Nain Ternet, j’ai découvert une option magique de ModSecurity : “pause”.

Avant toutes choses, je vous invite fortement à utiliser l’excellentissime ModSecurity sur vos serveurs Apache. Vous trouverez de très bons articles et documentation sur le site de Breach (l’éditeur de ModSecurity, chez HSC, ou le tuto de Lindev.

Pour résumer, ModSecurity est un filtre qui va intercepter les requêtes adressées à votre serveur Apache et vérifier dans une liste de règles pré-définies ou écrites par vous si elles correspondent et réagir en conséquence.

Contre les injections SQL, les attaques transversales ou tout les petits trucs joyeux du monde web, c’est quand même ce qu’il se fait de mieux.

Bref, Modsecurity permet de définir ses propres “SecRule” et c’est cela que nous allons utiliser pour retarder les requètes.

Je considère que votre module ModSecurity est actif et fonctionnel.

Basons nous sur les scans “RoundCube” qui tourne actuellement suite à des failles de sécurité découvertes dans le Webmail (http://isc.sans.org/diary.html?storyid=5659).

J’utiliserais le fichier ./modsecurity.d/modsecurity_crs_15_custom_rules.conf pour intégrer mes règles :

SecRule REQUEST_URI "/roundcube" "pause:30000,log,status:400,deny"
SecRule REQUEST_URI "/roundcubemail" "pause:30000,log,status:400,deny"
SecRule REQUEST_URI "/roundcubemail-0.1" "pause:30000,log,status:400,deny"
SecRule REQUEST_URI "/roundcubemail-0.2" "pause:30000,log,status:400,deny"
SecRule REQUEST_URI "/roundcube-0.1" "pause:30000,log,status:400,deny"
SecRule REQUEST_URI "/roundcube-0.2" "pause:30000,log,status:400,deny"
SecRule REQUEST_URI "/round" "pause:30000,log,status:400,deny"

Petite explication.

- Je définis une règle de sécurité par le champ “SecRule”

- Je demande a ModSecurity de vérifier les requêtes qui contiennent le chemin /round, /roundcube, etc..

- Si la règle match, on attend 30000 millisecondes, on log, on sort une erreur 400 et un accès refusé.

Ne reste plus qu’a tester :-D :

guiguiabloc@bofh:~$ wget -E -H -k -K -p http://monserveur.net/round
--15:05:54--  http://monserveur.net/round
=&gt; `monserveur.net/round'
Résolution de monserveur.net... 12.34.56.67
Connexion vers monserveur.net|12.34.56.67|:80...connecté.
requête HTTP transmise, en attente de la réponse...400 Bad Request
15:06:25 ERREUR 400: Bad Request.
 
Terminé --15:06:25--
Téléchargement: 0 octets dans 0 fichiers

Ah Ah Ah ! Je me gausse

Ou comment faire perdre du temps aux scanners web…

Je sais, ce n’est qu’une goutte d’eau dans le vase immense du Nain Ternet mais c’est fichtrement amusant…

Amusez vous bien

PS : Ce billet me permet en même temps de remercier les colles Cleopatre pour toutes ses années d’école passées a les renifler :-p

1 Commentaire :apache, modsecurity, tarpit suite...

Authentification par mot de passe jetable avec RADIUS et MOTP

par guiguiabloc le 21 avr., 2009, sous OpenBSD, linux, sécurité

En juillet de l’année dernière, j’avais écrit un billet sur l’authentification système par jeton tournant.

Je vous propose aujourd’hui de mettre en place une autre technique, l’authentification sur un serveur RADIUS par mot de passe unique, mot de passe généré sur votre téléphone portable.

Le principe reste assez simple. Pour vous identifier sur votre site web/équipement réseau/connexion wifi (etc, etc, la liste n’est pas exhaustive, du moment que l’authentification se base sur un serveur RADIUS), vous devrez saisir un code PIN sur votre téléphone, qui en retour vous générera un mot de passe, valable 1 seule fois et durant quelques minutes seulement.

Sympa comme moyen d’authentification (qui a dit “la frime” ?)

Pour mettre en œuvre cette solution, nous allons nous utiliser deux produits :

FREERADIUS

Pour le serveur RADIUS

MOTP

Pour le système d’authentification unique

RADIUS est un protocole client/serveur permettant de centraliser des données d’authentification.

Je vous invite à lire cette page :

http://fr.wikipedia.org/wiki/RADIUS_(informatique)

Vous l’utilisez tous les jours sans vous en rendre compte, tout simplement par votre accès au Nain Ternet de votre Fournisseur d’accès qui vous authentifie sur ses serveurs RADIUS avant de vous donner accès (ou pas) au réseau informatique mondial.

Bien sûr, tout cela est transparent pour vous, la plupart du temps, c’est votre box adsl qui négocie avec le RADIUS votre authentification.

(Pour les puristes, oui je résume énormément , si en plus on rajoute des proxy radius sur les BAS, on va y passer la nuit :-p )

Bref, pour résumer simplement, un serveur RADIUS sert à 3 choses :

L’authentification

Qui es-tu ?

L’autorisation

A quoi tu as le droit ?

L’accounting (ou traçabilité)

Combien tu consommes et qu’est ce que tu utilises ?

C’est le fameux AAA que vous avez déjà peut-être croisé au fil de vos pérégrinations informatiques.

Maintenant que nous avons survolé le but de ce billet, mettons-nous à la tâche :

Installation et configuration de FreeRadius

Que vous soyez sous Linux ou *BSD, FreeRadius est disponible.

L’installation reste des plus triviales, a coup de pkg_add, apt-get install, yum install ou compilation directe depuis les sources sur le site web :

http://freeradius.org/download.htm l

Je me baserais sur la version 2.x de Freeradius, si vous êtes encore en version 1.x, il serait peut être temps de migrer…

Je ne m’attarderais pas sur son installation, il existe un excellent tutoriel de Thuso, ici :

http://www.pervasive-network.org/SPIP/Installation-de-freeradius-2-4

Passons à la phase MOTP proprement dite :

Téléchargement et installation du script et du dictionnaire MOTP :

serveur:# cd /etc/raddb
serveur:/etc/raddb# wget http://motp.sourceforge.net/otpverify.sh
serveur:/etc/raddb# chmod +x otpverify.sh
 
serveur:/etc/raddb# wget http://motp.sourceforge.net/dictionary.motp
 
Modification du fichier /etc/raddb/dictionary
 
serveur:/etc/raddb#  cat /etc/raddb/dictionary
#
#       This is the master dictionary file, which references the
#       pre-defined dictionary files included with the server.
#
#       Any new/changed attributes MUST be placed in this file, as
#       the pre-defined dictionaries SHOULD NOT be edited.
#
#       $Id: dictionary.in,v 1.4 2004/04/14 15:26:20 aland Exp $
#
#
$INCLUDE        /usr/local/share/freeradius/dictionary
$INCLUDE        dictionary.motp

Dans /var, créer un répertoire motp et lui donner les droits au user “freeradius”

serveur:# mkdir /var/motp
serveur:# mkdir /var/motp/cache
serveur:# mkdir /var/motp/users
serveur:# chown -R _freeradius:_freeradius /var/motp

On va ajouter un module exec à la configuration (/etc/raddb/radiusd.conf)

modules {
          ...
 
        exec MOTP {
                wait = yes
                program = "/etc/raddb/otpverify.sh %{User-Name} %{User-Password} %{reply:Secret
} %{reply:Pin} %{reply:Offset}"
                input_pairs = request
                output_pairs = reply
 
               ....
 
(vérifier bien que vous avez "exec" dans la partie Instantiate :)
 
instantiate {
        exec
        expr
        expiration
        logintime
 
}

Depuis la version 2, Freeradius utilise des hôtes virtuels (comme Apache), modifier votre fichier vhost comme suit (la partie importante étant l’auth-type external)

serveur:/etc/raddb/sites-enabled# more radius.guiguiabloc.fr
#####################################
authorize {
        preprocess
        chap
        suffix
        sql
        files
        expiration
        logintime
        pap
}
 
#  Authentication.
#
authenticate {
        Auth-Type PAP {
                pap
        }
 
        Auth-Type CHAP {
                chap
        }
        Auth-Type External {
                 MOTP
        }
        unix
}
 
preacct {
        preprocess
        acct_unique
        suffix
        files
}
accounting {
        detail
        unix
        radutmp
        sql
        attr_filter.accounting_response
}
session {
        radutmp
        sql
}
post-auth {
        Post-Auth-Type REJECT {
                attr_filter.access_reject
        }
}
pre-proxy {
}
post-proxy {
}

On va s’arrêter la pour la partie Freeradius et nous occuper de notre téléphone portable.

Installation de MOTP

MOTP (Mobile One Time Password), est le projet source de Freeauth dont j’avais parlé dans mon précédent billet.

Le principe est simple, comme dans toute base d’authentification forte à deux facteurs.

- 1 code secret connu également du serveur Radius (ce que JE connais)

- 1 objet unique capable de générer mon code (ce que JE détiens)

Le téléphone ET le serveur RADIUS se partageant ensemble une clé hexadécimale unique.

Avoir le téléphone ne sert à rien (j’ignore le code PIN qui n’est pas enregistré dedans)

Avoir le code PIN et un autre téléphone avec le même programme ne sert à rien (je ne peux régénérer la même clé hexadécimale)

Une fois tout cela en main, quand vous tapez votre code PIN (pas celui du téléphone hein celui choisi pour l’authentification), le programme génère 1 mot de passe unique en utilisant un hash MD5 qui cumule le code pin, la clé hexadécimale et l’heure EPOCH (avec une granularité de 10 secondes) et vous donne les 6 premiers caractères qui sont votre mot de passe pour vous connecter.

Ce mot de passe est vérifié par le serveur qui connait le code PIN, l’init-key (la clé hexadécimale) et l’heure actuelle.

Pour pallier les variations de temps entre le téléphone et le serveur, celui accepte le mot de passe 3 minutes dans le passé et dans le futur par rapport à son heure actuelle.

C’est bien pour cela que je vous conseille fortement de synchroniser votre téléphone portable et votre serveur à intervalles réguliers sur un serveur de temps NTP (cf. précédent billet)

Le mot de passe n’est accepté qu’UNE seule fois et en cas de 8 échecs consécutifs, l’utilisateur est verrouillé et ne peux plus se connecter.

Le JAR que vous devez installer sur votre téléphone compatible JAVA est disponible ici :

http://motp.sourceforge.net/MobileOTP.jar

Vous trouverez d’autres formes du client MOTP sur le site du projet (BlackBerry par exemple) :

http://motp.sourceforge.net/#2

Bien sûr, les sources sont également disponibles.

L’installation faite, un nouvel icône fait son apparition

MOTP

Dans le menu Options, Time Zone, vérifier votre temps UTC (+0 pour moi) qui doit être identique sur le serveur.

(voir le précédent billet pour plus d’infos sur cette partie)

Commençons par initialiser le programme pour générer la clé Hexadécimale unique

Lancer le programme et en code PIN tapez : #**#

MOTP

Appuyez aléatoirement sur 20 touches

MOTP

Le programme vous affiche votre clé Hexadécimale unique (l’init Secret), NOTEZ LA BIEN !!!

MOTP

Vous pouvez déjà vérifier que cela fonctionne en lançant le script otpverify.sh sur votre serveur RADIUS, suivi de 5 variables :
- le user
- le mot de passe unique généré par votre téléphone
- la clé hexadécimale
- le code PIN
- l’offset (0 pour un UTC +0)

serveur:/etc/raddb# ./otpverify.sh guiguiabloc b662de e37629f6d057dcc5 1234 0
ACCEPT

Maintenant, avec cette clé, retournons à la configuration du serveur RADIUS.

Paramétrage du fichier “users” de RADIUS :

serveur:/etc/raddb# cat /etc/raddb/users
DEFAULT Auth-Type = External
        Exec-Program-Wait = "/etc/raddb/otpverify.sh '%{User-Name}' '%{User-Password}' '%{reply:Secret}' '%{reply:Pin}' '%{reply:Offset}'",
        Fall-Through = Yes
guiguiabloc
        Secret = e37629f6d057dcc5,
        PIN = 1234,
        Offset = 0

Explication :
On ajoute un utilisateur, guiguiabloc
Secret = la clé hexadécimale générée sur le téléphone
PIN = le code secret a 4 chiffres choisi par l’utilisateur
Offset = variation de temps UTC (voir le site pour une explication détaillée)

Ne reste qu’à démarrer votre serveur RADIUS (en mode debug pour l’instant) et tenter une authentification via l’utilitaire RADTEST

serveur:/etc/raddb# /usr/local/sbin/radiusd -X
FreeRADIUS Version 2.0.5, for host i386-unknown-openbsd4.4, built on Aug 13 2008 at 01:30:16
Copyright (C) 1999-2008 The FreeRADIUS server project and contributors.
There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A
PARTICULAR PURPOSE.
You may redistribute copies of FreeRADIUS under the terms of the
GNU General Public License v2.
Starting - reading configuration files ...
....
Listening on authentication address 192.168.18.100 port 1812
Listening on accounting address 192.168.18.100 port 1813
Ready to process requests.

Demande du mot de passe unique sur le téléphone :

MOTP

serveur:/etc/raddb# radtest guiguiabloc 356c18  192.168.18.100 0 secret_radius_client
Sending Access-Request of id 41 to 192.168.18.100 port 1812
        User-Name = "guiguiabloc"
        User-Password = "356c18"
        NAS-IP-Address = 192.168.18.70
        NAS-Port = 0
rad_recv: Access-Accept packet from host 192.168.18.100 port 1812, id=41, length=20
 
Côté serveur RADIUS on voit l'authentification se dérouler :
 
auth: type "External"
+- entering group External
        expand: %{User-Name} -> guiguiabloc
        expand: %{User-Password} -> 356c18
        expand: %{reply:Secret} -> e37629f6d057dcc5
        expand: %{reply:Pin} -> 1234
        expand: %{reply:Offset} -> 0
Exec-Program output: ACCEPT
Exec-Program-Wait: plaintext: ACCEPT
Exec-Program: returned: 0
++[MOTP] returns ok
Sending Access-Accept of id 41 to 192.168.18.100 port 29470
Finished request 2.
Going to the next request
Waking up in 4.9 seconds.
Cleaning up request 2 ID 41 with timestamp +215
Ready to process requests.

Un succès

Désormais vous pouvez demander à vos équipements d’interroger le serveur RADIUS pour valider l’authentification et utiliser votre téléphone pour générer votre mot de passe unique et jetable.

Ca fait “classe” quand même

Bonus, il existe un module mod_auth_radius pour Apache

Un petit .htaccess bien placé :

    AuthType Basic
    AuthName "RADIUS Authentication"
    AuthUserFile /dev/null
    AuthRadiusAuthoritative on
    AuthBasicAuthoritative off
    AuthRadiusCookieValid 5
    AuthRadiusActive On
    require valid-user

Et hop, authentification sur votre site web via RADIUS et MOTP…

Amusez-vous bien

3 Commentaires :freeradius, motp, otp, radius suite...

Gestion d’une PKI : Installation d’un répondeur OCSP

par guiguiabloc le 05 jan., 2009, sous cisco, linux, sécurité

Déjà avant tout, Excellente Année 2009 à vous tous

La gestion des certificats SSL et/ou X509 est une très bonne chose pour le contrôle et la sécurité de l’accès à vos systèmes d’informations.

Je ne parlerais pas de la façon de monter une PKI chez soi, j’avais écris un précédent billet ICI sur lequel vous pouvez vous baser.

OSCP ??? C’est quoi ce truc encore ….

OCSP signifie Online Certificate Status Protocol. C’est un protocole définit dans la RFC 2560 qui permet de valider un Certificat numérique X509.

En clair, cela vous permet d’offrir à vos “clients, amis, potes….” une fonction de vérification en ligne de la validité d’une certificat.

Petit exemple (source Wikipédia) :

Alice et Bob sont des clients d’Ivan, l’autorité de certification (AC). Ils possèdent le certificat de clé publique d’Ivan.
Alice et Bob possèdent chacun un certificat de clé publique émis par Ivan.
Alice veut effectuer une transaction avec Bob. Elle lui envoie donc son certificat contenant sa clé publique.
Bob veut s’assurer que le certificat d’Alice n’a pas été révoqué. Il crée une requête OCSP contenant l’empreinte du certificat d’Alice et l’envoi à Ivan.
Le répondeur OCSP d’Ivan vérifie le statut du certificat d’Alice dans la base de données de la CA.
Le répondeur OCSP confirme la validité du certificat d’Alice en envoyant une réponse OCSP positive signée à Bob.
Bob vérifie la signature cryptographique de la réponse.
Bob effectue sa transaction avec Alice.

Je vous invite donc fortement, avant de continuer, à lire cet article explicatif.

Il existe un projet libre de répondeur OCSP , qui est inclus dans l’excellentissime projet OpenCA :

http://www.openca.org/projects/ocspd/

Commencons donc par télécharger les sources ICI (dernière version disponible, la 1.5.1-rc1).

L’installation est des plus basiques (a vous de voir pour le prefix) :

$ ./configure --prefix=/opt/ocspd
$ make
$ su
# make install

On créer un groupe et un user dédié et on affecte les droits :

pki:/opt/ocspd# groupadd ocspd
pki:/opt/ocspd# useradd -d /opt/ocspd -g ocspd -s /bin/false ocspd
pki:/opt/ocspd# chown -R ocspd:ocspd /opt/ocspd

Avec votre système de PKI préférée, générer un certificat publique et un certificat privé pour votre serveur OCSP. (attention au hostname, dans mon cas, ocsp.guiguiabloc.fr)

Copier les, ainsi que votre certificat CA, dans /opt/ocspd/etc/ocspd/certs

Il ne reste qu’a configurer votre répondeur :

cat /opt/ocspd/etc/ocspd/ocspd.conf
 
[ ocspd ]
default_ocspd   = OCSPD_default         # The default ocspd section
 
####################################################################
[ OCSPD_default ]
 
dir              = /opt/ocspd/etc/ocspd         # Where everything is kept
db               = $dir/index.txt               # database index file.
md               = sha1
 
ca_certificate    = $dir/certs/CA_Guiguiabloc-cert.pem      # The CA certificate
ocspd_certificate = $dir/certs/ocsp-cert.crt    # The OCSP server cert
ocspd_key         = $dir/certs/ocsp-key.pem   # The OCSP server key
pidfile           = $dir/ocspd.pid              # Main process pid
 
user                    = ocspd
group                   = ocspd
 
bind                    = 192.168.1.1 (l'ip sur laquelle écouter ou * pour toutes les interfaces)
port                    = 2560
crl_auto_reload = 3600
crl_reload_expired = yes
response        = ocsp_response
 
....
 
[ ocsp_response ]
dir                     = /opt/ocspd/etc/ocspd
ocsp_add_response_keyid = yes
 
...
 
[ first_ca ]
 
crl_url = file:////opt/ocspd/etc/ocspd/crls/crl-Guiguiabloc.pem (la liste de révocation de certificat)
ca_url  = file:////opt/ocspd/etc/ocspd/certs/CA_Guiguiabloc-cert.pem

Je vous laisse consulter le fichier conf en entier pour en comprendre le contenu et le modifier suivant vos besoins, mais la configuration ci-dessous, très simple, fonctionne pour un premier test.

Ne reste qu’a lancer le démon et verifier le syslog :

pki:#/opt/ocspd/sbin/ocspd -c /opt/ocspd/etc/ocspd/ocspd.conf -v &amp;
 
Jan  5 14:56:15 pki ocspd[22154]: OpenCA OCSPD v1.5.1 - starting.
Jan  5 14:56:15 pki ocspd[22154]: reading certificate file (/opt/ocspd/etc/ocspd/certs/ocsp-cer
t.crt).
Jan  5 14:56:15 pki ocspd[22154]: Reading Private Key file /opt/ocspd/etc/ocspd/private/ocsp-ke
y.pem
Jan  5 14:56:15 pki ocspd[22154]: reading CA certificate file.
Jan  5 14:56:15 pki ocspd[22154]: OCSP Daemon setup completed
Jan  5 14:56:15 pki ocspd[22154]: variable lookup failed for OCSPD_default::chroot_dir
Jan  5 14:56:15 pki ocspd[22154]: Auto CRL reload every 3600 secs
Jan  5 14:56:15 pki ocspd[22154]: Reload on expired CRLs enabled
Jan  5 14:56:15 pki ocspd[22154]: Number of CAs in configuration is 1
Jan  5 14:56:15 pki ocspd[22154]: INFO::FORMAT::CA Cert [//opt/ocspd/etc/ocspd/certs/CA_Guiguiabloc-cert.pem] is PEM formatted
Jan  5 14:56:15 pki ocspd[22154]: CA CERT for first_ca loaded successfully.
Jan  5 14:56:15 pki ocspd[22154]: CA List Entry added (CA list num 0)
Jan  5 14:56:15 pki ocspd[22154]: INFO::CRL RELOAD::File Protocol
Jan  5 14:56:15 pki ocspd[22154]: INFO::FILE::CRL is in PEM format
Jan  5 14:56:15 pki ocspd[22154]: CRL loaded [ first_ca ]
Jan  5 14:56:15 pki ocspd[22154]: CRL and CA cert [0:1] check ok
Jan  5 14:56:15 pki ocspd[22154]: CRL matching CA cert ok [ 1 ]
Jan  5 14:56:15 pki ocspd[22154]: INFO::CRL::Verify 1 [OK=1]
Jan  5 14:56:15 pki ocspd[22154]: INFO::CRL is Valid
Jan  5 14:56:15 pki ocspd[22154]: INFO::CRL::16 Entries [ first_ca ]
Jan  5 14:56:15 pki ocspd[22154]: CRL loaded successfully [first_ca]
Jan  5 14:56:15 pki ocspd[22154]: variable lookup failed for ocsp_response::ocsp_add_response_c
erts
Jan  5 14:56:15 pki ocspd[22154]: variable lookup failed for OCSPD_default::crl_check_validity
Jan  5 14:56:15 pki ocspd[22154]: Configuration loaded and parsed
Jan  5 14:56:15 pki ocspd[22154]: INFO::Local Address 192.168.1.1 [2560]
Jan  5 14:56:15 pki ocspd[22154]: INFO::OPENCA_SRV_INFO_TREAD::new thread created

Bien évidemment, vous fournissez au répondeur OCSP, la Liste de révocation des certificats (fichier CRL) et la database (index.txt).
Si vous utilisez easyCA, ils sont générés sous $DIR et $DIR/crl par défaut (voir votre fichier openssl.cnf).

Et maintenant, interrogeons le serveur OCSP pour savoir si mon Certificat (ici webmail.guiguiabloc.fr) est encore valable :

pki:# openssl ocsp -issuer CA_Guiguiabloc-cert.pem -CAfile CA_Guiguiabloc-cert.pem -cert webmail.guiguiabloc.fr.crt -url http://192.168.1.1:2560 -text
OCSP Request Data:
    Version: 1 (0x0)
    Requestor List:
        Certificate ID:
          Hash Algorithm: sha1
          Issuer Name Hash: 4A694097441CA470D697E82AF367D1F196B59680
          Issuer Key Hash: 6490C296FF639D9B75A899E2DB29DC7DA42EE38D
          Serial Number: 13
    Request Extensions:
        OCSP Nonce:
            0410DDDA8DFEF460BA0C13ACCEBE7CDFDCB9
OCSP Response Data:
    OCSP Response Status: successful (0x0)
    Response Type: Basic OCSP Response
    Version: 1 (0x0)
    Responder Id: C = FR, ST = Bretagne, O = Guiguiabloc, OU = Guiguiabloc, CN = ocsp.guiguiabloc.fr, emailAddress = pki@guiguiabloc.fr
    Produced At: Jan  5 14:21:40 2009 GMT
    Responses:
    Certificate ID:
      Hash Algorithm: sha1
      Issuer Name Hash: 4A694097441CA470D697E82AF367D1F196B59680
      Issuer Key Hash: 6490C296FF639D9B75A899E2DB29DC7DA42EE38D
      Serial Number: 13
    Cert Status: good
    This Update: Jan  5 14:16:51 2009 GMT
    Next Update: Jan  5 14:26:40 2009 GMT
 
    Response Extensions:
        OCSP Nonce:
            0410DDDA8DFEF460BA0C13ACCEBE7CDFDCB9
Certificate:
    Data:
        Version: 3 (0x2)
        Serial Number: 16 (0x10)
        Signature Algorithm: md5WithRSAEncryption
        Issuer: C=FR, ST=Bretagne, L=Brest, O=Guiguiabloc, OU=Guiguiabloc, CN=Guiguiabloc CA Authority/emailAddress=pki@guiguiabloc.fr
        Validity
            Not Before: Jul 18 08:08:25 2008 GMT
            Not After : Jul 17 08:08:25 2013 GMT
        Subject: C=FR, ST=Bretagne, O=Guiguiabloc, OU=Guiguiabloc, CN=ocsp.guiguiabloc.fr/emailAddress=pki@guiguiabloc.fr
        Subject Public Key Info:
            Public Key Algorithm: rsaEncryption
            RSA Public Key: (1024 bit)
                Modulus (1024 bit):
                    00:bb:c8:c3:c0:78:26:88:8c:45:6c:2a:1b:88:fd:
                    71:57:c0:bb:23:e1:1e:40:86:d2:94:af:fc:e7:74:
                    41:3d:41:39:ac:a6:51:dc:4d:e8:80:53:a3:73:5d:
                    74:0e:1f:04:b1:78:dc:ad:45:65:5b:4f:0e:b2:92:
                    3c:bc:64:bb:3e:70:2c:ca:b8:ea:dc:fc:33:31:01:
                    d2:05:b2:e2:60:0c:d2:a6:c1:e9:83:b0:ca:d9:42:
                    98:44:8b:c3:df:63:dc:17:02:51:b6:f2:da:0e:c6:
                    81:fa:78:1c:d2:ca:56:52:f3
                Exponent: 65537 (0x10001)
        X509v3 extensions:
            X509v3 Basic Constraints:
                CA:FALSE
            X509v3 Key Usage:
                Digital Signature
            X509v3 Extended Key Usage:
                OCSP Signing
            X509v3 Issuer Alternative Name:
 
            X509v3 Subject Key Identifier:
                1A:18:4A:7A:BC:DB:3E:CD:60:87:0B:A3:11:4D:4F:E6:CE:19:17:27
            X509v3 Authority Key Identifier:
                keyid:64:90:C2:96:FF:63:9D:9B:75:A8:99:E2:DB:29:DC:7D:A4:2E:E3:8D
                DirName:/C=FR/ST=Bretagne/L=Brest/O=GuiGuiabloc/OU=Guiguiabloc/CN=Guiguiabloc CA Authority/emailAddress=pki@guiguiabloc.fr
                serial:B9:0E:D5:3E:0F:DA:79:FF
 
            Authority Information Access:
                OCSP - URI:http://ocsp.guiguiabloc.fr/
 
    Signature Algorithm: md5WithRSAEncryption
        0c:3a:3f:79:7e:e4:21:be:1b:d1:d4:ef:8f:1d:33:af:f2:88:
        eb:0f:40:cb:24:50:9b:47:cc:61:e2:a9:a3:6e:c5:4f:2a:7c:
        b5:03:f1:a1:b8:b7:23:c7:e1:00:61:3a:c0:7c:8f:c6:2f:c7:
        6a:c9:98:ad:af:ff:28:db:c6:1f:17:d3:54:f3:d7:1a:96:51:
        19:04:6c:f8:92:74:70:de:54:c1:55:d3:9d:27:99:8b:09:be:
        98:27:e6:5b:1e:14:a2:a9:d2:cb:a2:d7:52:8a:e1:ac:9b:a7:
        52:a2:5b:90:dc:cc:8f:33:4b:7a:99:60:4d:5e:b9:e6:71:ed:
        be:92
-----BEGIN CERTIFICATE-----
MIID/DCCA2WgAwIBAgIBEDANBgkqhkiG9w0BAQQFADCBnDELMAkGA1UEBhMCRlIx
ETAPBgNVBAgTCEJyZXRhZ25lMQ4wDAYDVQQHEwVCcmVzdDEVMBMGA1UEChMMU3R5
eCBOZXR3b3JrMRAwDgYDVQQLEwdTdHl4bmV0MSIwIAYDVQQDExlTdHl4IE5ldHdv
cmsgQ0EgQXV0aG9yaXR5MR0wGwYJKoZIhvcNAQkBFg5wa2lAc3R5eG5ldC5mcjAe
Fw0wODA3MTgwODA4MjVaFw0xMzA3MTcwODA4MjVaMIGCMQswCQYDVQQGEwJGUjER
MA8GA1UECBMIQnJldGFnbmUxFTATBgNVBAoTDFN0eXggTmV0d29yazEQMA4GA1UE
CxMHU3R5eG5ldDEYMBYGA1UEAxMPb2NzcC5zdHl4bmV0LmZyMR0wGwYJKoZIhvcN
AQkBFg5wa2lAc3R5eG5ldC5mcjCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEA
psHpg7DK2UKYRIvD32PcFwJRtvLaDsaB+ngc0spWUvMCAwEAAaOCAWQwggFgMAkG
A1UdEwQCMAAwCwYDVR0PBAQDAgeAMBMGA1UdJQQMMAoGCCsGAQUFBwMJMAkGA1Ud
EgQCMAAwHQYDVR0OBBYEFBoYSnq82z7NYIcLoxFNT+bOGRcnMIHRBgNVHSMEgckw
gcaAFGSQwpb/Y52bdaiZ4tsp3H2kLuONoYGipIGfMIGcMQswCQYDVQQGEwJGUjER
MA8GA1UECBMIQnJldGFnbmUxDjAMBgNVBAcTBUJyZXN0MRUwEwYDVQQKEwxTdHl4
IE5ldHdvcmsxEDAOBgNVBAsTB1N0eXhuZXQxIjAgBgNVBAMTGVN0eXggTmV0d29y
ayBDQSBBdXRob3JpdHkxHTAbBgkqhkiG9w0BCQEWDnBraUBzdHl4bmV0LmZyggkA
uQ7VPg/aef8wMwYIKwYBBQUHAQEEJzAlMCMGCCsGAQUFBzABhhdodHRwOi8vb2Nz
cC5zdHl4bmV0LmZyLzANBgkqhkiG9w0BAQQFAAOBgQAMOj95fuQhvhvR1O+PHTOv
8ojrD0DLJFCbR8xh4qmjbsVPKny1A/GhuLcjx+EAYTrAfI/GL8dqyZitr/8o28Yf
F9NU89callEZBGz4knRw3lTBVdOdJ5mLCb6YJ+ZbHhSiqdLLotdSiuGsm6dSoluQ
3MyPM0t6mWBNXrnmce2+kg==
-----END CERTIFICATE-----
Response verify OK
webmail.guiguiabloc.fr.crt: good

Réponse : GOOD tout va bien

La réponse peut être: GOOD - REVOKED - UNKNOWN

Vous pouvez inclure directement dans votre certificat l’adresse de votre répondeur OCSP en ajoutant des extensions à votre openssl.cnf :

[OCSP]
 
basicConstraints        = CA:FALSE
keyUsage                = digitalSignature
extendedKeyUsage        = OCSPSigning
issuerAltName           = issuer:copy
subjectKeyIdentifier    = hash
authorityKeyIdentifier  = keyid:always,issuer:always
authorityInfoAccess     = OCSP;URI:http://ocsp.guiguiabloc.fr/
 
[SERVEUR_OCSP]
nsComment                       = "Guiguiabloc Certificate"
subjectKeyIdentifier            = hash
authorityKeyIdentifier          = keyid,issuer:always
issuerAltName                   = issuer:copy
basicConstraints                = critical,CA:FALSE
keyUsage                        = digitalSignature, nonRepudiation, keyEncipherment
nsCertType                      = server
extendedKeyUsage                = serverAuth
authorityInfoAccess             = OCSP;URI:http://ocsp.guiguiabloc.fr/
 
[CLIENT_OCSP]
nsComment                       = "Certificat Client SSL"
subjectKeyIdentifier            = hash
authorityKeyIdentifier          = keyid,issuer:always
issuerAltName                   = issuer:copy
basicConstraints                = critical,CA:FALSE
keyUsage                        = digitalSignature, nonRepudiation
nsCertType                      = client
extendedKeyUsage                = clientAuth
authorityInfoAccess             = OCSP;URI:http://ocsp.guiguiabloc.fr/

Puis d’invoquer l’extension lors de la création du certificat avec openssl (-extensions CLIENT_OCSP (par exemple).

Dans Firefox, pour configurer l’interrogation automatique du répondeur OCSP, allez dans Outils/Options/Avance/Chiffrement et cliquez sur “Vérification”.

Génial non ?

Petit bonus, sur votre Cisco préféré, on peut aussi faire de l’OCSP

rt-2611&gt;en
Password:
rt-2611#conf t
Enter configuration commands, one per line.  End with CNTL/Z.
rt-2611(config)#crypto pki trustpoint guiguiabloc
rt-2611(ca-trustpoint)#ocsp url http://ocsp.guiguiabloc.fr:2560
rt-2611(ca-trustpoint)#revocation-check ocsp none

La dernière ligne est la méthode de vérification, l’option none spécifie que le routeur passera la vérification OSCP si le répondeur ne répond pas.
Pour les IOS 12.3 et supérieure (la page chez Cisco LA )

Amusez vous bien

4 Commentaires :ocsp, ocspd, pki suite...

« ENTREES PRECEDENTES