Java ProxyAuthenticator类代码示例

import org.littleshoot.proxy.ProxyAuthenticator; //导入依赖的package包/类
@BeforeClass
public static void setupProxy() {
    ProxyAuthenticator auth = new ProxyAuthenticator() {

        @Override
        public boolean authenticate(String username, String password) {
            return proxyUsername.equals(username) && proxyPassword.equals(password);
        }

        @Override
        public String getRealm() {
            return null;
        }

    };
    server = DefaultHttpProxyServer.bootstrap().withPort(proxyPort).withProxyAuthenticator(auth).start();

    setProxySettingForClient();
}
 

import org.littleshoot.proxy.ProxyAuthenticator; //导入依赖的package包/类
private DefaultHttpProxyServer(String name,
        TransportProtocol transportProtocol,
        InetSocketAddress address,
        SslEngineSource sslEngineSource,
        boolean authenticateSslClients,
        ProxyAuthenticator proxyAuthenticator,
        ChainedProxyManager chainProxyManager,
        MitmManager mitmManager,
        HttpFiltersSource filterSource,
        boolean useDnsSec,
        boolean transparent,
        int idleConnectionTimeout,
        Collection<ActivityTracker> activityTrackers) {
    this(new ServerGroup(name), transportProtocol, address,
            sslEngineSource, authenticateSslClients, proxyAuthenticator,
            chainProxyManager,
            mitmManager, filterSource, useDnsSec, transparent,
            idleConnectionTimeout, activityTrackers);
}
 

import org.littleshoot.proxy.ProxyAuthenticator; //导入依赖的package包/类
private DefaultHttpProxyServerBootstrap(
        ServerGroup serverGroup,
        TransportProtocol transportProtocol,
        InetSocketAddress requestedAddress,
        SslEngineSource sslEngineSource,
        boolean authenticateSslClients,
        ProxyAuthenticator proxyAuthenticator,
        ChainedProxyManager chainProxyManager,
        MitmManager mitmManager,
        HttpFiltersSource filtersSource,
        boolean transparent, int idleConnectionTimeout,
        Collection<ActivityTracker> activityTrackers,
        int connectTimeout, HostResolver serverResolver,
        long readThrottleBytesPerSecond,
        long  writeThrottleBytesPerSecond,
        InetSocketAddress localAddress,
        String proxyAlias) {
    this.serverGroup = serverGroup;
    this.transportProtocol = transportProtocol;
    this.requestedAddress = requestedAddress;
    this.port = requestedAddress.getPort();
    this.sslEngineSource = sslEngineSource;
    this.authenticateSslClients = authenticateSslClients;
    this.proxyAuthenticator = proxyAuthenticator;
    this.chainProxyManager = chainProxyManager;
    this.mitmManager = mitmManager;
    this.filtersSource = filtersSource;
    this.transparent = transparent;
    this.idleConnectionTimeout = idleConnectionTimeout;
    if (activityTrackers != null) {
        this.activityTrackers.addAll(activityTrackers);
    }
    this.connectTimeout = connectTimeout;
    this.serverResolver = serverResolver;
    this.readThrottleBytesPerSecond = readThrottleBytesPerSecond;
    this.writeThrottleBytesPerSecond = writeThrottleBytesPerSecond;
    this.localAddress = localAddress;
    this.proxyAlias = proxyAlias;
}
 

import org.littleshoot.proxy.ProxyAuthenticator; //导入依赖的package包/类
private DefaultHttpProxyServerBootstrap(
        DefaultHttpProxyServer original,
        TransportProtocol transportProtocol,
        InetSocketAddress requestedAddress,
        SslEngineSource sslEngineSource,
        boolean authenticateSslClients,
        ProxyAuthenticator proxyAuthenticator,
        ChainedProxyManager chainProxyManager,
        MitmManager mitmManager,
        HttpFiltersSource filtersSource,
        boolean transparent, int idleConnectionTimeout,
        Collection<ActivityTracker> activityTrackers,
        int connectTimeout, HostResolver serverResolver,
        long readThrottleBytesPerSecond, long  writeThrottleBytesPerSecond) {
    this.original = original;
    this.transportProtocol = transportProtocol;
    this.requestedAddress = requestedAddress;
    this.port = requestedAddress.getPort();
    this.sslEngineSource = sslEngineSource;
    this.authenticateSslClients = authenticateSslClients;
    this.proxyAuthenticator = proxyAuthenticator;
    this.chainProxyManager = chainProxyManager;
    this.filtersSource = filtersSource;
    this.transparent = transparent;
    this.idleConnectionTimeout = idleConnectionTimeout;
    if (activityTrackers != null) {
        this.activityTrackers.addAll(activityTrackers);
    }
    this.connectTimeout = connectTimeout;
    this.serverResolver = serverResolver;
    this.readThrottleBytesPerSecond = readThrottleBytesPerSecond;
    this.writeThrottleBytesPerSecond = writeThrottleBytesPerSecond;
}
 

import org.littleshoot.proxy.ProxyAuthenticator; //导入依赖的package包/类
public static HttpProxyServer start() {
	System.out.println("*** STARTED TEST PROXY SERVER ***");
	HttpProxyServer proxyServer = DefaultHttpProxyServer.bootstrap().withPort(8089).withProxyAuthenticator(new ProxyAuthenticator() {
		@Override
		public boolean authenticate(String username, String password) {
			return username.equals("test") && password.equals("works");
		}
	}).start();
	return proxyServer;
}
 

import org.littleshoot.proxy.ProxyAuthenticator; //导入依赖的package包/类
private DefaultHttpProxyServerBootstrap(
        DefaultHttpProxyServer original,
        TransportProtocol transportProtocol,
        InetSocketAddress address,
        SslEngineSource sslEngineSource,
        boolean authenticateSslClients,
        ProxyAuthenticator proxyAuthenticator,
        ChainedProxyManager chainProxyManager,
        MitmManager mitmManager,
        HttpFiltersSource filtersSource, boolean useDnsSec,
        boolean transparent, int idleConnectionTimeout,
        Collection<ActivityTracker> activityTrackers) {
    this.original = original;
    this.transportProtocol = transportProtocol;
    this.address = address;
    this.port = address.getPort();
    this.sslEngineSource = sslEngineSource;
    this.authenticateSslClients = authenticateSslClients;
    this.proxyAuthenticator = proxyAuthenticator;
    this.chainProxyManager = chainProxyManager;
    this.filtersSource = filtersSource;
    this.useDnsSec = useDnsSec;
    this.transparent = transparent;
    this.idleConnectionTimeout = idleConnectionTimeout;
    if (activityTrackers != null) {
        this.activityTrackers.addAll(activityTrackers);
    }
}
 

import org.littleshoot.proxy.ProxyAuthenticator; //导入依赖的package包/类
/**
 * Runs a proxy server counting requests
 * @param authenticating true if the proxy should require authentication
 * @throws Exception if an error occurred
 */
private void startProxy(boolean authenticating) throws Exception {
    proxyPort = findPort();
    
    HttpProxyServerBootstrap bootstrap = DefaultHttpProxyServer.bootstrap()
            .withPort(proxyPort)
            .withFiltersSource(new HttpFiltersSourceAdapter() {
                public HttpFilters filterRequest(HttpRequest originalRequest,
                        ChannelHandlerContext ctx) {
                   return new HttpFiltersAdapter(originalRequest) {
                      @Override
                      public void proxyToServerRequestSent() {
                          proxyCounter++;
                      }
                   };
                }
            });
    
    if (authenticating) {
        bootstrap = bootstrap.withProxyAuthenticator(new ProxyAuthenticator() {
            @Override
            public boolean authenticate(String userName, String password) {
                return PROXY_USERNAME.equals(userName) &&
                        PROXY_PASSWORD.equals(password);
            }

            @Override
            public String getRealm() {
                return "gradle-download-task";
            }
        });
    }
    
    proxy = bootstrap.start();
}
 

import org.littleshoot.proxy.ProxyAuthenticator; //导入依赖的package包/类
/**
 * <p>
 * Checks whether the given HttpRequest requires authentication.
 * </p>
 * 
 * <p>
 * If the request contains credentials, these are checked.
 * </p>
 * 
 * <p>
 * If authentication is still required, either because no credentials were
 * provided or the credentials were wrong, this writes a 407 response to the
 * client.
 * </p>
 * 
 * @param request
 * @return
 */
private boolean authenticationRequired(HttpRequest request) {

    if (authenticated.get()) {
        return false;
    }

    final ProxyAuthenticator authenticator = proxyServer
            .getProxyAuthenticator();

    if (authenticator == null)
        return false;

    if (!request.headers().contains(HttpHeaders.Names.PROXY_AUTHORIZATION)) {
        writeAuthenticationRequired(authenticator.getRealm());
        return true;
    }

    List<String> values = request.headers().getAll(
            HttpHeaders.Names.PROXY_AUTHORIZATION);
    String fullValue = values.iterator().next();
    String value = StringUtils.substringAfter(fullValue, "Basic ").trim();
    
    byte[] decodedValue = Base64.decodeBase64(value.getBytes(Charset.forName("UTF-8")));
    String decodedString = new String(decodedValue, Charset.forName("UTF-8"));
    
    String userName = StringUtils.substringBefore(decodedString, ":");
    String password = StringUtils.substringAfter(decodedString, ":");
    if (!authenticator.authenticate(userName, password)) {
        writeAuthenticationRequired(authenticator.getRealm());
        return true;
    }

    LOG.debug("Got proxy authorization!");
    // We need to remove the header before sending the request on.
    String authentication = request.headers().get(
            HttpHeaders.Names.PROXY_AUTHORIZATION);
    LOG.debug(authentication);
    request.headers().remove(HttpHeaders.Names.PROXY_AUTHORIZATION);
    authenticated.set(true);
    return false;
}
 

import org.littleshoot.proxy.ProxyAuthenticator; //导入依赖的package包/类
protected ProxyAuthenticator getProxyAuthenticator() {
    return proxyAuthenticator;
}
 

import org.littleshoot.proxy.ProxyAuthenticator; //导入依赖的package包/类
@Override
public HttpProxyServerBootstrap withProxyAuthenticator(
        ProxyAuthenticator proxyAuthenticator) {
    this.proxyAuthenticator = proxyAuthenticator;
    return this;
}
 

import org.littleshoot.proxy.ProxyAuthenticator; //导入依赖的package包/类
/**
 * <p>
 * Checks whether the given HttpRequest requires authentication.
 * </p>
 * 
 * <p>
 * If the request contains credentials, these are checked.
 * </p>
 * 
 * <p>
 * If authentication is still required, either because no credentials were
 * provided or the credentials were wrong, this writes a 407 response to the
 * client.
 * </p>
 * 
 * @param request
 * @return
 */
private boolean authenticationRequired(HttpRequest request) {

    if (authenticated.get()) {
        return false;
    }

    final ProxyAuthenticator authenticator = proxyServer
            .getProxyAuthenticator();

    if (authenticator == null)
        return false;

    if (!request.headers().contains(HttpHeaders.Names.PROXY_AUTHORIZATION)) {
        writeAuthenticationRequired();
        return true;
    }

    List<String> values = request.headers().getAll(
            HttpHeaders.Names.PROXY_AUTHORIZATION);
    String fullValue = values.iterator().next();
    String value = StringUtils.substringAfter(fullValue, "Basic ")
            .trim();
    byte[] decodedValue = Base64.decodeBase64(value);
    try {
        String decodedString = new String(decodedValue, "UTF-8");
        String userName = StringUtils.substringBefore(decodedString,
                ":");
        String password = StringUtils.substringAfter(decodedString,
                ":");
        if (!authenticator.authenticate(userName,
                password)) {
            writeAuthenticationRequired();
            return true;
        }
    } catch (UnsupportedEncodingException e) {
        LOG.error("Could not decode?", e);
    }

    LOG.info("Got proxy authorization!");
    // We need to remove the header before sending the request on.
    String authentication = request.headers().get(
            HttpHeaders.Names.PROXY_AUTHORIZATION);
    LOG.info(authentication);
    request.headers().remove(HttpHeaders.Names.PROXY_AUTHORIZATION);
    authenticated.set(true);
    return false;
}