Java AuthScope类代码示例

import org.apache.commons.httpclient.auth.AuthScope; //导入依赖的package包/类
/**
 * Retrieves the content under the given URL with username and passwort
 * authentication.
 * 
 * @param url
 *            the URL to read
 * @param username
 * @param password
 * @return the read content.
 * @throws IOException
 *             if an I/O exception occurs.
 */
private static byte[] getUrlContent(URL url, String username,
        String password) throws IOException {
    final HttpClient client = new HttpClient();

    // Set credentials:
    client.getParams().setAuthenticationPreemptive(true);
    final Credentials credentials = new UsernamePasswordCredentials(
            username, password);
    client.getState()
            .setCredentials(
                    new AuthScope(url.getHost(), url.getPort(),
                            AuthScope.ANY_REALM), credentials);

    // Retrieve content:
    final GetMethod method = new GetMethod(url.toString());
    final int status = client.executeMethod(method);
    if (status != HttpStatus.SC_OK) {
        throw new IOException("Error " + status + " while retrieving "
                + url);
    }
    return method.getResponseBody();
}
 

import org.apache.commons.httpclient.auth.AuthScope; //导入依赖的package包/类
/**
 * Find matching {@link Credentials credentials} for the given authentication scope.
 *
 * @param map the credentials hash map
 * @param token the {@link AuthScope authentication scope}
 * @return the credentials 
 * 
 */
private static Credentials matchCredentials(final HashMap map, final AuthScope authscope) {
    // see if we get a direct hit
    Credentials creds = (Credentials)map.get(authscope);
    if (creds == null) {
        // Nope.
        // Do a full scan
        int bestMatchFactor  = -1;
        AuthScope bestMatch  = null;
        Iterator items = map.keySet().iterator();
        while (items.hasNext()) {
            AuthScope current = (AuthScope)items.next();
            int factor = authscope.match(current);
            if (factor > bestMatchFactor) {
                bestMatchFactor = factor;
                bestMatch = current;
            }
        }
        if (bestMatch != null) {
            creds = (Credentials)map.get(bestMatch);
        }
    }
    return creds;
}
 

import org.apache.commons.httpclient.auth.AuthScope; //导入依赖的package包/类
/**
 * Tests POST via authenticating proxy + host auth + connection close 
 */
public void testPostProxyAuthHostAuthConnClose() throws Exception {
    UsernamePasswordCredentials creds = 
        new UsernamePasswordCredentials("testuser", "testpass");
    
    this.client.getState().setCredentials(AuthScope.ANY, creds);
    this.client.getState().setProxyCredentials(AuthScope.ANY, creds);
    
    HttpRequestHandlerChain handlerchain = new HttpRequestHandlerChain();
    handlerchain.appendHandler(new AuthRequestHandler(creds, "test", false));
    handlerchain.appendHandler(new HttpServiceHandler(new FeedbackService()));
    
    this.server.setRequestHandler(handlerchain);
    
    this.proxy.requireAuthentication(creds, "test", true);

    PostMethod post = new PostMethod("/");
    post.setRequestEntity(new StringRequestEntity("Like tons of stuff", null, null));
    try {
        this.client.executeMethod(post);
        assertEquals(HttpStatus.SC_OK, post.getStatusCode());
        assertNotNull(post.getResponseBodyAsString());
    } finally {
        post.releaseConnection();
    }
}
 

import org.apache.commons.httpclient.auth.AuthScope; //导入依赖的package包/类
@Create
public void create() {
	Protocol.registerProtocol("https", new Protocol("https",
			new EasySSLProtocolSocketFactory(), 8443));
	this.httpClient = new HttpClient();
	this.httpClient.getParams().setAuthenticationPreemptive(true);
	Credentials defaultcreds = new UsernamePasswordCredentials("admin",
			this.entityManager.find(CommandParameter.class,
					CommandParameter.HERITRIX_ADMINPW_KEY)
					.getCommandValue());
	this.httpClient.getState().setCredentials(
			new AuthScope(AuthScope.ANY_SCHEME, AuthScope.ANY_PORT,
					AuthScope.ANY_REALM), defaultcreds);
	this.engineUri = this.entityManager.find(Parameter.class,
			Parameter.ENGINE_URI.getKey()).getValue();
	Logger httpClientlogger = Logger.getLogger(this.httpClient.getClass());
	httpClientlogger.setLevel(Level.ERROR);
	Logger authChallengeProcessorLogger = Logger
			.getLogger(AuthChallengeProcessor.class);
	authChallengeProcessorLogger.setLevel(Level.ERROR);
	Logger httpMethodBaseLogger = Logger.getLogger(HttpMethodBase.class);
	httpMethodBaseLogger.setLevel(Level.ERROR);
	this.jobsDir = this.entityManager.find(Parameter.class,
			Parameter.JOBS_DIR.getKey()).getValue();
}
 

import org.apache.commons.httpclient.auth.AuthScope; //导入依赖的package包/类
private void create() {
	Protocol.registerProtocol("https", new Protocol("https",
			new EasySSLProtocolSocketFactory(), 8443));
	this.httpClient = new HttpClient();
	this.httpClient.getParams().setAuthenticationPreemptive(true);
	Credentials defaultcreds = new UsernamePasswordCredentials("admin",
			this.entityManager.find(CommandParameter.class,
					CommandParameter.HERITRIX_ADMINPW_KEY)
					.getCommandValue());
	this.httpClient.getState().setCredentials(
			new AuthScope(AuthScope.ANY_SCHEME, AuthScope.ANY_PORT,
					AuthScope.ANY_REALM), defaultcreds);
	this.engineUri = this.entityManager.find(Parameter.class,
			Parameter.ENGINE_URI.getKey()).getValue();
	Logger httpClientlogger = Logger.getLogger(this.httpClient.getClass());
	httpClientlogger.setLevel(Level.ERROR);
	Logger authChallengeProcessorLogger = Logger
			.getLogger(AuthChallengeProcessor.class);
	authChallengeProcessorLogger.setLevel(Level.ERROR);
	Logger httpMethodBaseLogger = Logger.getLogger(HttpMethodBase.class);
	httpMethodBaseLogger.setLevel(Level.ERROR);
	this.jobsDir = this.entityManager.find(Parameter.class,
			Parameter.JOBS_DIR.getKey()).getValue();
}
 

import org.apache.commons.httpclient.auth.AuthScope; //导入依赖的package包/类
private static void tryAuthentication(RemoteFileReference wsReference) throws Exception {
	URL urlToConnect = wsReference.getUrl();
	String wsdlUrl = wsReference.getUrlpath();
	String username = wsReference.getAuthUser();
	String password = wsReference.getAuthPassword();
	
       HttpClient client = new HttpClient();

	client.getState().setCredentials(
			new AuthScope(urlToConnect.getHost(), urlToConnect.getPort()),
			new UsernamePasswordCredentials(username, password)
	);
       
       GetMethod get = new GetMethod(wsdlUrl);
       get.setDoAuthentication( true );
       
       int statuscode = client.executeMethod(get);
       
       if (statuscode == HttpStatus.SC_UNAUTHORIZED) {
       	throw new Exception(HttpStatus.SC_UNAUTHORIZED + " - Unauthorized connection!");
       }
}
 

import org.apache.commons.httpclient.auth.AuthScope; //导入依赖的package包/类
/**
 * Constructor.
 * 
 * @param metadataURL the URL to fetch the metadata
 * @param requestTimeout the time, in milliseconds, to wait for the metadata server to respond
 * 
 * @throws MetadataProviderException thrown if the URL is not a valid URL or the metadata can not be retrieved from
 *             the URL
 */
@Deprecated
public HTTPMetadataProvider(String metadataURL, int requestTimeout) throws MetadataProviderException {
    super();
    try {
        metadataURI = new URI(metadataURL);
    } catch (URISyntaxException e) {
        throw new MetadataProviderException("Illegal URL syntax", e);
    }

    HttpClientParams clientParams = new HttpClientParams();
    clientParams.setSoTimeout(requestTimeout);
    httpClient = new HttpClient(clientParams);
    httpClient.getHttpConnectionManager().getParams().setConnectionTimeout(requestTimeout);
    authScope = new AuthScope(metadataURI.getHost(), metadataURI.getPort());

}
 

import org.apache.commons.httpclient.auth.AuthScope; //导入依赖的package包/类
public void testAnonymousContent() throws Exception {
    // disable credentials -> anonymous session
    final URL url = new URL(HTTP_BASE_URL);
    final AuthScope scope = new AuthScope(url.getHost(), url.getPort(), AuthScope.ANY_REALM);
    httpClient.getParams().setAuthenticationPreemptive(false);
    httpClient.getState().setCredentials(scope, null);
    
    try {
        assertContent();
    } finally {
        // re-enable credentials -> admin session
        httpClient.getParams().setAuthenticationPreemptive(true);
        Credentials defaultcreds = new UsernamePasswordCredentials("admin", "admin");
        httpClient.getState().setCredentials(scope, defaultcreds);
    }
}
 

import org.apache.commons.httpclient.auth.AuthScope; //导入依赖的package包/类
@Test
public void testValidatingIncorrectHttpBasicCredentials() throws Exception {

    // assume http and webdav are on the same host + port
    URL url = new URL(HttpTest.HTTP_BASE_URL);
    Credentials defaultcreds = new UsernamePasswordCredentials("garbage", "garbage");
    H.getHttpClient().getState()
            .setCredentials(new AuthScope(url.getHost(), url.getPort(), AuthScope.ANY_REALM), defaultcreds);

    List<NameValuePair> params = new ArrayList<NameValuePair>();
    params.add(new NameValuePair("j_validate", "true"));
    HttpMethod post = H.assertPostStatus(HttpTest.HTTP_BASE_URL + "/j_security_check",
            HttpServletResponse.SC_FORBIDDEN, params, null);
    assertXReason(post);

    HttpMethod get = H.assertHttpStatus(HttpTest.HTTP_BASE_URL + "/?j_validate=true",
            HttpServletResponse.SC_FORBIDDEN);
    assertXReason(get);
}
 

import org.apache.commons.httpclient.auth.AuthScope; //导入依赖的package包/类
@Test
public void testPreventLoopIncorrectHttpBasicCredentials() throws Exception {

    // assume http and webdav are on the same host + port
    URL url = new URL(HttpTest.HTTP_BASE_URL);
    Credentials defaultcreds = new UsernamePasswordCredentials("garbage", "garbage");
    H.getHttpClient().getState()
            .setCredentials(new AuthScope(url.getHost(), url.getPort(), AuthScope.ANY_REALM), defaultcreds);

    final String requestUrl = HttpTest.HTTP_BASE_URL + "/junk?param1=1";
    HttpMethod get = new GetMethod(requestUrl);
    get.setRequestHeader("Referer", requestUrl);
    get.setRequestHeader("User-Agent", "Mozilla/5.0 Sling Integration Test");
    int status = H.getHttpClient().executeMethod(get);
    assertEquals(HttpServletResponse.SC_UNAUTHORIZED, status);
}
 

import org.apache.commons.httpclient.auth.AuthScope; //导入依赖的package包/类
/** Verify that given URL returns expectedStatusCode
 * @throws IOException */
public void assertAuthenticatedHttpStatus(Credentials creds, String urlString, int expectedStatusCode, String assertMessage) throws IOException {
    URL baseUrl = new URL(HTTP_BASE_URL);
    AuthScope authScope = new AuthScope(baseUrl.getHost(), baseUrl.getPort(), AuthScope.ANY_REALM);
    GetMethod getMethod = new GetMethod(urlString);
    getMethod.setDoAuthentication(true);
    Credentials oldCredentials = httpClient.getState().getCredentials(authScope);
    try {
        httpClient.getState().setCredentials(authScope, creds);

        final int status = httpClient.executeMethod(getMethod);
        if(assertMessage == null) {
            assertEquals(urlString,expectedStatusCode, status);
        } else {
            assertEquals(assertMessage, expectedStatusCode, status);
        }
    } finally {
        httpClient.getState().setCredentials(authScope, oldCredentials);
    }
}
 

import org.apache.commons.httpclient.auth.AuthScope; //导入依赖的package包/类
public void testAuthProxyWithRedirect() throws Exception {
    UsernamePasswordCredentials creds = 
        new UsernamePasswordCredentials("testuser", "testpass");
    
    this.client.getState().setProxyCredentials(AuthScope.ANY, creds);
    this.server.setHttpService(new BasicRedirectService("/"));
    this.proxy.requireAuthentication(creds, "test", true);
    
    GetMethod get = new GetMethod("/redirect/");
    try {
        this.client.executeMethod(get);
        assertEquals(HttpStatus.SC_OK, get.getStatusCode());
    } finally {
        get.releaseConnection();
    }
}
 

import org.apache.commons.httpclient.auth.AuthScope; //导入依赖的package包/类
public void testAuthProxyWithCrossSiteRedirect() throws Exception {
    UsernamePasswordCredentials creds = 
        new UsernamePasswordCredentials("testuser", "testpass");
    
    this.client.getState().setProxyCredentials(AuthScope.ANY, creds);
    this.server.setHttpService(new BasicRedirectService(
            "http://127.0.0.1:" + this.server.getLocalPort()));

    this.proxy.requireAuthentication(creds, "test", true);
    
    GetMethod get = new GetMethod("/redirect/");
    try {
        this.client.executeMethod(get);
        assertEquals(HttpStatus.SC_OK, get.getStatusCode());
    } finally {
        get.releaseConnection();
    }
}
 

import org.apache.commons.httpclient.auth.AuthScope; //导入依赖的package包/类
public void testPreemptiveAuthProxyWithCrossSiteRedirect() throws Exception {
    UsernamePasswordCredentials creds = 
        new UsernamePasswordCredentials("testuser", "testpass");
    
    this.client.getState().setProxyCredentials(AuthScope.ANY, creds);
    this.client.getParams().setAuthenticationPreemptive(true);
    this.server.setHttpService(new BasicRedirectService(
            "http://127.0.0.1:" + this.server.getLocalPort()));

    this.proxy.requireAuthentication(creds, "test", true);
    
    GetMethod get = new GetMethod("/redirect/");
    try {
        this.client.executeMethod(get);
        assertEquals(HttpStatus.SC_OK, get.getStatusCode());
    } finally {
        get.releaseConnection();
    }
}
 

import org.apache.commons.httpclient.auth.AuthScope; //导入依赖的package包/类
/**
 * Direct unit test for host versification in SSL.
 * The test has been proposed as a patch in <a href="https://issues.apache.org/jira/browse/HTTPCLIENT-1265">HTTPCLIENT-1265</a>
 */
@Issue("SECURITY-555")
public void testHostNameValidation() {
    HttpClient client = new HttpClient();
    if (PROXY_HOST != null) {
        if (PROXY_USER != null) {
            HttpState state = client.getState();
            state.setProxyCredentials(AuthScope.ANY, new UsernamePasswordCredentials(
                    PROXY_USER, PROXY_PASS));
        }
        client.getHostConfiguration().setProxy(PROXY_HOST, Integer.parseInt(PROXY_PORT));
    }
    GetMethod method = new GetMethod(_urlWithIp);

    try {
        client.executeMethod(method);
        fail("Invalid hostname not detected");
    } catch (SSLException e) {
        assertTrue("Connection with a invalid server certificate rejected", true);
    } catch (Throwable t) {
        t.printStackTrace();
        fail("Unexpected exception" + t.getMessage());
    }
}