1
2
3
4
5
6
7
8
9
10
11
12
13
14
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
61
62
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
84
85
86
87 public LdaptiveAuthenticationAutoConfiguration(AuthenticationProperties properties) {
88 this.properties = LdaptivePropertiesMapper.map(properties);
89 this.rememberMeKey = properties.getRememberMe().getKey();
90 }
91
92
93
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
109
110
111
112 @ConditionalOnMissingBean
113 @Bean
114 public LdaptivePasswordEncoderProvider ldaptivePasswordEncoderProvider() {
115 return LdaptivePasswordEncoderProvider.defaultProvider();
116 }
117
118
119
120
121
122
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
140
141
142
143
144
145
146
147
148
149
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
177
178
179
180
181
182
183
184
185
186
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
239
240 @Mapper(nullValueCheckStrategy = NullValueCheckStrategy.ALWAYS)
241 interface PropertiesMapper {
242
243
244
245
246 PropertiesMapper INSTANCE = Mappers.getMapper(PropertiesMapper.class);
247
248
249
250
251
252
253
254 LdaptiveAuthenticationProperties map(AuthenticationProperties.LdaptiveProperties source);
255
256 }
257
258 }