基于springboot+Ldaps协议进行AD账号管理

最新推荐文章于 2024-06-14 17:36:41 发布
最新推荐文章于 2024-06-14 17:36:41 发布
阅读量864 收藏 11
点赞数 9
文章标签： spring boot java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zjpopo/article/details/135226773
版权

一、背景

      近期使用springboot 自带ldapsTemplate进行AD账号管理技术改造，查阅了多份资料结合实战，整理一份可运行的案例，考虑到ldapTemplate返回的错误信息晦涩难懂，详细参照文中细节一定可以大大减轻你接入时的痛苦！

二、结合代码实战解析

2.1 ldaps依赖引入

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-ldap</artifactId>
</dependency>

2.2 application.yaml配置添加

ldap:
  #ldaps服务地址，636为ldaps端口
  url: ldaps://10.230.22.76:636/
  base: DC=ddd,DC=com
  username: 'ddd\ldap_admin'
  passwd: 'xxxxxxxx'

以实际服务器及账号密钥为主，其中base很重要，代表你的顶级树域；

2.3 核心配置类


import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.ldap.core.LdapTemplate;
import org.springframework.ldap.core.support.LdapContextSource;

import javax.naming.Context;
import java.util.Hashtable;
import java.util.Objects;

/**
 * @author z先生
 * @date 2023/12/04
 */
@Slf4j
@Configuration
// @ConditionalOnExpression("${ldap.enabled:false}")
public class LdapConfiguration {

    private LdapTemplate ldapTemplate;

    @Value("${ldap.url}")
    private String ldapUrl;

    @Value("${ldap.base}")
    private String ldapBaseDc;

    @Value("${ldap.username}")
    private String ldapUsername;

    @Value("${ldap.passwd}")
    private String ldapPasswd;


    /**
     * 继承LdapContextSource重写getAnonymousEnv方法来加载，
     * 使连接ldap时用SSL连接（由于修改AD密码时必须使用SSL连接）
     */
    public class SsldapContextSource extends LdapContextSource {
        public Hashtable<String, Object> getAnonymousEnv() {
            System.setProperty("com.sun.jndi.ldap.object.disableEndpointIdentification", "true");
            Hashtable<String, Object> anonymousEnv = super.getAnonymousEnv();
            anonymousEnv.put("java.naming.security.protocol", "ssl");
            anonymousEnv.put("java.naming.ldap.factory.socket", CustomSslSocketFactory.class.getName());
            anonymousEnv.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.ldap.LdapCtxFactory");
            return anonymousEnv;
        }
    }


    @Bean
    public LdapContextSource contextSource() {

        SsldapContextSource ldapContextSource = new SsldapContextSource();
        ldapContextSource.setBase(ldapBaseDc);
        ldapContextSource.setUrl(ldapUrl);
        ldapContextSource.setUserDn(ldapUsername);
        ldapContextSource.setPassword(ldapPasswd);
        ldapContextSource.setPooled(false);
        ldapContextSource.setReferral("follow");
        ldapContextSource.afterPropertiesSet();
        return ldapContextSource;
    }

    @Bean
    public LdapTemplate ldapTemplate(LdapContextSource contextSource) {
        if (Objects.isNull(contextSource)) {
            throw new RuntimeException("ldap contextSource error");
        }
        if (null == ldapTemplate) {
            ldapTemplate = new LdapTemplate(contextSource);
        }
        return ldapTemplate;
    }

}

关联CustomSslSocketFactory，用于跳过证书认证；


import javax.net.SocketFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSocketFactory;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import java.io.IOException;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
import java.security.SecureRandom;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;

/**
 * 自定义的SSL工厂里面加载自己实现X509TrustManager，信任自签证书
 * @author z先生
 */
public class CustomSslSocketFactory extends SSLSocketFactory {
    private SSLSocketFactory socketFactory;

    public CustomSslSocketFactory() {
        try {
            SSLContext ctx = SSLContext.getInstance("TLS");
            ctx.init(null, new TrustManager[]{new DummyTrustmanager()}, new SecureRandom());
            socketFactory = ctx.getSocketFactory();
        } catch (Exception ex) {
            ex.printStackTrace(System.err);
        }
    }

    public static SocketFactory getDefault() {
        return new CustomSslSocketFactory();
    }

    @Override
    public String[] getDefaultCipherSuites() {
        return socketFactory.getDefaultCipherSuites();
    }

    @Override
    public String[] getSupportedCipherSuites() {
        return socketFactory.getSupportedCipherSuites();
    }

    @Override
    public Socket createSocket(Socket socket, String string, int num, boolean bool) throws IOException {
        return socketFactory.createSocket(socket, string, num, bool);
    }

    @Override
    public Socket createSocket(String string, int num) throws IOException, UnknownHostException {
        return socketFactory.createSocket(string, num);
    }

    @Override
    public Socket createSocket(String string, int num, InetAddress netAdd, int i) throws IOException, UnknownHostException {
        return socketFactory.createSocket(string, num, netAdd, i);
    }

    @Override
    public Socket createSocket(InetAddress netAdd, int num) throws IOException {
        return socketFactory.createSocket(netAdd, num);
    }

    @Override
    public Socket createSocket(InetAddress netAdd1, int num, InetAddress netAdd2, int i) throws IOException {
        return socketFactory.createSocket(netAdd1, num, netAdd2, i);
    }


    /**
     * 证书
     */
    public static class DummyTrustmanager implements X509TrustManager {
        @Override
        public void checkClientTrusted(X509Certificate[] cert, String string) throws CertificateException {
        }

        @Override
        public void checkServerTrusted(X509Certificate[] cert, String string) throws CertificateException {
        }

        @Override
        public X509Certificate[] getAcceptedIssuers() {
            return new java.security.cert.X509Certificate[0];
        }

    }
}

核心ad账号实体类


import com.fasterxml.jackson.annotation.JsonIgnore;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.ldap.odm.annotations.Attribute;
import org.springframework.ldap.odm.annotations.DnAttribute;
import org.springframework.ldap.odm.annotations.Entry;
import org.springframework.ldap.odm.annotations.Id;

import javax.naming.Name;

/**
 * sss
 *
 * @author: z先生 
 * 2023/12/04
 */
@Data
@NoArgsConstructor
@Entry(objectClasses = {"user", "organizationalPerson", "person", "top"})
public final class AdPerson {

    @Id
    @JsonIgnore
    private Name id;

    @Attribute(name = "samAccountName")
    private String samAccountName;

    @DnAttribute(value = "CN", index = 0)
    @Attribute(name = "cn")
    private String cn;

    @Attribute(name = "sn")
    private String sn;
    /**
     * 取值：First Name
     */
    @Attribute(name = "givenName")
    private String givenName;
    @Attribute(name = "userPrincipalName")
    private String userPrincipalName;

    @Attribute(name = "displayName")
    private String displayName;

    @Attribute(name = "mobile")
    private String mobile;

    @Attribute(name = "mail")
    private String mail;

    /**
     * ouName：从映射表中获取 ad_ou
     */
    private String ouName;
    @Attribute(name = "name")
    private String name;
    /**
     * 职位 jobTitle
     */
    @Attribute(name = "title")
    private String title;
    /**
     * 部门名称：从映射表中获取 display_name
     */
    @Attribute(name = "department")
    private String department;

    /**
     * 领导：从映射表中获取 managerOu
     */
    @Attribute(name = "manager")
    private String manager;

    /**
     * 密码，默认，从配置文件中获取
     */
    @Attribute(name = "password")
    private String password;

    @Attribute(name = "telephoneNumber")
    private String telephoneNumber;

    /**
     * 集团工号：customerString1
     */
    @Attribute(name = "employeeID")
    private String employeeID;
    /**
     * 子公司工号：personIdExternal
     */
    @Attribute(name = "employeeNumber")
    private String employeeNumber;
    /**
     * 公司：company
     */
    @Attribute(name = "company")
    private String company;

    @Attribute(name = "co")
    private String co;

    @Attribute(name = "l")
    private String l;
    @Attribute(name = "description")
    private String description;
    private String payGrade;
}

 三、AD账号管理相关方法

主服务类

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson2.JSONObject;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.ldap.core.LdapTemplate;
import org.springframework.ldap.filter.EqualsFilter;
import org.springframework.ldap.query.LdapQuery;
import org.springframework.ldap.query.LdapQueryBuilder;
import org.springframework.ldap.support.LdapNameBuilder;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import javax.naming.Name;
import javax.naming.directory.BasicAttribute;
import javax.naming.directory.DirContext;
import javax.naming.directory.ModificationItem;
import javax.naming.ldap.LdapName;
import javax.naming.ldap.Rdn;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * ldap服务方法类
 *
 * @author: z先生
 * 2023/12/05
 */
@Slf4j
@Service
public class LdapService {
    @Autowired
    private LdapTemplate ldapTemplate;
    @Value("${ldap.base}")
    private String baseOu;

    private final String ACCOUNT_ENABLE = Integer.toString(0x0220);
    private final String ACCOUNT_DISABLE = Integer.toString(0x0220);

    private final static String INNER_ACCOUNT_DEL_OU = "CN=%s,OU=HQ,OU=Disable,OU=IT-Service";
    private final static String OUT_ACCOUNT_DEL_OU = "CN=%s,OU=External,OU=Disable,OU=IT-Service";

    private final static String SAM_ACCOUNT = "samAccountName";
    private final static String ACCOUNT_CTL = "userAccountControl";
    private final static String U_P_P = "userPrincipalName";

/**
     * 移动ou
     *
     * @param person
     * @param toOu
     * @return
     */
    public Boolean removeOu(AdPerson person, String toOu) {
        String originOu = getDnStr(person, baseOu);

        // ldapTemplate.rename(dnName, getDnName(person));
        ldapTemplate.rename(originOu, toOu);
        return true;
    }
}

核心工具类


import javax.naming.ldap.LdapName;
import javax.naming.ldap.Rdn;
import java.util.List;

/**
 * @author: z先生
 * 2023/12/05
 */
public class LdapUtil {
    private final static String NORMAL_OU = "CN=%s%s";
    private final static String DC = ",DC=ddd,DC=com";

    public static String getDnNameById(LdapName id) {
        List<Rdn> list = id.getRdns();
  
        StringBuilder sb = new StringBuilder(64);
        int i = list.size();
        while (--i >= 0) {
            Rdn tmp = list.get(i);
            sb.append(tmp.getType()).append("=").append(tmp.getValue()).append(",");
        }
        sb.setLength(sb.length() - 1);
        return sb.toString();
    }

    public static String getDnStr(AdPerson person, String baseOu) {
        if (person.getId() != null) {
            return getDnNameById((LdapName) (person.getId()));
        }
        Integer index = person.getOuName().indexOf(baseOu);
        String ou = "";
        if (index > 0) {
            ou = "," + person.getOuName().substring(0, index - 1);
        }
        return String.format(NORMAL_OU, person.getDisplayName(), ou);
    }

    public static String getOuNameById(LdapName id) {
        List<Rdn> list = id.getRdns();
        StringBuilder sb = new StringBuilder(64);
        for (Rdn tmp : list) {
            if (tmp.getType().equals("OU")) {
                sb.append(tmp.getValue()).append("/");
            }
        }
        sb.setLength(sb.length() - 1);
        return sb.toString();
    }

    public static String getWholeOuName(LdapName id) {
        return getDnNameById(id) + DC;
    }

    public static String getAdOuName(String managerOu) {
        return managerOu.substring(managerOu.indexOf(",") + 1);
    }
}

 日志工具类

import java.io.PrintWriter;
import java.io.StringWriter;

/**
 * 日志工具类
 *
 * @author: z先生
 * 2023/3/14
 */
public class LogUtil {
    public static String printEx(Exception ex) {
        StringWriter stringWriter = new StringWriter();
        PrintWriter printWriter = new PrintWriter(stringWriter);
        ex.printStackTrace(printWriter);
        return stringWriter.toString();
    }

}

3.1 查询

    /**
     * @param keyword
     * @param isPrecise true精确查询，false模糊查询
     * @return
     */
    public List<AdPerson> queryUser(String keyword, Boolean isPrecise) {
        //keyword = keyword + "*";
        LdapQuery query = isPrecise ?
                LdapQueryBuilder.query().where(SAM_ACCOUNT).is(keyword)
                : LdapQueryBuilder.query().where(SAM_ACCOUNT).is("*" + keyword + "*");
        Long start = System.currentTimeMillis();
        Long start = System.currentTimeMillis();
        List<AdPerson> list = ldapTemplate.find(query, AdPerson.class);
        System.out.println("延时：" + (System.currentTimeMillis() - start));
        return list;
    }

      查询时，最好根据实际场景来确定使用精确还是模糊查询，精确查询延时较低，模糊查询延时较大； 

3.2新增

 /**
     * 账号创建
     *
     * @param person
     * @return
     * @throws UnsupportedEncodingException
     */
    public Boolean createUser(AdPerson person) throws UnsupportedEncodingException {
        Name name = getDnName(person);
        person.setId(name);
        person.setOuName(null);
        String psd = person.getPassword();
        person.setPassword(null);
        ldapTemplate.create(person);
        //密码等属性，只能通过更改属性的方式写入
        List<ModificationItem> itemList = new ArrayList<>();
        if (StringUtils.isNotBlank(psd)) {
            //unicodePwd构建
            String newQuotedPassword = "\"" + psd + "\"";
            byte[] newUnicodePassword = newQuotedPassword.getBytes("UTF-16LE");
            itemList.add(new ModificationItem(DirContext.REPLACE_ATTRIBUTE,
                    new BasicAttribute("unicodePwd", newUnicodePassword)));
        }
        //职级
        if (StringUtils.isNotBlank(person.getPayGrade())) {
            itemList.add(new ModificationItem(DirContext.REPLACE_ATTRIBUTE,
                    new BasicAttribute(AD_P_GRADE, person.getPayGrade())));
        }
        itemList.add(new ModificationItem(DirContext.REPLACE_ATTRIBUTE,
                new BasicAttribute(SAM_ACCOUNT, person.getSamAccountName())));
        itemList.add(new ModificationItem(DirContext.REPLACE_ATTRIBUTE,
                new BasicAttribute(ACCOUNT_CTL, ACCOUNT_ENABLE)));
        ModificationItem[] items = new ModificationItem[itemList.size()];
        itemList.toArray(items);
        ldapTemplate.modifyAttributes(name, items);
        return true;
    }

   密码、samAccount需要以更改属性的方式传入； 

3.3更新

  /**
  * 更新时需要忽略的属性
  */

 private Set<String> ignoreSet = new HashSet<>(Arrays.asList(SAM_ACCOUNT, "password", "cn", "ouName", "mail","name"));

    /**
     * 账号更新
     * 
     * @param person
     * @return
     */
    public Boolean updateUser(AdPerson person) throws UnsupportedEncodingException {
        //查询账户
        List<AdPerson> lists = queryUser(person.getSamAccountName(), true);
        if (CollectionUtils.isEmpty(lists)) {
            log.info("updateUser失败，未查询到{}", person.getMail());
            return createUser(person);
        }
        AdPerson old = lists.get(0);
        String oldOu = getDnNameById((LdapName) (old.getId()));
        String newOu = getDnStr(person, baseOu);

        //比对差异，进行属性替换
        JSONObject oldJson = JSON.parseObject(JSON.toJSONString(old));
        JSONObject newJson = JSON.parseObject(JSON.toJSONString(person));
        List<ModificationItem> items = new ArrayList<>();
        for (String key : newJson.keySet()) {
            if (ignoreSet.contains(key)) {
                continue;
            }
            String nValue = getValue(newJson, key);
            String oValue = getValue(oldJson, key);
            if (!nValue.equals(oValue)) {
                String attr = key;
                if (key.equals("payGrade")) {
                    attr = AD_P_GRADE;
                }
                items.add(new ModificationItem(DirContext.REPLACE_ATTRIBUTE, new BasicAttribute(attr, nValue)));
            }
        }
        if (items.size() > 0) {
            ModificationItem[] modificationItems = new ModificationItem[items.size()];
            items.toArray(modificationItems);
            ldapTemplate.modifyAttributes(oldOu, modificationItems);
        }
        //替换ou
        if (!oldOu.equals(newOu)) {
            ldapTemplate.rename(oldOu, newOu);
        }

        return true;
    }

    private String getValue(JSONObject js, String key) {
        String result = js.getString(key);
        return StringUtils.isBlank(result) ? "" : result;
    }

3.4停用

 /**
     * 停用户
     *
     * @param person
     * @return
     */
    public Boolean disableAccount(AdPerson person) {
        Name dnName = getDnName(person);
        ModificationItem[] items = new ModificationItem[1];
        items[0] = new ModificationItem(DirContext.REPLACE_ATTRIBUTE,
                new BasicAttribute(ACCOUNT_CTL, ACCOUNT_DISABLE));
        ldapTemplate.modifyAttributes(dnName, items);
        //外协员工和正式员工
        String delOu = person.getSamAccountName().startsWith("e-") ?
                String.format(OUT_ACCOUNT_DEL_OU, person.getDisplayName()) : String.format(INNER_ACCOUNT_DEL_OU, person.getDisplayName());
        removeOu(person, delOu);
        return true;
    }

3.5启用

    public Boolean enableAccount(AdPerson person) {
        Name dnName = getDnName(person);
        ModificationItem[] items = new ModificationItem[1];
        items[0] = new ModificationItem(DirContext.REPLACE_ATTRIBUTE,
                new BasicAttribute(ACCOUNT_CTL, ACCOUNT_ENABLE));
        try {
            ldapTemplate.modifyAttributes(dnName, items);
        } catch (Exception e) {
            log.warn("开启账号失败:" + LogUtil.printEx(e));
            return false;
        }
        return true;
    }

四、接口封装

   基于LdapService进行接口封装和实现即可，无难度，自行实现

五、结语

网上杂文很多，很多是不能用的；本篇是最近实践结论，100%可行；欢迎打赏

有问题加我微信 popodadan

樵峪人
关注
  • 9
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
Springboot使用LDAP集成AD域，实现用户认证、检索用户、重置密码
WWF_HelloWorld
01-10 1万+
文章目录一、基本概念理解和注意事项二、代码实现1. 引入依赖2. 在`application.yml`中配置ldap(s)连接信息3. 生成和导入ssl证书4. 创建domain类`Person.java`5. `ILdapService.java`6. `LdapServiceImpl.java`三、常见错误排除References 一、基本概念理解和注意事项 LDAP客户端工具 二、代码实现 1. 引入依赖 2. 在application.yml中配置ldap(s)连接信息 3. 生成和导入ssl证
Springboot-LDAP针对AD域控做用户和组织进行同步.zip
06-02
Springboot-LDAP针对AD域控做用户和组织进行同步
Spring Boot应用程序集成LDAP
最新发布
iaong的专栏
06-14 1238
以下是一个Spring Boot应用程序，集成LDAP实现用户信息存储和查询的示例。我们将使用Spring Data LDAP模块来与LDAP服务器进行交互。
springBoot集成AD域
m0_56512023的博客
06-07 799
Active Directory（AD）是由微软开发的用于管理网络资源和用户身份的目录服务。它是一种目录服务，用于存储组织内的网络资源（如计算机、打印机、用户等）的信息，并提供对这些资源的集中化管理。
SpringBoot集成 Windows2012 AD 认证服务
一颗浑身披带雪花的松树---[雪松]
03-29 2866
目录 1、应用背景 2、Windows2012 AD 服务安装及验证是否成功 2.1、Microsoft Windows Server 2012 Ad域搭建 2.2、安装完毕后如何验证是否成功 3、SpringBoot如何集成Windows AD服务认证 4、实践成果内容 5、参考文章 6、最后实现可执行源码 1、应用背景 因最近项目需要做欧洲的国际版本；欧洲那边要求...
springboot操作ldap
m0_64053569的博客
06-26 2203
以下可能不是特别深入讲解，只是开发用到，浅谈一下。尽量用数据库的方式去对应LDAP：轻量级目录访问协议。微软的AD域，openldap之类的都可以通过LDAP协议去连接访问。ad(active diretory)活动目录；openldap就是ldap协议的具体实现。在这里把他们当成一个数据库来看待，目录存储数据库。如下图，就是openldap的层级图。
spring boot集成ldap
01-22
项目中使用spring boot框架集成了ldap协议的方法，调用了增删改查的API，基本实现了spring boot对于ldap的所有方法，只要搭建好了ldap服务器，改一下配置文件即可运行。
ldap:使用ldaps协议对AD 2003进行身份验证
05-13
身份验证应用使用ldaps协议对AD 2003进行身份验证入门这些说明将为您提供在本地计算机上运行并运行的项目的副本，以进行开发和测试。先决条件AD服务器具有读/写访问权限的AD中的auth-app帐户主机（在JVM的keystore中...
LDAP实现AD域账号验证 - Java/SpringBoot
03-23
在IT行业中， Lightweight Directory Access Protocol (LDAP) 是一种用于存储和检索目录信息的标准协议，而Active Directory (AD) 是微软提供的目录服务，广泛应用于企业环境中进行用户身份验证和权限管理。...
LDAP加密访问AD（overssl）（LDAPS ）C++
05-17
本文将详细介绍如何在C++环境中，通过LDAPS协议与Active Directory（AD）服务器建立安全连接，并忽略证书验证，以便在证书过期或无效时仍能正常通信。 首先，要实现LDAPS连接，我们需要一个支持SSL/TLS的库。在这个...
JAVA使用Ldap操作AD域的方法示例
08-26
首先，我们需要了解AD域是一个集中式服务，用于管理网络中的用户、计算机和其他资源的身份和权限。Ldap（轻量级目录访问协议）是用于访问和操作这些目录信息的标准协议。 在Java中操作AD域，我们通常需要以下几个...
Spring Boot 连接LDAP的方法
08-28
主要介绍了Spring Boot 连接LDAP的方法,仅仅涉及基本的使用ODM来快速实现LDAP增删改查操作。具有一定的参考价值，有兴趣的可以了解一下
基于spring boot同域名单点登录
06-30
基于spring boot同域名单点登录
Java操作ldap（springboot工程）
04-25
springboot工程对ldap进行操作，反射提取公用转化类，运行简单
基于SSL的ldap安全访问AD认证
04-12
基于SSL的LDAP安全访问AD认证是指使用SSL（Secure Sockets Layer）协议来保护LDAP（Lightweight Directory Access Protocol）协议与AD（Active Directory）的通信，使得密码在网络中不再以明文传输，从而提高系统的...
springboot 配置ldaps 连接
wokoone的博客
11-14 2132
springboot 配置ldaps 连接
Spring Boot集成AD域实现统一用户认证
热门推荐
夜影风个人空间
05-07 2万+
1. 引言 由于近期需要开发基于JWT Token的统一身份认证服务项目， 因此需要集成公司原有的AD域实现用户的身份认证问题， 项目采用Spring Boot框架进行开发， 在此将相应的集成开发步骤进行记录。 1.1 LDAP简介 目录是一个为查询、浏览和搜索而优化的专业分布式数据库，它呈树状结构组织数据，就好象Linux/Unix系统中的文件目录一样。目录数据库和关系数据库不同，它有...
写 一个 Spring boot 集成 ldap 支持SSL 的demo
weixin_42611310的博客
02-15 214
好的，下面是一个 Spring Boot 集成 LDAP 并支持 SSL 的示例： 首先，需要在 pom.xml 文件中添加以下依赖项： <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-ldap</a...
springboot使用ldaps协议修改密码，需要导入AD证书，一共需要导入哪几个证书，应该如何导入
03-02
为了使用LDAPS协议修改密码，需要导入根证书和中间证书。首先，您需要从AD服务器上获取根证书和中间证书的PEM格式文件。然后，您可以按照以下步骤导入证书： 1. 将根证书和中间证书的PEM格式文件保存到本地机器上。 2. 将PEM格式文件转换为JKS格式。您可以使用以下命令： ``` keytool -import -alias root -keystore truststore.jks -file root.pem ``` ``` keytool -import -alias intermediate -keystore truststore.jks -file intermediate.pem ``` 3. 在Spring Boot应用程序的配置文件中，设置以下属性来指定JKS信任存储库的位置： ``` spring.ldap.embedded.trust-store=classpath:truststore.jks spring.ldap.embedded.trust-store-password=<password> ``` 其中，`<password>` 是您指定的信任库密码。 这样，您就可以使用LDAPS协议修改密码了。
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值