A few issues/discussion posts have been opened regarding mitm's certificates & and its use with Chrome. It would be a nice addition to have an easy method for installing certificates on different machines.

Hello, I wanted to know if it was possible to use this project without having to use verify=False. I heard this was possible by installing a certificate. Not using verify=False while doing requests will make my program crash because of SSL errors

Hello, here I am again!

EDIT: If I knew how to fix this I'd make a PR, sorry in advance!

Code (from examples):

from mitm import MITM, protocol, middleware, crypto

mitm = MITM(
    host="127.0.0.1",
    port=8888,
    protocols=[protocol.HTTP],
    middlewares=[middleware.Log],
    buffer_size=8192,
    timeout=5,
    ssl_context=crypto.mitm_ssl_default_context(),
    start=False,
)
mitm.start()

Output error:

Traceback (most recent call last):
  File "c:\Users\Slimakoi\Desktop\Coding\test\falling_new.py", line 3, in <module>
    mitm = MITM(
  File "C:\Program Files\Python310\lib\site-packages\mitm\mitm.py", line 65, in __init__
    super().__init__(
TypeError: ClassTask.__init__() got an unexpected keyword argument 'run_forever'

G'day,

I tried using the proxy as a normal HTTPs proxy for normal web-browsing. It seems like it struggles with a backlog of requests and does things sequentially.

I'm not sure if it's built for this kind of purpose, but it's what I intend on using it for so any help in getting it to run slightly smoother would be of great help!

Cheers,

Mitch

G'day!

I just got around to trying the 1.3.0 release. I created a fresh project on PyCharm, using Python 3.10 - When running the following code:

from mitm import MITM, CertificateAuthority, middleware, protocol
from pathlib import Path

# Loads the CA certificate.
path = Path("")
ca = CertificateAuthority.init(path=path)

# Starts the MITM server.
mitm = MITM(
    host="127.0.0.1",
    port=8888,
    protocols=[protocol.HTTP],
    middlewares=[middleware.Log],
    buffer_size=8192,
    timeout=5,
    ca=ca,
)
mitm.run()

It throws this error:

Traceback (most recent call last):
  File "/Users/myname/PycharmProjects/ComputerScience/misc/mitm.py", line 1, in <module>
    from mitm import CertificateAuthority, middleware, protocol
  File "/Users/myname/PycharmProjects/ComputerScience/misc/mitm.py", line 1, in <module>
    from mitm import CertificateAuthority, middleware, protocol
ImportError: cannot import name 'CertificateAuthority' from partially initialized module 'mitm' (most likely due to a circular import) (/Users/myname/PycharmProjects/ComputerScience/misc/mitm.py)

Hey, I'm using your example in the Middleware section in the readme of the project.

But I'm only getting following :

py main.py
2021-11-09 18:27:17 INFO     Booting up server on 127.0.0.1:8888.
2021-11-09 18:27:18 INFO     Client 127.0.0.1:62708 has connected.
2021-11-09 18:27:19 INFO     Successfully closed connection with 127.0.0.1:62708.

When running the following script:

import requests

proxies = {"http": "http://127.0.0.1:8888", "https": "http://127.0.0.1:8888"}
requests.get("https://httpbin.org/anything", proxies=proxies, verify=False)

I'd like to be able to see the headers, the content, etc of the request

A testing suite needs to be built for the project. I'm currently unsure how to go about this, and so any suggestions are welcomed.

I've tried to use Pytest for this, but I've had major issues booting up the server and having it run in the background before tests.

Code (from examples):

from mitm import MITM, protocol, middleware, crypto

mitm = MITM(
    host="127.0.0.1",
    port=8888,
    protocols=[protocol.HTTP],
    middlewares=[middleware.Log],
    buffer_size=8192,
    timeout=5,
    ssl_context=crypto.mitm_ssl_context(),
    start=False,
)
mitm.start()

Error:

C:\Users\Slimakoi\Desktop\Coding>main.py
Traceback (most recent call last):
  File "C:\Users\Slimakoi\Desktop\Coding\main.py", line 10, in <module>
    ssl_context=crypto.mitm_ssl_context(),
AttributeError: module 'mitm.crypto' has no attribute 'mitm_ssl_context'

As of right now mitm does not deal with hanging connections and unknown protocols very well. httpq will hang if the client never provide the correct bytes:

https://github.com/synchronizing/mitm/blob/5b9ae6306eae029aa6da1efa130a534ca223657c/mitm/mitm.py#L117-L121

Probable solution:

(a) Check if client.at_eof directly on the while loop, and (b) Read up to n bytes. If we don't have a valid HTTP first line by then, the client is sending some other protocol.

As mentioned by #18, mitm has a bottleneck that does not allow it to be used in conjunction with normal web use.

This PR increases performance by caching ssl.SSLContext that are generated by mitm so that it does not have to save/load from disk on every request.

Currently mitm.MITM is the location in which the relaying of data between the client and server occurs. This PR moves this relaying mechanism to inside of the individual protocols, and making Protocol (similar to Middleware now) into an objects as opposed to classes. This PR changes the mitm.Protocol to have the following methods:

class Protocol:
    def __init__(
        self,
        bytes_needed: int = 8192,
        buffer_size: int = 8192,
        timeout: int = 5,
        keep_alive: bool = True,
        ca: CertificateAuthority = CertificateAuthority(),
        middlewares: List[Middleware] = [],
    )
    async def resolve(self, connection: Connection, data: bytes) -> Optional[Tuple[str, int, bool]]
    async def connect(self, connection: Connection, host: str, port: int, tls: bool, data: bytes)
    async def handle(self, connection: Connection)

Where resolve resolves the initial data coming in from the client (resolves what the destination server is); connect connects to the clients destination server; and handle handles the relaying of data between the client and server. This allows better customization on how the data should be relayed between client/server. As a result of the new class, mitm.MITM has changed to a simpler API as well:

class MITM:
    def __init__(
        self,
        host: str = "127.0.0.1",
        port: int = 8888,
        protocols: List[protocol.Protocol] = [protocol.HTTP],
        middlewares: List[middleware.Middleware] = [middleware.Log],
        ca: CertificateAuthority = None,
        run: bool = False,
    )

This should, in theory, allow a caching mechanism to be build on top of a protocol - as suggested by #9.

Todo

• [x] Convert mitm.Protocol from a class object to an instantiated object.
• [x] Transfer buffer_size, timeout, and keep_alive to the individual protocols.
• [x] Update documentation & type hints.