authenticate 함수를 이용해서 Exception  처리를 하면 될듯 한데요..

userpassword 는 엔진에서 제공하는 암호화 모듈을 태워 바이너리로 값을 저장하게 되는데, 보통은 복호화가 않되는 hash 계열의 암호화 모듈을 사용하기 때문에 사용자 암호를 ldap이 사용하는 암호모듈에 태워 비교를 해야 하는데  아직 실력이 부족하여......

netscape LDAP JDK4.1 을 사용하고 있습니다.

jndi 경우 

         try {

         env.put(Context.INITIAL_CONTEXT_FACTORY, Env.INITCTX);

         /* Specify host and port to use for directory service */
         env.put(Context.PROVIDER_URL, Env.MY_SERVICE);

        /* specify authentication information */
       env.put(Context.SECURITY_AUTHENTICATION, "simple");
       env.put(Context.SECURITY_PRINCIPAL, Env.MGR_DN);
       env.put(Context.SECURITY_CREDENTIALS, Env.MGR_PW);

       DirContext ctx = null;

       /* get a handle to an Initial DirContext */
        ctx = new InitialDirContext(env);
   } catch (NamingException e) {
        System.err.println("Create Connection Fail ." + e);
    }
요걸 쓰면 되지 않을까 합니다.

저역시 초보 2님과 같은 생각입니다.

텍스트 형식의 비밀번호를 해쉬하는게 어렵다면 그냥 ldap에 bind를 해보는 거지요..

어차피 bind가 성공한다면 그 사용자에 대한 정보는 가져올 수 있으니깐요...

bind할때 dn을 사용자의 dn으로 맞춰주시구요....패스워드 부분에 입력한 패스워드를 넣어준다음 ldap에 bind가 되는지 확인하는 방법입니다.

제가 사용하는 것은 이렇습니다..

  LDAPConnection ld = null;

  ld = new LDAPConnection();

 try {

       /* connection to ldap server */
       ld.connect( LdapIP, LdapPort );
       ld.authenticate( LdapDN, LdapPwd );
      ....

}

authenticate 부분을 사용자 dn과 패스워드로 맞춰주시면 됩니다.

인증성공하면 패스워드가 맞는거구요....실패는 Exception으로 잡아주시면 되구요....

아니면 SHA1이나 MD5 같은 해쉬 정보를 찾아보신 다음 하셔야 할거에요....

제가 아는..... 해쉬함수를 사용할 수 있는 것은 openssl 밖에 없네요...( 딴건 잘 모르겠습니다..ㅡ.ㅡ;;;)

import java.security.MessageDigest; // http://www.javasoft.com/products/jdk/1.1/docs/api/java.security.MessageDigest.html
import javax.commerce.util.BASE64Encoder; // http://www.javasoft.com/products/commerce/ jecf.jar
import javax.commerce.util.BASE64Decoder;
// An alternative: import util.BASE64Encoder; // http://professionals.com/~cmcmanis/java/encoders/

class pwdSHA {

    public static void main (String[] args)
 throws java.io.IOException,
  java.security.NoSuchAlgorithmException
    {
 if (args.length < 1) {
     String myName = "pwdSHA";
     System.out.print (
  "usage: " + myName + " [-v] [-s salt] password ...\n" +
  "   or: " + myName + " [-v] -c digest password ...\n" +
  "       salt is in hexadecimal notation.\n" +
  "       digest contains SHA-1 hash and salt, base64 encoded.\n");
     return;
 }
 int i = 0;
 boolean verbose = false;
 if (args[i].equals ("-v")) {
     ++i;
     verbose = true;
 }
 MessageDigest sha = MessageDigest.getInstance ("SHA-1");

 if (args[i].equals ("-c")) { // check passwords against digest
     ++i;
     String digest = args[i++];
     if (digest.regionMatches (true, 0, "{SHA}", 0, 5)) {
  digest = digest.substring (5); // ignore the label
     } else if (digest.regionMatches (true, 0, "{SSHA}", 0, 6)) {
  digest = digest.substring (6); // ignore the label
     }
     BASE64Decoder base64 = new BASE64Decoder();
     byte[][] hs = split (base64.decodeBuffer (digest), 20);
     byte[] hash = hs[0];
     byte[] salt = hs[1];
     if (verbose) System.out.println (toHex (hash) + " " +
          toHex (salt));
     for (; i < args.length; ++i) {
  sha.reset();
  sha.update (args[i].getBytes());
  sha.update (salt);
  byte[] pwhash = sha.digest();
  if (verbose) System.out.println (toHex (pwhash));
  if (! sha.isEqual (hash, pwhash)) {
      System.out.println ("doesn't match: " + args[i]);
  }
     }

 } else { // generate digest from passwords
     byte[] salt = {};
     if (args[i].equals ("-s")) {
  ++i;
  salt = fromHex (args[i++]);
  if (verbose) System.out.println (toHex (salt));
     }
     String label = (salt.length > 0) ? "{SSHA}" : "{SHA}";
     BASE64Encoder base64 = new BASE64Encoder();

     for (; i < args.length; ++i) {
  sha.reset();
  sha.update (args[i].getBytes());
  sha.update (salt);
  byte[] pwhash = sha.digest();
  if (verbose) System.out.print (toHex (pwhash) + " ");
  System.out.println (label + base64.encode (concatenate (pwhash, salt)));
     }
 }
    }

    private static byte[] concatenate (byte[] l, byte[] r) {
 byte[] b = new byte [l.length + r.length];
 System.arraycopy (l, 0, b, 0, l.length);
 System.arraycopy (r, 0, b, l.length, r.length);
 return b;
    }

    private static byte[][] split (byte[] src, int n) {
 byte[] l, r;
 if (src.length <= n) {
     l = src;
     r = new byte[0];
 } else {
     l = new byte[n];
     r = new byte[src.length - n];
     System.arraycopy (src, 0, l, 0, n);
     System.arraycopy (src, n, r, 0, r.length);
 }
 byte[][] lr = {l, r};
 return lr;
    }

    private static String hexits = "0123456789abcdef";

    private static String toHex( byte[] block ) {
 StringBuffer buf = new StringBuffer();
 for ( int i = 0; i < block.length; ++i ) {
     buf.append( hexits.charAt( ( block[i] >>> 4 ) & 0xf ) );
     buf.append( hexits.charAt( block[i] & 0xf ) );
 }
 return buf + "";
    }

    private static byte[] fromHex( String s ) {
 s = s.toLowerCase();
 byte[] b = new byte [(s.length() + 1) / 2];
 int j = 0;
 int h;
 int nybble = -1;
 for (int i = 0; i < s.length(); ++i) {
     h = hexits.indexOf (s.charAt(i));
     if (h >= 0) {
  if (nybble < 0) {
      nybble = h;
  } else {
      b[j++] = (byte)((nybble << 4) + h);
      nybble = -1;
  }
     }
 }
 if (nybble >= 0) {
     b[j++] = (byte)(nybble << 4);
 }
 if (j < b.length) {
     byte[] b2 = new byte [j];
     System.arraycopy (b, 0, b2, 0, j);
     b = b2;
 }
 return b;
    }
}