Refine search
config = AUTH_CONTEXT_CLIENT.getAuthenticationConfiguration(uri, AuthenticationContext.captureCurrent()); final CallbackHandler callbackHandler = AUTH_CONTEXT_CLIENT.getCallbackHandler(config); query = null; digestUri = new URI(uri.getScheme(), uri.getUserInfo(), uri.getHost(), uri.getPort(), path, query, null).toString(); } catch (URISyntaxException e) { throw new RuntimeException(e);
final URI destinationUri = connectionService.getDestinationUri(); MatchRule rule = MatchRule.ALL; final String scheme = destinationUri.getScheme(); if (scheme != null) { rule = rule.matchProtocol(scheme); final String host = destinationUri.getHost(); if (host != null) { rule = rule.matchHost(host); final int port = destinationUri.getPort(); if (port != -1) { rule = rule.matchPort(port); final OptionMap connectOptions = connectionSpec.getConnectOptions(); authenticationConfiguration = RemotingOptions.mergeOptionsIntoAuthenticationConfiguration(connectOptions, authenticationConfiguration); AuthenticationConfiguration ejbConfiguration = CLIENT.getAuthenticationConfiguration(destinationUri, context, - 1, "ejb", "jboss"); AuthenticationConfiguration jtaConfiguration = CLIENT.getAuthenticationConfiguration(destinationUri, context, - 1, "jta", "jboss"); if (sslContext == null) { try { sslContext = CLIENT.getSSLContext(destinationUri, context); } catch (GeneralSecurityException e) { throw EjbLogger.ROOT_LOGGER.failedToObtainSSLContext(e); AuthenticationContext mergedAuthenticationContext = context.with(0, ejbRule, ejbConfiguration.with(authenticationConfiguration)).with(jtaRule, jtaConfiguration.with(authenticationConfiguration)); return mergedAuthenticationContext.withSsl(0, rule, () -> finalSSLContext);
private SocketFactory getSocketFactory() throws NamingException { if (socketFactory == null && authenticationContext != null) { try { URI uri = new URI(providerUrl.split(" ")[0]); // only first URI used for AC resolution if ( ! uri.getScheme().equalsIgnoreCase(LDAPS_SCHEME)) { return socketFactory; // non-SSL connection } SecurityFactory<SSLContext> sslContextFactory = authClient.getSSLContextFactory(uri, authenticationContext, null, null); return sslContextFactory.create().getSocketFactory(); } catch (Exception e) { throw log.obtainingDirContextCredentialFromAuthenticationContextFailed(e); } } return socketFactory; }
private IoFuture<ConnectionPeerIdentity> getFuturePeerIdentityPrivileged(final URI location) { final Supplier<AuthenticationContext> supplier = providerEnvironment.getAuthenticationContextSupplier(); final AuthenticationContext context = supplier.get(); final SSLContext sslContext; try { sslContext = CLIENT.getSSLContext(location, context, "jndi", "jboss"); } catch (GeneralSecurityException e) { return new FailedIoFuture<>(new IOException(e)); } final AuthenticationConfiguration authenticationConfiguration = CLIENT.getAuthenticationConfiguration(location, context, -1, "jndi", "jboss"); return endpoint.getConnectedIdentity(location, sslContext, authenticationConfiguration); } }
ConnectionPeerIdentity getPeerIdentity() throws IOException { SSLContext finalSslContext; if (sslContext == null) { try { finalSslContext = CLIENT.getSSLContext(location, AuthenticationContext.captureCurrent(), "jta", "jboss"); } catch (GeneralSecurityException e) { throw new IOException(e); } } else { finalSslContext = sslContext; } AuthenticationConfiguration finalAuthenticationConfiguration; if (authenticationConfiguration == null) { finalAuthenticationConfiguration = CLIENT.getAuthenticationConfiguration(location, AuthenticationContext.captureCurrent(), -1, "jta", "jboss"); } else { finalAuthenticationConfiguration = authenticationConfiguration; } return endpoint.getConnectedIdentity(location, finalSslContext, finalAuthenticationConfiguration).get(); }
/** * Creates a new {@link OAuth2CredentialSource} instance. * * @return a OAuth2 credential source */ public OAuth2CredentialSource build() { if (authenticationHandler == null) { authenticationHandler = parameters -> { AuthenticationContext context = AuthenticationContext.captureCurrent(); AuthenticationContextConfigurationClient client = AccessController.doPrivileged(AuthenticationContextConfigurationClient.ACTION); AuthenticationConfiguration configuration = client.getAuthenticationConfiguration(URI.create(tokenEndpointUrl.toString()), context); CallbackHandler handler = client.getCallbackHandler(configuration); NameCallback nameCallback = new NameCallback("Client ID"); PasswordCallback password1 = new PasswordCallback("Client Secret", false); try { handler.handle(new Callback[]{nameCallback, password1}); } catch (Exception ignore) { } String userName = nameCallback.getName(); char[] password = password1.getPassword(); configureClientCredentialsParameters(parameters, userName, password); }; } return new OAuth2CredentialSource(tokenEndpointUrl, authenticationHandler.andThen(parameters -> { if (!parameters.containsKey("client_id") || !parameters.containsKey("client_secret")) { throw saslOAuth2.oauth2ClientCredentialsNotProvided(); } }), scopes, sslContextSupplier, hostnameVerifierSupplier); }
ClearPassword password = null; try { URI uri = new URI(providerUrl.split(" ")[0]); // only first URI used for AC resolution AuthenticationConfiguration configuration = authClient.getAuthenticationConfiguration(uri, authenticationContext, 0, null, null); authClient.getCallbackHandler(configuration).handle(new Callback[]{nameCallback, credentialCallback}); } catch (Exception e) { throw log.couldNotObtainCredentialWithCause(e);
final AuthenticationContext context = receiverContext.getAuthenticationContext(); final AuthenticationContextConfigurationClient client = CLIENT; final int defaultPort = uri.getScheme().equals("https") ? 443 : 80; final AuthenticationConfiguration authenticationConfiguration = client.getAuthenticationConfiguration(uri, context, defaultPort, "jndi", "jboss"); final SSLContext sslContext; try { sslContext = client.getSSLContext(uri, context, "jndi", "jboss"); } catch (GeneralSecurityException e) { .setBeanName(locator.getBeanName()); final CompletableFuture<Boolean> result = new CompletableFuture<>(); targetContext.sendRequest(builder.createRequest(targetContext.getUri().getPath()), sslContext, authenticationConfiguration, null, (stream, response, closeable) -> { try { result.complete(true);
connURI = new URI(address.getProtocol(), null, address.getHost(), address.getPort(), null, null, null); } catch (URISyntaxException e) { throw new IOException("Failed to create URI" , e); AuthenticationContext authenticationContext = AuthenticationContext.captureCurrent(); if (sslContextFactory != null) { authenticationContext = authenticationContext.withSsl(MatchRule.ALL, sslContextFactory); this.sslContext = AUTH_CONFIGURATION_CLIENT.getSSLContext(connURI, authenticationContext);
authConfigUri = (URI) authConfig; } else { authConfigUri = URI.create(authConfig.toString()); captured = AuthenticationContext.captureCurrent(); } else { try { AuthenticationConfiguration mergedConfiguration = AUTH_CONFIGURATION_CLIENT.getAuthenticationConfiguration(uri, captured); tempContext = AUTH_CONFIGURATION_CLIENT.getSSLContext(uri, captured); } catch (GeneralSecurityException e) { log.trace("No SSLContext available", e); AuthenticationContext context = AuthenticationContext.empty().with(MatchRule.ALL, mergedConfiguration); final SSLContext sslContext = tempContext; context = sslContext != null ? context.withSsl(MatchRule.ALL, () -> sslContext) : context;
cc.setCredential(new PasswordCredential(DigestPassword.createRaw(DigestPassword.ALGORITHM_DIGEST_MD5, username, realm, bytes))); } else if (cc.isCredentialTypeSupported(BearerTokenCredential.class)) { AuthenticationContext context = AuthenticationContext.captureCurrent(); AuthenticationContextConfigurationClient client = AccessController.doPrivileged(AuthenticationContextConfigurationClient.ACTION); AuthenticationConfiguration configuration = client.getAuthenticationConfiguration(URI.create(connectionAddress.toString()), context); CallbackHandler callbackHandler = client.getCallbackHandler(configuration); context.with(MatchRule.ALL, configuration.useCallbackHandler(this)).run((PrivilegedAction<Object>) () -> { try { callbackHandler.handle(callbacks);
private void acquireSessionAffinity(CountDownLatch latch, AuthenticationConfiguration authenticationConfiguration) { ClientRequest clientRequest = new ClientRequest(); clientRequest.setMethod(Methods.GET); clientRequest.setPath(uri.getPath() + "/common/v1/affinity"); AuthenticationContext context = AuthenticationContext.captureCurrent(); SSLContext sslContext; try { sslContext = AUTH_CONTEXT_CLIENT.getSSLContext(uri, context); } catch (GeneralSecurityException e) { latch.countDown(); HttpClientMessages.MESSAGES.failedToAcquireSession(e); return; } sendRequest(clientRequest, sslContext, authenticationConfiguration, null, null, (e) -> { latch.countDown(); HttpClientMessages.MESSAGES.failedToAcquireSession(e); }, null, latch::countDown); }
final AuthenticationContext context = providerEnvironment.getAuthenticationContextSupplier().get(); AuthenticationContextConfigurationClient client = CLIENT; final int defaultPort = providerUri.getScheme().equals("https") ? 443 : 80; final AuthenticationConfiguration authenticationConfiguration = client.getAuthenticationConfiguration(providerUri, context, defaultPort, "jndi", "jboss"); final SSLContext sslContext; try { sslContext = client.getSSLContext(providerUri, context, "jndi", "jboss"); } catch (GeneralSecurityException e) { final CommunicationException e2 = new CommunicationException(e.toString());
final AuthenticationContext context = AuthenticationContext.captureCurrent(); final AuthenticationConfiguration authenticationConfiguration; try { authenticationConfiguration = client.getAuthenticationConfiguration(getRequestingURL().toURI(), context); } catch (URISyntaxException e) { log.tracef("URISyntaxException getting URI from the requesting URL [%s]:", getRequestingURL(), e); final CallbackHandler callbackHandler = client.getCallbackHandler(authenticationConfiguration); final NameCallback nameCallback = new NameCallback(getRequestingPrompt()); final CredentialCallback credentialCallback = new CredentialCallback(PasswordCredential.class); return null; final PasswordFactory factory = PasswordFactory.getInstance(twoWayPassword.getAlgorithm(), client.getProviderSupplier(authenticationConfiguration)); password = factory.getKeySpec(factory.translate(twoWayPassword), ClearPasswordSpec.class).getEncodedPassword(); } catch (UnsupportedCallbackException e) {
AuthenticationContext authContext = this.authContext == null ? AuthenticationContext.captureCurrent() : this.authContext; final AuthenticationConfiguration configuration = AUTH_CONFIG_CLIENT.getAuthenticationConfiguration(uri, authContext, -1, null, null); final CallbackHandler handler = AUTH_CONFIG_CLIENT.getCallbackHandler(configuration); final NameCallback nameCallback = new NameCallback("Username: "); final PasswordCallback passwordCallback = new PasswordCallback("Password: ", false);
authContext = this.authContext; } else if(currentIdentity == null || currentIdentity.isAnonymous()) { authContext = AuthenticationContext.captureCurrent(); } else { authContext = AuthenticationContext.empty().with(MatchRule.ALL, AuthenticationConfiguration.empty().useForwardedIdentity(domain)); final AuthenticationConfiguration configuration = AUTH_CONFIG_CLIENT.getAuthenticationConfiguration(uri, authContext, -1, null, null); final Principal principal = AUTH_CONFIG_CLIENT.getPrincipal(configuration);
void init() { if (eagerlyAcquireAffinity) { acquireAffinitiy(AUTH_CONTEXT_CLIENT.getAuthenticationConfiguration(uri, AuthenticationContext.captureCurrent())); } }
@Override public SSLContext get() { AuthenticationContextConfigurationClient contextConfigurationClient = AccessController.doPrivileged(AuthenticationContextConfigurationClient.ACTION); try { return contextConfigurationClient.getSSLContext(tokenEndpointUrl.toURI(), AuthenticationContext.captureCurrent()); } catch (Exception cause) { throw saslOAuth2.failedToObtainSSLContext(cause); } } };
final AuthenticationConfiguration configuration = AUTH_CONFIG_CLIENT.getAuthenticationConfiguration(this.targetURI, authenticationContext); final CallbackHandler handler = AUTH_CONFIG_CLIENT.getCallbackHandler(configuration); final NameCallback nameCallback = new NameCallback("Username: "); final PasswordCallback passwordCallback = new PasswordCallback("Password: ", false);
/** * Get the authentication configuration which matches the given URI, or {@link AuthenticationConfiguration#EMPTY} if there is none. * * @param uri the URI to match (must not be {@code null}) * @param authenticationContext the authentication context to examine (must not be {@code null}) * @return the matching configuration */ public AuthenticationConfiguration getAuthenticationConfiguration(URI uri, AuthenticationContext authenticationContext) { return getAuthenticationConfiguration(uri, authenticationContext, -1); }