@Test(groups = { "standalone", "default_provider" }) public void digestAuthTest() throws IOException, ExecutionException, TimeoutException, InterruptedException { try (AsyncHttpClient client = getAsyncHttpClient(null)) { AsyncHttpClient.BoundRequestBuilder r = client.prepareGet("http://127.0.0.1:" + port1 + "/").setRealm((new Realm.RealmBuilder()).setPrincipal(user).setPassword(admin).setRealmName("MyRealm").setScheme(Realm.AuthScheme.DIGEST).build()); Future<Response> f = r.execute(); Response resp = f.get(60, TimeUnit.SECONDS); assertNotNull(resp); assertEquals(resp.getStatusCode(), HttpServletResponse.SC_OK); assertNotNull(resp.getHeader("X-Auth")); } }
private void doTest(boolean usePreemptiveAuth) throws UnknownHostException, InterruptedException, ExecutionException { try (AsyncHttpClient client = getAsyncHttpClient(new AsyncHttpClientConfig.Builder().build())) { Request request = new RequestBuilder("GET").setProxyServer(basicProxy()).setUrl(getTargetUrl()).setRealm( new Realm.RealmBuilder().setPrincipal("user").setPassword("passwd").setScheme(BASIC).setUsePreemptiveAuth(usePreemptiveAuth).build()).build(); Future<Response> responseFuture = client.executeRequest(request); Response response = responseFuture.get(); Assert.assertEquals(response.getStatusCode(), HttpServletResponse.SC_OK); Assert.assertTrue(getTargetUrl().endsWith(response.getHeader("target"))); } }
public Builder setRealmScheme(Realm.AuthScheme scheme) { realm().setScheme(scheme); return this; }
public Builder setRealmScheme(Realm.AuthScheme scheme) { realm().setScheme(scheme); return this; }
private Request auth(String username, String password, AuthScheme scheme) { this.setRealm((new RealmBuilder()).setScheme(scheme).setPrincipal(username).setPassword(password) .setUsePreemptiveAuth(true).build()); return this; }
@Override public RequestBuilder withBasicAuth(final String username, final String password) { final Realm realm = new Realm.RealmBuilder(). setPrincipal(username). setPassword(password). setUsePreemptiveAuth(true). setScheme(Realm.AuthScheme.BASIC). build(); ningRequestBuilder.setRealm(realm); return this; }
private RealmBuilder realmBuilderBase() { return new Realm.RealmBuilder()// .setScheme(AuthScheme.NTLM)// .setNtlmDomain("Ursa-Minor")// .setNtlmHost("LightCity")// .setPrincipal("Zaphod")// .setPassword("Beeblebrox"); }
private WSRequest auth(String username, String password, AuthScheme scheme) { this.setRealm((new RealmBuilder()) .setScheme(scheme) .setPrincipal(username) .setPassword(password) .setUsePreemptiveAuth(true) .build()); return this; }
public Realm.RealmBuilder realmBuilder() { return new Realm.RealmBuilder()// .setTargetProxy(true) .setNtlmDomain(ntlmDomain) .setNtlmHost(ntlmHost) .setPrincipal(principal) .setPassword(password) .setScheme(scheme); }
/** * {@inheritDoc} */ @Override public WebClient auth(final AuthScheme scheme, final String user, final String password) { realm = new RealmBuilder().setPrincipal(user).setPassword(password).setScheme(mapScheme(scheme)).build(); return this; }
public Realm.RealmBuilder realmBuilder() { return new Realm.RealmBuilder()// .setTargetProxy(true) .setNtlmDomain(ntlmDomain) .setNtlmHost(ntlmHost) .setPrincipal(principal) .setPassword(password) .setScheme(scheme); }
private Realm kerberosChallenge(Channel channel,// List<String> authHeaders,// Request request,// FluentCaseInsensitiveStringsMap headers,// Realm realm,// NettyResponseFuture<?> future) throws NTLMEngineException { Uri uri = request.getUri(); String host = request.getVirtualHost() == null ? uri.getHost() : request.getVirtualHost(); try { String challengeHeader = SpnegoEngine.INSTANCE.generateToken(host); headers.remove(HttpHeaders.Names.AUTHORIZATION); headers.add(HttpHeaders.Names.AUTHORIZATION, "Negotiate " + challengeHeader); return new Realm.RealmBuilder().clone(realm)// .setUri(uri)// .setMethodName(request.getMethod())// .setScheme(Realm.AuthScheme.KERBEROS)// .build(); } catch (Throwable throwable) { String ntlmAuthenticate = getNTLM(authHeaders); if (ntlmAuthenticate != null) { return ntlmChallenge(ntlmAuthenticate, request, headers, realm, future); } requestSender.abort(channel, future, throwable); return null; } }
private Realm kerberosProxyChallenge(Channel channel,// List<String> proxyAuth,// Request request,// ProxyServer proxyServer,// FluentCaseInsensitiveStringsMap headers,// NettyResponseFuture<?> future) throws NTLMEngineException { Uri uri = request.getUri(); try { String challengeHeader = SpnegoEngine.INSTANCE.generateToken(proxyServer.getHost()); headers.remove(HttpHeaders.Names.AUTHORIZATION); headers.add(HttpHeaders.Names.AUTHORIZATION, "Negotiate " + challengeHeader); return proxyServer.realmBuilder()// .setUri(uri)// .setMethodName(request.getMethod())// .setScheme(Realm.AuthScheme.KERBEROS)// .build(); } catch (Throwable throwable) { String ntlmAuthenticate = getNTLM(proxyAuth); if (ntlmAuthenticate != null) { return ntlmProxyChallenge(ntlmAuthenticate, request, proxyServer, headers, future); } requestSender.abort(channel, future, throwable); return null; } }
public RealmBuilder clone(Realm clone) { return setRealmName(clone.getRealmName())// .setAlgorithm(clone.getAlgorithm())// .setMethodName(clone.getMethodName())// .setNc(clone.getNc())// .setNonce(clone.getNonce())// .setPassword(clone.getPassword())// .setPrincipal(clone.getPrincipal())// .setCharset(clone.getCharset())// .setOpaque(clone.getOpaque())// .setQop(clone.getQop())// .setScheme(clone.getScheme())// .setUri(clone.getUri())// .setUsePreemptiveAuth(clone.getUsePreemptiveAuth())// .setNtlmDomain(clone.getNtlmDomain())// .setNtlmHost(clone.getNtlmHost())// .setUseAbsoluteURI(clone.isUseAbsoluteURI())// .setOmitQuery(clone.isOmitQuery())// .setTargetProxy(clone.isTargetProxy()); }
public RealmBuilder parseProxyAuthenticateHeader(String headerLine) { setRealmName(match(headerLine, "realm")); setNonce(match(headerLine, "nonce")); setOpaque(match(headerLine, "opaque")); String algorithm = match(headerLine, "algorithm"); if (isNonEmpty(algorithm)) { setAlgorithm(algorithm); } setQop(match(headerLine, "qop")); if (isNonEmpty(getNonce())) { setScheme(AuthScheme.DIGEST); } else { setScheme(AuthScheme.BASIC); } setTargetProxy(true); return this; }
public RealmBuilder parseWWWAuthenticateHeader(String headerLine) { setRealmName(match(headerLine, "realm")); setNonce(match(headerLine, "nonce")); String algorithm = match(headerLine, "algorithm"); if (isNonEmpty(algorithm)) { setAlgorithm(algorithm); } setOpaque(match(headerLine, "opaque")); String rawQop = match(headerLine, "qop"); if (rawQop != null) { setQop(parseRawQop(rawQop)); } if (isNonEmpty(getNonce())) { setScheme(AuthScheme.DIGEST); } else { setScheme(AuthScheme.BASIC); } return this; }
private static Realm ntlmProxyChallenge(final Connection c, final String wwwAuth, final Request request, final ProxyServer proxyServer) throws NTLMEngineException { final FluentCaseInsensitiveStringsMap headers = request.getHeaders(); headers.remove(Header.ProxyAuthorization.toString()); Realm realm = proxyServer.realmBuilder()// .setScheme(AuthScheme.NTLM)// .setUri(request.getUri())// .setMethodName(request.getMethod()).build(); addType3NTLMAuthorizationHeader(wwwAuth, headers, realm, true); // we mark NTLM as established for the Connection to // avoid preemptive NTLM Utils.setNtlmEstablished(c); return realm; }
public Builder setRealmScheme(Realm.AuthScheme scheme) { realm().setScheme(scheme); return this; }
public Realm.RealmBuilder realmBuilder() { return new Realm.RealmBuilder()// .setTargetProxy(true) .setNtlmDomain(ntlmDomain) .setNtlmHost(ntlmHost) .setPrincipal(principal) .setPassword(password) .setScheme(scheme); }
private Realm ntlmProxyChallenge(String wwwAuth, Request request, ProxyServer proxyServer, FluentCaseInsensitiveStringsMap headers, NettyResponseFuture<?> future) throws NTLMEngineException { future.getAndSetAuth(false); headers.remove(HttpHeaders.Names.PROXY_AUTHORIZATION); Realm realm = proxyServer.realmBuilder()// .setScheme(AuthScheme.NTLM)// .setUri(request.getUri())// .setMethodName(request.getMethod()).build(); addType3NTLMAuthorizationHeader(wwwAuth, headers, realm, true); return realm; }