import org.littleshoot.proxy.MitmManager; //导入依赖的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.MitmManager; //导入依赖的package包/类
protected Future<?> execute() {
    LOG.debug("Handling CONNECT request through Chained Proxy");
    chainedProxy.filterRequest(initialRequest);
    MitmManager mitmManager = proxyServer.getMitmManager();
    boolean isMitmEnabled = mitmManager != null;
    /*
     * We ignore the LastHttpContent which we read from the client
     * connection when we are negotiating connect (see readHttp()
     * in ProxyConnection). This cannot be ignored while we are
     * doing MITM + Chained Proxy because the HttpRequestEncoder
     * of the ProxyToServerConnection will be in an invalid state
     * when the next request is written. Writing the EmptyLastContent
     * resets its state.
     */
    if(isMitmEnabled){
        ChannelFuture future = writeToChannel(initialRequest);
        future.addListener(new ChannelFutureListener() {

            @Override
            public void operationComplete(ChannelFuture arg0) throws Exception {
                if(arg0.isSuccess()){
                    writeToChannel(LastHttpContent.EMPTY_LAST_CONTENT);
                }
            }
        });
    	return future;
    } else {
        return writeToChannel(initialRequest);
    }
}
 

import org.littleshoot.proxy.MitmManager; //导入依赖的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.MitmManager; //导入依赖的package包/类
@Override
public HttpProxyServerBootstrap withManInTheMiddle(
        MitmManager mitmManager) {
    this.mitmManager = mitmManager;
    if (this.sslEngineSource != null) {
        LOG.warn("Enabled man in the middle with encrypted inbound connections. "
                + "These are mutually exclusive - encrypted inbound connections will be disabled.");
        this.sslEngineSource = null;
    }
    return this;
}
 

import org.littleshoot.proxy.MitmManager; //导入依赖的package包/类
/**
 * This method initializes our {@link ConnectionFlow} based on however this
 * connection has been configured.
 */
private void initializeConnectionFlow() {
    this.connectionFlow = new ConnectionFlow(clientConnection, this,
            connectLock)
            .then(ConnectChannel);

    if (chainedProxy != null && chainedProxy.requiresEncryption()) {
        connectionFlow.then(serverConnection.EncryptChannel(chainedProxy
                .newSslEngine()));
    }

    if (ProxyUtils.isCONNECT(initialRequest)) {
        MitmManager mitmManager = proxyServer.getMitmManager();
        boolean isMitmEnabled = mitmManager != null;

        if (isMitmEnabled) {
            connectionFlow.then(serverConnection.EncryptChannel(
                    mitmManager.serverSslEngine()))
                    .then(clientConnection.RespondCONNECTSuccessful)
                    .then(serverConnection.MitmEncryptClientChannel);
        } else {
            // If we're chaining, forward the CONNECT request
            if (hasUpstreamChainedProxy()) {
                connectionFlow.then(
                        serverConnection.HTTPCONNECTWithChainedProxy);
            }

            connectionFlow.then(serverConnection.StartTunneling)
                    .then(clientConnection.RespondCONNECTSuccessful)
                    .then(clientConnection.StartTunneling);
        }
    }
}
 

import org.littleshoot.proxy.MitmManager; //导入依赖的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.MitmManager; //导入依赖的package包/类
@Override
public HttpProxyServerBootstrap withManInTheMiddle(
        MitmManager mitmManager) {
    this.mitmManager = mitmManager;
    if (this.chainProxyManager != null) {
        LOG.warn("Enabled man in the middle along with proxy chaining.  These are mutually exclusive - proxy chaining will be disabled.");
        this.chainProxyManager = null;
    }
    return this;
}
 

import org.littleshoot.proxy.MitmManager; //导入依赖的package包/类
/**
 * This method initializes our {@link ConnectionFlow} based on however this
 * connection has been configured.
 */
private void initializeConnectionFlow() {
    this.connectionFlow = new ConnectionFlow(clientConnection, this,
            connectLock)
            .then(ConnectChannel);

    if (chainedProxy != null && chainedProxy.requiresEncryption()) {
        connectionFlow.then(serverConnection.EncryptChannel(chainedProxy
                .newSslEngine()));
    }

    if (ProxyUtils.isCONNECT(initialRequest)) {
        MitmManager mitmManager = proxyServer.getMitmManager();
        boolean isMitmEnabled = mitmManager != null;

        if (isMitmEnabled) {
            connectionFlow.then(serverConnection.EncryptChannel(
                    mitmManager.serverSslEngine()))
                    .then(clientConnection.RespondCONNECTSuccessful)
                    .then(serverConnection.MitmEncryptClientChannel);
        } else {
            // If we're chaining, forward the CONNECT request
            if (hasDownstreamChainedProxy()) {
                connectionFlow.then(
                        serverConnection.HTTPCONNECTWithChainedProxy);
            }

            connectionFlow.then(serverConnection.StartTunneling)
                    .then(clientConnection.RespondCONNECTSuccessful)
                    .then(clientConnection.StartTunneling);
        }
    }
}
 

import org.littleshoot.proxy.MitmManager; //导入依赖的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.MitmManager; //导入依赖的package包/类
@Override
public HttpProxyServerBootstrap withManInTheMiddle(
        MitmManager mitmManager) {
    this.mitmManager = mitmManager;
    if (this.chainProxyManager != null) {
        Log.w(TAG, "Enabled man in the middle along with proxy chaining.  These are mutually exclusive - proxy chaining will be disabled.");
        this.chainProxyManager = null;
    }
    return this;
}
 

import org.littleshoot.proxy.MitmManager; //导入依赖的package包/类
@Override
public void setMitmManager(MitmManager mitmManager) {
    this.mitmManager = mitmManager;
}
 

import org.littleshoot.proxy.MitmManager; //导入依赖的package包/类
/**
 * This method initializes our {@link ConnectionFlow} based on however this connection has been configured. If
 * the {@link #disableSni} value is true, this method will not pass peer information to the MitmManager when
 * handling CONNECTs.
 */
private void initializeConnectionFlow() {
    this.connectionFlow = new ConnectionFlow(clientConnection, this,
            connectLock)
            .then(ConnectChannel);

    if (chainedProxy != null && chainedProxy.requiresEncryption()) {
        connectionFlow.then(serverConnection.EncryptChannel(chainedProxy
                .newSslEngine()));
    }

    if (ProxyUtils.isCONNECT(initialRequest)) {
        // If we're chaining, forward the CONNECT request
        if (hasUpstreamChainedProxy()) {
            connectionFlow.then(
                    serverConnection.HTTPCONNECTWithChainedProxy);
        }        	
    	
        MitmManager mitmManager = proxyServer.getMitmManager();
        boolean isMitmEnabled = mitmManager != null;

        if (isMitmEnabled) {
            // When MITM is enabled and when chained proxy is set up, remoteAddress
            // will be the chained proxy's address. So we use serverHostAndPort
            // which is the end server's address.
            HostAndPort parsedHostAndPort = HostAndPort.fromString(serverHostAndPort);

            // SNI may be disabled for this request due to a previous failed attempt to connect to the server
            // with SNI enabled.
            if (disableSni) {
                connectionFlow.then(serverConnection.EncryptChannel(proxyServer.getMitmManager()
                        .serverSslEngine()));
            } else {
                connectionFlow.then(serverConnection.EncryptChannel(proxyServer.getMitmManager()
                        .serverSslEngine(parsedHostAndPort.getHostText(), parsedHostAndPort.getPort())));
            }

        	connectionFlow
                    .then(clientConnection.RespondCONNECTSuccessful)
                    .then(serverConnection.MitmEncryptClientChannel);
        } else {
            connectionFlow.then(serverConnection.StartTunneling)
                    .then(clientConnection.RespondCONNECTSuccessful)
                    .then(clientConnection.StartTunneling);
        }
    }
}
 

import org.littleshoot.proxy.MitmManager; //导入依赖的package包/类
protected MitmManager getMitmManager() {
    return mitmManager;
}
 

import org.littleshoot.proxy.MitmManager; //导入依赖的package包/类
public LittleProxyMitmProxy(int proxyPort, MitmManager mitmManager) {
    super(proxyPort);
    this.mitmManager = mitmManager;
}
 

import org.littleshoot.proxy.MitmManager; //导入依赖的package包/类
/**
 * Sets the MITM manager, which is responsible for generating forged SSL certificates to present to clients. By default,
 * BrowserMob Proxy uses the ca-certificate-rsa.cer root certificate for impersonation. See the documentation at
 * {@link net.lightbody.bmp.mitm.manager.ImpersonatingMitmManager} and {@link net.lightbody.bmp.mitm.manager.ImpersonatingMitmManager.Builder}
 * for details on customizing the root and server certificate generation.
 *
 * @param mitmManager MITM manager to use
 */
void setMitmManager(MitmManager mitmManager);