Discussion :

[toctof]

Bonjour,

Je travaille sur une application web (JSP) pour laquelle il est nécessaire de s'identifier. Les utilisateurs sont tous enregistrés dans un annuaire LDAP.

L'utilisateur doit donc donner son login et son mot de passe en clair, et je souhaite vérifier quer le couple login/mdp existe bien dans l'annuaire.

Comment faire, sachant que les mots de passe stockés dans LDAP sont cryptés ?? Avez-vous un exemple de code pour procéder à l'authentification ?

Je cherche quelque chose qui ferait la chose suivante :

- récupérer le login et le mot de passe en clair
- chiffrer le mot de passe (avec une fonction équivalente à crypt(salt, mdp) de PHP)
- comparer le couple login/mot de passe crypté aux logins et mdp cryptés de l'annuaire LDAP.



J'ai vu qu'il existait un package jldap de Novell pour utiliser LDAP, mais je dois avouer que je n'ai pas saisi grand chose...

Merci d'avance.

ToCToF

[shaun_the_sheep]

Salut,

va sur :
http://developer.novell.com/ndk/doc/samplecode/jldap_sample/index.htm

il y a pleins d'exemples

[toctof]

Merci pour le lien,

Désormais je me connecte correctement en tant qu'administrateur de l'annuaire, mais mon problème vient du cryptage du mot de passe.

Les mots de passe des utilisateurs dans l'annuaire sont de type {crypt}6fJJ0JK4rZlt. et il faut donc que je crypte le mot de passe qui a été fourni en clair avant de le comparer au mot de passe de l'annuaire. Y'a-t-il une fonction qui ressemble à la fonction crypt(salt, mdp) de PHP ?

Je ne l'ai pas trouvé dans les exemples de novell.

Merci d'avance

ToCToF

[shaun_the_sheep]

tu connais l'algorithme utilisé pour le cryptage du password ?

[toctof]

Oui l'algorythme correspond à la fonction "crypt".
C'est l'algorythme DES.

[shaun_the_sheep]

j'ai trouvé ce code sur developpez.com

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
import java.security.*;
import javax.crypto.*;
 
//
// encrypt and decrypt using the DES private key algorithm
 
public class PrivateExample {
 
   public static void main(String[] args) throws Exception {
      //
      // check args and get plaintext
      if (args.length != 1) {
         System.err.println("Usage: java PrivateExample text");
         System.exit(1);
      }
 
//    byte[] plainText = args[0].getBytes("UTF8");
      String ss = "Hello world, haris is here!";
      byte[] plainText = ss.getBytes();
      //
      // get a DES private key
      System.out.println("\nStart generating DES key");
      KeyGenerator keyGen = KeyGenerator.getInstance("DES");
      keyGen.init(56);
      Key key = keyGen.generateKey();
      System.out.println("Finish generating DES key");
      //
      // get a DES cipher object and print the provider
      Cipher cipher = Cipher.getInstance("DES/ECB/PKCS5Padding");
      System.out.println("\n" + cipher.getProvider().getInfo());
      //
      // encrypt using the key and the plaintext
      System.out.println("\nStart encryption");
      cipher.init(Cipher.ENCRYPT_MODE, key);
      byte[] cipherText = cipher.doFinal(plainText);
      System.out.println("Finish encryption: ");
      System.out.println(new String(cipherText, "UTF8"));
 
      //
      // decrypt the ciphertext using the same key
      System.out.println("\nStart decryption");
      cipher.init(Cipher.DECRYPT_MODE, key);
      byte[] newPlainText = cipher.doFinal(cipherText);
      System.out.println("Finish decryption: ");
 
      System.out.println(new String(newPlainText, "UTF8"));
   }
}

je pense que cela peut aider à crypter le mot de passe et le comparer par la suite

[toctof]

Merci, je viens d'essayer ton code mais je n'obtiens pas le bon résultat. En fait, le chiffrement du mot de passe correspond à la commande crypt de unix, et je pensais que cela correspondait à l'algorithme (au passage, désolé pour la faute d'orthographe pour algorithme tout à l'heure.... ) DES, mais ce n'est visiblement pas le cas.

J'ai trouvé mon bonheur sur : http://locutus.kingwoodcable.com/jfd/crypt.html

Là ça crypte parfaitement.... apparement.

Il ne me reste plus qu'à lire la doc de jldap de Novell pour voir comment comparer des attributs et le tour sera joué. Je mettrais mon code en ligne une fois que j'aurai fini, ça pourrait en aider d'autres...

Merci pour ton aide.

ToCToF

[toctof]

Voilà qui est fait, je dispose maintenant d'une méthode qui permet de vérifier si le couple login/mot de passe d'un utilisateur est présent dans l'annuaire LDAP et est correct :

J'utilise le package jldap de Novell, téléchargeable sur :
http://developer.novell.com/ndk/down...hortname=jldap

Et j'utilise également la classe jcrypt trouvée sur http://locutus.kingwoodcable.com/jfd/crypt.html

La méthode que j'ai faite à partir des exemples de novell est la suivante :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
 
  /**
   * Method verifyIdUser : authentifier un utilisateur depuis un annuaire LDAP
   * @param login String : le login de l'utilisateur
   * @param pwdClair String : le mot de passe de l'utilisateur
   * @return boolean : true si l'utilisateur existe, false sinon
   */
  public static boolean verifyIdUser(String login, String pwdClair) {
 
    //Déclaration des variables
 
    //Booléen qui sera retourné par la fonction
    boolean exist = false; 
 
    //Port d'accesion à LDAP
    int ldapPort = LDAPConnection.DEFAULT_PORT;
 
    //Méthode de recherche dans l'annuaire (SUB = descend dans tous les sous-arbres
    //du contexte donné (BaseDN)
    int searchScope = LDAPConnection.SCOPE_SUB;
 
    //Protocole de connection
    int ldapVersion = LDAPConnection.LDAP_V3;
 
    //false pour récupérer noms ET valeurs des attributs en résultat de recherche
    boolean attributeOnly = false;
 
    //Nom des attributs à retrouver (ici : tous)
    String attrs[] = {LDAPConnection.ALL_USER_ATTRS};
 
    //Paramètres d'accession à LDAP (Serveur, BindDN et son mot de passe, contexte
    //à partir duquel la rechecherche se fait, et la requête LDAP (filtre))
    String ldapHost = "mettre ici le nom du serveur";
    String loginDN = "mettre ici le nom de l'administareur LDAP";
    String password = "mettre ici le pwd de l'admin";
    String searchBase = "mettre ici le contexte de départ de la recherche";
    String searchFilter = "mettre ici le filtre de recherche (tout = "(objectclas=*)")";
 
    //Nouvel objet de type LDAPConnection
    LDAPConnection lc = new LDAPConnection();
 
    try {
      // connexion au serveur
      lc.connect(ldapHost, ldapPort);
 
      // Identification de l'administrateur
      lc.bind(ldapVersion, loginDN, password.getBytes("UTF8"));
 
      //Recherche à effectuer
      LDAPSearchResults searchResults =
          lc.search(searchBase, // container to search
 
                    searchScope, // search scope
 
                    searchFilter, // search filter
 
                    attrs, // Attributes
 
                    attributeOnly); // all attributes are returned
 
      //*****************************
      // *Traitement des résultats*
     //*****************************
      //Nouvel attribut uid de valeur login
      LDAPAttribute attrLog = new LDAPAttribute( "uid", login );
 
      //Nouvel attribut pour le mot de passe
      LDAPAttribute attrPass = null;
 
      //Booléen pour le résultat de la comparaison des attributs
      boolean compareResults = false;
 
      //Pour chaque résultat trouvé
      while ( searchResults.hasMore()) {
 
        //Variable de type donnée de LDAP
        LDAPEntry nextEntry = null;
        try {
          //Donner la valeur du résultat à la variable nextEntry
          nextEntry = searchResults.next();
        }
        catch(LDAPException e) {
          System.out.println("Error: " + e.toString());
          continue;
        }
 
        // Si l'uid de l'entrée a la même valeur que le login 
        if ( compareResults = lc.compare(nextEntry.getDN(), attrLog)) {
 
          //Récupérer le mot de passe chiffré correspondant à l'utilisateur
          String mdpChiffre = nextEntry.getAttribute("userpassword").getStringValue();
 
          //Récupérer le "grain de sel" du mot de passe chiffré (2 caractères
          //après le mot "{crypt}")
          String salt = mdpChiffre.substring(7,9);
 
          //Grâce au grain de sel, chiffrer le mot de passe clair donné en 
          //argument de la méthode, en utilisant la méthode crypt de la classe 
          //jcrypt
          String mdpTransforme = "{crypt}" + jcrypt.crypt(salt,pwdClair);
 
          //Utiliser la valeur calculée pour créer un nouvel attribut userpassword
          attrPass = new LDAPAttribute( "userpassword", mdpTransforme );
 
          //Comparer ce dernier attribut avec l'attribut userpassword de l'annuaire
          //S'il est identique, passer exist à true
          if ( compareResults = lc.compare(nextEntry.getDN(), attrPass))
            exist = true;
 
        }
      }
      //Se déconnecter de l'annuaire
      lc.disconnect();
    }
    //Gestion des erreurs
    catch( LDAPException e ) {
      System.out.println( "Error: " + e.toString() );
    }
    catch( UnsupportedEncodingException e ) {
      System.out.println( "Error: " + e.toString() );
    }
 
    //Retourner le résultat
    return exist;
  }

Voilà, en espérant que ça puisse aider d'autres personnes...

@+

ToCToF