mitmdump抓包中遇到的一些问题总结_tls_passthrough.py

mitmdump是 mitmproxy 的命令行接口，利用它我们可以捕获手机app中的请求并对接 Python 脚本，用 Python 实现监听后的处理。安装方法可以参考相关链接，下面主要讲下遇到的问题及处理方法。

问题：Cannot establish TLS with client报错

在配置完电脑和手机端的证书并且手机代理设置好后，滑动手机捕获请求时cmd会一直闪动并且报Cannot establish TLS with client错误，如下图：

错误原因：mitmproxy缺少https的证书，继而导致mitmproxy解析ssl协议出错

解决办法: 把tls_passthrough.py中的代码整合进我们的监听脚本即可

下面是tls_passthrough.py的全部内容

 
"""
This inline script allows conditional TLS Interception based
on a user-defined strategy.
Example:
    > mitmdump -s tls_passthrough.py
    1. curl --proxy http://localhost:8080 https://example.com --insecure
    // works - we'll also see the contents in mitmproxy
    2. curl --proxy http://localhost:8080 https://example.com --insecure
    // still works - we'll also see the contents in mitmproxy
    3. curl --proxy http://localhost:8080 https://example.com
    // fails with a certificate error, which we will also see in mitmproxy
    4. curl --proxy http://localhost:8080 https://example.com
    // works again, but mitmproxy does not intercept and we do *not* see the contents
Authors: Maximilian Hils, Matthew Tuusberg
"""
import collections
import random
 
from enum import Enum
 
import mitmproxy
from mitmproxy import ctx
from mitmproxy.exceptions import TlsProtocolException
from mitmproxy.proxy.protocol import TlsLayer, RawTCPLayer
 
 
class InterceptionResult(Enum):
    success = True
    failure = False
    skipped = None
 
 
class _TlsStrategy:
    """
    Abstract base class for interception strategies.
    """
 
    def __init__(self):
        # A server_address -> interception results mapping
        self.history = collections.defaultdict(lambda: collections.deque(maxlen=500))
 
    def should_intercept(self, server_address):
        """
        Returns:
            True, if we should attempt to intercept the connection.
            False, if we want to employ pass-through instead.
        """
        raise NotImplementedError()
 
    def record_success(self, server_address):
        self.history[server_address].append(InterceptionResult.success)
 
    def record_failure(self, server_address):
        self.history[server_address].append(InterceptionResult.failure)
 
    def record_skipped(self, server_address):
        self.history[server_address].append(InterceptionResult.skipped)
 
 
class ConservativeStrategy(_TlsStrategy):
    """
    Conservative Interception Strategy - only intercept if there haven't been any failed attempts
    in the history.
    """
 
    def should_intercept(self, server_address):
        if InterceptionResult.failure in self.history[server_address]:
            return False
        return True
 
 
class ProbabilisticStrategy(_TlsStrategy):
    """
    Fixed probability that we intercept a given connection.
    """
 
    def __init__(self, p):
        self.p = p
        super(ProbabilisticStrategy, self).__init__()
 
    def should_intercept(self, server_address):
        return random.uniform(0, 1) < self.p
 
 
class TlsFeedback(TlsLayer):
    """
    Monkey-patch _establish_tls_with_client to get feedback if TLS could be established
    successfully on the client connection (which may fail due to cert pinning).
    """
 
    def _establish_tls_with_client(self):
        server_address = self.server_conn.address
 
        try:
            super(TlsFeedback, self)._establish_tls_with_client()
        except TlsProtocolException as e:
            tls_strategy.record_failure(server_address)
            raise e
        else:
            tls_strategy.record_success(server_address)
 
 
# inline script hooks below.
 
tls_strategy = None
 
 
def load(l):
    l.add_option(
        "tlsstrat", int, 0, "TLS passthrough strategy (0-100)",
    )
 
 
def configure(updated):
    global tls_strategy
    if ctx.options.tlsstrat > 0:
        tls_strategy = ProbabilisticStrategy(float(ctx.options.tlsstrat) / 100.0)
    else:
        tls_strategy = ConservativeStrategy()
 
 
def next_layer(next_layer):
    """
    This hook does the actual magic - if the next layer is planned to be a TLS layer,
    we check if we want to enter pass-through mode instead.
    """
    if isinstance(next_layer, TlsLayer) and next_layer._client_tls:
        server_address = next_layer.server_conn.address
 
        if tls_strategy.should_intercept(server_address):
            # We try to intercept.
            # Monkey-Patch the layer to get feedback from the TLSLayer if interception worked.
            next_layer.__class__ = TlsFeedback
        else:
            # We don't intercept - reply with a pass-through layer and add a "skipped" entry.
            mitmproxy.ctx.log("TLS passthrough for %s" % repr(next_layer.server_conn.address), "info")
            next_layer_replacement = RawTCPLayer(next_layer.ctx, ignore=True)
            next_layer.reply.send(next_layer_replacement)
            tls_strategy.record_skipped(server_address)

新建保存上面的tls_passthrough.py代码文件后，使用以下在cmd中执行以下命令，整合进我们的监听脚本即可（这里记得将tls_passthrough.py文件保存到cmd的文件目录下）

mitmproxy -s tls_passthrough.py

相关链接

mitmproxy的安装：mitmproxy 的安装 | 静觅 (cuiqingcai.com)

Cannot establish TLS with client报错：mintproxy跳坑集锦 - SegmentFault 思否

mitmdump控制台使用mitmdump -s script.py命令会No such script的问题：mitmdump控制台如何打开/为何使用mitmdump -s script.py命令会No such script_零零Hua的博客-CSDN博客_mitmdump不是内部或外部命令