import org.ldaptive.LdapException; //导入依赖的package包/类
/**
 * Execute modify operation boolean.
 *
 * @param currentDn         the current dn
 * @param connectionFactory the connection factory
 * @param attributes        the attributes
 * @return the boolean
 */
public static boolean executeModifyOperation(final String currentDn,
                                             final ConnectionFactory connectionFactory,
                                             final Map<String, Set<String>> attributes) {
    try (Connection modifyConnection = createConnection(connectionFactory)) {
        final ModifyOperation operation = new ModifyOperation(modifyConnection);
        final List<AttributeModification> mods = new ArrayList<>();
        for (final Map.Entry<String, Set<String>> entry : attributes.entrySet()) {
            mods.add(new AttributeModification(AttributeModificationType.REPLACE,
                    new LdapAttribute(entry.getKey(), entry.getValue().toArray(new String[]{}))));
        }
        final ModifyRequest request = new ModifyRequest(currentDn,
                mods.toArray(new AttributeModification[]{}));
        request.setReferralHandler(new ModifyReferralHandler());
        operation.execute(request);
        return true;
    } catch (final LdapException e) {
        LOGGER.error(e.getMessage(), e);
    }
    return false;
}
 

import org.ldaptive.LdapException; //导入依赖的package包/类
@Override
public RegisteredService save(final RegisteredService rs) {
    if (this.ldapServiceMapper != null) {
        if (rs.getId() != RegisteredService.INITIAL_IDENTIFIER_VALUE) {
            return update(rs);
        }

        try {
            final LdapEntry entry = this.ldapServiceMapper.mapFromRegisteredService(this.baseDn, rs);
            LdapUtils.executeAddOperation(this.connectionFactory, entry);
        } catch (final LdapException e) {
            logger.error(e.getMessage(), e);
        }
        return rs;
    }
    return null;
}
 

import org.ldaptive.LdapException; //导入依赖的package包/类
@Override
public List<RegisteredService> load() {
    final List<RegisteredService> list = new LinkedList<>();
    if (ldapServiceMapper == null) {
        return list;
    }

    try {
        final Response<SearchResult> response = LdapUtils.executeSearchOperation(this.connectionFactory,
                this.baseDn, new SearchFilter(this.loadFilter));
        if (LdapUtils.containsResultEntry(response)) {
            for (final LdapEntry entry : response.getResult().getEntries()) {
                final RegisteredService svc = this.ldapServiceMapper.mapToRegisteredService(entry);
                list.add(svc);
            }
        }
    } catch (final LdapException e) {
        logger.error(e.getMessage(), e);
    }
    return list;
}
 

import org.ldaptive.LdapException; //导入依赖的package包/类
/**
 * Downloads a CRL from given LDAP url.
 *
 * @param r the resource that is the ldap url.
 * @return the x 509 cRL
 * @throws Exception if connection to ldap fails, or attribute to get the revocation list is unavailable
 */
protected X509CRL fetchCRLFromLdap(final Object r) throws Exception {
    try {
        final String ldapURL = r.toString();
        logger.debug("Fetching CRL from ldap {}", ldapURL);

        final Response<SearchResult> result = performLdapSearch(ldapURL);
        if (result.getResultCode() == ResultCode.SUCCESS) {
            final LdapEntry entry = result.getResult().getEntry();
            final LdapAttribute attribute = entry.getAttribute();

            logger.debug("Located entry [{}]. Retrieving first attribute [{}]",
                    entry, attribute);
            return fetchX509CRLFromAttribute(attribute);
        } else {
            logger.debug("Failed to execute the search [{}]", result);
        }

        throw new CertificateException("Failed to establish a connection ldap and search.");

    } catch (final LdapException e) {
        logger.error(e.getMessage(), e);
        throw new CertificateException(e);
    }
}
 

import org.ldaptive.LdapException; //导入依赖的package包/类
/**
 * Gets a connection from the underlying connection factory and attempts to validate it.
 *
 * @return  Status with code {@link StatusCode#OK} on success otherwise {@link StatusCode#ERROR}.
 */
@Override
public Status observe() {
    Connection conn = null;
    try {
        conn = this.connectionFactory.getConnection();
        if (!conn.isOpen()) {
            conn.open();
        }
        return this.validator.validate(conn) ? OK : ERROR;
    } catch (final LdapException e) {
        logger.warn("Validation failed with error.", e);
    } finally {
        LdapUtils.closeConnection(conn);
    }
    return ERROR;
}
 

import org.ldaptive.LdapException; //导入依赖的package包/类
@Override
public RegisteredService save(final RegisteredService rs) {
    if (rs.getId() != RegisteredService.INITIAL_IDENTIFIER_VALUE) {
        return update(rs);
    }

    Connection connection = null;
    try {
        connection = getConnection();
        final AddOperation operation = new AddOperation(connection);

        final LdapEntry entry = this.ldapServiceMapper.mapFromRegisteredService(this.searchRequest.getBaseDn(), rs);
        operation.execute(new AddRequest(entry.getDn(), entry.getAttributes()));
    } catch (final LdapException e) {
        logger.error(e.getMessage(), e);
    } finally {
        LdapUtils.closeConnection(connection);
    }
    return rs;
}
 

import org.ldaptive.LdapException; //导入依赖的package包/类
@Override
public List<RegisteredService> load() {
    Connection connection = null;
    final List<RegisteredService> list = new LinkedList<>();
    try {
        connection = getConnection();
        final Response<SearchResult> response =
                executeSearchOperation(connection, new SearchFilter(this.loadFilter));
        if (hasResults(response)) {
            for (final LdapEntry entry : response.getResult().getEntries()) {
                final RegisteredService svc = this.ldapServiceMapper.mapToRegisteredService(entry);
                list.add(svc);
            }
        }
    } catch (final LdapException e) {
        logger.error(e.getMessage(), e);
    } finally {
        LdapUtils.closeConnection(connection);
    }
    return list;
}
 

import org.ldaptive.LdapException; //导入依赖的package包/类
@Override
public RegisteredService findServiceById(final long id) {
    Connection connection = null;
    try {
        connection = getConnection();

        final Response<SearchResult> response = searchForServiceById(connection, id);
        if (hasResults(response)) {
            return this.ldapServiceMapper.mapToRegisteredService(response.getResult().getEntry());
        }
    } catch (final LdapException e) {
        logger.error(e.getMessage(), e);
    } finally {
        LdapUtils.closeConnection(connection);
    }

    return null;
}
 

import org.ldaptive.LdapException; //导入依赖的package包/类
@Override
protected CommonProfile generateAuthorizationForLdapEntry(final CommonProfile profile, final LdapEntry userEntry) {
    try {
        LOGGER.debug("Attempting to get roles for user [{}].", userEntry.getDn());
        final Response<SearchResult> response = this.groupSearchExecutor.search(
                this.connectionFactory,
                Beans.newLdaptiveSearchFilter(this.groupSearchExecutor.getSearchFilter().getFilter(),
                        Beans.LDAP_SEARCH_FILTER_DEFAULT_PARAM_NAME, Arrays.asList(userEntry.getDn())));
        LOGGER.debug("LDAP role search response: [{}]", response);
        final SearchResult groupResult = response.getResult();

        for (final LdapEntry entry : groupResult.getEntries()) {
            final LdapAttribute groupAttribute = entry.getAttribute(this.groupAttributeName);
            if (groupAttribute == null) {
                LOGGER.warn("Role attribute not found on entry [{}]", entry);
                continue;
            }
            addProfileRolesFromAttributes(profile, groupAttribute, this.groupPrefix);
        }
    } catch (final LdapException e) {
        throw new RuntimeException("LDAP error fetching roles for user.", e);
    }
    return profile;
}
 

import org.ldaptive.LdapException; //导入依赖的package包/类
/**
 * Execute modify operation boolean.
 *
 * @param currentDn         the current dn
 * @param connectionFactory the connection factory
 * @param attributes        the attributes
 * @return true/false
 */
public static boolean executeModifyOperation(final String currentDn, final ConnectionFactory connectionFactory,
                                             final Map<String, Set<String>> attributes) {
    try (Connection modifyConnection = createConnection(connectionFactory)) {
        final ModifyOperation operation = new ModifyOperation(modifyConnection);
        final List<AttributeModification> mods = attributes.entrySet()
                .stream().map(entry -> new AttributeModification(AttributeModificationType.REPLACE,
                        new LdapAttribute(entry.getKey(), entry.getValue().toArray(new String[]{})))).collect(Collectors.toList());
        final ModifyRequest request = new ModifyRequest(currentDn,
                mods.toArray(new AttributeModification[]{}));
        request.setReferralHandler(new ModifyReferralHandler());
        operation.execute(request);
        return true;
    } catch (final LdapException e) {
        LOGGER.error(e.getMessage(), e);
    }
    return false;
}
 

import org.ldaptive.LdapException; //导入依赖的package包/类
@Override
public List<RegisteredService> load() {
    final List<RegisteredService> list = new LinkedList<>();

    try {
        final Response<SearchResult> response = getSearchResultResponse();
        if (LdapUtils.containsResultEntry(response)) {
            response.getResult().getEntries()
                    .stream()
                    .map(this.ldapServiceMapper::mapToRegisteredService)
                    .forEach(s -> {
                        publishEvent(new CasRegisteredServiceLoadedEvent(this, s));
                        list.add(s);
                    });
        }
    } catch (final LdapException e) {
        LOGGER.error(e.getMessage(), e);
    }
    return list;
}
 

import org.ldaptive.LdapException; //导入依赖的package包/类
/**
 * Downloads a CRL from given LDAP url.
 *
 * @param r the resource that is the ldap url.
 * @return the x 509 cRL
 * @throws IOException          the exception thrown if resources cant be fetched
 * @throws CRLException         the exception thrown if resources cant be fetched
 * @throws CertificateException if connection to ldap fails, or attribute to get the revocation list is unavailable
 */
protected X509CRL fetchCRLFromLdap(final Object r) throws CertificateException, IOException, CRLException {
    try {
        final String ldapURL = r.toString();
        LOGGER.debug("Fetching CRL from ldap [{}]", ldapURL);

        final Response<SearchResult> result = performLdapSearch(ldapURL);
        if (result.getResultCode() == ResultCode.SUCCESS) {
            final LdapEntry entry = result.getResult().getEntry();
            final LdapAttribute attribute = entry.getAttribute(this.certificateAttribute);

            if (attribute.isBinary()) {
                LOGGER.debug("Located entry [{}]. Retrieving first attribute [{}]", entry, attribute);
                return fetchX509CRLFromAttribute(attribute);
            }
            LOGGER.warn("Found certificate attribute [{}] but it is not marked as a binary attribute", this.certificateAttribute);
        }

        LOGGER.debug("Failed to execute the search [{}]", result);
        throw new CertificateException("Failed to establish a connection ldap and search.");

    } catch (final LdapException e) {
        LOGGER.error(e.getMessage(), e);
        throw new CertificateException(e.getMessage());
    }
}
 

import org.ldaptive.LdapException; //导入依赖的package包/类
@Override
public RegisteredService save(final RegisteredService rs) {
    if (rs.getId() != RegisteredService.INITIAL_IDENTIFIER_VALUE) {
        return update(rs);
    }

    Connection connection = null;
    try {
        connection = this.connectionFactory.getConnection();
        final AddOperation operation = new AddOperation(connection);

        final LdapEntry entry = this.ldapServiceMapper.mapFromRegisteredService(this.searchRequest.getBaseDn(), rs);
        operation.execute(new AddRequest(entry.getDn(), entry.getAttributes()));
    } catch (final LdapException e) {
        logger.error(e.getMessage(), e);
    } finally {
        LdapUtils.closeConnection(connection);
    }
    return rs;
}
 

import org.ldaptive.LdapException; //导入依赖的package包/类
@Override
public List<RegisteredService> load() {
    Connection connection = null;
    final List<RegisteredService> list = new LinkedList<RegisteredService>();
    try {
        connection = this.connectionFactory.getConnection();
        final Response<SearchResult> response =
                executeSearchOperation(connection, new SearchFilter(this.loadFilter));
        if (hasResults(response)) {
            for (final LdapEntry entry : response.getResult().getEntries()) {
                final RegisteredService svc = this.ldapServiceMapper.mapToRegisteredService(entry);
                list.add(svc);
            }
        }
    } catch (final LdapException e) {
        logger.error(e.getMessage(), e);
    } finally {
        LdapUtils.closeConnection(connection);
    }
    return list;
}
 

import org.ldaptive.LdapException; //导入依赖的package包/类
@Override
public RegisteredService findServiceById(final long id) {
    Connection connection = null;
    try {
        connection = this.connectionFactory.getConnection();

        final Response<SearchResult> response = searchForServiceById(connection, id);
        if (hasResults(response)) {
            return this.ldapServiceMapper.mapToRegisteredService(response.getResult().getEntry());
        }
    } catch (final LdapException e) {
        logger.error(e.getMessage(), e);
    } finally {
        LdapUtils.closeConnection(connection);
    }

    return null;
}
 

import org.ldaptive.LdapException; //导入依赖的package包/类
@Override
public RegisteredService save(final RegisteredService rs) {

    if (this.ldapServiceMapper != null && this.searchRequest != null) {
        if (rs.getId() != RegisteredService.INITIAL_IDENTIFIER_VALUE) {
            return update(rs);
        }

        try (final Connection connection = getConnection()) {
            final AddOperation operation = new AddOperation(connection);

            final LdapEntry entry = this.ldapServiceMapper.mapFromRegisteredService(this.searchRequest.getBaseDn(), rs);
            operation.execute(new AddRequest(entry.getDn(), entry.getAttributes()));
        } catch (final LdapException e) {
            logger.error(e.getMessage(), e);
        }
        return rs;
    }
    return null;
}
 

import org.ldaptive.LdapException; //导入依赖的package包/类
@Override
public List<RegisteredService> load() {
    final List<RegisteredService> list = new LinkedList<>();
    if (ldapServiceMapper == null) {
        return list;
    }

    try (final Connection connection = getConnection()) {
        final Response<SearchResult> response =
                executeSearchOperation(connection, new SearchFilter(this.loadFilter));
        if (hasResults(response)) {
            for (final LdapEntry entry : response.getResult().getEntries()) {
                final RegisteredService svc = this.ldapServiceMapper.mapToRegisteredService(entry);
                list.add(svc);
            }
        }
    } catch (final LdapException e) {
        logger.error(e.getMessage(), e);
    }
    return list;
}
 

import org.ldaptive.LdapException; //导入依赖的package包/类
@Override
public RegisteredService findServiceById(final long id) {
    if (ldapServiceMapper == null) {
        return null;
    }

    try (final Connection connection = getConnection()) {
        final Response<SearchResult> response = searchForServiceById(connection, id);
        if (hasResults(response)) {
            return this.ldapServiceMapper.mapToRegisteredService(response.getResult().getEntry());
        }
    } catch (final LdapException e) {
        logger.error(e.getMessage(), e);
    }
    return null;
}
 

import org.ldaptive.LdapException; //导入依赖的package包/类
/**
 * Performs authentication.
 *
 * @param auth UsernamePasswordAuthenticationToken.
 * @return authenticated  object.
 * @throws AuthenticationException if authentication fails.
 */
@Override
public Authentication authenticate(Authentication auth) throws AuthenticationException {
    Assert.notNull(auth, "No authentication data provided.");
    String userName = (String) auth.getPrincipal();
    String password = (String) auth.getCredentials();
    String domain = (String) auth.getDetails();

    OneOpsUser user = null;
    try {
        user = ldapUserService.authenticate(userName, password.toCharArray(), domain);
    } catch (LdapException ex) {
        log.debug("Ldap Authentication failed for user: " + userName, ex);
    }

    if (user == null) {
        throw new BadCredentialsException("Invalid Username/Password.");
    }

    // Check for user privileges.
    if (user.getAuthorities().isEmpty()) {
        throw new InsufficientAuthenticationException(user.getUsername() + " user has no roles assigned.");
    }

    return new LoginAuthToken(user, null, user.getAuthorities());
}
 

import org.ldaptive.LdapException; //导入依赖的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());
}