How to use

getPassword

method

in

org.apache.cxf.configuration.security.AuthorizationPolicy

public String getAuthorization(AuthorizationPolicy  authPolicy,
                URI currentURI,
                Message message,
                String fullHeader) {
  if (authPolicy.getUserName() != null && authPolicy.getPassword() != null) {
    boolean encodeBasicAuthWithIso8859 = PropertyUtils.isTrue(
      message.getContextualProperty(ENCODE_BASIC_AUTH_WITH_ISO8859));
    return getBasicAuthHeader(authPolicy.getUserName(),
                 authPolicy.getPassword(),
                 encodeBasicAuthWithIso8859);
  }
  return null;
}

              Message message,
              String fullHeader) {
if (authPolicy == null || (authPolicy.getUserName() == null && authPolicy.getPassword() == null)) {
  return null;
                authPolicy.getPassword());
                authPolicy.getPassword());

    message.put(AuthorizationPolicy.class.getName(), authPolicy);
  ret = authPolicy.getPassword();
  authPolicy.setPassword((String)value);
} else if (MessageContext.HTTP_REQUEST_HEADERS.equals(key)) {

&& StringUtils.isEmpty(contextName) && loginConfig == null)) {
CallbackHandler callbackHandler = getUsernamePasswordHandler(
  authPolicy.getUserName(), authPolicy.getPassword());
LoginContext lc = new LoginContext(contextName, null, callbackHandler, loginConfig);
lc.login();

String pwd = httpConduit.getAuthorization().getPassword();
if (un != null && pwd != null) {
  auth = new PasswordAuthentication(un, pwd.toCharArray());

  (AuthorizationPolicy)message.get(AuthorizationPolicy.class.getName());
if (authPolicy != null) {
  ret = authPolicy.getPassword();

public void handleMessage(Message message) throws Fault {
  String method = (String)message.get(Message.HTTP_REQUEST_METHOD);
  String query = (String)message.get(Message.QUERY_STRING);
  if (!"GET".equals(method) || StringUtils.isEmpty(query)) {
    return;
  }
  Endpoint endpoint = message.getExchange().getEndpoint();
  synchronized (endpoint) {
    if (!StringUtils.isEmpty(contextName)) {
      AuthorizationPolicy policy = message.get(AuthorizationPolicy.class);
      if (policy == null) {
        handle401response(message, endpoint);
        return;
      }
      Subject subject = (Subject)authenticate(policy.getUserName(), policy.getPassword());
      if (subject == null) {
        handle401response(message, endpoint);
        return;
      }
    }
  }
}

AuthorizationPolicy policy = message.get(AuthorizationPolicy.class);
 if (policy == null) {
   sendErrorResponse(message, HttpURLConnection.HTTP_UNAUTHORIZED);
   return;
 }
 message.put("request_usr", policy.getUserName());
 message.put("request_pwd", policy.getPassword());

public String getAuthorization(AuthorizationPolicy  authPolicy,
                URI currentURI,
                Message message,
                String fullHeader) {
  if (authPolicy.getUserName() != null && authPolicy.getPassword() != null) {
    return getBasicAuthHeader(authPolicy.getUserName(), 
                 authPolicy.getPassword());
  } else {
    return null;
  }
}

@Override
protected PasswordAuthenticationContext createAuthenticationContext(AuthorizationPolicy policy, ContainerRequestContext requestCtx){
  return new PasswordAuthenticationContext(policy.getUserName(), policy.getPassword());
}

public String getAuthorization(AuthorizationPolicy  authPolicy,
                URI currentURI,
                Message message,
                String fullHeader) {
  if (authPolicy.getUserName() != null && authPolicy.getPassword() != null) {
    boolean encodeBasicAuthWithIso8859 = PropertyUtils.isTrue(
      message.getContextualProperty(ENCODE_BASIC_AUTH_WITH_ISO8859));
    return getBasicAuthHeader(authPolicy.getUserName(),
                 authPolicy.getPassword(),
                 encodeBasicAuthWithIso8859);
  }
  return null;
}

@Override
public CallbackHandler create(Message message) {
  AuthorizationPolicy policy = message.get(AuthorizationPolicy.class);
  if (policy == null) {
    return null;
  }
  return new NamePasswordCallbackHandler(policy.getUserName(), policy.getPassword());
}

@Override
public CallbackHandler create(Message message) {
  AuthorizationPolicy policy = message.get(AuthorizationPolicy.class);
  if (policy == null) {
    return null;
  }
  return new NamePasswordCallbackHandler(policy.getUserName(), policy.getPassword());
}

public void handleMessage(Message message) throws Fault {
   String requestURI = message.get(Message.REQUEST_URI).toString();
   String methodKeyword = requestURI.substring("localhost".length()+1).split("/")[0];
   if(methodKeyword.equals("open")) {
     AuthorizationPolicy policy = message.get(AuthorizationPolicy.class);
     if(policy == null) {
       Fault fault = new Fault("incorrect username or password", Logger.getGlobal());
       fault.setStatusCode(401);
       throw fault;
     }
     String realPassword = userPasswords.get(policy.getUserName());
     if (realPassword == null || !realPassword.equals(policy.getPassword())) {
       Fault fault = new Fault("incorrect username or password", Logger.getGlobal());
       fault.setStatusCode(403);
       throw fault;
     }
   }
 }

protected UsernameToken convertPolicyToToken(AuthorizationPolicy policy) {
  Document doc = DOMUtils.getEmptyDocument();
  UsernameToken token = new UsernameToken(false, doc,
                      WSS4JConstants.PASSWORD_TEXT);
  token.setName(policy.getUserName());
  token.setPassword(policy.getPassword());
  return token;
}

public void handleMessage(Message message) throws Fault {
  AuthorizationPolicy policy = message.get(AuthorizationPolicy.class);
  if (policy == null || policy.getUserName() == null || policy.getPassword() == null) {
    String name = null;
    if (policy != null) {
      name = policy.getUserName();
    }
    org.apache.cxf.common.i18n.Message errorMsg =
      new org.apache.cxf.common.i18n.Message("NO_USER_PASSWORD",
                          BUNDLE,
                          name);
    LOG.warning(errorMsg.toString());
    throw new SecurityException(errorMsg.toString());
  }
  try {
    super.validate(message);
  } catch (Exception ex) {
    throw new Fault(ex);
  }
}

public void handleMessage(Message message) throws Fault {
  AuthorizationPolicy policy = message.get(AuthorizationPolicy.class);
  if (policy == null || policy.getUserName() == null || policy.getPassword() == null) {
    String name = null;
    if (policy != null) {
      name = policy.getUserName();
    }
    org.apache.cxf.common.i18n.Message errorMsg =
      new org.apache.cxf.common.i18n.Message("NO_USER_PASSWORD",
                          BUNDLE,
                          name);
    LOG.warning(errorMsg.toString());
    throw new SecurityException(errorMsg.toString());
  }
  try {
    super.validate(message);
  } catch (Exception ex) {
    throw new Fault(ex);
  }
}

public void filter(ContainerRequestContext requestContext) throws IOException {
  Message message = JAXRSUtils.getCurrentMessage();
  AuthorizationPolicy policy = message.get(AuthorizationPolicy.class);
  if (policy == null || policy.getUserName() == null || policy.getPassword() == null) {
    requestContext.abortWith(
      Response.status(401).header("WWW-Authenticate", "Basic realm=\"IdP\"").build());
    return;
  }
  try {
    super.validate(message);
  } catch (Exception ex) {
    throw ExceptionUtils.toInternalServerErrorException(ex, null);
  }
}

@Override
public void filter(ClientRequestContext requestContext) throws IOException {
  JwtToken jwt = getJwtToken(requestContext);
  if (jwt == null && super.isJweRequired()) {
    AuthorizationPolicy ap = JAXRSUtils.getCurrentMessage().getExchange()
      .getEndpoint().getEndpointInfo().getExtensor(AuthorizationPolicy.class);
    if (ap != null && ap.getUserName() != null) {
      JwtClaims claims = new JwtClaims();
      claims.setSubject(ap.getUserName());
      claims.setClaim("password", ap.getPassword());
      claims.setIssuedAt(System.currentTimeMillis() / 1000L);
      jwt = new JwtToken(new JweHeaders(), claims);
    }
  }
  if (jwt == null) {
    throw new JoseException("JWT token is not available");
  }
  String data = super.processJwt(jwt);
  requestContext.getHeaders().putSingle(HttpHeaders.AUTHORIZATION,
                     authScheme + " " + data);
}

private synchronized AsyncHttpClient getAsyncHttpClient(Message message) {
  if (ahcclient == null) {
    DefaultAsyncHttpClientConfig.Builder builder = new DefaultAsyncHttpClientConfig.Builder();
    AuthorizationPolicy ap = getEffectiveAuthPolicy(message);
    if (ap != null
      && (!StringUtils.isEmpty(ap.getAuthorizationType())
        || !StringUtils.isEmpty(ap.getUserName()))) {
      Realm.Builder rb = new Realm.Builder(ap.getUserName(), ap.getPassword());
      if (ap.getAuthorizationType() == null) {
        rb.setScheme(AuthScheme.BASIC);
      } else {
        rb.setScheme(AuthScheme.valueOf(ap.getAuthorizationType().toUpperCase()));
      }
      rb.setUsePreemptiveAuth(true);
      builder.setRealm(rb.build());
    }
    AsyncHttpClientConfig config = builder.build();
    ahcclient = new DefaultAsyncHttpClient(config);
  }
  return ahcclient;
}