Java BasicCredentials.getUsername方法代码示例

import io.dropwizard.auth.basic.BasicCredentials; //导入方法依赖的package包/类
@Override
public Optional<User> authenticate(final BasicCredentials credentials) throws AuthenticationException {
    String username = credentials.getUsername();
    String password = credentials.getPassword();

    try {
        try (AutoclosableDirContext context = buildContext(username, password)) {

            //Get the user DN
            SearchResult userSearched = searchUser(context, username);

            //Check if user is in the prod group
            final boolean prodUser = checkIfUserBelongsToGroup(context, userSearched.getNameInNamespace(), configuration.getProdGroupName());
            final boolean techUser = checkIfUserBelongsToGroup(context, userSearched.getNameInNamespace(), configuration.getTechGroupName());

            User user = new User(username, prodUser, techUser);
            return Optional.of(user);
        }

    } catch (NamingException e) {
        LOGGER.debug("{} failed to authenticate {}", username);
    }

    return Optional.empty();
}
 

import io.dropwizard.auth.basic.BasicCredentials; //导入方法依赖的package包/类
@Override public Optional<User> authenticate(BasicCredentials credentials)
    throws AuthenticationException {
  User user = null;
  String username = credentials.getUsername();
  if (!User.isSanitizedUsername(username)) {
    logger.info("Username: {} must match pattern: {}", username, User.USERNAME_PATTERN);
    return Optional.empty();
  }

  String password = credentials.getPassword();

  // Get hashed password column from BCrypt table by username
  Optional<String> optionalHashedPwForUser = userDAO.getHashedPassword(username);
  if (!optionalHashedPwForUser.isPresent()) {
    return Optional.empty();
  }

  if (BCrypt.checkpw(password, optionalHashedPwForUser.get())) {
    user = User.named(username);
  }

  return Optional.ofNullable(user);
}
 

import io.dropwizard.auth.basic.BasicCredentials; //导入方法依赖的package包/类
@UnitOfWork
public Optional<User> authenticate(final BasicCredentials basicCredentials) throws AuthenticationException {

    String email = basicCredentials.getUsername();
    String plaintextPassword = basicCredentials.getPassword();

    final Optional<User> user = userDao.findByEmail(email);
    if (user.isPresent()) {
        final User existingUser = user.get();
        checkState(existingUser.getPassword() != null, "Cannot authenticate: user with id: %s (email: %s) without password",
                existingUser.getId(), existingUser.getEmail());

        if (isMatched(plaintextPassword, existingUser.getPassword())) {
            return user;
        }
    }
    return Optional.absent();
}
 

import io.dropwizard.auth.basic.BasicCredentials; //导入方法依赖的package包/类
@Override
public Optional<String> authenticate(BasicCredentials credentials)
    throws AuthenticationException {
  checkNotNull(credentials);

  String username = credentials.getUsername();
  String secret = credentials.getPassword();

  ApiKey key = provider.get(username);
  if (key == null) {
    return Optional.absent();
  }

  if (!secret.equals(key.getSecret())) {
    return Optional.absent();
  }

  return Optional.of(key.getUsername());
}
 

import io.dropwizard.auth.basic.BasicCredentials; //导入方法依赖的package包/类
@Override
public String authenticate(HttpServletRequest request) throws AuthenticationException {
    BasicCredentials credentials = getCredentials(request);
    if (credentials == null) {
        throw new AuthenticationException("Could not parse Basic Authorization header", "Anonymous", request.getRemoteAddr());
    }
    try {
        Optional<T> user = authenticator.authenticate(credentials);
        if (!user.isPresent()) {
            throw new AuthenticationException("User authention failed", credentials.getUsername(), request.getRemoteAddr());
        }
    } catch (io.dropwizard.auth.AuthenticationException e) {
        throw new AuthenticationException("User authention failed", e, credentials.getUsername(), request.getRemoteAddr());
    }
   
     return credentials.getUsername();
}
 

import io.dropwizard.auth.basic.BasicCredentials; //导入方法依赖的package包/类
@Override
public Optional<Principal> authenticate(BasicCredentials basicCredentials) throws AuthenticationException {
    final UserId id = new UserId(basicCredentials.getUsername());

    return readonlyUserDAO
            .getUserCredentialsById(id)
            .filter(BasicAuthenticator::hasCorrectAuthType)
            .filter(credentials -> matchesTheCredentialsSuppliedByTheClient(credentials, basicCredentials))
            .map(UserCredentials::getId)
            .map(UserId::toString)
            .map(PrincipalImpl::new);
}
 

import io.dropwizard.auth.basic.BasicCredentials; //导入方法依赖的package包/类
@Override
public Optional<User> authenticate(BasicCredentials credentials) throws AuthenticationException {

  final String username = credentials.getUsername();
  LOGGER.debug("Authenticating user {}", username);
  if ("secret".equals(credentials.getPassword())) {
    return Optional.of(new User(username, Optional.empty()));
  }
  return Optional.empty();
}
 

import io.dropwizard.auth.basic.BasicCredentials; //导入方法依赖的package包/类
@Override
public Optional<EyeballUser> authenticate(BasicCredentials basicCredentials) throws AuthenticationException {
    String password = basicCredentials.getPassword();
    String username = basicCredentials.getUsername();
    if (username.equals(eyeballsConfiguration.getUsername()) && password.equals(eyeballsConfiguration.getPassword())) {
        return Optional.of(new EyeballUser());
    }
    return Optional.absent();
}
 

import io.dropwizard.auth.basic.BasicCredentials; //导入方法依赖的package包/类
@Override
public Optional<SimplePrincipal> authenticate(BasicCredentials credentials) {
    User user = userDAO.findByUsername(credentials.getUsername());
    if (user != null && user.getPassword().equals(
            PasswordUtils.hashPassword(credentials.getPassword(), user.getSalt()))) {
        SimplePrincipal principal = new SimplePrincipal(credentials.getUsername());
        principal.getRoles().addAll(user.getRoles());
        return Optional.of(principal);
    }
    return Optional.absent();
}
 

import io.dropwizard.auth.basic.BasicCredentials; //导入方法依赖的package包/类
private Optional<Peer> authenticateUnencrypted(BasicCredentials credentials) throws AuthenticationException {
    Peer peer = new Peer(credentials.getUsername(), credentials.getPassword());

    if (this.allPeers.contains(peer)) {
        LOGGER.debug("{} authenticated and allowed to request service", credentials.getUsername());
        return Optional.of(peer);
    }
    else {
        LOGGER.debug("{} is not known in our list of allowed peers", credentials.getUsername());
    }
    return Optional.empty();
}
 

import io.dropwizard.auth.basic.BasicCredentials; //导入方法依赖的package包/类
@Override
public Optional<BasicUserPrincipal> authenticate(BasicCredentials credentials) throws AuthenticationException {
	String loginUserName = credentials.getUsername();
	String loginPassword = credentials.getPassword();
	String htUsersPass = readHtUsers().getPassword(loginUserName);
	if(negate(comparePasswords(loginPassword, htUsersPass))) {
		logger.info("Failed to login " + loginUserName);
		return Optional.empty();
	}
	return Optional.of(new BasicUserPrincipal(loginUserName));
}
 

import io.dropwizard.auth.basic.BasicCredentials; //导入方法依赖的package包/类
private Optional<AuthorizedPrincipal> authenticate(BasicCredentials credentials,
                                                   Model model) {
    String username = credentials.getUsername();
    List<? extends ExistentialRuleform> agencies = model.getPhantasmModel()
                                                        .findByAttributeValue(model.getKernel()
                                                                                   .getLogin(),
                                                                              username);
    if (agencies.size() > 1) {
        log.error(String.format("Multiple agencies with username %s",
                                username));
        return absent();
    }
    if (agencies.size() == 0) {
        log.warn(String.format("Attempt to login from non existent username %s",
                               username));
        return absent();
    }
    ExistentialRuleform agency = agencies.get(0);
    if (agency.getDomain() != ExistentialDomain.Agency) {
        log.warn(String.format("Attempt to login from non existent agency %s",
                               username));
        return absent();
    }
    CoreUser user = model.wrap(CoreUser.class, agency);

    if (!canLoginToInstance(user, model)) {
        return noCapability(username, user);
    }

    boolean authenticated = authenticate(user, credentials.getPassword());
    if (authenticated) {
        return authenticatedPrincipal(user, username);
    } else {
        return authenticationFailure(username, user);
    }
}
 

import io.dropwizard.auth.basic.BasicCredentials; //导入方法依赖的package包/类
@Override
public Optional<User> authenticate(BasicCredentials credentials) {
  User user = null;

  try {
    String username = credentials.getUsername();
    if (!User.isSanitizedUsername(username)) {
      logger.info("Username: {} must match pattern: {}", username, User.USERNAME_PATTERN);
      return Optional.empty();
    }

    String userDN = dnFromUsername(username);
    String password = credentials.getPassword();

    // Must have password for current config
    if (Strings.isNullOrEmpty(password)) {
      logger.info("No password for user provided");
      return Optional.empty();
    }

    LDAPConnection authenticatedConnection = connectionFactory.getLDAPConnection(userDN, password);
    authenticatedConnection.close();

    Set<String> requiredRoles = config.getRequiredRoles();
    if (!requiredRoles.isEmpty()) {
      Set<String> roles = rolesFromDN(userDN);

      boolean accessAllowed = false;
      for (String requiredRole : requiredRoles) {
        if (roles.contains(requiredRole)) {
          accessAllowed = true;
        }
      }

      if (!accessAllowed) {
        logger.warn("User {} not in one of required LDAP roles: [{}].", username, requiredRoles);
        throw new ForbiddenException();
      }
    }

    user = User.named(username);
  } catch (LDAPException le) {
    // The INVALID_CREDENTIALS case is handled by returning an absent optional from this function
    if (le.getResultCode() != ResultCode.INVALID_CREDENTIALS) {
      logger.error("Error connecting to LDAP", le);
      throw Throwables.propagate(le);
    }
  } catch (GeneralSecurityException gse) {
      logger.error("TLS error connecting to LDAP", gse);
      throw Throwables.propagate(gse);
  }

  return Optional.ofNullable(user);
}