ldap demo

最新推荐文章于 2021-03-13 13:24:10 发布
最新推荐文章于 2021-03-13 13:24:10 发布
阅读量2.3k 收藏
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gm_163/article/details/18268485
版权
package com.alan;

import java.util.List;
import java.util.Map;


/**
 * LDAP服务接口
 * @author guoming
 *
 */
public interface LDAPServiceI {

    /**
     * 验证指定的用户是否存在<br/>
     * @param userName 用户名
     * @return
     */
    public boolean verifyUserExists(String userName);
    
    /**
     * 验证用户
     *
     * @param userDn 用户名
     * @param password 用户密码
     * @return 验证是否成功
     */
    public boolean authUser(String userName, String password);
    
    /**
     * 获取指定DN下的所有用户名称列表<br/>
     * @param DN
     * @return 用户名称列表
     */
    public List<String> getAllUserNameList();
    
    /**
     * 增加用户
     * @param uid 用户名
     * @param pwd 用户密码:如果密码没有值，则表示无密码
     * @return map键值:{uid:xxxx,success:boolean,msg:reason}
     */
    Map<String,Object> addUser(String uid,String pwd);
    
    /**
     * 删除用户
     * @param uid 用户名
     * @return
     */
    boolean delUser(String uid);
    
    /**
     * 修改指定用户密码
     * @param uid 用户名
     * @param originalPwd 用户原始密码
     * @param newPwd 用户新密码
     * @return
     */
    boolean modifyPwd(String uid,String originalPwd,String newPwd);
}






package com.alan;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.springframework.util.Assert;
import org.springframework.util.StringUtils;

import com.unboundid.ldap.sdk.Attribute;
import com.unboundid.ldap.sdk.Filter;
import com.unboundid.ldap.sdk.LDAPConnection;
import com.unboundid.ldap.sdk.LDAPException;
import com.unboundid.ldap.sdk.LDAPSearchException;
import com.unboundid.ldap.sdk.Modification;
import com.unboundid.ldap.sdk.ModificationType;
import com.unboundid.ldap.sdk.SearchRequest;
import com.unboundid.ldap.sdk.SearchResult;
import com.unboundid.ldap.sdk.SearchResultEntry;
import com.unboundid.ldap.sdk.SearchScope;
import com.unboundid.util.Base64;


/**
 * LDAP服务实现类
 * @author guoming
 *
 */
public class LDAPServiceImpl implements LDAPServiceI {

    
        private static String ldapHost="10.0.31.58";
        private static int ldapPort=10389;
        private static LDAPConnection connection = null;
        private static String baseDN="ou=system";
        private static String ldapPassword="secret";
        
        /**
         * 连接LDAP
         */
        private static void openConnection(){
            
            if (null == connection) {
                
                try {
                    connection = new LDAPConnection(ldapHost,ldapPort,"uid=admin,"+baseDN,ldapPassword);
                    System.out.println(connection);
                } catch (LDAPException e) {
                    System.out.println("connection ldap occurs error:\n"+e.getMessage());
                }
            }
        }
        static{
            
            openConnection();
        }
        
        public static void main(String[] args)throws Exception {
            
            LDAPServiceImpl service = new LDAPServiceImpl();
            //System.out.println(service.addUser("tiao",""));
            //System.out.println(service.delUser("baiy"));
            System.out.println(service.authUser("tiao","111111"));
            //System.out.println(service.modifyPwd("tiao","123456","111111"));
//            List<String> resultList = service.getAllUserNameList();
//            for (String name:resultList) {
//                System.out.println("--->"+name);
//            }
//            if (service.verifyUserExists(userName)) {
//                
//                System.out.println(service.authUser(userName,pwd));
//            }else{
//                
//                System.out.println(userName+" not exists!");
//            }
        }
        
        @Override
        public boolean verifyUserExists(String userName) {
            
            Assert.notNull(userName,"user name can't be null!");
            boolean flag = false;// 默认用户不存在
            Filter filter = Filter.createEqualityFilter("uid",userName);
            SearchRequest searchRequest = new SearchRequest(baseDN,SearchScope.SUB,filter);
            SearchResult searchResult = null;
            try {
                searchResult=connection.search(searchRequest);
                if (null != searchResult && searchResult.getEntryCount()>0) {
                    
                    flag = true;
                }
            } catch (LDAPSearchException e) {
                System.out.println("query occurs error:\n"+e.getMessage());
            }
            return flag;
        }

        @Override
        public boolean authUser(String userName, String password) {
            
            boolean authResult = false;
            Assert.notNull(userName,"user name can't be null!");
            Filter filter = Filter.createEqualityFilter("uid",userName);
            SearchRequest searchRequest = new SearchRequest(baseDN,SearchScope.ONE,filter);
            SearchResult searchResult = null;
            try {
                searchResult=connection.search(searchRequest);
                if (null != searchResult && searchResult.getEntryCount()>0) {
                    
                    SearchResultEntry entry = searchResult.getSearchEntries().get(0);
                    authResult = this.verifyPwdEquality(entry, password);
                }
            } catch (LDAPSearchException e) {
                System.out.println("query occurs error:\n"+e.getMessage());
            }
            return authResult;
        }
        /**
         * 验证密码的一致性
         * @param entry
         * @param password 用户输入的密码
         * @return
         */
        private boolean verifyPwdEquality(SearchResultEntry entry,String password) {
            Assert.notNull(entry, "entry can't be empty");
            boolean authResult = false;
            String oldPwd = entry.getAttributeValue("userPassword");
            if (!StringUtils.hasLength(password) && !StringUtils.hasLength(oldPwd)) {// 如果不存在userPassword属性,前password为空则返回true
                
                authResult = true;
                return authResult;
            }
            if (StringUtils.hasLength(password) && (StringUtils.hasLength(oldPwd))){
                
                String algorithmStr = "";
                if (oldPwd.contains("{SHA}") || oldPwd.contains("{SSHA}")
                        || oldPwd.contains("{sha}") || oldPwd.contains("{ssha}")) {// 使用sha-1算法对新旧密码进行比较
                    
                    algorithmStr = "sha-1";
                    
                }else if(oldPwd.contains("{md5}") || oldPwd.contains("{MD5}")) {// 使用md5算法对新旧密码进行比较
                    
                    algorithmStr = "md5";
                    
                }
                try {
                    authResult = verifySHA(algorithmStr,oldPwd,password);
                } catch (NoSuchAlgorithmException e) {
                    
                    e.printStackTrace();
                }
                
            }
            
            return authResult;
        }
        /**
         * 验证密码是否一致
         * @param algorithm 算法名称
         * @param ldappw ldap中的密码
         * @param inputpw 用户输入的密码
         * @return
         * @throws NoSuchAlgorithmException
         */
         public static boolean verifySHA(String algorithm,String ldappw, String inputpw)
                    throws NoSuchAlgorithmException {

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

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

                // 解码BASE64
                byte[] ldappwbyte=null;
                try {
                    ldappwbyte = Base64.decode(ldappw);
                } catch (ParseException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                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);
            }

        @Override
        public List<String> getAllUserNameList() {
            
            
            List<String> resultList = new ArrayList<String>();
            Filter filter = Filter.createEqualityFilter("objectClass","person");
            SearchRequest searchRequest = new SearchRequest(baseDN,SearchScope.ONE,filter);
            SearchResult searchResult = null;
            try {
                searchResult=connection.search(searchRequest);
                if (null != searchResult && searchResult.getEntryCount()>0) {
                    
                    for (SearchResultEntry entry : searchResult.getSearchEntries()) {
                        resultList.add(entry.getAttributeValue("uid"));
                    }
                }
            } catch (LDAPSearchException e) {
                
                e.printStackTrace();
            }
            return resultList;
        }

        @Override
        public Map<String,Object> addUser(String uid, String pwd) {
            
            Assert.hasLength(uid,"uid can't be empty");
            Map<String,Object> so = new HashMap<String,Object>();
            so.put("uid","");
            so.put("success",false);
            so.put("msg","");
            if(this.verifyUserExists(uid)){// 说明用户已存在
                
                so.put("uid",uid);
                so.put("success",false);
                so.put("msg",uid+" have exists!");
                return so;
            }
            List<Attribute> attributes = new ArrayList<Attribute>();
            attributes.add(new Attribute("objectClass","organizationalPerson","person","inetOrgPerson","top"));
            attributes.add(new Attribute("sn","person"));
            attributes.add(new Attribute("cn","person"));
            attributes.add(new Attribute("uid",uid));
            if (StringUtils.hasLength(pwd)) {
                
                attributes.add(new Attribute("userPassword",pwd));
            }
            try {
                connection.add("uid="+uid+","+baseDN, attributes);
                so.put("uid",uid);
                so.put("success",true);
                so.put("msg","");
            } catch (LDAPException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            return so;
        }

        @Override
        public boolean delUser(String uid) {
            
            Assert.hasLength(uid,"uid can't be empty");
            boolean flag = true;
            if (this.verifyUserExists(uid)) {
                
                try {
                    connection.delete("uid="+uid+","+baseDN);
                } catch (LDAPException e) {
                    
                    flag = false;
                    e.printStackTrace();
                }
            }
            return flag;
        }

        @Override
        public boolean modifyPwd(String uid, String originalPwd,String newPwd) {
            
            Assert.hasLength(uid,"uid can't be empty");
            Assert.hasLength(newPwd,"new pwd can't be empty");
            boolean flag = false;
            /***************第一步 首先取出指定用户的旧密码**********************/
            
            String filter = "(&(objectclass=person)(uid="+uid+"))";
            try {
                SearchRequest searchRequest = new SearchRequest(baseDN,SearchScope.ONE,filter);
                SearchResult searchResult = null;
                searchResult=connection.search(searchRequest);
                SearchResultEntry entry= null;
                if (null != searchResult && searchResult.getEntryCount()>0) {
                    entry = searchResult.getSearchEntries().get(0);
                }
                
             /***************第二步 验证输入的旧密码是否与LDAP服务器上的旧密码一致**********************/
               boolean authResult = false;
               if (null != entry) {
                   authResult = this.verifyPwdEquality(entry, originalPwd);
               }
               System.out.println("authResult="+authResult);
               Modification modification = null;
               String exists="";
               if (authResult) {// 说明旧密码认证通过,则修改新的密码
                   
                   exists = entry.getAttributeValue("userPassword");
                   modification = new Modification(ModificationType.ADD,"userPassword",newPwd);
                   if (StringUtils.hasLength(exists)) {// 则进行替换
                       
                       modification = new Modification(ModificationType.REPLACE,"userPassword",newPwd);
                   }
                   connection.modify("uid="+uid+","+baseDN, modification);
                   flag = true;
               }
            } catch (LDAPException e) {
                
                e.printStackTrace();
            }
            return flag;
        }
    
}


一无所知163
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
LDAP代码操作 Demo
01-22
LDAP代码操作Demo，LDAP操作代码样例 初始化LDAP 目录服务上下文、绑定/创建LDAP条目对象、获取条目属性、修改条目属性等实例
ldap-demo:LDAP扩展的示范Wiki
05-02
为LDAPGroups和受限命名空间配置MediaWiki 这个文件 该文件旨在记录MediaWiki中进行的每个配置。 它旨在驻留在ldap-demo/README.org并使用 ldap-demo/README.org 。 “缠结”来自（ ）的思想。 如何使用这个档案 任何时候需要更改部分配置时，都应遵循以下过程： 编辑此文件的相关部分 通过在emacs中打开并在文件中键入“ CTRL-C CTRL-v t”或用emacs所用术语Cc Cv t。 将生成的文件检入git存储库。 初始设置 要求： 您已经设置了MySQL和httpd （用于海绵） PHP CLI 基本裸LocalSettings.php git checkout与子模块 if [ ! -x mediawiki/.git ] ; then git submodule add -f -b REL1_3
spring ldap demo
chen88358323的专栏
05-27 3010
tag: spring ldap demo 最近在弄AD 活动目录的登录功能，用到了spring-ldap1.3，留个脚印! package sample; import java.util.List; import javax.naming.NamingException; import javax.naming.directory.Attributes; import org.spring
基于JavaJNDI的LDAP Demo
05-24
基于Java JNDI 操纵LDAP的基础实现,包括LDAP连接相关生命周期,认证的两种策略demo,条目的操作,schema的基础操作包括(attributeDefinition\objectDefinition\)但未包含相关syntaxDefinition的操纵. 没有资源分的朋友可给我发邮件ybygjy#gmail.com
java ldap demo,JAVA操作LDAP
weixin_29715563的博客
03-13 199
package com.bi.test;import java.util.Hashtable;import javax.naming.Context;import javax.naming.NamingEnumeration;import javax.naming.NamingException;import javax.naming.directory.SearchControls;import...
SpringLdapDemo
01-17
学习SpringSecurity时，看到LDAP认证，不了解LDAP...所以转头学习了一下LDAP，搭建了一个DEMO，仅作记录。 LDAP(Lightweight Directory Access Protocol) 轻量级目录访问协议，LDAP目录以树状的层次结构来存储数据。
spring-ldap demo
02-18
本示例项目 "spring-ldap demo" 提供了一个关于如何使用 Spring LDAP 进行实际操作的详细教程，包括与 LDAP 目录的增删查改操作，并结合了 EXT.js 进行前端展示。 首先，我们来了解一下 Spring LDAP 的核心概念。...
cas整合ldap demo
08-27
这是cas+ldap的完整demo,只需要将这个下载下来的demo解压缩，就可直接导入eclipse或者myeclipse中使用，只需要修改几个参数而已，详情请看博客: http://blog.csdn.net/danruoshui315/article/details/48001547
LDAP完整读取demo
06-05
LDAP完整读取demo
LDAP代码操作Demo
chilongxph2的博客
08-12 439
LDAP操作代码样例 初始化LDAP 目录服务上下文 该例子中，我们使用uid=linly,ou=People,dc=jsoso,dc=net这个账号，链接位于本机8389端口的LDAP服务器（ldap://localhost:8389），认证方式采用simple类型，即用户名/密码方式。 private static void initialContext() throws Nami...
AD、LDAP本身及可编程介绍（附demo代码）
07-30
比较宏观全面的介绍AD， AD LDS，LDAP， OpenLdap，LDAP client API，并提供了c++，java，python的示例代码，不是很深入，但对入门，对全面的理解这几个技术之间的关系，有很大的帮助。
使用Java操作LDAP案例
04-07
NULL 博文链接：https://cgs1999.iteye.com/blog/1574635
apache+ldap
09-23
描述apache怎么配置使用 openladp进行认证
java 连接ldap_ldap java 连接demo
weixin_39640024的博客
02-20 246
public class LDAPHelper {/*** LDAP可以理解为一个多级目录，这里，表示要连接到那个具体的目录*/private final String baseDn = "ou=People,dc=changyeyi,dc=com";private LdapContext ctx = null;private final Control[] connCtls = null;pri...
java ldap demo_java操作Ldap，支持建立开启状态的用户，支持修改密码，放入eclipse测试即用...
weixin_39619170的博客
03-01 106
【实例简介】java操作Ldap，支持建立开启状态的用户，支持修改密码，放入eclipse测试即用，彻底操作AD域用户，有不明白的可以联系我【实例截图】【核心代码】6d20438f-b5e8-488e-982d-5eb71c286ad8└── Edesktop-LDAP├── bin│ ├── applicationContext.xml│ └── com│ └── china...
Spring LDAPTemplate连接LDAP数据库demo
ki_boy的专栏
08-21 6350
step1、创建maven工程
VC封装LDAP开发接口
pengpengcsdn的专栏
10-12 1337
在使用IBM 的Tivoli Directory Server（TDS）即LDAP服务器的时候，TDS有提供C－client SDK，包括一些*.h和*.lib的文件，还有一些已经可以用的工具，比如搜索(ldapsearch.exe)等等，包括这些工具的一些源代码。我以前没用过VC，现在想要把ldapsearch.exe的功能封装到一个DLL文件中，让其他应用可以调用，这样在用户登陆的时候可以
2-8连接到LDAP
郝大侠的博客
08-08 669
集中式用户认证1、账户信息储存在远程服务器上，从集中式储存服务器检索信息； 可以实现单点登陆（sso），用户凭借密码进行一次身份验证； 单点登录：一家公司可能有多台server，只要一台server上认证过了，登录其他server无需认证； 2、LDAP服务器不仅提供账户和身份验证两个服务，还提供数据储存；（移动使用） ①LDAP是轻量目录访问协议，结构用树来表示，而不是用表格；②适合查，写
写 一个 Spring boot 集成 ldap 支持SSL 的demo
最新发布
02-16
好的，下面是一个 Spring Boot 集成 LDAP 并支持 SSL 的示例： 首先，需要在 pom.xml 文件中添加以下依赖项： ``` <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-ldap</artifactId> </dependency> <dependency> <groupId>org.springframework.security</groupId> <artifactId>spring-security-ldap</artifactId> </dependency> <dependency> <groupId>org.springframework.security</groupId> <artifactId>spring-security-config</artifactId> </dependency> ``` 然后，在 application.properties 文件中添加以下配置： ``` spring.ldap.urls=ldaps://ldap.example.com:636 spring.ldap.base=dc=example,dc=com spring.ldap.username=cn=admin,dc=example,dc=com spring.ldap.password=admin_password spring.ldap.user-search-base=ou=users spring.ldap.user-search-filter=(uid={0}) spring.ldap.group-search-base=ou=groups spring.ldap.group-search-filter=(member={0}) spring.ldap.group-role-attribute=cn spring.ldap.use-ssl=true ``` 这些配置将指定 LDAP 服务器的 URL、基本 DN、管理员用户名和密码，以及用于搜索用户和组的基本 DN 和过滤器。最后，将 `spring.ldap.use-ssl` 属性设置为 `true`，以启用 SSL。 接下来，可以编写一个简单的 Spring Boot 应用程序，使用上述配置连接到 LDAP 服务器。下面是一个示例： ``` @SpringBootApplication public class LdapDemoApplication implements CommandLineRunner { @Autowired private LdapTemplate ldapTemplate; public static void main(String[] args) { SpringApplication.run(LdapDemoApplication.class, args); } @Override public void run(String... args) throws Exception { List<String> groupNames = ldapTemplate.search( Query.query().where("objectclass").is("groupOfNames"), (AttributesMapper<String>) attrs -> (String) attrs.get("cn").get()); System.out.println("Groups: " + groupNames); } } ``` 这个示例使用 `LdapTemplate` 类搜索所有名为 "groupOfNames" 的 LDAP 对象，并将它们的 "cn" 属性映射到一个字符串列表中。然后，应用程序将列表输出到控制台。 希望这个示例能够帮助您集成 LDAP 并支持 SSL。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值