How to use

AuthorizationPolicy

in

org.apache.cxf.configuration.security

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;
      }
    }
  }
}

    ? new AuthorizationPolicy() : new PrincipalAuthorizationPolicy(sc);
  policy.setUserName(username);
  policy.setPassword(password);
  policy.setAuthorizationType(authType);
  return policy;
} catch (Base64Exception ex) {
policy.setAuthorization(credentials);
policy.setAuthorizationType(authType);
return policy;

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;
}

private void applyAuthorization(Dictionary<String, String> d, HTTPConduit c) {
  Enumeration<String> keys = d.keys();
  AuthorizationPolicy p = c.getAuthorization();
  while (keys.hasMoreElements()) {
    String k = keys.nextElement();
    if (k.startsWith("authorization.")) {
      if (p == null) {
        p = new AuthorizationPolicy();
        c.setAuthorization(p);
      }
      String v = d.get(k);
      k = k.substring("authorization.".length());
      if ("UserName".equals(k)) {
        p.setUserName(v);
      } else if ("Password".equals(k)) {
        p.setPassword(v);
      } else if ("Authorization".equals(k)) {
        p.setAuthorization(v);
      } else if ("AuthorizationType".equals(k)) {
        p.setAuthorizationType(v);
      }
    }
  }
}

              Message message,
              String fullHeader) {
if (authPolicy == null || (authPolicy.getUserName() == null && authPolicy.getPassword() == null)) {
  return null;
                authPolicy.getUserName(),
                authPolicy.getPassword());
      di.charset = map.get("charset");
    di.method = (String)message.get(Message.HTTP_REQUEST_METHOD);
    if (di.method == null) {
      di.method = "POST";
                authPolicy.getUserName(),
                authPolicy.getPassword());

private static void configureConduitFromEndpointInfo(HTTPConduit conduit,
    EndpointInfo endpointInfo) {
  if (conduit.getClient() == null) {
    conduit.setClient(endpointInfo.getTraversedExtensor(
        new HTTPClientPolicy(), HTTPClientPolicy.class));
  }
  if (conduit.getAuthorization() == null) {
    conduit.setAuthorization(endpointInfo.getTraversedExtensor(
        new AuthorizationPolicy(), AuthorizationPolicy.class));
  }
  if (conduit.getProxyAuthorization() == null) {
    conduit.setProxyAuthorization(endpointInfo.getTraversedExtensor(
        new ProxyAuthorizationPolicy(),
        ProxyAuthorizationPolicy.class));
  }
  if (conduit.getTlsClientParameters() == null) {
    conduit.setTlsClientParameters(endpointInfo.getTraversedExtensor(
        null, TLSClientParameters.class));
  }
  if (conduit.getTrustDecider() == null) {
    conduit.setTrustDecider(endpointInfo.getTraversedExtensor(null,
        MessageTrustDecider.class));
  }
  if (conduit.getAuthSupplier() == null) {
    conduit.setAuthSupplier(endpointInfo.getTraversedExtensor(null,
        HttpAuthSupplier.class));
  }
}

  if (tmp != null) {
    if (MessageContext.HTTP_RESPONSE_HEADERS.equals(key)) {
      return tmp.put(Message.PROTOCOL_HEADERS, value);
    return tmp.put(mappedKey, value);
    (AuthorizationPolicy)message.get(AuthorizationPolicy.class.getName());
  if (authPolicy == null) {
    authPolicy = new AuthorizationPolicy();
    message.put(AuthorizationPolicy.class.getName(), authPolicy);
  ret = authPolicy.getUserName();
  authPolicy.setUserName((String)value);
} else if (BindingProvider.PASSWORD_PROPERTY.equals(key)) {
  AuthorizationPolicy authPolicy =
    (AuthorizationPolicy)message.get(AuthorizationPolicy.class.getName());
  if (authPolicy == null) {
    authPolicy = new AuthorizationPolicy();
    message.put(AuthorizationPolicy.class.getName(), authPolicy);
  ret = authPolicy.getPassword();
  authPolicy.setPassword((String)value);
} else if (MessageContext.HTTP_REQUEST_HEADERS.equals(key)) {
  ret = message.put(Message.PROTOCOL_HEADERS, value);
  Message tmp = createResponseMessage();
  if (tmp != null) {
    tmp.put(mappedKey, value);

Message m = PhaseInterceptorChain.getCurrentMessage();
if (m != null) {
  Exchange exchange = m.getExchange();
  Conduit conduit = exchange.getConduit(m);
  if (conduit instanceof HTTPConduit) {
    HTTPConduit httpConduit = (HTTPConduit)conduit;
    if (getRequestorType() == RequestorType.PROXY
      && httpConduit.getProxyAuthorization() != null) {
      String un = httpConduit.getProxyAuthorization().getUserName();
      String pwd = httpConduit.getProxyAuthorization().getPassword();
      if (un != null && pwd != null) {
        auth = new PasswordAuthentication(un, pwd.toCharArray());
      String un = httpConduit.getAuthorization().getUserName();
      String pwd = httpConduit.getAuthorization().getPassword();
      if (un != null && pwd != null) {
        auth = new PasswordAuthentication(un, pwd.toCharArray());

Message m = JAXRSUtils.getCurrentMessage();
AuthorizationPolicy policy = (AuthorizationPolicy) m.get(AuthorizationPolicy.class);
if (policy != null) {
  passwordAuthenticator.handleRequest(policy, m, requestCtx);
    m.put(RestServiceUtil.MESSAGE_PROPERTY_TASK_NAME, task);
  try {
    String decodedCredentials = new String(Base64Utility.decode(base64Credentials));
    policy = new AuthorizationPolicy();
    policy.setAuthorizationType(RestAuthenticationMethod.SECURITY_QUESTIONS.getMethod());
    policy.setAuthorization(decodedCredentials);
    securityQuestionAuthenticator.handleRequest(policy, m, requestCtx);

/**
 * Determines effective auth policy from message, conduit and empty default
 * with priority from first to last
 *
 * @param message
 * @return effective AthorizationPolicy
 */
public AuthorizationPolicy getEffectiveAuthPolicy(Message message) {
  AuthorizationPolicy authPolicy = getAuthorization();
  AuthorizationPolicy newPolicy = message.get(AuthorizationPolicy.class);
  AuthorizationPolicy effectivePolicy = newPolicy;
  if (effectivePolicy == null) {
    effectivePolicy = authPolicy;
  }
  if (effectivePolicy == null) {
    effectivePolicy = new AuthorizationPolicy();
  }
  return effectivePolicy;
}

private String getPrincipal(Message message) {
  String principal = getJAASPrincipal();
  if (principal != null) {
    return principal;
  }
  SecurityContext sc = message.get(SecurityContext.class);
  if (sc != null && sc.getUserPrincipal() != null) {
    return sc.getUserPrincipal().getName();
  }
  AuthorizationPolicy authPolicy = message.get(AuthorizationPolicy.class);
  if (authPolicy != null) {
    return authPolicy.getUserName();
  }
  return null;
}

  httpClientPolicy.setProxyServerPort(Integer.valueOf(_config.getProxyConfig().getPort()).intValue());
conduit.setClient(httpClientPolicy);
if (_config.getProxyConfig().getUser() != null) {
  ProxyAuthorizationPolicy policy = new ProxyAuthorizationPolicy();
  policy.setUserName(_config.getProxyConfig().getUser());
  policy.setPassword(_config.getProxyConfig().getPassword());
  conduit.setProxyAuthorization(policy);
AuthorizationPolicy policy = new AuthorizationPolicy();
  policy.setUserName(_config.getBasicAuthConfig().getUser());
  policy.setPassword(_config.getBasicAuthConfig().getPassword());
  policy.setAuthorizationType("Basic");
} else {
  policy.setUserName(_config.getNtlmAuthConfig().getDomain() + "\\" + _config.getNtlmAuthConfig().getUser());
  policy.setPassword(_config.getNtlmAuthConfig().getPassword());
  HTTPClientPolicy httpClientPolicy = new HTTPClientPolicy();
  if (timeout != null) {
  conduit.setClient(httpClientPolicy);
conduit.setAuthorization(policy);

  private Message setupMessage(String name, String password) {
    AuthorizationPolicy policy = new AuthorizationPolicy();
    policy.setUserName(name);
    policy.setPassword(password);
    Message message = new MessageImpl();
    message.put(AuthorizationPolicy.class, policy);
    return message;
  }
}

@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);
}

AuthorizationPolicy authPolicy = new AuthorizationPolicy();
authPolicy.setUserName("Betty");
authPolicy.setPassword("password");
http.setClient(httpClientPolicy);
http.setTlsClientParameters(tlsClientParameters);
http.setAuthorization(authPolicy);

(GSSCredential)message.getContextualProperty(GSSCredential.class.getName());
String contextName = authPolicy.getAuthorization();
if (contextName == null) {
  contextName = "";
if (!(StringUtils.isEmpty(authPolicy.getUserName())
  && StringUtils.isEmpty(contextName) && loginConfig == null)) {
  CallbackHandler callbackHandler = getUsernamePasswordHandler(
    authPolicy.getUserName(), authPolicy.getPassword());
  LoginContext lc = new LoginContext(contextName, null, callbackHandler, loginConfig);
  lc.login();

protected void configureHttpConduit(HTTPConduit httpConduit) {
  if (isSecure()) {
    TLSClientParameters tlsClientParameters = httpConduit.getTlsClientParameters();
    // If no TLSClientParameters are configured and no custom SslContext is configured, we use the system default
    // otherwise we overwrite TLSClientParameters if a custom SslContext is configured
    if (tlsClientParameters == null) {
      tlsClientParameters = new TLSClientParameters();
      maybeUpdateSslContext(tlsClientParameters, true);
    } else {
      maybeUpdateSslContext(tlsClientParameters, false);
    }
    if (getHostnameVerifier() != null) {
      tlsClientParameters.setHostnameVerifier(getHostnameVerifier());
    }
    httpConduit.setTlsClientParameters(tlsClientParameters);
  }
  if (getUsername() != null) {
    AuthorizationPolicy authorizationPolicy = new AuthorizationPolicy();
    authorizationPolicy.setUserName(getUsername());
    authorizationPolicy.setPassword(getPassword());
    httpConduit.setAuthorization(authorizationPolicy);
  }
}

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());

private void verifyBethalClient(Greeter bethal) {
  Client client = ClientProxy.getClient(bethal);
  HTTPConduit http =
    (HTTPConduit) client.getConduit();
  HTTPClientPolicy httpClientPolicy = http.getClient();
  assertEquals("the httpClientPolicy's autoRedirect should be true",
         true, httpClientPolicy.isAutoRedirect());
  TLSClientParameters tlsParameters = http.getTlsClientParameters();
  assertNotNull("the http conduit's tlsParameters should not be null", tlsParameters);
  // If we set any name, but Edward, Mary, or George,
  // and a password of "password" we will get through
  // Bethal.
  AuthorizationPolicy authPolicy = http.getAuthorization();
  assertEquals("Set the wrong user name from the configuration",
         "Betty", authPolicy.getUserName());
  assertEquals("Set the wrong pass word form the configuration",
         "password", authPolicy.getPassword());
  configureProxy(ClientProxy.getClient(bethal));
  String answer = bethal.sayHi();
  answer = bethal.sayHi();
  answer = bethal.sayHi();
  answer = bethal.sayHi();
  answer = bethal.sayHi();
  assertTrue("Unexpected answer: " + answer,
      "Bonjour from Bethal".equals(answer));
  //With HTTPS, it will just be a CONNECT to the proxy and all the
  //data is encrypted.  Thus, the proxy cannot distinquish the requests
  assertProxyRequestCount(0);
}

 // setup the basic authentication property
if (ObjectHelper.isNotEmpty(username)) {
  AuthorizationPolicy authPolicy = new AuthorizationPolicy();
  authPolicy.setUserName(username);
  authPolicy.setPassword(password);
  factoryBean.getProperties().put(AuthorizationPolicy.class.getName(), authPolicy);
}