One Time Password , 3 secrets et compagnie avec yubikey La firme yubico

La firme yubico produit une clé USB délivrant à chaque utilisation un mot de passe jetable (OTP).
L'utilisateur ne paye que la clé, le service d'authentification est gratuit , les librairies sont libres.

Et en plus, on peut s'en servir de porte-clé !




Lorsque la yubikey est sollicitée , elle génère un token de 44 octets qui prennent la forme d'une chaine de caractère qui serait 'tapée' sur le clavier de l'ordinateur. Cette pseudo clé USB simule la frappe de 44 caractères sur votre clavier. cette séquence est chaque fois différente mais présente toujours la structure suivante :

* secret ID :(6 octets)
* session counter: (2 octets)
* horodatage: (3 oct)
* compteur de session :(1 oct)
* valeur aleatoire :(2 oct)
* Controle CRC : (2 oct)


Le tout encodé en AES 128 bits puis protegé par l'encodage MODHEX

La firme propose un service de validation en ligne des OTP. Mais il est possible de monter soit même un service de validation interne à son entreprise.

Le cout de cette clé : de 10 $ à 25 $ en fonction du volume.

La liste des services ou logiciels compatibles s'allonge tous les jours :

* Login sous Windows
* PAM
* SSH
* openID
* VPN
* Rails
* openSSO
* APACHE
* et ... Mandriva.



Déroulement d'une connexion:

* L'utilisateur glisse sa clé dans un port USB
* Le formulaire web lui demande son OTP.
* L'utilisateur presse le bouton de la clé ou 2 fois la touche verrouillage du pavé numérique.
* La clé inscrit les 44 caractères dans le champs du formulaire.
* Apres vérification auprès du fournisseur d'identité un autre formulaire est envoyé demandant le nom d'utilisateur et le mot de passe.
* L'utilisateur complète le formulaire et est accepté par le service.

REMARQUE IMPORTANTE: il serait possible de mettre les 3 secrets dans la même page, mais cela serait moins sécurisé car un pirate pourrait capturer les 3 secrets dans un seul échange (revoir ou relire le 'seigneur des anneaux' pour les questions de secret partagé) .

Validation des données par Rails (ActiveRecord)

Rails propose trois modes de validation des données :

A) Le mode standard
On ajoute une serie de methodes predifinies pour vérifier la présence d'un champs ,sa longueur ou encore sa composition (forme validates.._of :attribut )

* validates_acceptance_of
* validates_associated
* validates_confirmation_of
* validates_each
* validates_exclusion_of
* validates_format_of
* validates_inclusion_of
* validates_length_of
* validates_numericality_of
* validates_presence_of
* validates_size_of
* validates_uniqueness_of




B) Les callbacks.
Rails propose 18 points d'accroche de fonction de vérification (avant/apres sauvegarde, apres recherche etc.) Il suffit d'ecrire la methode de callback propre à une classe.
(extrait)

* (-) save
* (-) valid
* (1) before_validation
* (2) before_validation_on_create
* (-) validate
* (-) validate_on_create
* (3) after_validation
* (4) after_validation_on_create
* (5) before_save
* (6) before_create
* (-) create
* (7) after_create
* (8) after_save




C) Les observateurs.
Ces objets 'observent' le cycle de vie des autres objets. L'avantage est la totale indépendance de l'observateur et de la classe à surveiller et aussi le fait que la classe scrutée n'a pas à etre modifiée pour supporter des observateurs.

Fedora Directory Server une alternative à openldap

Fedora Directory server est l'évolution de l'ancien server LDAP de Netscape lui même issu de la même souche de l'Université du Michigan (Umich) qu'openldap.

FDS et openldap sont donc des cousins. Une visite sur le site de Fedora Directory server vous démontrera que les gars de Red Hat ont fait fructifier l'héritage de Netscape.

Jugez plutot :

1. Multimaster replication
2. aci
3. directory server gateway : offre un service SOAP d'annuaire et une interface WEB
4. Organigramme : plugin pour fournir un vrai organigramme d'entreprise
5. etc...


Tous les composants de FDS sont open Source.

Administrer un cluster de serveur avec ssh

Il est possible de mutualiser des configurations de serveur avec rsync et monit. Il suffit de modifier sur une machine 'maitre' un fichier pour qu'après un délais programmé les services rsync et monit diffusent le fichier aux autres noeuds du cluster. Le service monit sur les noeuds 'esclaves' detectera la reception et donc la modification du fichier et déclachera alors une action définie (ex: redemarrer un service Apache) . Par contre il est parfois necessaire dde lancer une même serie de commandes sur chaque noeud du cluster. Il existe un outils qui va soulager bien des administrateurs de cluster: Cluster ssh. Ce programme basé sur du Tcl/Tk propose une fenetre qui diffuse les commandes sur chaque noeud (en bas à droite) . Il est aussi possible de gerer individuellement chaque noeud.

Voici une copie d'écran:

Jeux en javascript

Le top des 25 jeux en javascript ici et encore ici
Certains jeux sont des bijoux de programmation

Une copie d'écran:










Ce n'est ni plus ni moins qu'une course sur une google map. Organisez un rodéo dans votre quartier !

Nouveau projet

Je lance un nouveau projet :

http://code.google.com/p/lemonid/

Sa description :

Lemon-id is digital identity manager integrator based on Rails , Database and LDAP

Ses objectifs:

Lemon-id n'est pas un nouveau projet de gestion d'identité numérique. Il a pour but d'intégrer les autres projets de web SSO ,d'authentification dans un framework fournisseur d'identité. Lemon-id servira de base d'authentification à d'autres composants et pour cela il proposera plusieurs interfaces.

Ses principes :

* Une base de données pour les Meta-données
* Fichiers de configuration au format YAML
* Format JSON pour les échanges entre les composants
* Interface graphique en Rails

SSO CAS exemple de servlet

Utiliser la librairie client CAS de Yale dans le cadre d'un servlet est très simple :
Une fois récupéré le ticket , le servlet doit le faire valider par le serveur CAS de cette facon :


/* contact CAS and validate */
sv.validate();

/* if we want to look at the raw response, we can use getResponse() */
xmlResponse = sv.getResponse();

/* read the response */

// Yes, this method is misspelled in this way
// in the ServiceTicketValidator implementation.
// Sorry.
if(sv.isAuthenticationSuccesful()) {
user = sv.getUser();
} else {
errorCode = sv.getErrorCode();
errorMessage = sv.getErrorMessage();
/* handle the error */
}

Il reste un problème : Le client CAS standard n'accepte de valider un ticket qu'en utilisant le protocole HTTPS. Or pour les tests, il est parfois plus facile d'utiliser HTTP pour faciliter la capture des trames réseaux.

J'ai donc adapté le client CAS de cette façon :

Attention le code semble complexe mais il est une série de copier/coller

 import javax.servlet.*;

 import javax.servlet.http.*;

 import java.io.*;

 import edu.yale.its.tp.cas.client.*;

 import org.xml.sax.*;

 import java.net.URL;

 import java.net.URLConnection;

 import java.util.regex.*;

   

 public class MyServlet extends HttpServlet {

 

  public void init() {

  }

  public void doGet(HttpServletRequest req, HttpServletResponse res)

    throws ServletException, IOException {

       

        String CASLogin = "http://cas.demo.net/cas/login" ;

        String CASValidate = "http://cas.demo.net/cas/serviceValidate/" ;

            String UrlMonService = "http://serviceprovider.demo.net:8080/servlets- examples/servlet/myservlet";



 String ticket = req.getParameter( "ticket");

 if (ticket == null )

 {     

     res.sendRedirect( CASLogin + "?service=" +UrlMonService);

 }  else {

    res.setContentType("text/html");

    PrintWriter out = res.getWriter();

   



    edu.yale.its.tp.cas.client.ServiceTicketValidator st = new  edu.yale.its.tp.cas.client.ServiceTicketValidator();

    st.setCasValidateUrl(CASValidate);

    st.setServiceTicket( ticket );

    st.setService( UrlMonService );

    StringBuffer sb = new StringBuffer();

    sb.append(CASValidate);

    if (CASValidate.indexOf('?') == -1)

        sb.append('?');

         else

            sb.append('&');

    sb.append("service=" + UrlMonService + "&ticket=" + ticket);

    String url = sb.toString();

    BufferedReader r = null;

        String response="" ;



    try {

            URL u = new URL(url);

            URLConnection uc = u.openConnection();

            uc.setRequestProperty("Connection", "close");

            r = new BufferedReader(new InputStreamReader(uc.getInputStream()));

            String line;

            StringBuffer buf = new StringBuffer();

            while ((line = r.readLine()) != null)

                buf.append(line + "\n");

            response = buf.toString(); 

          } finally {

            try {

                    if (r != null)

                    r.close();

                 } catch (IOException ex) {

                // ignore

                 }



     

          }

      Integer result =0;

      String user="";

    /* reponse negative */

       if   (response.indexOf("authenticationFailure") >= 0 )

        {

           result =0  ;

        }  else

        {

           result =1  ;

           Pattern p = Pattern.compile("(.+)");

           Matcher m = p.matcher(response);

        if (m.find()) {

                // recup du user

                 user= m.group(1) ;

                }

        }

 

        out.println("");

    out.println("");

    out.println("");

    out.println("Ma première servlet  v5  CAS Client ");

    if (result == 1 )

        {

         out.println("connexion reussie pour l\'utilisateur:" + user );

         out.println("Avec le ticket " + ticket);       

           }  else {  

       out.println("ERREUR  de connexion" );

       out.println("ticket " + ticket); 

    }

    out.println("");

    out.println("");

    out.close();    

     }

  }











 }

   

Good hacking