通过JNDI访问LDAP目录服务

package com.sina.test;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Hashtable;
import java.util.logging.Level;
import java.util.logging.Logger;

import javax.naming.Context;
import javax.naming.NamingEnumeration;
import javax.naming.NamingException;
import javax.naming.directory.Attribute;
import javax.naming.directory.Attributes;
import javax.naming.directory.BasicAttribute;
import javax.naming.directory.BasicAttributes;
import javax.naming.directory.DirContext;
import javax.naming.directory.InitialDirContext;
import javax.naming.directory.ModificationItem;
import javax.naming.directory.SearchControls;
import javax.naming.directory.SearchResult;

import com.sun.org.apache.xerces.internal.impl.dv.util.Base64;


public class LdapHelper {

    private static DirContext ctx;

    @SuppressWarnings(value = "unchecked")
    public static DirContext getCtx() {
//        if (ctx != null ) {
//            return ctx;
//        }
        String account = "cn=aicaiadmin,ou=authusers,dc=2caipiao,dc=com"; //binddn 
        String password = "Yae0zohV2mieJooCho";    //bindpwd
        String root = "dc=2caipiao,dc=com"; // root
        Hashtable env = new Hashtable();
        env.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.ldap.LdapCtxFactory");
        env.put(Context.PROVIDER_URL, "ldap://192.168.90.144:389/" + root);
        env.put(Context.SECURITY_AUTHENTICATION, "simple");
        env.put(Context.SECURITY_PRINCIPAL, account);
        env.put(Context.SECURITY_CREDENTIALS, password);
        try {
            // 链接ldap
            ctx = new InitialDirContext(env);
            System.out.println("认证成功");
        } catch (javax.naming.AuthenticationException e) {
        	e.printStackTrace();
            System.out.println("认证失败");
        } catch (Exception e) {
            System.out.println("认证出错：");
            e.printStackTrace();
        }
        return ctx;
    }
    
    public static void closeCtx(){
        try {
            ctx.close();
        } catch (NamingException ex) {
            Logger.getLogger(LdapHelper.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
    
    @SuppressWarnings(value = "unchecked")
    public static boolean verifySHA(String ldappw, String inputpw)
            throws NoSuchAlgorithmException {

        // MessageDigest 提供了消息摘要算法，如 MD5 或 SHA，的功能，这里LDAP使用的是SHA-1
        MessageDigest md = MessageDigest.getInstance("SHA-1");

        // 取出加密字符
        if (ldappw.startsWith("{SSHA}")) {
            ldappw = ldappw.substring(6);
        } else if (ldappw.startsWith("{SHA}")) {
            ldappw = ldappw.substring(5);
        }

        // 解码BASE64
        byte[] ldappwbyte = Base64.decode(ldappw);
        byte[] shacode;
        byte[] salt;

        // 前20位是SHA-1加密段，20位后是最初加密时的随机明文
        if (ldappwbyte.length <= 20) {
            shacode = ldappwbyte;
            salt = new byte[0];
        } else {
            shacode = new byte[20];
            salt = new byte[ldappwbyte.length - 20];
            System.arraycopy(ldappwbyte, 0, shacode, 0, 20);
            System.arraycopy(ldappwbyte, 20, salt, 0, salt.length);
        }

        // 把用户输入的密码添加到摘要计算信息
        md.update(inputpw.getBytes());
        // 把随机明文添加到摘要计算信息
        md.update(salt);

        // 按SSHA把当前用户密码进行计算
        byte[] inputpwbyte = md.digest();

        // 返回校验结果
        return MessageDigest.isEqual(shacode, inputpwbyte);
    }
    
    public static boolean addUser(String usr, String pwd) {
        boolean success = false;
        DirContext ctx = null;
        try {
            ctx = LdapHelper.getCtx();
            BasicAttributes attrsbu = new BasicAttributes();
            BasicAttribute objclassSet = new BasicAttribute("objectclass");
            objclassSet.add("person");
            objclassSet.add("top");
            objclassSet.add("organizationalPerson");
            objclassSet.add("inetOrgPerson");
            attrsbu.put(objclassSet);
            attrsbu.put("sn", usr);
            attrsbu.put("uid", usr);
            attrsbu.put("userPassword", pwd);
            ctx.createSubcontext("cn=" + usr + ",ou=People", attrsbu);
            ctx.close();
            return true;
        } catch (NamingException ex) {
            try {
                if (ctx != null) {
                    ctx.close();
                }
            } catch (NamingException namingException) {
                namingException.printStackTrace();
            }
            Logger.getLogger(LdapHelper.class.getName()).log(Level.SEVERE, null, ex);
        }
        return false;
    }
    
    
    public static boolean authenticate(String usr, String pwd) {
        boolean success = false;
        DirContext ctx = null;
        try {
            ctx = LdapHelper.getCtx();
            SearchControls constraints = new SearchControls();
            constraints.setSearchScope(SearchControls.SUBTREE_SCOPE);
            // constraints.setSearchScope(SearchControls.ONELEVEL_SCOPE);
            NamingEnumeration en = ctx.search("", "cn=" + usr, constraints); // 查询所有用户
            while (en != null && en.hasMoreElements()) {
                Object obj = en.nextElement();
                if (obj instanceof SearchResult) {
                    SearchResult si = (SearchResult) obj;
                    System.out.println("name:   " + si.getName());
                    Attributes attrs = si.getAttributes();
                    if (attrs == null) {
                        System.out.println("No   attributes");
                    } else {
                        Attribute attr = attrs.get("userPassword");
                        Object o = attr.get();
                        byte[] s = (byte[]) o;
                        String pwd2 = new String(s);
                        success = LdapHelper.verifySHA(pwd2, pwd);
                        return success;
                    }
                } else {
                    System.out.println(obj);
                }
                System.out.println();
            }
            ctx.close();
        } catch (NoSuchAlgorithmException ex) {
            try {
                if (ctx != null) {
                    ctx.close();
                }
            } catch (NamingException namingException) {
                namingException.printStackTrace();
            }
//            Logger.getLogger(DBAccess.class.getName()).log(Level.SEVERE, null, ex);
        } catch (NamingException ex) {
            try {
                if (ctx != null) {
                    ctx.close();
                }
            } catch (NamingException namingException) {
                namingException.printStackTrace();
            }
            Logger.getLogger(LdapHelper.class.getName()).log(Level.SEVERE, null, ex);
        }
        return false;
    }
    
    
    public static boolean updatePwdLdap(String usr, String pwd) {
        boolean success = false;
        DirContext ctx = null;
        try {
            ctx = LdapHelper.getCtx();
            ModificationItem[] modificationItem = new ModificationItem[1];
            modificationItem[0] = new ModificationItem(DirContext.REPLACE_ATTRIBUTE, new BasicAttribute("userPassword", pwd));
            ctx.modifyAttributes("cn=" + usr+",ou=People", modificationItem);
            ctx.close();
            return true;
        } catch (NamingException ex) {
            try {
                if (ctx != null) {
                    ctx.close();
                }
            } catch (NamingException namingException) {
                namingException.printStackTrace();
            }
            Logger.getLogger(LdapHelper.class.getName()).log(Level.SEVERE, null, ex);
        }
        return success;
    }

    public static void main(String[] args) {
        getCtx();
    }
  
}

1、现象、问题描述
目录服务是一种网络服务，它记载网络中所有资源与对象的基础信息，建立并确认各资源与对象的关系。多年来，目录服务与Internet同步发展，从本地目录，到网络目录，到跨平台目录，到可扩展的开放目录，纷繁芜杂，众多的目录服务和系统，不仅增加跟踪用户和网络资源的困难，而且每个目录服务都有自己特定的协议，也给应用开发者造成困难。由此，LDAP和JNDI作为一种标准化的目录协议和API应时而生。
2、关键过程、根本原因分析
1）LDAP
LDAP（Lightweight Directory Access Protocol，轻量目录访问协议）是一种使用TCP/IP以允许客户机访问目录信息并完成认证服务的跨平台标准协议。LDAP以目录信息树（DIT）的层次结构来组织数据，DIT的“根”是一个没有实际意义的虚根，树上的“叶”称为条目（Entry），用于存储数据。条目的名称由一个或多个属性组成，称为相对辨识名（Relative Distinguished Name, RDN），从某条目到根的直接下级条目的RDN序列组成了在DIT中惟一标识该条目的辨识名（Distinguished Name, DN）。条目由属性组成，属性由属性类型和相关的若干值构成。
LDAP协议采用C/S模式，它有三种基本的应用：即访问控制、白页服务和分布计算目录。LDAP并没有描述目录服务本身，而是定义了一致的数据交换格式（LDIF）和访问目录中数据的标准方法。通过这些标准的LDAP方法，一个LDAP客户端并不需要知道其服务器如何组织数据，就可以完成搜寻服务器、增加条目、修改条目和删除条目等目录操作。
2）JNDI
Sun公 司 组 织 开 发 了JNDI（Java Naming Directory Interface，Java命名和目录接口）用来简化对目录基础结构的访问。用JNDI可以创建基本的目录服务应用程序，如E-Mail地址簿、执行用户认证或管理网络打印之类的计算机资源。JNDI也能够创建具体的Java应用程序，如在目录中存放和检索串行化的Java对象。
从J2SDK1.3起，JNDI就被随同发布。因此，对于Java应用开发者来说，只要关心一个特定的协议和API，采用JNDI与LDAP目录服务器通讯，进而再依靠各厂商提供的目录协议的LDAP接口，就可以在程序不变的情况下实现客户与任何目录服务的交互。目前，对于各种流行的目录服务，都已经有产品允许通过LDAP与目录服务通信。JNDI与目录服务的交互如图所示。

图：JNDI与目录服务的交互
3、结论、解决方案及效果
JNDI API编程：
使用LDAP时，有几个标准的步骤：
a）连接到LDAP服务器；
b）绑定到LDAP服务器；
c）执行一系列的LDAP操作，如查询、增加条目、修改条目、删除条目等；
d）与LDAP服务器断开连接。
下面依次介绍与各步骤相关的编程
1）JNDI服务提供者
服务提供者是一个驱动器，它可以与命名/目录服务进行通信，类似于用JDBC驱动器和数据库进行通信。服务提供者实现了具备目录服务功能的DirContext接口，使应用开发者只需要学习JNDI，了解连接命名和目录服务的API。
2）连接LDAP服务器
在使用JNDI时，必须首先得到一个实现了DirContext接口的对象引用，一般使用InitialDirContext对象，它采用一个Hashtable作为参数，Hashtable中存储JNDI的环境变量。
// 创建存储JNDI环境变量的Hashtable
Hashtable env = new Hashtable();
// 定义JNDI服务提供者，这里是Sun提供的缺省的服务提供者env.put(Context.INITIAL_CONTEXT_FACTORY,
"com.sun.jndi.ldap.LdapCtxFactory");
// 定义LDAP服务器的主机名和端口号，缺省为389
env.put(Context.PROVIDER_URL, "ldap://10.10.10.10:389");
3）建立与到LDAP服务器的连接（即绑定到LDAP服务器）
LDAP中的认证叫做绑定，因为一个被认证的连接是绑定到目录中的一个特定的条目（用户）上。要具体地绑定到服务器上，必须为认证方法（如：simple、SSL或SASL）提供环境。所以必须定义待绑定的DN和口令。
// 定义认证的方式为“simple”
        env.put(Context.SECURITY_AUTHENTICATION, "simple");
// 定义DN
        env.put(Context.SECURITY_PRINCIPAL,
"cn=administrator,cn=users,dc=example,dc=com");
// 定义DN口令
        env.put(Context.SECURITY_CREDENTIALS, "example");
// 建立与LDAP服务器的连接，即绑定到LDAP服务器
        DirContext ctx = new InitialDirContext(env);
4）执行LDAP操作
a）查询
        public void query() throws NamingException
         {
            // 定义查询的DIT
         String dit = "ou=fin,dc=example,dc=com";
          
          // 定义查询的条目属性
          String[] attrs = {"cn","telephoneNumber","mobile"};
         
           // 定义过滤器（即：查询条件）
           //条件为 2006年12月31日8点整<=最后一次修改时间<=2007年1月1日8点整，
// 时间为格林尼治时间
           String filter = "(&(modifyTimestamp>=20061231080000Z) " + "
(modifyTimestamp<=20070101080000Z))";
         
           // 设置搜索器
           SearchControls ctls = new SearchControls();
           
           // 设置查询范围为：以当前DIT为根，查询整个子树
           ctls.setSearchScope(SearchControls.SUBTREE_SCOPE);
           
           // 设置需要搜索的属性
           ctls.setReturningAttributes(attrs);
           
           // 通过LDAP服务器的上下文对象查询
           NamingEnumeration result = this.ctx.search(dit, filter, ctls);
         
           // 输出条目信息
           // 定义查询结果
           SearchResult entry = null;
           while (result.hasMore())
           {
               // 取出查询结果
               entry = (SearchResult) result.next();
               if (entry != null && entry.getAttributes().size() > 0)
               {
                  // 打印条目
                   System.out.println(entry.getAttributes());
               }
           }
}
b）插入
          public void insert() throws NamingException
           {
              // 定义条目属性
              Attributes attrs = new BasicAttributes(true);
            
              // ID属性    
              Attribute id = new BasicAttribute("documentIdentifier");
              id.add("张三");
            
              // 基本属性
              Attribute objclass = new BasicAttribute("objectclass");
              objclass.add("inetOrgPerson");
              objclass.add("organizationalPerson");
              objclass.add("person");
              objclass.add("top");
              objclass.add("groupOfNames");
              objclass.add("document");
              objclass.add("pilotObject");
            
              // 名
              Attribute firstName = new BasicAttribute("givenName");
              firstName.add("三");
            
              // 姓
              Attribute secondName = new BasicAttribute("sn");
              secondName.add("张");
            
              // 公司
              Attribute company = new BasicAttribute("owner");
              company.add("测试");
            
              // 电话号码
              Attribute telephone = new BasicAttribute("telephoneNumber");
              telephone.add("025-88880000");
            
              // 手机
              Attribute mobile = new BasicAttribute("mobile");
              mobile.add("15988880000");
            
              // E-Mail
              Attribute email = new BasicAttribute("mail");
              email.add("[email protected]");
            
              // 设置条目属性
              attrs.put(id);
              attrs.put(objclass);
              attrs.put(firstName);
              attrs.put(secondName);
              attrs.put(company);
              attrs.put(telephone);
              attrs.put(mobile);
              attrs.put(email);
            
              // 通过LDAP服务器的上下文对象插入一个条目
              Context entry = this.ctx.createSubcontext(
                      "cn=张三,ou=fin,dc=example,dc=com", attrs);
            
              System.out.println(entry);
  }
c）更新
          public void update() throws NamingException
           {
              // 定义条目属性
              Attributes attrs = new BasicAttributes(true);
              // 电话号码
              Attribute telephone = new BasicAttribute("telephoneNumber");
              telephone.add("025-66660000");
            
              // 手机
              Attribute mobile = new BasicAttribute("mobile");
              mobile.add("15966660000");
            
              // 设置属性
              attrs.put(telephone);
              attrs.put(mobile);
            
              // 更新的DN
              String dn = "cn=张三,ou=fin,dc=example,dc=com";
            
              // 通过LDAP服务器的上下文对象更新一个条目
              this.ctx.modifyAttributes(dn,
                  DirContext.REPLACE_ATTRIBUTE, attrs);
  }
d）删除
          public void delete() throws NamingException
           {
              // 条目DN
              String dn = "cn=张三,ou=fin,dc=example,dc=com";
            
              // 通过LDAP服务器的上下文对象删除一个条目
              this.ctx.destroySubcontext(dn);
   }
注：更详细的接口信息，请参阅JDK的帮助文档javax.naming.directory里的接口描述。
   举例中的代码java文件：
4、经验总结、预防措施和规范建议
LDAP为目录服务提供了开放的标准化协议，JNDI则提供了与LDAP服务器进行交互的标准API，从而简化了对目录基础结构的访问，实现了与各种目录服务的交互。两者的充分结合必将使网络计算以及网络应用的开发更加简捷、高效。
5、备注
参考文献:
《JDK1.5API_CN.CHM》
《RFC2251-轻型目录访问协议.pdf》
《RFC2252-属性语法定义.pdf》
《RFC2254-LDAP查询过滤器的字符串表示法.pdf》
《RFC2829-LDAP认证方法.pdf》
《draft-ietf-pkix-time-stamp-15-from-14_diff.txt》
[ 本帖最后由 这件马甲不错 2013-05-16 09:39:40 编辑 ]


LDAP的英文全称是Lightweight Directory Access Protocol，一般都简称为LDAP。它是基于X.500标准的，但是简单多了并且可以根据需要定制。与X.500不同，LDAP支持TCP/IP，这对访问Internet是必须的。LDAP的核心规范在RFC中都有定义，所有与LDAP相关的RFC都可以在LDAPman RFC网页中找到。现在LDAP技术不仅发展得很快而且也是激动人心的。在企业范围内实现LDAP可以让运行在几乎所有计算机平台上的所有的应用程序从 LDAP目录中获取信息。LDAP目录中可以存储各种类型的数据：电子邮件地址、邮件路由信息、人力资源数据、公用密匙、联系人列表，等等。通过把 LDAP目录作为系统集成中的一个重要环节，可以简化员工在企业内部查询信息的步骤，甚至连主要的数据源都可以放在任何地方。
        在前一阵子改版Sun SITE的时候，由于考虑到学校里的同学们使用的基本都是教育网，连接外网很麻烦，所以学习learningconnection上的课程也非常的麻烦，于是我和Vincent就考虑把SAI的一部分课程移植到Sun SITE上面来，以供教育网的同学使用。我们使用了Sakai这一套开源软件来提供SAI课程的在线学习，由于Sakai的用户需要在LDAP上进行认证，因此需要把用户认证放到LDAP上来。在学习使用LDAP的过程中遇到了一些问题，现在总结一下：

1、管理连接的LdapHelper.java



package sunsite.basic;

import com.sun.org.apache.xerces.internal.impl.dv.util.Base64;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Hashtable;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.naming.Context;
import javax.naming.NamingException;
import javax.naming.directory.DirContext;
import javax.naming.directory.InitialDirContext;


public class LdapHelper {

    private static DirContext ctx;

    @SuppressWarnings(value = "unchecked")
    public static DirContext getCtx() {
//        if (ctx != null ) {
//            return ctx;
//        }
        String account = "Manager"; //binddn
        String password = "pwd";    //bindpwd
        String root = "dc=scut,dc=edu,dc=cn"; // root
        Hashtable env = new Hashtable();
        env.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.ldap.LdapCtxFactory");
        env.put(Context.PROVIDER_URL, "ldap://localhost:389/" + root);
        env.put(Context.SECURITY_AUTHENTICATION, "simple");
        env.put(Context.SECURITY_PRINCIPAL, "cn="+account );
        env.put(Context.SECURITY_CREDENTIALS, password);
        try {
            // 链接ldap
            ctx = new InitialDirContext(env);
            System.out.println("认证成功");
        } catch (javax.naming.AuthenticationException e) {
            System.out.println("认证失败");
        } catch (Exception e) {
            System.out.println("认证出错：");
            e.printStackTrace();
        }
        return ctx;
    }
   
    public static void closeCtx(){
        try {
            ctx.close();
        } catch (NamingException ex) {
            Logger.getLogger(LdapHelper.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
   
    @SuppressWarnings(value = "unchecked")
    public static boolean verifySHA(String ldappw, String inputpw)
            throws NoSuchAlgorithmException {

        // MessageDigest 提供了消息摘要算法，如 MD5 或 SHA，的功能，这里LDAP使用的是SHA-1
        MessageDigest md = MessageDigest.getInstance("SHA-1");

        // 取出加密字符
        if (ldappw.startsWith("{SSHA}")) {
            ldappw = ldappw.substring(6);
        } else if (ldappw.startsWith("{SHA}")) {
            ldappw = ldappw.substring(5);
        }

        // 解码BASE64
        byte[] ldappwbyte = Base64.decode(ldappw);
        byte[] shacode;
        byte[] salt;

        // 前20位是SHA-1加密段，20位后是最初加密时的随机明文
        if (ldappwbyte.length <= 20) {
            shacode = ldappwbyte;
            salt = new byte[0];
        } else {
            shacode = new byte[20];
            salt = new byte[ldappwbyte.length - 20];
            System.arraycopy(ldappwbyte, 0, shacode, 0, 20);
            System.arraycopy(ldappwbyte, 20, salt, 0, salt.length);
        }

        // 把用户输入的密码添加到摘要计算信息
        md.update(inputpw.getBytes());
        // 把随机明文添加到摘要计算信息
        md.update(salt);

        // 按SSHA把当前用户密码进行计算
        byte[] inputpwbyte = md.digest();

        // 返回校验结果
        return MessageDigest.isEqual(shacode, inputpwbyte);
    }

    public static void main(String[] args) {
        getCtx();
    }
 
}
以上这段代码中，public static DirContext getCtx() 这一个方法负责建立与ldap服务器的连接，public static boolean verifySHA(String ldappw, String inputpw)
方法负责判断将明文密码跟ldap中的用户密码进行匹配判断。因为ldap中的用户密码是经过SSHA散列的，因此必须将明文转换为SSHA码才能够进行匹配。这一个算法，我是参考

http://raistlin.spaces.live.com/blog/cns!20be4528d42aa141!165.entry

上的代码，仅作为学习参考而用。

2、添加人员的操作：

public static boolean addUser(String usr, String pwd) {
        boolean success = false;
        DirContext ctx = null;
        try {
            ctx = LdapHelper.getCtx();
            BasicAttributes attrsbu = new BasicAttributes();
            BasicAttribute objclassSet = new BasicAttribute("objectclass");
            objclassSet.add("person");
            objclassSet.add("top");
            objclassSet.add("organizationalPerson");
            objclassSet.add("inetOrgPerson");
            attrsbu.put(objclassSet);
            attrsbu.put("sn", usr);
            attrsbu.put("uid", usr);
            attrsbu.put("userPassword", pwd);
            ctx.createSubcontext("cn=" + usr + ",ou=People", attrsbu);
            ctx.close();
            return true;
        } catch (NamingException ex) {
            try {
                if (ctx != null) {
                    ctx.close();
                }
            } catch (NamingException namingException) {
                namingException.printStackTrace();
            }
            Logger.getLogger(LdapHelper.class.getName()).log(Level.SEVERE, null, ex);
        }
        return false;
    }
这一段代码为每个用户分配了一个cn，使用userPassword的属性来存储用户密码，这一属性是经过SSHA散列的。

3、用户认证：

public static boolean authenticate(String usr, String pwd) {
        boolean success = false;
        DirContext ctx = null;
        try {
            ctx = LdapHelper.getCtx();
            SearchControls constraints = new SearchControls();
            constraints.setSearchScope(SearchControls.SUBTREE_SCOPE);
            // constraints.setSearchScope(SearchControls.ONELEVEL_SCOPE);
            NamingEnumeration en = ctx.search("", "cn=" + usr, constraints); // 查询所有用户
            while (en != null && en.hasMoreElements()) {
                Object obj = en.nextElement();
                if (obj instanceof SearchResult) {
                    SearchResult si = (SearchResult) obj;
                    System.out.println("name:   " + si.getName());
                    Attributes attrs = si.getAttributes();
                    if (attrs == null) {
                        System.out.println("No   attributes");
                    } else {
                        Attribute attr = attrs.get("userPassword");
                        Object o = attr.get();
                        byte[] s = (byte[]) o;
                        String pwd2 = new String(s);
                        success = LdapHelper.verifySHA(pwd2, pwd);
                        return success;
                    }
                } else {
                    System.out.println(obj);
                }
                System.out.println();
            }
            ctx.close();
        } catch (NoSuchAlgorithmException ex) {
            try {
                if (ctx != null) {
                    ctx.close();
                }
            } catch (NamingException namingException) {
                namingException.printStackTrace();
            }
            Logger.getLogger(DBAccess.class.getName()).log(Level.SEVERE, null, ex);
        } catch (NamingException ex) {
            try {
                if (ctx != null) {
                    ctx.close();
                }
            } catch (NamingException namingException) {
                namingException.printStackTrace();
            }
            Logger.getLogger(LdapHelper.class.getName()).log(Level.SEVERE, null, ex);
        }
        return false;
    }
这一段代码事实上在查询用户的的cn和密码，当然由于密码这个属性需要散列成SSHA，因此调用了LdapHelper中的verifySHA方法。

3、修改密码：

public static boolean updatePwdLdap(String usr, String pwd) {
        boolean success = false;
        DirContext ctx = null;
        try {
            ctx = LdapHelper.getCtx();
            ModificationItem[] modificationItem = new ModificationItem[1];
            modificationItem[0] = new ModificationItem(DirContext.REPLACE_ATTRIBUTE, new BasicAttribute("userPassword", pwd));
            ctx.modifyAttributes("cn=" + usr+",ou=People", modificationItem);
            ctx.close();
            return true;
        } catch (NamingException ex) {
            try {
                if (ctx != null) {
                    ctx.close();
                }
            } catch (NamingException namingException) {
                namingException.printStackTrace();
            }
            Logger.getLogger(LdapHelper.class.getName()).log(Level.SEVERE, null, ex);
        }
        return success;
    }
这一方法实质上执行的是一个ldap update的操作，只不过是把密码散列了一下。

4、删除用户，非常简单，只要执行一下

ctx.destroySubcontext("cn=" + account);   即可。

5、为了方便地查看ldap上的信息，可以使用ldapbrowser这一开源软件，这是一款非常不错的ldap工具，下载地址是

http://www-unix.mcs.anl.gov/~gawor/ldap/download.html

参考资料：

http://www.blogjava.net/anwenhao/archive/2007/05/31/121157.html

http://raistlin.spaces.live.com/blog/cns!20be4528d42aa141!165.entry