import org.ldaptive.auth.AuthenticationRequest; //导入依赖的package包/类
@Override
public String authenticate(String login, String password) throws AuthenticationException {

  final AuthenticationResponse response;
  try {
    LOG.debug("Attempting LDAP authentication for: {}", login);
    final AuthenticationRequest request =
        new AuthenticationRequest(login, new Credential(password));
    request.setReturnAttributes(returnAttributes);
    response = this.ldapAuthenticator.authenticate(request);
  } catch (final LdapException e) {
    throw new AuthenticationException(401, "Unexpected LDAP error");
  }
  LOG.debug("LDAP response: {}", response);

  if (!response.getResult()) {
    throw new AuthenticationException(
        401, "Authentication failed. Please check username and password.");
  }

  if (AuthenticationResultCode.DN_RESOLUTION_FAILURE == response.getAuthenticationResultCode()) {
    throw new AuthenticationException(login + "  is not found");
  }
  LOG.debug("Account state {}", response.getAccountState());
  return idNormalizer.retrieveAndNormalize(response.getLdapEntry());
}
 

import org.ldaptive.auth.AuthenticationRequest; //导入依赖的package包/类
@Override
protected HandlerResult authenticateUsernamePasswordInternal(final UsernamePasswordCredential upc)
        throws GeneralSecurityException, PreventedException {
    final AuthenticationResponse response;
    try {
        logger.debug("Attempting LDAP authentication for {}", upc);
        final String password = getPasswordEncoder().encode(upc.getPassword());
        final AuthenticationRequest request = new AuthenticationRequest(upc.getUsername(),
                new org.ldaptive.Credential(password),
                this.authenticatedEntryAttributes);
        response = this.authenticator.authenticate(request);
    } catch (final LdapException e) {
        throw new PreventedException("Unexpected LDAP error", e);
    }
    logger.debug("LDAP response: {}", response);

    final List<MessageDescriptor> messageList;
    
    final LdapPasswordPolicyConfiguration ldapPasswordPolicyConfiguration =
            (LdapPasswordPolicyConfiguration) super.getPasswordPolicyConfiguration();
    if (ldapPasswordPolicyConfiguration != null) {
        logger.debug("Applying password policy to {}", response);
        messageList = ldapPasswordPolicyConfiguration.getAccountStateHandler().handle(
                response, ldapPasswordPolicyConfiguration);
    } else {
        messageList = Collections.emptyList();
    }
    
    if (response.getResult()) {
        return createHandlerResult(upc, createPrincipal(upc.getUsername(), response.getLdapEntry()), messageList);
    }

    if (AuthenticationResultCode.DN_RESOLUTION_FAILURE == response.getAuthenticationResultCode()) {
        throw new AccountNotFoundException(upc.getUsername() + " not found.");
    }
    throw new FailedLoginException("Invalid credentials");
}
 

import org.ldaptive.auth.AuthenticationRequest; //导入依赖的package包/类
@Override
protected HandlerResult authenticateUsernamePasswordInternal(final UsernamePasswordCredential upc,
                                                             final String originalPassword) throws GeneralSecurityException, PreventedException {
    final AuthenticationResponse response;
    try {
        LOGGER.debug("Attempting LDAP authentication for [{}]. Authenticator pre-configured attributes are [{}], "
                        + "additional requested attributes for this authentication request are [{}]",
                upc, authenticator.getReturnAttributes(), authenticatedEntryAttributes);
        final AuthenticationRequest request = new AuthenticationRequest(upc.getUsername(),
                new org.ldaptive.Credential(upc.getPassword()), authenticatedEntryAttributes);
        response = authenticator.authenticate(request);
    } catch (final LdapException e) {
        LOGGER.trace(e.getMessage(), e);
        throw new PreventedException("Unexpected LDAP error", e);
    }
    LOGGER.debug("LDAP response: [{}]", response);

    final List<MessageDescriptor> messageList;
    final LdapPasswordPolicyConfiguration ldapPasswordPolicyConfiguration = (LdapPasswordPolicyConfiguration) super.getPasswordPolicyConfiguration();
    if (ldapPasswordPolicyConfiguration != null) {
        LOGGER.debug("Applying password policy to [{}]", response);
        messageList = ldapPasswordPolicyConfiguration.getAccountStateHandler().handle(response, ldapPasswordPolicyConfiguration);
    } else {
        LOGGER.debug("No ldap password policy configuration is defined");
        messageList = Collections.emptyList();
    }

    if (response.getResult()) {
        LOGGER.debug("LDAP response returned a result. Creating the final LDAP principal");
        return createHandlerResult(upc, createPrincipal(upc.getUsername(), response.getLdapEntry()), messageList);
    }

    if (AuthenticationResultCode.DN_RESOLUTION_FAILURE == response.getAuthenticationResultCode()) {
        LOGGER.warn("DN resolution failed. [{}]", response.getMessage());
        throw new AccountNotFoundException(upc.getUsername() + " not found.");
    }
    throw new FailedLoginException("Invalid credentials");
}
 

import org.ldaptive.auth.AuthenticationRequest; //导入依赖的package包/类
@Override
protected HandlerResult authenticateUsernamePasswordInternal(final UsernamePasswordCredential upc)
        throws GeneralSecurityException, PreventedException {
    final AuthenticationResponse response;
    try {
        logger.debug("Attempting LDAP authentication for {}", upc);
        final AuthenticationRequest request = new AuthenticationRequest(upc.getUsername(),
                new org.ldaptive.Credential(upc.getPassword()),
                this.authenticatedEntryAttributes);
        response = this.authenticator.authenticate(request);
    } catch (final LdapException e) {
        throw new PreventedException("Unexpected LDAP error", e);
    }
    logger.debug("LDAP response: {}", response);

    final List<Message> messageList;
    
    final LdapPasswordPolicyConfiguration ldapPasswordPolicyConfiguration =
            (LdapPasswordPolicyConfiguration) super.getPasswordPolicyConfiguration();
    if (ldapPasswordPolicyConfiguration != null) {
        logger.debug("Applying password policy to {}", response);
        messageList = ldapPasswordPolicyConfiguration.getAccountStateHandler().handle(
                response, ldapPasswordPolicyConfiguration);
    } else {
        messageList = Collections.emptyList();
    }
    
    if (response.getResult()) {
        return createHandlerResult(upc, createPrincipal(upc.getUsername(), response.getLdapEntry()), messageList);
    }

    if (AuthenticationResultCode.DN_RESOLUTION_FAILURE == response.getAuthenticationResultCode()) {
        throw new AccountNotFoundException(upc.getUsername() + " not found.");
    }
    throw new FailedLoginException("Invalid credentials.");
}
 

import org.ldaptive.auth.AuthenticationRequest; //导入依赖的package包/类
@Override
public void validate(final UsernamePasswordCredentials credentials, final WebContext context) throws HttpAction {
    init(context);

    final String username = credentials.getUsername();
    final String[] ldapAttributes = attributes.split(",");
    final AuthenticationResponse response;
    try {
        logger.debug("Attempting LDAP authentication for: {}", credentials);
        final AuthenticationRequest request = new AuthenticationRequest(username,
                new org.ldaptive.Credential(credentials.getPassword()),
                ldapAttributes);
        response = this.ldapAuthenticator.authenticate(request);
    } catch (final LdapException e) {
        throw new TechnicalException("Unexpected LDAP error", e);
    }
    logger.debug("LDAP response: {}", response);

    if (response.getResult()) {
        final LdapProfile profile = createProfile(username, ldapAttributes, response.getLdapEntry());
        credentials.setUserProfile(profile);
        return;
    }

    if (AuthenticationResultCode.DN_RESOLUTION_FAILURE == response.getAuthenticationResultCode()) {
        throw new AccountNotFoundException(username + " not found");
    }
    throw new BadCredentialsException("Invalid credentials for: " + username);
}
 

import org.ldaptive.auth.AuthenticationRequest; //导入依赖的package包/类
@Override
protected HandlerResult authenticateUsernamePasswordInternal(final UsernamePasswordCredential upc)
        throws GeneralSecurityException, PreventedException {
    final AuthenticationResponse response;
    try {
        logger.debug("Attempting LDAP authentication for {}", upc);
        final String password = getPasswordEncoder().encode(upc.getPassword());
        final AuthenticationRequest request = new AuthenticationRequest(upc.getUsername(),
                new org.ldaptive.Credential(password),
                this.authenticatedEntryAttributes);
        response = this.authenticator.authenticate(request);
    } catch (final LdapException e) {
        logger.trace(e.getMessage(), e);
        throw new PreventedException("Unexpected LDAP error", e);
    }
    logger.debug("LDAP response: {}", response);

    final List<MessageDescriptor> messageList;
    
    final LdapPasswordPolicyConfiguration ldapPasswordPolicyConfiguration =
            (LdapPasswordPolicyConfiguration) super.getPasswordPolicyConfiguration();
    if (ldapPasswordPolicyConfiguration != null) {
        logger.debug("Applying password policy to {}", response);
        messageList = ldapPasswordPolicyConfiguration.getAccountStateHandler().handle(
                response, ldapPasswordPolicyConfiguration);
    } else {
        logger.debug("No ldap password policy configuration is defined");
        messageList = Collections.emptyList();
    }
    
    if (response.getResult()) {
        logger.debug("LDAP response returned as result. Creating the final LDAP principal");
        return createHandlerResult(upc, createPrincipal(upc.getUsername(), response.getLdapEntry()), messageList);
    }

    if (AuthenticationResultCode.DN_RESOLUTION_FAILURE == response.getAuthenticationResultCode()) {
        logger.warn("DN resolution failed. {}", response.getMessage());
        throw new AccountNotFoundException(upc.getUsername() + " not found.");
    }
    throw new FailedLoginException("Invalid credentials");
}
 

import org.ldaptive.auth.AuthenticationRequest; //导入依赖的package包/类
@Override
public Authentication authenticate(final Authentication authentication) throws AuthenticationException {
    try {
        final String username = authentication.getPrincipal().toString();
        final Object credentials = authentication.getCredentials();
        final String password = credentials == null ? null : credentials.toString();

        LOGGER.debug("Preparing LDAP authentication request for user [{}]", username);

        final AuthenticationRequest request = new AuthenticationRequest(username, new org.ldaptive.Credential(password), ReturnAttributes.ALL.value());
        final Authenticator authenticator = Beans.newLdaptiveAuthenticator(adminPagesSecurityProperties.getLdap());
        LOGGER.debug("Executing LDAP authentication request for user [{}]", username);
        
        final AuthenticationResponse response = authenticator.authenticate(request);
        LOGGER.debug("LDAP response: [{}]", response);
        
        if (response.getResult()) {
            final LdapEntry entry = response.getLdapEntry();

            final CommonProfile profile = new CommonProfile();
            profile.setId(username);
            entry.getAttributes().forEach(a -> profile.addAttribute(a.getName(), a.getStringValues()));

            LOGGER.debug("Collected user profile [{}]", profile);

            this.authorizationGenerator.generate(WebUtils.getPac4jJ2EContext(), profile);
            LOGGER.debug("Assembled user profile with roles after generating authorization claims [{}]", profile);

            final Collection<GrantedAuthority> authorities = new ArrayList<>();
            authorities.addAll(profile.getRoles().stream().map(SimpleGrantedAuthority::new).collect(Collectors.toList()));
            LOGGER.debug("List of authorities remapped from profile roles are [{}]", authorities);

            final RequireAnyRoleAuthorizer authorizer = new RequireAnyRoleAuthorizer(adminPagesSecurityProperties.getAdminRoles());
            LOGGER.debug("Executing authorization for expected admin roles [{}]", authorizer.getElements());

            final J2EContext context = WebUtils.getPac4jJ2EContext();

            if (authorizer.isAllAuthorized(context, Arrays.asList(profile))) {
                return new UsernamePasswordAuthenticationToken(username, password, authorities);
            }
            LOGGER.warn("User [{}] is not authorized to access the requested resource allowed to roles [{}]",
                    username, authorizer.getElements());
        } else {
            LOGGER.warn("LDAP authentication response produced no results for [{}]", username);
        }

    } catch (final Exception e) {
        LOGGER.error(e.getMessage(), e);
        throw new InsufficientAuthenticationException("Unexpected LDAP error", e);
    }
    throw new BadCredentialsException("Could not authenticate provided credentials");
}
 

import org.ldaptive.auth.AuthenticationRequest; //导入依赖的package包/类
/**
 * Perform authentication with given username and password.
 * Receive the result from Ldap server
 * @param username Username that user entered to login
 * @param password Password that user entered to login
 * @return LdapEntry which contains all user attributes
 */
private LdapEntry authenticate(String username,Object password)
{
  try {
    SearchDnResolver dnResolver = new SearchDnResolver(new DefaultConnectionFactory(connConfig));

    dnResolver.setBaseDn(_userBaseDn);
    dnResolver.setSubtreeSearch(true);
    String userFilter = buildFilter(_userFilter, _userObjectClass, _userIdAttribute);
    LOG.debug("Searching a user with filter {} where user is {}", userFilter, username);
    dnResolver.setUserFilter(userFilter);

    // Set Authenticator with username and password. It will return the user if username/password matches.
    BindAuthenticationHandler authHandler = new BindAuthenticationHandler(new DefaultConnectionFactory(connConfig));
    Authenticator auth = new Authenticator(dnResolver, authHandler);
    AuthenticationRequest authRequest = new AuthenticationRequest();
    authRequest.setUser(username);
    if (password instanceof char[]) {
      authRequest.setCredential(new org.ldaptive.Credential(new String((char[]) password)));
    } else if (password instanceof String){
      authRequest.setCredential(new org.ldaptive.Credential((String)password));
    } else {
      LOG.error("Unexpected type for password '{}'", (password != null) ? password.getClass() : "NULL");
      return null;
    }
    String[] userRoleAttribute = ReturnAttributes.ALL.value();
    authRequest.setReturnAttributes(userRoleAttribute);

    LOG.debug("Retrieved authenticator from factory: {}", auth);
    LOG.debug("Retrieved authentication request from factory: {}", authRequest);

    AuthenticationResponse response = auth.authenticate(authRequest);
    LOG.info("Found user?: {}", response.getResult());
    if (response.getResult()) {
      LdapEntry entry = response.getLdapEntry();
      return entry;
    } else {
      // User not found. Most likely username/password didn't match. Log the reason.
      LOG.error("Result code: {} - {}", response.getResultCode(), response.getMessage());
    }
  } catch (LdapException e) {
    LOG.warn(e.getMessage());
  }
  return null;
}