Java 类org.apache.http.impl.auth.DigestScheme 实例源码

private synchronized void checkLocalContext()
{
    if (null != sdkProtocolAdatperCustProvider && null != target)
    {
        // Create AuthCache instance
        AuthCache authCache = new BasicAuthCache();
        // Generate DIGEST scheme object, initialize it and add it to the local auth cache
        String authType = (String) ThreadLocalHolder.get().getEntities().get("AuthType");
        if ("Basic".equals(authType))
        {
            LOGGER.debug("authentication type: basic");
        }
        else
        {
            DigestScheme digestAuth = new DigestScheme();
            digestAuth.overrideParamter("nc", String.valueOf(serverNounceCount++));
            digestAuth.overrideParamter("cnonce", UUID.randomUUID().toString().replaceAll("-", ""));
            digestAuth.overrideParamter("qop", "auth");
            authCache.put(target, digestAuth);
        }

        // Add AuthCache to the execution context
        localContext = new BasicHttpContext();
        localContext.setAttribute(ClientContext.AUTH_CACHE, authCache);
    }
}

private synchronized void checkLocalContext()
{
    if (null != sdkProtocolAdatperCustProvider && null != target)
    {
        // Create AuthCache instance
        AuthCache authCache = new BasicAuthCache();
        // Generate DIGEST scheme object, initialize it and add it to the local auth cache
        String authType = (String)ThreadLocalHolder.get().getEntities().get("AuthType");
        if ("Basic".equals(authType))
        {
            LOGGER.debug("authentication type: basic");
        }
        else
        {
            DigestScheme digestAuth = new DigestScheme();
            digestAuth.overrideParamter("nc", String.valueOf(serverNounceCount++));
            digestAuth.overrideParamter("cnonce", UUID.randomUUID().toString().replaceAll("-", ""));
            digestAuth.overrideParamter("qop", "auth");
            authCache.put(target, digestAuth);
        }

        // Add AuthCache to the execution context
        localContext = new BasicHttpContext();
        localContext.setAttribute(ClientContext.AUTH_CACHE, authCache);
    }
}

private synchronized void checkLocalContext()
{
    if (null != sdkProtocolAdatperCustProvider && null != target)
    {
        // Create AuthCache instance
        AuthCache authCache = new BasicAuthCache();
        // Generate DIGEST scheme object, initialize it and add it to the local auth cache
        String authType = (String) ThreadLocalHolder.get().getEntities().get("AuthType");
        if ("Basic".equals(authType))
        {
            LOGGER.debug("authentication type: basic");
        }
        else
        {
            DigestScheme digestAuth = new DigestScheme();
            digestAuth.overrideParamter("nc", String.valueOf(serverNounceCount++));
            digestAuth.overrideParamter("cnonce", UUID.randomUUID().toString().replaceAll("-", ""));
            digestAuth.overrideParamter("qop", "auth");
            authCache.put(target, digestAuth);
        }

        // Add AuthCache to the execution context
        localContext = new BasicHttpContext();
        localContext.setAttribute(ClientContext.AUTH_CACHE, authCache);
    }
}

private synchronized void checkLocalContext()
{
    if (null != sdkProtocolAdatperCustProvider && null != target)
    {
        // Create AuthCache instance
        AuthCache authCache = new BasicAuthCache();
        // Generate DIGEST scheme object, initialize it and add it to the local auth cache
        String authType = (String)ThreadLocalHolder.get().getEntities().get("AuthType");
        if ("Basic".equals(authType))
        {
            LOGGER.debug("authentication type: basic");
        }
        else
        {
            DigestScheme digestAuth = new DigestScheme();
            digestAuth.overrideParamter("nc", String.valueOf(serverNounceCount++));
            digestAuth.overrideParamter("cnonce", UUID.randomUUID().toString().replaceAll("-", ""));
            digestAuth.overrideParamter("qop", "auth");
            authCache.put(target, digestAuth);
        }

        // Add AuthCache to the execution context
        localContext = new BasicHttpContext();
        localContext.setAttribute(ClientContext.AUTH_CACHE, authCache);
    }
}

public void init() throws ClientProtocolException, IOException, JAXBException {
    if (user != null && pwd != null) {
        CredentialsProvider credsProvider = new BasicCredentialsProvider();
        credsProvider.setCredentials(AuthScope.ANY,
                new UsernamePasswordCredentials(user, pwd));
        AuthCache authCache = new BasicAuthCache();
        DigestScheme digestScheme = new DigestScheme();
        digestScheme.overrideParamter("realm", "F!Box SOAP-Auth");
        digestScheme.overrideParamter("nonce", Long.toString(new Random().nextLong(), 36));
        digestScheme.overrideParamter("qop", "auth");
        digestScheme.overrideParamter("nc", "0");
        digestScheme.overrideParamter("cnonce", DigestScheme.createCnonce());
        authCache.put(targetHost, digestScheme);
        context.setCredentialsProvider(credsProvider);
        context.setAuthCache(authCache);
        readTR64();
    } else {
        readIGDDESC();
    }

}

public String postWithDigestAuth(final String url, final String file) {
    String responseBodyAsString = "";
    try (CloseableHttpResponse response =
            httpClient.execute(targetHost, httpPost(url, MultipartEntityBuilder.create().
                    addPart("bin", new FileBody(new File(file))).build()),
                    setAuth(targetHost, new DigestScheme()))) {
        responseBodyAsString = IOUtils.toString(response.getEntity().getContent(), Charset.forName("UTF-8"));
        handler.logOutput("Http status: " + response.getStatusLine().getStatusCode(), true);
        InstallLog.getInstance().info("Http status: " + response.getStatusLine().getStatusCode());
    } catch (IOException e) {
        final String messageError = "Error calling " + url + ": " + e.getMessage();
        handler.emitError(messageError, messageError);
        InstallLog.getInstance().error(messageError);
    }

    return responseBodyAsString;
}

public int postWithStringEntity(final String url, final String stringEntity) {
    int status = 0;
    try {
        final HttpPost httPost = httpPost(url, new StringEntity(stringEntity));
        httPost.addHeader("Content-Type", ContentType.APPLICATION_JSON.getMimeType());
        try (CloseableHttpResponse response =
                httpClient.execute(targetHost, httPost, setAuth(targetHost, new DigestScheme()))) {
            status = response.getStatusLine().getStatusCode();
            handler.logOutput("Http status: " + status, true);
            InstallLog.getInstance().info("Http status: " + status);
        }
    } catch (final IOException ioe) {
        final String messageError = "Error calling " + url + ": " + ioe.getMessage();
        handler.emitError(messageError, messageError);
        InstallLog.getInstance().error(messageError);

    }
    return status;
}

private void buildBasicHttpContext()
{
    AuthCache authCache = new BasicAuthCache();
    DigestScheme digestScheme = new DigestScheme();
    digestScheme.overrideParamter("nc", String.valueOf(serverNounceCount++));
    digestScheme.overrideParamter("cnonce", UUID.randomUUID().toString().replaceAll("-", ""));
    digestScheme.overrideParamter("qop", "auth");
    authCache.put(target, digestScheme);

    localContext = new BasicHttpContext();
    localContext.setAttribute(ClientContext.AUTH_CACHE, authCache);
}

private void buildBasicHttpContext()
{
    AuthCache authCache = new BasicAuthCache();
    DigestScheme digestScheme = new DigestScheme();
    digestScheme.overrideParamter("nc", String.valueOf(serverNounceCount++));
    digestScheme.overrideParamter("cnonce", UUID.randomUUID().toString().replaceAll("-", ""));
    digestScheme.overrideParamter("qop", "auth");
    authCache.put(target, digestScheme);

    localContext = new BasicHttpContext();
    localContext.setAttribute(ClientContext.AUTH_CACHE, authCache);
}

private void buildBasicHttpContext()
{
    AuthCache authCache = new BasicAuthCache();
    DigestScheme digestScheme = new DigestScheme();
    digestScheme.overrideParamter("nc", String.valueOf(serverNounceCount++));
    digestScheme.overrideParamter("cnonce", UUID.randomUUID().toString().replaceAll("-", ""));
    digestScheme.overrideParamter("qop", "auth");
    authCache.put(target, digestScheme);

    localContext = new BasicHttpContext();
    localContext.setAttribute(ClientContext.AUTH_CACHE, authCache);
}

private void buildBasicHttpContext()
{
    AuthCache authCache = new BasicAuthCache();
    DigestScheme digestScheme = new DigestScheme();
    digestScheme.overrideParamter("nc", String.valueOf(serverNounceCount++));
    digestScheme.overrideParamter("cnonce", UUID.randomUUID().toString().replaceAll("-", ""));
    digestScheme.overrideParamter("qop", "auth");
    authCache.put(target, digestScheme);

    localContext = new BasicHttpContext();
    localContext.setAttribute(ClientContext.AUTH_CACHE, authCache);
}

public void process(
        final HttpResponse response, 
        final HttpContext context) throws HttpException, IOException {
    AuthState authState = (AuthState) context.getAttribute(
            ClientContext.TARGET_AUTH_STATE);
    if (authState != null) {
        AuthScheme authScheme = authState.getAuthScheme();
        // Stick the auth scheme to the local context, so
        // we could try to authenticate subsequent requests
        // preemptively
        if (authScheme instanceof DigestScheme) {
            context.setAttribute("preemptive-auth", authScheme);
        }
    }
}

@Test
public void testCredentialsFound() throws Exception {
    final TargetAuthenticationStrategy authStrategy = new TargetAuthenticationStrategy();
    final HttpResponse response = new BasicHttpResponse(HttpVersion.HTTP_1_1, HttpStatus.SC_UNAUTHORIZED, "UNAUTHORIZED");
    final HttpHost authhost = new HttpHost("somehost", 80);
    final HttpClientContext context = HttpClientContext.create();

    final Map<String, Header> challenges = new HashMap<String, Header>();
    challenges.put("basic", new BasicHeader(AUTH.WWW_AUTH, "Basic realm=\"realm1\""));
    challenges.put("digest", new BasicHeader(AUTH.WWW_AUTH, "Digest realm=\"realm2\", nonce=\"1234\""));

    final Registry<AuthSchemeProvider> authSchemeRegistry = RegistryBuilder.<AuthSchemeProvider>create()
        .register("basic", new BasicSchemeFactory())
        .register("digest", new DigestSchemeFactory()).build();
    context.setAuthSchemeRegistry(authSchemeRegistry);

    final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
    credentialsProvider.setCredentials(new AuthScope("somehost", 80, "realm2"),
            new UsernamePasswordCredentials("user", "pwd"));
    context.setCredentialsProvider(credentialsProvider);

    final Queue<AuthOption> options = authStrategy.select(challenges, authhost, response, context);
    Assert.assertNotNull(options);
    Assert.assertEquals(1, options.size());
    final AuthOption option = options.remove();
    Assert.assertTrue(option.getAuthScheme() instanceof DigestScheme);
}

@Test
public void testUnsupportedScheme() throws Exception {
    final TargetAuthenticationStrategy authStrategy = new TargetAuthenticationStrategy();
    final HttpResponse response = new BasicHttpResponse(HttpVersion.HTTP_1_1, HttpStatus.SC_UNAUTHORIZED, "UNAUTHORIZED");
    final HttpHost authhost = new HttpHost("somehost", 80);
    final HttpClientContext context = HttpClientContext.create();

    final Map<String, Header> challenges = new HashMap<String, Header>();
    challenges.put("basic", new BasicHeader(AUTH.WWW_AUTH, "Basic realm=\"realm1\""));
    challenges.put("digest", new BasicHeader(AUTH.WWW_AUTH, "Digest realm=\"realm2\", nonce=\"1234\""));
    challenges.put("whatever", new BasicHeader(AUTH.WWW_AUTH, "Whatever realm=\"realm3\""));

    final Registry<AuthSchemeProvider> authSchemeRegistry = RegistryBuilder.<AuthSchemeProvider>create()
        .register("basic", new BasicSchemeFactory())
        .register("digest", new DigestSchemeFactory()).build();
    context.setAuthSchemeRegistry(authSchemeRegistry);

    final CredentialsProvider credentialsProvider = new BasicCredentialsProvider();
    credentialsProvider.setCredentials(new AuthScope("somehost", 80),
            new UsernamePasswordCredentials("user", "pwd"));
    context.setCredentialsProvider(credentialsProvider);

    final Queue<AuthOption> options = authStrategy.select(challenges, authhost, response, context);
    Assert.assertNotNull(options);
    Assert.assertEquals(2, options.size());
    final AuthOption option1 = options.remove();
    Assert.assertTrue(option1.getAuthScheme() instanceof DigestScheme);
    final AuthOption option2 = options.remove();
    Assert.assertTrue(option2.getAuthScheme() instanceof BasicScheme);
}

private AuthCache getAuthCache(AuthenticationType authenticationType, HttpHost target) {
    AuthCache authCache = new BasicAuthCache();
    if (authenticationType == AuthenticationType.BASIC) {
        authCache.put(target, new BasicScheme());
    } else {
        authCache.put(target, new DigestScheme());
    }
    return authCache;
}

private int invokeHTTPRequestWithAuth(HttpHost httpHost, HttpPost httpPost,
        String contentType, String acceptContentType, String userName,
        String password) throws ClientProtocolException, IOException {

    DefaultHttpClient httpClient = new DefaultHttpClient();

    if (acceptContentType != null && !acceptContentType.isEmpty()) {
        httpPost.setHeader(HTTP_HEADERS.Accept.name(), acceptContentType);
    }
    if (contentType != null && !contentType.isEmpty()) {
        httpPost.setHeader("Content-Type", contentType);
    }

    httpClient.getCredentialsProvider().setCredentials(
            new AuthScope(httpHost.getHostName(), httpHost.getPort()),
            new UsernamePasswordCredentials(userName, password));

    AuthCache authCache = new BasicAuthCache();
    DigestScheme digestScheme = new DigestScheme();

    digestScheme.overrideParamter("realm", "SPARQL"); // Virtuoso specific
    // digestScheme.overrideParamter("nonce", new Nonc);

    authCache.put(httpHost, digestScheme);

    BasicHttpContext localcontext = new BasicHttpContext();
    localcontext.setAttribute(ClientContext.AUTH_CACHE, authCache);

    // Execute the request
    HttpResponse response = httpClient.execute(httpHost, httpPost,
            localcontext);

    return response.getStatusLine().getStatusCode();
}

private int invokeHTTPDeleteWithAuth(HttpHost httpHost, String url,
        String userName, String password) throws ClientProtocolException,
        IOException {
    HttpDelete httpDelete = new HttpDelete(url);

    DefaultHttpClient httpClient = new DefaultHttpClient();

    httpClient.getCredentialsProvider().setCredentials(
            new AuthScope(httpHost.getHostName(), httpHost.getPort()),
            new UsernamePasswordCredentials(userName, password));

    AuthCache authCache = new BasicAuthCache();
    DigestScheme digestScheme = new DigestScheme();

    digestScheme.overrideParamter("realm", "SPARQL"); // Virtuoso specific
    // digestScheme.overrideParamter("nonce", new Nonc);

    authCache.put(httpHost, digestScheme);

    BasicHttpContext localcontext = new BasicHttpContext();
    localcontext.setAttribute(ClientContext.AUTH_CACHE, authCache);

    // Execute the request
    HttpResponse response = httpClient.execute(httpHost, httpDelete,
            localcontext);

    logger.info(Integer.toString(response.getStatusLine().getStatusCode()));

    return response.getStatusLine().getStatusCode();
}

public void process(
        final HttpResponse response, 
        final HttpContext context) throws HttpException, IOException {
    AuthState authState = (AuthState) context.getAttribute(
            ClientContext.TARGET_AUTH_STATE);
    if (authState != null) {
        AuthScheme authScheme = authState.getAuthScheme();
        // Stick the auth scheme to the local context, so
        // we could try to authenticate subsequent requests
        // preemptively
        if (authScheme instanceof DigestScheme) {
            context.setAttribute("preemptive-auth", authScheme);
        }
    }
}

private HttpContext createHttpContext(URI uri){
    AuthCache authCache = new BasicAuthCache();
    DigestScheme digestScheme = new DigestScheme();
    HttpHost targetHost = new HttpHost(uri.getHost(), uri.getPort());
    authCache.put(targetHost, digestScheme);

    BasicHttpContext localcontext = new BasicHttpContext();
    localcontext.setAttribute(HttpClientContext.AUTH_CACHE, authCache);
    return localcontext;
}

public HttpClientContext preemptive() {
AuthCache authCache = new BasicAuthCache();

DigestScheme digestAuth = new DigestScheme();

digestAuth.overrideParamter("realm", "");
digestAuth.overrideParamter("nonce", "");

// TODO : Add target
// authCache.put(target, digestAuth);
HttpClientContext localContext = HttpClientContext.create();
localContext.setAuthCache(authCache);

return localContext;
   }

private HttpContext createHttpContext(URI uri){
    AuthCache authCache = new BasicAuthCache();
    DigestScheme digestScheme = new DigestScheme();
    HttpHost targetHost = new HttpHost(uri.getHost(), uri.getPort());
    authCache.put(targetHost, digestScheme);

    BasicHttpContext localcontext = new BasicHttpContext();
    localcontext.setAttribute(HttpClientContext.AUTH_CACHE, authCache);
    return localcontext;
}

/**
 * 
 * @param scheme
 * @return
 */
protected AuthScheme identifyScheme(String scheme) {
    if(new BasicScheme().getSchemeName().equalsIgnoreCase(scheme)) {
        return new BasicScheme();
    } else if (new DigestScheme().getSchemeName().equalsIgnoreCase(scheme)) {
        return new DigestScheme();
    } else {
        // fallback
        return new BasicScheme();
    }
}

public void process(
        final HttpResponse response, 
        final HttpContext context) throws HttpException, IOException {
    AuthState authState = (AuthState) context.getAttribute(
            ClientContext.TARGET_AUTH_STATE);
    if (authState != null) {
        AuthScheme authScheme = authState.getAuthScheme();
        if (authScheme instanceof DigestScheme) {
            context.setAttribute("preemptive-auth", authScheme);
        }
    }
}

/**
 * Tests if the plugin correctly converts the Digest authentication scheme
 * @throws Exception if anything goes wrong
 */
@Test
public void convertDigest() throws Exception {
    Download t = makeProjectAndTask();
    t.authScheme("Digest");
    assertTrue(t.getAuthScheme() instanceof DigestScheme);
}

public static void main(String[] args) throws Exception {

        DefaultHttpClient httpclient = new DefaultHttpClient();

        httpclient.getCredentialsProvider().setCredentials(
                new AuthScope("localhost", 80), 
                new UsernamePasswordCredentials("username", "password"));

        BasicHttpContext localcontext = new BasicHttpContext();
        // Generate DIGEST scheme object, initialize it and stick it to 
        // the local execution context
        DigestScheme digestAuth = new DigestScheme();
        // Suppose we already know the realm name
        digestAuth.overrideParamter("realm", "some realm");        
        // Suppose we already know the expected nonce value 
        digestAuth.overrideParamter("nonce", "whatever");        
        localcontext.setAttribute("preemptive-auth", digestAuth);

        // Add as the first request interceptor
        httpclient.addRequestInterceptor(new PreemptiveAuth(), 0);
        // Add as the last response interceptor
        httpclient.addResponseInterceptor(new PersistentDigest());

        HttpHost targetHost = new HttpHost("localhost", 80, "http"); 

        HttpGet httpget = new HttpGet("/");

        System.out.println("executing request: " + httpget.getRequestLine());
        System.out.println("to target: " + targetHost);

        for (int i = 0; i < 3; i++) {
            HttpResponse response = httpclient.execute(targetHost, httpget, localcontext);
            HttpEntity entity = response.getEntity();

            System.out.println("----------------------------------------");
            System.out.println(response.getStatusLine());
            if (entity != null) {
                System.out.println("Response content length: " + entity.getContentLength());
                entity.consumeContent();
            }
        }

        // When HttpClient instance is no longer needed, 
        // shut down the connection manager to ensure
        // immediate deallocation of all system resources
        httpclient.getConnectionManager().shutdown();        
    }

public static void main(String[] args) throws Exception {
    HttpHost target = new HttpHost("httpbin.org", 80, "http");
    CredentialsProvider credsProvider = new BasicCredentialsProvider();
    credsProvider.setCredentials(
            new AuthScope(target.getHostName(), target.getPort()),
            new UsernamePasswordCredentials("user", "passwd"));
    CloseableHttpClient httpclient = HttpClients.custom()
            .setDefaultCredentialsProvider(credsProvider)
            .build();
    try {

        // Create AuthCache instance
        AuthCache authCache = new BasicAuthCache();
        // Generate DIGEST scheme object, initialize it and add it to the local
        // auth cache
        DigestScheme digestAuth = new DigestScheme();
        // Suppose we already know the realm name
        digestAuth.overrideParamter("realm", "some realm");
        // Suppose we already know the expected nonce value
        digestAuth.overrideParamter("nonce", "whatever");
        authCache.put(target, digestAuth);

        // Add AuthCache to the execution context
        HttpClientContext localContext = HttpClientContext.create();
        localContext.setAuthCache(authCache);

        HttpGet httpget = new HttpGet("http://httpbin.org/digest-auth/auth/user/passwd");

        System.out.println("Executing request " + httpget.getRequestLine() + " to target " + target);
        for (int i = 0; i < 3; i++) {
            CloseableHttpResponse response = httpclient.execute(target, httpget, localContext);
            try {
                System.out.println("----------------------------------------");
                System.out.println(response.getStatusLine());
                System.out.println(EntityUtils.toString(response.getEntity()));
            } finally {
                response.close();
            }
        }
    } finally {
        httpclient.close();
    }
}

/**
 * Obtiene el valor que hay que poner en la cabecera "Authorization" de la request HTTP
 * @param code c�d
 * @param headers
 * @param requestMethod
 * @param url
 * @param authUser
 * @param authPwd
 * @return
 */
public static String getAuthorizationHeaderValue(final HttpURLConnection serverConnectionNoAuth,
                                                 final RequestMethod requestMethod,final String strUrl,
                                                 final UserCode authUser,final Password authPwd) throws IOException,
                                                                                                        AuthenticationException,
                                                                                                        MalformedChallengeException {
    // A org.apache.http.impl.auth.DigestScheme instance is
    // what will process the challenge from the web-server
    final DigestScheme md5Auth = new DigestScheme();
    // Validate that we got an HTTP 401 back
    HttpResponseCode serverNoAuthResponseCode = HttpResponseCode.of(serverConnectionNoAuth.getResponseCode());
    if (serverNoAuthResponseCode.is(HttpResponseCode.UNAUTHORIZED)) {
        if (CollectionUtils.isNullOrEmpty(serverConnectionNoAuth.getHeaderFields())) throw new IllegalStateException("HTTP Headers not received!");
        // headers normalization
        Map<String,String> headersKeys = _normalizeHeadersKeys(serverConnectionNoAuth.getHeaderFields());
        if (headersKeys.containsKey("WWW-AUTHENTICATE")) {
            // [1] Obtener un objeto HttpRequest a partir de la URL y el m�todo (GET/POST/PUT/DELETE)
            java.net.URL url = null;
            try {
                url = new URL(strUrl);
            } catch (MalformedURLException e1) {
                throw new IllegalStateException("The url is malformed");
            }
            HttpRequestBase commonsHttpRequest = _commonsHttpClientRequestFrom(requestMethod,url.getPath());

            // [2] Generate a solution Authentication header using the username and password.
            // 2.1 Get the challenge and solve.
            String challenge = serverConnectionNoAuth.getHeaderFields()
                                                     .get(headersKeys.get("WWW-AUTHENTICATE"))
                                                     .get(0);
            commonsHttpRequest.addHeader(headersKeys.get("WWW-AUTHENTICATE"),
                                         challenge);
            md5Auth.processChallenge(commonsHttpRequest.getHeaders(headersKeys.get("WWW-AUTHENTICATE"))[0]);

            // 2.2 Compose a Header object for the "Authorization" header
            Header solution = md5Auth.authenticate(new UsernamePasswordCredentials(authUser.asString(),
                                                                                   authPwd.asString()),
                                                   commonsHttpRequest,
                                                   new BasicHttpContext());
            return solution.getValue();     // the value of the composed Authorization header

        } 
        throw new IllegalStateException("A 401 response (unauthorized) has been received, but NO WWW-Authenticate header in this response!");
    } 
    throw new IllegalStateException("The request is supossed to be authenticated but the server response code was NOT 401 (unauthorized)");
}

@Test
public void testInitializationCustomNoSslDigestAuth() throws Exception {
  Properties props = new Properties();
  props.setProperty(WebServicesFetcher.URL_KEY, "http://foo");
  props.setProperty(WebServicesFetcher.APP_ID_KEY, "appId");
  props.setProperty(WebServicesFetcher.KEYSTORE_FILE_KEY, "");
  props.setProperty(WebServicesFetcher.KEYSTORE_PASSWORD_KEY, "");
  props.setProperty(WebServicesFetcher.KEY_PASSWORD_KEY, "");
  props.setProperty(WebServicesFetcher.TRUSTSTORE_FILE_KEY, "");
  props.setProperty(WebServicesFetcher.TRUSTSTORE_PASSWORD_KEY, "");
  props.setProperty(WebServicesFetcher.SUPPORTED_PROTOCOLS_KEY, "");
  props.setProperty(WebServicesFetcher.HOSTNAME_VERIFIER_SKIP_KEY, "");
  props.setProperty(WebServicesFetcher.MAX_CONCURRENT_CONNECTIONS_KEY, "1");
  props.setProperty(WebServicesFetcher.VALIDATE_AFTER_INACTIVITY_KEY, "2");
  props.setProperty(WebServicesFetcher.CONNECTION_TIMEOUT_KEY, "5000");
  props.setProperty(WebServicesFetcher.NAME_SEPARATOR_KEY, "+");
  props.setProperty(WebServicesFetcher.HTTP_AUTH_TYPE_KEY, "digest");
  props.setProperty(WebServicesFetcher.HTTP_AUTH_USER_KEY, "user");
  props.setProperty(WebServicesFetcher.HTTP_AUTH_PASSWORD_KEY, "password");
  Configuration conf = createConfig(props);

  WebServicesFetcher fetcher = new WebServicesFetcher();
  try {
    fetcher.init(conf);
    Assert.assertNotNull(fetcher.getConfig());

    Assert.assertEquals("http://foo", fetcher.getUrl());
    Assert.assertEquals("appId", fetcher.getAppId());
    Assert.assertEquals(5000, fetcher.getConnectionTimeout());
    Assert.assertEquals("+", fetcher.getSeparator());
    Assert.assertEquals("digest", fetcher.getHttpAuth());
    Assert.assertEquals("user", fetcher.getHttpAuthUser());
    Assert.assertEquals("password", fetcher.getHttpAuthPassword());
    Assert.assertNotNull(fetcher.getCredentialsProvider());
    Assert.assertEquals("user",
        fetcher.getCredentialsProvider().getCredentials(AuthScope.ANY).getUserPrincipal().getName()
    );
    Assert.assertEquals("password", fetcher.getCredentialsProvider().getCredentials(AuthScope.ANY).getPassword());
    Assert.assertTrue(fetcher.getAuthCache().get(new HttpHost(fetcher.getUrl())) instanceof DigestScheme);

    PoolingHttpClientConnectionManager connectionManager = fetcher.getConnectionManager();
    Assert.assertEquals(1, connectionManager.getMaxTotal());
    Assert.assertEquals(1, connectionManager.getDefaultMaxPerRoute());
    Assert.assertEquals(2, connectionManager.getValidateAfterInactivity());

    Assert.assertNull(fetcher.getSslConnectionSocketFactory());
  } finally {
    fetcher.destroy();
  }
}

public DigestAuthenticator(DigestScheme mDigestScheme, Credentials credentials) {
    this.mDigestScheme = mDigestScheme;
    this.mCredentials = credentials;

}

@Provides
@Singleton
public DigestAuthenticator provideDigestAuthenticator(DigestScheme digestScheme, @Nullable Credentials credentials) {
    return new DigestAuthenticator(digestScheme, credentials);
}

@Provides
@Singleton
public DigestScheme providesDigestScheme() {
    return new DigestScheme();
}

public static void main(String[] args) throws Exception {
    HttpHost target = new HttpHost("localhost", 80, "http");
    CredentialsProvider credsProvider = new BasicCredentialsProvider();
    credsProvider.setCredentials(
            new AuthScope(target.getHostName(), target.getPort()),
            new UsernamePasswordCredentials("username", "password"));
    CloseableHttpClient httpclient = HttpClients.custom()
            .setDefaultCredentialsProvider(credsProvider)
            .build();
    try {

        // Create AuthCache instance
        AuthCache authCache = new BasicAuthCache();
        // Generate DIGEST scheme object, initialize it and add it to the local
        // auth cache
        DigestScheme digestAuth = new DigestScheme();
        // Suppose we already know the realm name
        digestAuth.overrideParamter("realm", "some realm");
        // Suppose we already know the expected nonce value
        digestAuth.overrideParamter("nonce", "whatever");
        authCache.put(target, digestAuth);

        // Add AuthCache to the execution context
        HttpClientContext localContext = HttpClientContext.create();
        localContext.setAuthCache(authCache);

        HttpGet httpget = new HttpGet("/");

        System.out.println("Executing request " + httpget.getRequestLine() + " to target " + target);
        for (int i = 0; i < 3; i++) {
            CloseableHttpResponse response = httpclient.execute(target, httpget, localContext);
            try {
                System.out.println("----------------------------------------");
                System.out.println(response.getStatusLine());
                EntityUtils.consume(response.getEntity());
            } finally {
                response.close();
            }
        }
    } finally {
        httpclient.close();
    }
}

public static void main(String[] args) throws Exception {

        DefaultHttpClient httpclient = new DefaultHttpClient();

        httpclient.getCredentialsProvider().setCredentials(
                new AuthScope("localhost", 80), 
                new UsernamePasswordCredentials("username", "password"));

        BasicHttpContext localcontext = new BasicHttpContext();
        // Generate DIGEST scheme object, initialize it and stick it to 
        // the local execution context
        DigestScheme digestAuth = new DigestScheme();
        // Suppose we already know the realm name
        digestAuth.overrideParamter("realm", "some realm");        
        // Suppose we already know the expected nonce value 
        digestAuth.overrideParamter("nonce", "whatever");        
        localcontext.setAttribute("preemptive-auth", digestAuth);

        // Add as the first request interceptor
        httpclient.addRequestInterceptor(new PreemptiveAuth(), 0);
        // Add as the last response interceptor
        httpclient.addResponseInterceptor(new PersistentDigest());

        HttpHost targetHost = new HttpHost("localhost", 80, "http"); 

        HttpGet httpget = new HttpGet("/");

        System.out.println("executing request: " + httpget.getRequestLine());
        System.out.println("to target: " + targetHost);

        for (int i = 0; i < 3; i++) {
            HttpResponse response = httpclient.execute(targetHost, httpget, localcontext);
            HttpEntity entity = response.getEntity();

            System.out.println("----------------------------------------");
            System.out.println(response.getStatusLine());
            if (entity != null) {
                System.out.println("Response content length: " + entity.getContentLength());
                entity.consumeContent();
            }
        }

        // When HttpClient instance is no longer needed, 
        // shut down the connection manager to ensure
        // immediate deallocation of all system resources
        httpclient.getConnectionManager().shutdown();        
    }

public static void main(String[] args) throws Exception {
    HttpHost target = new HttpHost("localhost", 80, "http");
    CredentialsProvider credsProvider = new BasicCredentialsProvider();
    credsProvider.setCredentials(
            new AuthScope(target.getHostName(), target.getPort()),
            new UsernamePasswordCredentials("username", "password"));
    CloseableHttpClient httpclient = HttpClients.custom()
            .setDefaultCredentialsProvider(credsProvider)
            .build();
    try {

        // Create AuthCache instance
        AuthCache authCache = new BasicAuthCache();
        // Generate DIGEST scheme object, initialize it and add it to the local
        // auth cache
        DigestScheme digestAuth = new DigestScheme();
        // Suppose we already know the realm name
        digestAuth.overrideParamter("realm", "some realm");
        // Suppose we already know the expected nonce value
        digestAuth.overrideParamter("nonce", "whatever");
        authCache.put(target, digestAuth);

        // Add AuthCache to the execution context
        HttpClientContext localContext = HttpClientContext.create();
        localContext.setAuthCache(authCache);

        HttpGet httpget = new HttpGet("/");

        System.out.println("Executing request " + httpget.getRequestLine() + " to target " + target);
        for (int i = 0; i < 3; i++) {
            CloseableHttpResponse response = httpclient.execute(target, httpget, localContext);
            try {
                System.out.println("----------------------------------------");
                System.out.println(response.getStatusLine());
                EntityUtils.consume(response.getEntity());
            } finally {
                response.close();
            }
        }
    } finally {
        httpclient.close();
    }
}

public static void main(String[] args) throws Exception {
    HttpHost target = new HttpHost("localhost", 80, "http");
    CredentialsProvider credsProvider = new BasicCredentialsProvider();
    credsProvider.setCredentials(
            new AuthScope(target.getHostName(), target.getPort()),
            new UsernamePasswordCredentials("username", "password"));
    CloseableHttpClient httpclient = HttpClients.custom()
            .setDefaultCredentialsProvider(credsProvider)
            .build();
    try {

        // Create AuthCache instance
        AuthCache authCache = new BasicAuthCache();
        // Generate DIGEST scheme object, initialize it and add it to the local
        // auth cache
        DigestScheme digestAuth = new DigestScheme();
        // Suppose we already know the realm name
        digestAuth.overrideParamter("realm", "some realm");
        // Suppose we already know the expected nonce value
        digestAuth.overrideParamter("nonce", "whatever");
        authCache.put(target, digestAuth);

        // Add AuthCache to the execution context
        HttpClientContext localContext = HttpClientContext.create();
        localContext.setAuthCache(authCache);

        HttpGet httpget = new HttpGet("/");

        System.out.println("Executing request " + httpget.getRequestLine() + " to target " + target);
        for (int i = 0; i < 3; i++) {
            CloseableHttpResponse response = httpclient.execute(target, httpget, localContext);
            try {
                System.out.println("----------------------------------------");
                System.out.println(response.getStatusLine());
                EntityUtils.consume(response.getEntity());
            } finally {
                response.close();
            }
        }
    } finally {
        httpclient.close();
    }
}

public static void main(String[] args) throws Exception {

        HttpHost targetHost = new HttpHost("localhost", 80, "http");

        DefaultHttpClient httpclient = new DefaultHttpClient();
        try {
            httpclient.getCredentialsProvider().setCredentials(
                    new AuthScope(targetHost.getHostName(), targetHost.getPort()),
                    new UsernamePasswordCredentials("username", "password"));

            // Create AuthCache instance
            AuthCache authCache = new BasicAuthCache();
            // Generate DIGEST scheme object, initialize it and add it to the local
            // auth cache
            DigestScheme digestAuth = new DigestScheme();
            // Suppose we already know the realm name
            digestAuth.overrideParamter("realm", "some realm");
            // Suppose we already know the expected nonce value
            digestAuth.overrideParamter("nonce", "whatever");
            authCache.put(targetHost, digestAuth);

            // Add AuthCache to the execution context
            BasicHttpContext localcontext = new BasicHttpContext();
            localcontext.setAttribute(ClientContext.AUTH_CACHE, authCache);

            HttpGet httpget = new HttpGet("/");

            System.out.println("executing request: " + httpget.getRequestLine());
            System.out.println("to target: " + targetHost);

            for (int i = 0; i < 3; i++) {
                HttpResponse response = httpclient.execute(targetHost, httpget, localcontext);
                HttpEntity entity = response.getEntity();

                System.out.println("----------------------------------------");
                System.out.println(response.getStatusLine());
                if (entity != null) {
                    System.out.println("Response content length: " + entity.getContentLength());
                }
                EntityUtils.consume(entity);
            }

        } finally {
            // When HttpClient instance is no longer needed,
            // shut down the connection manager to ensure
            // immediate deallocation of all system resources
            httpclient.getConnectionManager().shutdown();
        }
    }

/***
 * Creates a apache HTTP Client object, ignoring SSL Exceptions like self signed
 * certificates and sets Auth. Scheme to Digest Auth
 *
 * @param fboxUrl
 *            the URL from config file of fbox to connect to
 * @return the ready-to-use httpclient for tr064 requests
 */
private CloseableHttpClient createTr064HttpClient(String fboxUrl) {
    CloseableHttpClient hc = null;
    // Convert URL String from config in easy explotable URI object
    URIBuilder uriFbox = null;
    try {
        uriFbox = new URIBuilder(fboxUrl);
    } catch (URISyntaxException e) {
        logger.error("Invalid FritzBox URL! {}", e.getMessage());
        return null;
    }
    // Create context of the http client
    _httpClientContext = HttpClientContext.create();
    CookieStore cookieStore = new BasicCookieStore();
    _httpClientContext.setCookieStore(cookieStore);

    // SETUP AUTH
    // Auth is specific for this target
    HttpHost target = new HttpHost(uriFbox.getHost(), uriFbox.getPort(), uriFbox.getScheme());
    // Add digest authentication with username/pw from global config
    CredentialsProvider credp = new BasicCredentialsProvider();
    credp.setCredentials(new AuthScope(target.getHostName(), target.getPort()),
            new UsernamePasswordCredentials(_user, _pw));
    // Create AuthCache instance. Manages authentication based on server response
    AuthCache authCache = new BasicAuthCache();
    // Generate DIGEST scheme object, initialize it and add it to the local auth
    // cache. Digeste is standard for fbox auth SOAP
    DigestScheme digestAuth = new DigestScheme();
    digestAuth.overrideParamter("realm", "HTTPS Access"); // known from fbox specification
    digestAuth.overrideParamter("nonce", ""); // never known at first request
    authCache.put(target, digestAuth);
    // Add AuthCache to the execution context
    _httpClientContext.setAuthCache(authCache);

    // SETUP SSL TRUST
    SSLContextBuilder sslContextBuilder = new SSLContextBuilder();
    SSLConnectionSocketFactory sslsf = null;
    try {
        sslContextBuilder.loadTrustMaterial(null, new TrustSelfSignedStrategy()); // accept self signed certs
        // dont verify hostname against cert CN
        sslsf = new SSLConnectionSocketFactory(sslContextBuilder.build(), null, null, new NoopHostnameVerifier());
    } catch (Exception ex) {
        logger.error(ex.getMessage());
    }

    // Set timeout values
    RequestConfig rc = RequestConfig.copy(RequestConfig.DEFAULT).setSocketTimeout(4000).setConnectTimeout(4000)
            .setConnectionRequestTimeout(4000).build();

    // BUILDER
    // setup builder with parameters defined before
    hc = HttpClientBuilder.create().setSSLSocketFactory(sslsf) // set the SSL options which trust every self signed
                                                               // cert
            .setDefaultCredentialsProvider(credp) // set auth options using digest
            .setDefaultRequestConfig(rc) // set the request config specifying timeout
            .build();

    return hc;
}

public static void main(String[] args) throws Exception {

        HttpHost targetHost = new HttpHost("localhost", 80, "http");

        DefaultHttpClient httpclient = new DefaultHttpClient();
        try {
            httpclient.getCredentialsProvider().setCredentials(
                    new AuthScope(targetHost.getHostName(), targetHost.getPort()),
                    new UsernamePasswordCredentials("username", "password"));

            // Create AuthCache instance
            AuthCache authCache = new BasicAuthCache();
            // Generate DIGEST scheme object, initialize it and add it to the local
            // auth cache
            DigestScheme digestAuth = new DigestScheme();
            // Suppose we already know the realm name
            digestAuth.overrideParamter("realm", "some realm");
            // Suppose we already know the expected nonce value
            digestAuth.overrideParamter("nonce", "whatever");
            authCache.put(targetHost, digestAuth);

            // Add AuthCache to the execution context
            BasicHttpContext localcontext = new BasicHttpContext();
            localcontext.setAttribute(ClientContext.AUTH_CACHE, authCache);

            HttpGet httpget = new HttpGet("/");

            System.out.println("executing request: " + httpget.getRequestLine());
            System.out.println("to target: " + targetHost);

            for (int i = 0; i < 3; i++) {
                HttpResponse response = httpclient.execute(targetHost, httpget, localcontext);
                HttpEntity entity = response.getEntity();

                System.out.println("----------------------------------------");
                System.out.println(response.getStatusLine());
                if (entity != null) {
                    System.out.println("Response content length: " + entity.getContentLength());
                }
                EntityUtils.consume(entity);
            }

        } finally {
            // When HttpClient instance is no longer needed,
            // shut down the connection manager to ensure
            // immediate deallocation of all system resources
            httpclient.getConnectionManager().shutdown();
        }
    }

/**
 * Create cnonce string.
 *
 * @return the cnonce
 */
public static String createCnonce() {
    return DigestScheme.createCnonce();
}