Refine search
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); }