View Javadoc
1   /*
2    * Copyright 2024-2026 the original author or authors.
3    *
4    * Licensed under the Apache License, Version 2.0 (the "License");
5    * you may not use this file except in compliance with the License.
6    * You may obtain a copy of the License at
7    *
8    *      http://www.apache.org/licenses/LICENSE-2.0
9    *
10   * Unless required by applicable law or agreed to in writing, software
11   * distributed under the License is distributed on an "AS IS" BASIS,
12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   * See the License for the specific language governing permissions and
14   * limitations under the License.
15   */
16  
17  package org.bremersee.spring.boot.autoconfigure.security.authentication;
18  
19  import static java.util.Objects.nonNull;
20  import static org.springframework.util.ObjectUtils.isEmpty;
21  
22  import org.apache.commons.logging.Log;
23  import org.apache.commons.logging.LogFactory;
24  import org.bremersee.ldaptive.LdaptiveTemplate;
25  import org.bremersee.spring.boot.autoconfigure.ldaptive.LdaptiveAutoConfiguration;
26  import org.bremersee.spring.security.core.mapping.authority.NormalizedGrantedAuthoritiesMapper;
27  import org.bremersee.spring.security.ldaptive.authentication.AccountControlEvaluator;
28  import org.bremersee.spring.security.ldaptive.authentication.LdaptiveAuthentication;
29  import org.bremersee.spring.security.ldaptive.authentication.LdaptiveAuthenticationManager;
30  import org.bremersee.spring.security.ldaptive.authentication.LdaptiveAuthenticationProperties;
31  import org.bremersee.spring.security.ldaptive.authentication.ReactiveLdaptiveAuthenticationManager;
32  import org.bremersee.spring.security.ldaptive.userdetails.LdaptiveEvaluatedRememberMeTokenProvider;
33  import org.bremersee.spring.security.ldaptive.userdetails.LdaptivePwdLastSetRememberMeTokenProvider;
34  import org.bremersee.spring.security.ldaptive.userdetails.LdaptiveRememberMeTokenProvider;
35  import org.bremersee.spring.security.ldaptive.userdetails.LdaptiveUserDetails;
36  import org.ldaptive.ConnectionConfig;
37  import org.ldaptive.ConnectionFactory;
38  import org.ldaptive.DefaultConnectionFactory;
39  import org.mapstruct.Mapper;
40  import org.mapstruct.NullValueCheckStrategy;
41  import org.mapstruct.factory.Mappers;
42  import org.springframework.beans.factory.ObjectProvider;
43  import org.springframework.boot.autoconfigure.AutoConfiguration;
44  import org.springframework.boot.autoconfigure.AutoConfigureAfter;
45  import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
46  import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
47  import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
48  import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
49  import org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplication;
50  import org.springframework.boot.autoconfigure.condition.ConditionalOnWebApplication.Type;
51  import org.springframework.boot.context.event.ApplicationReadyEvent;
52  import org.springframework.boot.context.properties.EnableConfigurationProperties;
53  import org.springframework.context.annotation.Bean;
54  import org.springframework.context.event.EventListener;
55  import org.springframework.core.convert.converter.Converter;
56  import org.springframework.security.core.authority.mapping.GrantedAuthoritiesMapper;
57  import org.springframework.util.ClassUtils;
58  
59  /**
60   * The ldaptive authentication autoconfiguration.
61   *
62   * @author Christian Bremer
63   */
64  @AutoConfiguration
65  @ConditionalOnClass(name = {
66      "org.ldaptive.ConnectionFactory",
67      "org.bremersee.ldaptive.LdaptiveTemplate",
68      "org.bremersee.spring.security.ldaptive.authentication.LdaptiveAuthenticationManager"
69  })
70  @ConditionalOnBean({ConnectionConfig.class})
71  @ConditionalOnProperty(prefix = "bremersee.authentication.ldaptive", name = "user-base-dn")
72  @AutoConfigureAfter({LdaptiveAutoConfiguration.class})
73  @EnableConfigurationProperties(AuthenticationProperties.class)
74  public class LdaptiveAuthenticationAutoConfiguration {
75  
76    private static final Log log = LogFactory.getLog(LdaptiveAuthenticationAutoConfiguration.class);
77  
78    private final LdaptiveAuthenticationProperties properties;
79  
80    private final String rememberMeKey;
81  
82    /**
83     * Instantiates a new ldaptive authentication autoconfiguration.
84     *
85     * @param properties the properties
86     */
87    public LdaptiveAuthenticationAutoConfiguration(AuthenticationProperties properties) {
88      this.properties = LdaptivePropertiesMapper.map(properties);
89      this.rememberMeKey = properties.getRememberMe().getKey();
90    }
91  
92    /**
93     * Init.
94     */
95    @EventListener(ApplicationReadyEvent.class)
96    public void init() {
97      log.info(String.format("""
98              
99              *********************************************************************************
100             * %s
101             * properties = %s
102             *********************************************************************************""",
103         ClassUtils.getUserClass(getClass()).getSimpleName(),
104         properties));
105   }
106 
107   /**
108    * Creates ldaptive password encoder provider.
109    *
110    * @return the ldaptive password encoder provider
111    */
112   @ConditionalOnMissingBean
113   @Bean
114   public LdaptivePasswordEncoderProvider ldaptivePasswordEncoderProvider() {
115     return LdaptivePasswordEncoderProvider.defaultProvider();
116   }
117 
118   /**
119    * The ldaptive remember-me token provider.
120    *
121    * @param accountControlEvaluator the account control evaluator
122    * @return the ldaptive remember-me token provider
123    */
124   @ConditionalOnMissingBean
125   @Bean
126   public LdaptiveRememberMeTokenProvider ldaptiveRememberMeTokenProvider(
127       ObjectProvider<AccountControlEvaluator> accountControlEvaluator) {
128 
129     AccountControlEvaluator evaluator = accountControlEvaluator
130         .getIfAvailable(() -> properties.getAccountControlEvaluator().get());
131     if (!isEmpty(properties.getPasswordLastSetAttribute())) {
132       return new LdaptivePwdLastSetRememberMeTokenProvider(
133           evaluator, properties.getPasswordLastSetAttribute());
134     }
135     return new LdaptiveEvaluatedRememberMeTokenProvider(evaluator);
136   }
137 
138   /**
139    * Creates ldaptive authentication manager.
140    *
141    * @param connectionConfig the connection config
142    * @param connectionFactoryProvider the connection factory provider
143    * @param ldaptiveTemplateProvider the ldaptive template provider
144    * @param ldaptivePasswordEncoderProvider the ldaptive password encoder provider
145    * @param ldaptiveRememberMeTokenProvider the ldaptive remember-me token provider
146    * @param accountControlEvaluator the account control evaluator
147    * @param grantedAuthoritiesMapper the groups mapper
148    * @param tokenConverter the token converter
149    * @return the ldaptive authentication manager
150    */
151   @ConditionalOnWebApplication(type = Type.SERVLET)
152   @Bean(initMethod = "init")
153   public LdaptiveAuthenticationManager ldaptiveAuthenticationManager(
154       ConnectionConfig connectionConfig,
155       ObjectProvider<ConnectionFactory> connectionFactoryProvider,
156       ObjectProvider<LdaptiveTemplate> ldaptiveTemplateProvider,
157       LdaptivePasswordEncoderProvider ldaptivePasswordEncoderProvider,
158       LdaptiveRememberMeTokenProvider ldaptiveRememberMeTokenProvider,
159       ObjectProvider<AccountControlEvaluator> accountControlEvaluator,
160       ObjectProvider<GrantedAuthoritiesMapper> grantedAuthoritiesMapper,
161       ObjectProvider<Converter<LdaptiveUserDetails, LdaptiveAuthentication>> tokenConverter) {
162 
163     LdaptiveAuthenticationManager manager = new LdaptiveAuthenticationManager(
164         getLdaptiveTemplate(connectionConfig, connectionFactoryProvider, ldaptiveTemplateProvider),
165         properties,
166         rememberMeKey);
167     manager.setPasswordEncoder(ldaptivePasswordEncoderProvider.get());
168     manager.setPasswordProvider(ldaptiveRememberMeTokenProvider);
169     accountControlEvaluator.ifAvailable(manager::setAccountControlEvaluator);
170     manager.setGrantedAuthoritiesMapper(getGrantedAuthoritiesMapper(grantedAuthoritiesMapper));
171     tokenConverter.ifAvailable(manager::setTokenConverter);
172     return manager;
173   }
174 
175   /**
176    * Creates reactive ldaptive authentication manager.
177    *
178    * @param connectionConfig the connection config
179    * @param connectionFactoryProvider the connection factory provider
180    * @param ldaptiveTemplateProvider the ldaptive template provider
181    * @param ldaptivePasswordEncoderProvider the ldaptive password encoder provider
182    * @param ldaptiveRememberMeTokenProvider the ldaptive remember-me token provider
183    * @param accountControlEvaluator the account control evaluator
184    * @param grantedAuthoritiesMapper the groups mapper
185    * @param tokenConverter the token converter
186    * @return the reactive ldaptive authentication manager
187    */
188   @ConditionalOnWebApplication(type = Type.REACTIVE)
189   @Bean
190   public ReactiveLdaptiveAuthenticationManager reactiveLdaptiveAuthenticationManager(
191       ConnectionConfig connectionConfig,
192       ObjectProvider<ConnectionFactory> connectionFactoryProvider,
193       ObjectProvider<LdaptiveTemplate> ldaptiveTemplateProvider,
194       LdaptivePasswordEncoderProvider ldaptivePasswordEncoderProvider,
195       LdaptiveRememberMeTokenProvider ldaptiveRememberMeTokenProvider,
196       ObjectProvider<AccountControlEvaluator> accountControlEvaluator,
197       ObjectProvider<GrantedAuthoritiesMapper> grantedAuthoritiesMapper,
198       ObjectProvider<Converter<LdaptiveUserDetails, LdaptiveAuthentication>> tokenConverter) {
199     return new ReactiveLdaptiveAuthenticationManager(
200         ldaptiveAuthenticationManager(
201             connectionConfig,
202             connectionFactoryProvider,
203             ldaptiveTemplateProvider,
204             ldaptivePasswordEncoderProvider,
205             ldaptiveRememberMeTokenProvider,
206             accountControlEvaluator,
207             grantedAuthoritiesMapper,
208             tokenConverter));
209   }
210 
211   private LdaptiveTemplate getLdaptiveTemplate(
212       ConnectionConfig connectionConfig,
213       ObjectProvider<ConnectionFactory> connectionFactoryProvider,
214       ObjectProvider<LdaptiveTemplate> ldaptiveTemplateProvider) {
215 
216     LdaptiveTemplate ldaptiveTemplate = ldaptiveTemplateProvider.getIfAvailable();
217     if (nonNull(ldaptiveTemplate)) {
218       return ldaptiveTemplate;
219     }
220     ConnectionFactory connectionFactory = connectionFactoryProvider.getIfAvailable();
221     if (nonNull(connectionFactory)) {
222       return new LdaptiveTemplate(connectionFactory);
223     }
224     return new LdaptiveTemplate(new DefaultConnectionFactory(connectionConfig));
225   }
226 
227   private GrantedAuthoritiesMapper getGrantedAuthoritiesMapper(
228       ObjectProvider<GrantedAuthoritiesMapper> grantedAuthoritiesMapper) {
229     return grantedAuthoritiesMapper.getIfAvailable(() -> new NormalizedGrantedAuthoritiesMapper(
230         properties.getDefaultRoles(),
231         properties.toRoleMappings(),
232         properties.getRolePrefix(),
233         properties.getRoleCaseTransformation(),
234         properties.toRoleStringReplacements()));
235   }
236 
237   /**
238    * The interface Properties mapper.
239    */
240   @Mapper(nullValueCheckStrategy = NullValueCheckStrategy.ALWAYS)
241   interface PropertiesMapper {
242 
243     /**
244      * The constant INSTANCE.
245      */
246     PropertiesMapper INSTANCE = Mappers.getMapper(PropertiesMapper.class);
247 
248     /**
249      * Map ldaptive authentication properties.
250      *
251      * @param source the source
252      * @return the ldaptive authentication properties
253      */
254     LdaptiveAuthenticationProperties map(AuthenticationProperties.LdaptiveProperties source);
255 
256   }
257 
258 }