final HttpHost proxyHost = new HttpHost(proxy.getHost(), proxy.getPort(), "http"); if (proxy.isAuthEnabled()) { CredentialsProvider credsProvider = new BasicCredentialsProvider(); credsProvider.setCredentials( new AuthScope(proxy.getHost(), proxy.getPort()), new UsernamePasswordCredentials(proxy.getUsername(), new String(proxy.getPassword()))); hcBuilder.setDefaultCredentialsProvider(credsProvider); String realm = StringUtil.isEmpty(a.getRealm()) ? AuthScope.ANY_REALM : a.getRealm(); CredentialsProvider credsProvider = new BasicCredentialsProvider(); credsProvider.setCredentials( new AuthScope(host, urlPort, realm), new UsernamePasswordCredentials(uid, pwd)); hcBuilder.setDefaultCredentialsProvider(credsProvider); String pwd = new String(a.getPassword()); CredentialsProvider credsProvider = new BasicCredentialsProvider(); credsProvider.setCredentials( AuthScope.ANY, new NTCredentials( uid, pwd, a.getWorkstation(), a.getDomain())); hcBuilder.setDefaultCredentialsProvider(credsProvider);
if (this.state == State.CHALLENGE_RECEIVED || this.state == State.FAILED) { response = this.engine.generateType1Msg( ntcredentials.getDomain(), ntcredentials.getWorkstation()); this.state = State.MSG_TYPE1_GENERATED; } else if (this.state == State.MSG_TYPE2_RECEVIED) { response = this.engine.generateType3Msg( ntcredentials.getUserName(), ntcredentials.getPassword(), ntcredentials.getDomain(), ntcredentials.getWorkstation(), this.challenge); this.state = State.MSG_TYPE3_GENERATED;
httpClientParams, getSocketTimeout(config)); DefaultHttpClient httpclient = new DefaultHttpClient(httpClientParams); httpclient.getParams().setParameter( ConnRoutePNames.DEFAULT_PROXY, proxy); && config.getProxyPassword() != null) { httpclient.getCredentialsProvider().setCredentials( new AuthScope(proxyHost, proxyPort), new NTCredentials(config.getProxyUsername(), config.getProxyPassword(), config.getProxyWorkstation(),
DefaultHttpClient httpclient = new DefaultHttpClient(); List<String> authpref = new ArrayList<String>(); authpref.add(AuthPolicy.NTLM); httpclient.getParams().setParameter(AuthPNames.TARGET_AUTH_PREF, authpref); NTCredentials creds = new NTCredentials("username", "pwd", "server", "domain"); httpclient.getCredentialsProvider().setCredentials(AuthScope.ANY, creds); HttpHost target = new HttpHost("localhost", 80, "http"); // Make sure the same context is used to execute logically related requests HttpContext localContext = new BasicHttpContext(); // Execute a cheap method first. This will trigger NTLM authentication HttpGet httpget = new HttpGet("/index.html"); HttpResponse response = httpclient.execute(target, httpget, localContext); HttpEntity entity = response.getEntity(); System.out.println(EntityUtils.toString(entity));
cm.setMaxTotal(200); cm.setDefaultMaxPerRoute(20); HttpClient httpClient = new DefaultHttpClient(cm); _executor = new ApacheHttpClient4Executor(httpClient); if (model.isBasicAuth()) { authScope = createAuthScope(model.getBasicAuthConfig().getHost(), model.getBasicAuthConfig().getPort(), model.getBasicAuthConfig().getRealm()); credentials = new UsernamePasswordCredentials(model.getBasicAuthConfig().getUser(), model.getBasicAuthConfig().getPassword()); authCache.put(new HttpHost(authScope.getHost(), authScope.getPort()), new BasicScheme(ChallengeState.TARGET)); BasicHttpContext context = new BasicHttpContext(); context.setAttribute(ClientContext.AUTH_CACHE, authCache); } else { authScope = createAuthScope(model.getNtlmAuthConfig().getHost(), model.getNtlmAuthConfig().getPort(), model.getNtlmAuthConfig().getRealm()); credentials = new NTCredentials(model.getNtlmAuthConfig().getUser(), model.getNtlmAuthConfig().getPassword(), "", model.getNtlmAuthConfig().getDomain()); ((DefaultHttpClient)httpClient).getCredentialsProvider().setCredentials(authScope, credentials); } else { ProxyModel proxy = model.getProxyConfig();
connectionManager = new BasicClientConnectionManager(); httpClient = new DefaultHttpClient(connectionManager, httpClientParams); if (config.getCredentials() != null) { httpClient.getCredentialsProvider().setCredentials(AuthScope.ANY, config.getCredentials()); httpClient.getConnectionManager().getSchemeRegistry().register(new Scheme("https", httpsPort, sf)); if ((proxyUsername != null) && (proxyPassword != null)) { if (config.getClientProxyConfiguration().getAuthType() == ClientProxyConfiguration.AuthType.NT) { httpClient.getCredentialsProvider().setCredentials(new AuthScope(proxyHost, proxyPort), new NTCredentials(proxyUsername, proxyPassword, proxyWorkstation, proxyDomain)); } else if (config.getClientProxyConfiguration().getAuthType() == ClientProxyConfiguration.AuthType.BASIC) { httpClient.getCredentialsProvider().setCredentials(new AuthScope(proxyHost, proxyPort), new UsernamePasswordCredentials(proxyUsername, proxyPassword));
DefaultHttpClient httpclient = new DefaultHttpClient(); HttpContext localContext = new BasicHttpContext(); HttpGet httpget = new HttpGet("url"); CredentialsProvider credsProvider = new BasicCredentialsProvider(); credsProvider.setCredentials(AuthScope.ANY, new NTCredentials("username", "pwd", "", "domain")); List<String> authtypes = new ArrayList<String>(); authtypes.add(AuthPolicy.NTLM); httpclient.getParams().setParameter(AuthPNames.TARGET_AUTH_PREF,authtypes); localContext.setAttribute(ClientContext.CREDS_PROVIDER, credsProvider); HttpResponse response = httpclient.execute(httpget, localContext); HttpEntity entity=response.getEntity();
BasicCredentialsProvider credentialsProvider = new BasicCredentialsProvider(); AuthScope authScope = new AuthScope(proxyHost.getHostName(), proxyHost.getPort(), ANY_REALM, NTLM); Credentials creds = new NTCredentials(ntlmUsername, password, getWorkstation(), ntlmDomain); credentialsProvider.setCredentials(authScope, creds); authScope = new AuthScope(proxyHost.getHostName(), proxyHost.getPort()); creds = new UsernamePasswordCredentials(username, password); credentialsProvider.setCredentials(authScope, creds);
AuthScope authScope = new AuthScope(remoteWebDriverProxyHost, Integer.parseInt(remoteWebDriverProxyPort)); if (remoteWebDriverProxyDomain.length() == 0) { client.getCredentialsProvider().setCredentials(authScope, new UsernamePasswordCredentials(remoteWebDriverProxyUser, remoteWebDriverProxyPassword)); } else { client.getCredentialsProvider().setCredentials( authScope, new NTCredentials(remoteWebDriverProxyUser, remoteWebDriverProxyPassword, remoteWebDriverProxyWorkstation, remoteWebDriverProxyDomain)); client.setRoutePlanner(new DefaultHttpRoutePlanner(client.getConnectionManager().getSchemeRegistry())); HttpHost proxy = new HttpHost(remoteWebDriverProxyHost, Integer.parseInt(remoteWebDriverProxyPort)); client.getParams().setParameter(ConnRoutePNames.DEFAULT_PROXY, proxy);
/** * Set NTLM authentication credentials to be used for the given host and port. * * @param host * @param port * @param user * @param pass * @param workstation * @param domain */ public void ntlm(String host, int port, String user, String pass, String workstation, String domain) { builder.getClient().getCredentialsProvider().setCredentials( new AuthScope(host, port), new NTCredentials(user, pass, workstation, domain) ); }
if (scope == null || scope.getScheme() == null) { return null; Credentials credentials = mCredentialProvider.getCredentials(scope); if (credentials!=null){ return credentials; if (scope.getScheme().equals("ntlm")) { System.out.println("Proxy Authentication Required -- " + "Host " + scope.getHost() + ":" + scope.getPort() + " requires Windows authentication"); System.out.print("Username: "); String username = inputReader.readLine(); System.out.print("Domain: "); String domain = inputReader.readLine(); credentials = new NTCredentials(username, password, scope.getHost(), domain); } else if (scope.getScheme().equals("basic") || scope.getScheme().equals("digest")) { String password = inputReader.readLine(); credentials = new UsernamePasswordCredentials(username, password); } else { throw new IllegalArgumentException("Unsupported authentication scheme: " + mCredentialProvider.setCredentials(scope, credentials);
final NTCredentials ntCredentials = new NTCredentials("username", "Passworrd","destination", "domain"); CredentialsProvider credsProvider = new BasicCredentialsProvider(); credsProvider.setCredentials(AuthScope.ANY, ntCredentials); CloseableHttpClient httpclient = HttpClientBuilder.create() .setDefaultCredentialsProvider(credsProvider) .build();
getLogger().info( "... {} authentication setup for NTLM domain '{}'", authScope, nras.getNtlmDomain() ); credentials = new NTCredentials( nras.getUsername(), nras.getPassword(), nras.getNtlmHost(), nras.getNtlmDomain() ); getLogger().info( "... {} authentication setup for remote storage with username '{}'", authScope, uras.getUsername() ); credentials = new UsernamePasswordCredentials( uras.getUsername(), uras.getPassword() ); httpClient.getCredentialsProvider().setCredentials( new AuthScope( proxyHost ), credentials ); httpClient.getParams().setParameter( AuthPNames.PROXY_AUTH_PREF, authorisationPreference ); httpClient.getCredentialsProvider().setCredentials( AuthScope.ANY, credentials ); httpClient.getParams().setParameter( AuthPNames.TARGET_AUTH_PREF, authorisationPreference );
sb.append(spUri).append("UserInformationList").toString(); DefaultHttpClient httpClient = new DefaultHttpClient(); httpClient.getAuthSchemes().register("ntlm",new JCIFSNTLMSchemeFactory()); CredentialsProvider credsProvider = new BasicCredentialsProvider(); NTCredentials ntcred = new NTCredentials("username_here", "password_here", InetAddress.getLocalHost().getHostName(), "domain_here"); credsProvider.setCredentials(new AuthScope("base_url_here_sans_https://", 443, AuthScope.ANY_REALM, "NTLM"), ntcred); httpClient.setCredentialsProvider(credsProvider);
private static AbstractHttpClient createHTTPClient() { AbstractHttpClient client = new DefaultHttpClient(); String proxyHost = System.getProperty("https.proxyHost", ""); if (!proxyHost.isEmpty()) { int proxyPort = Integer.parseInt(System.getProperty("https.proxyPort", "-1")); log.info("Using proxy " + proxyHost + ":" + proxyPort); HttpParams params = client.getParams(); HttpHost proxy = new HttpHost(proxyHost, proxyPort); params.setParameter(ConnRoutePNames.DEFAULT_PROXY, proxy); String proxyUser = System.getProperty(JMeter.HTTP_PROXY_USER, JMeterUtils.getProperty(JMeter.HTTP_PROXY_USER)); if (proxyUser != null) { log.info("Using authenticated proxy with username: " + proxyUser); String proxyPass = System.getProperty(JMeter.HTTP_PROXY_PASS, JMeterUtils.getProperty(JMeter.HTTP_PROXY_PASS)); String localHost; try { localHost = InetAddress.getLocalHost().getCanonicalHostName(); } catch (Throwable e) { log.error("Failed to get local host name, defaulting to 'localhost'", e); localHost = "localhost"; } AuthScope authscope = new AuthScope(proxyHost, proxyPort); String proxyDomain = JMeterUtils.getPropDefault("http.proxyDomain", ""); NTCredentials credentials = new NTCredentials(proxyUser, proxyPass, localHost, proxyDomain); client.getCredentialsProvider().setCredentials(authscope, credentials); } } return client; }
@Override public Credentials getCredentials(final AuthScope authscope) { Args.notNull(authscope, "Auth scope"); final Credentials localcreds = internal.getCredentials(authscope); if (localcreds != null) { return localcreds; if (authscope.getHost() != null) { PasswordAuthentication systemcreds = getSystemCreds( authscope, Authenticator.RequestorType.SERVER); final String domain = System.getProperty("http.auth.ntlm.domain"); if (domain != null) { return new NTCredentials( systemcreds.getUserName(), new String(systemcreds.getPassword()), null, domain); } else { if (AuthSchemes.NTLM.equalsIgnoreCase(authscope.getScheme())) { return new NTCredentials( systemcreds.getUserName(), new String(systemcreds.getPassword()), null, null); } else { return new UsernamePasswordCredentials( systemcreds.getUserName(), new String(systemcreds.getPassword()));
/** * determine the Credentials implementation to use * @param auth * @return a {@code Credentials} instance, either {{@link UsernamePasswordCredentials} or {@link NTCredentials}} */ protected Credentials configureCredentials(AuthConfiguration auth) { if (null != auth.getCredentialType() && auth.getCredentialType().equalsIgnoreCase(AuthConfiguration.NT_CREDS)) { return new NTCredentials(auth.getUsername(), auth.getPassword(), auth.getHostname(), auth.getDomain()); } else { return new UsernamePasswordCredentials(auth.getUsername(), auth.getPassword()); } } }
public class JsonRpcClient { private static final String HOST = "blabla.yourhostname.com"; private final AbstractHttpClient httpClient; public JsonRpcClient(String username, String password) { httpClient = new DefaultHttpClient(); httpClient.getAuthSchemes().register("ntlm", new JCIFSNTLMSchemeFactory()); httpClient.getCredentialsProvider().setCredentials( new AuthScope(HOST, -1), new NTCredentials(username, password, "", "")); } ... }
@Override public DefaultHttpClient create(final HttpMethod method, final URI uri) { final DefaultHttpClient httpclient = super.create(method, uri); final CredentialsProvider credsProvider = new BasicCredentialsProvider(); credsProvider.setCredentials(AuthScope.ANY, new NTCredentials(username, password, workstation, domain)); httpclient.setCredentialsProvider(credsProvider); return httpclient; } }
HttpClient httpclient = new DefaultHttpClient(); NTCredentials creds = new NTCredentials("user", "pwd", "myworkstation", "microsoft.com"); httpclient.getCredentialsProvider().setCredentials(AuthScope.ANY, creds);