Esempio n. 1
0
  private boolean processProxyAuthChallenge(final HttpMethod method)
      throws MalformedChallengeException, AuthenticationException {
    AuthState authstate = method.getProxyAuthState();
    Map proxyChallenges =
        AuthChallengeParser.parseChallenges(method.getResponseHeaders(PROXY_AUTH_CHALLENGE));
    if (proxyChallenges.isEmpty()) {
      LOG.debug("Proxy authentication challenge(s) not found");
      return false;
    }
    AuthScheme authscheme = null;
    try {
      authscheme = this.authProcessor.processChallenge(authstate, proxyChallenges);
    } catch (AuthChallengeException e) {
      if (LOG.isWarnEnabled()) {
        LOG.warn(e.getMessage());
      }
    }
    if (authscheme == null) {
      return false;
    }
    AuthScope authscope =
        new AuthScope(
            conn.getProxyHost(),
            conn.getProxyPort(),
            authscheme.getRealm(),
            authscheme.getSchemeName());

    if (LOG.isDebugEnabled()) {
      LOG.debug("Proxy authentication scope: " + authscope);
    }
    if (authstate.isAuthAttempted() && authscheme.isComplete()) {
      // Already tried and failed
      Credentials credentials =
          promptForProxyCredentials(authscheme, method.getParams(), authscope);
      if (credentials == null) {
        if (LOG.isInfoEnabled()) {
          LOG.info("Failure authenticating with " + authscope);
        }
        return false;
      } else {
        return true;
      }
    } else {
      authstate.setAuthAttempted(true);
      Credentials credentials = this.state.getProxyCredentials(authscope);
      if (credentials == null) {
        credentials = promptForProxyCredentials(authscheme, method.getParams(), authscope);
      }
      if (credentials == null) {
        if (LOG.isInfoEnabled()) {
          LOG.info("No credentials available for " + authscope);
        }
        return false;
      } else {
        return true;
      }
    }
  }
Esempio n. 2
0
  /**
   * Executes a ConnectMethod to establish a tunneled connection.
   *
   * @return <code>true</code> if the connect was successful
   * @throws IOException
   * @throws HttpException
   */
  private boolean executeConnect() throws IOException, HttpException {

    this.connectMethod = new ConnectMethod(this.hostConfiguration);
    this.connectMethod.getParams().setDefaults(this.hostConfiguration.getParams());

    int code;
    for (; ; ) {
      if (!this.conn.isOpen()) {
        this.conn.open();
      }
      if (this.params.isAuthenticationPreemptive() || this.state.isAuthenticationPreemptive()) {
        LOG.debug("Preemptively sending default basic credentials");
        this.connectMethod.getProxyAuthState().setPreemptive();
        this.connectMethod.getProxyAuthState().setAuthAttempted(true);
      }
      try {
        authenticateProxy(this.connectMethod);
      } catch (AuthenticationException e) {
        LOG.error(e.getMessage(), e);
      }
      applyConnectionParams(this.connectMethod);
      this.connectMethod.execute(state, this.conn);
      code = this.connectMethod.getStatusCode();
      boolean retry = false;
      AuthState authstate = this.connectMethod.getProxyAuthState();
      authstate.setAuthRequested(code == HttpStatus.SC_PROXY_AUTHENTICATION_REQUIRED);
      if (authstate.isAuthRequested()) {
        if (processAuthenticationResponse(this.connectMethod)) {
          retry = true;
        }
      }
      if (!retry) {
        break;
      }
      if (this.connectMethod.getResponseBodyAsStream() != null) {
        this.connectMethod.getResponseBodyAsStream().close();
      }
    }
    if ((code >= 200) && (code < 300)) {
      this.conn.tunnelCreated();
      // Drop the connect method, as it is no longer needed
      this.connectMethod = null;
      return true;
    } else {
      this.conn.close();
      return false;
    }
  }
Esempio n. 3
0
 private void authenticateProxy(final HttpMethod method) throws AuthenticationException {
   // Clean up existing authentication headers
   if (!cleanAuthHeaders(method, PROXY_AUTH_RESP)) {
     // User defined authentication header(s) present
     return;
   }
   AuthState authstate = method.getProxyAuthState();
   AuthScheme authscheme = authstate.getAuthScheme();
   if (authscheme == null) {
     return;
   }
   if (authstate.isAuthRequested() || !authscheme.isConnectionBased()) {
     AuthScope authscope =
         new AuthScope(
             conn.getProxyHost(),
             conn.getProxyPort(),
             authscheme.getRealm(),
             authscheme.getSchemeName());
     if (LOG.isDebugEnabled()) {
       LOG.debug("Authenticating with " + authscope);
     }
     Credentials credentials = this.state.getProxyCredentials(authscope);
     if (credentials != null) {
       String authstring = authscheme.authenticate(credentials, method);
       if (authstring != null) {
         method.addRequestHeader(new Header(PROXY_AUTH_RESP, authstring, true));
       }
     } else {
       if (LOG.isWarnEnabled()) {
         LOG.warn("Required proxy credentials not available for " + authscope);
         if (method.getProxyAuthState().isPreemptive()) {
           LOG.warn(
               "Preemptive authentication requested but no default "
                   + "proxy credentials available");
         }
       }
     }
   }
 }