Часть 1: Философия

Ты оставляешь след везде. Каждый пост, фото, заказ, логин, маршрут. Эти данные уже публичны — просто разложены по сотням мест.

OSINT — искусство собирать эти куски в единую картину.

• Фрагмент 1: ник на форуме
• Фрагмент 2: почта в утечке
• Фрагмент 3: фото с геолокацией
• Фрагмент 4: номер телефона в объявлении
• Фрагмент 5: коммент в соцсети

По отдельности — мусор.
Вместе — досье.

Часть 2: Классификация

OSINT делится на дисциплины. У каждой свои инструменты и методы.

Часть 3: SOCMINT — человек через соцсети

Метод 1: Пивот от ника

Один ник почти всегда используется на десятках площадок. Это точка входа.

Инструменты:

• WhatsMyName (web) — 600+ площадок
• Sherlock (CLI) — быстрый перебор
• Maigret (CLI) — Sherlock на стероидах
• Nexfil (CLI) — фокус на стриминг и киносайты
• Blackbird (CLI) — быстрый + поиск аккаунтов
• ID Crawl — веб-интерфейс

Sherlock в действии:

# Установка
pip install sherlock-project

# Поиск ника на 400+ сайтах
sherlock vatican --timeout 10

# Результат:
# [+] GitHub: https://github.com/vatican
# [+] Telegram: https://t.me/vatican
# [+] Steam: https://steamcommunity.com/id/vatican
# [+] Reddit: https://reddit.com/user/vatican
# [+] SoundCloud: https://soundcloud.com/vatican

Maigret — глубже:

# Поддерживает больше сайтов + вытаскивает доп. инфо
maigret vatican --html report

# Парсит аватарки, био, количество постов
# Генерирует HTML-отчёт со всеми найденными аккаунтами

Метод 2: Пивот от email

Почта — ключ к большинству сервисов.

Как пример:

• Email → leaks → пароли
• Email → GitHub → код, коммиты, юзернейм
• Email → Gravatar → аватар
• Email → соцсети → восстановление → маска номера

Агрегаторы email:

• Epieos — покажет где зарегистрирован email
• EmailRep — репутация и возраст почты
• Holehe — проверка регистрации на 120+ сайтах

Holehe — где зарегистрирована почта:

pip install holehe
holehe target@example.com

# [+] Instagram — зарегистрирован
# [+] Twitter — зарегистрирован
# [+] Spotify — зарегистрирован
# [+] Discord — зарегистрирован

Метод 3: Пивот от телефона

Номер телефона — это оператор, регион, и часто — имя.

• Номер → оператор/регион → гео
• Номер → Telegram → аватар, юзернейм, био
• Номер → мессенджеры (WhatsApp, Viber)
• Номер → объявления (Avito, Юла)
• Номер → утечки

Определение оператора и региона:

Портация номеров между операторами делает определение оператора неточным

import phonenumbers
from phonenumbers import carrier, geocoder, timezone

def analyze_phone(number_str):
    try:
        number = phonenumbers.parse(number_str, "RU")
        
        if not phonenumbers.is_valid_number(number):
            return {"valid": False}
        
        return {
            "valid": True,
            "country": geocoder.description_for_number(number, "ru"),
            "carrier": carrier.name_for_number(number, "ru"),
            "timezone": str(timezone.time_zones_for_number(number)),
            "type": phonenumbers.number_type(number),
            "formatted": phonenumbers.format_number(
                number, phonenumbers.PhoneNumberFormat.INTERNATIONAL
            )
        }
    except Exception as e:
        return {"error": str(e)}

Telegram как OSINT-инструмент:

• Метод 1: Добавление в контакты
  Telegram покажет: аватар, имя, юзернейм, био, последний раз онлайн
• Метод 2: через Telegram API
  даже без сохранения контакта можно получить:
  - аватар
  - юзернейм
  - last seen
  - статус (был недавно/онлайн/офлайн)

Пример использования:

api id и api hash можно получить тут
https://my.telegram.org/auth

from telethon.sync import TelegramClient

api_id = API_ID
api_hash = "API_HASH"

with TelegramClient("session", api_id, api_hash) as client:
    # Поиск по номеру
    contact = client.get_entity("+79991234567")
    
    print(f"Имя: {contact.first_name} {contact.last_name}")
    print(f"Юзернейм: @{contact.username}")
    print(f"Телефон: {contact.phone}")
    print(f"Статус: {contact.status}")
    
    # Скачать аватар
    client.download_profile_photo(contact, file="avatar.jpg")
    
    # Получить био
    full = client.get_entity(contact)
    print(f"Био: {full.about}")

Определение наличия в мессенджерах:

• truecaller — имя по номеру (платно, но есть триал)
• eyecon — то же
• GetContact — показывает как записан в контактах других
• NumBuster — аналогично

Метод 4: Кросс-корреляция

Самое мощное — когда данные из разных источников сходятся.

Пример пайплайна:

Ник "vatican"
→ Sherlock находит Twitter, GitHub, Telegram
→ GitHub → email в коммите → vatican@example.com
→ Holehe → почта зарегистрирована в VK, Avito
→ VK → настоящие имя и фамилия, город
→ Avito → телефон → пробив в Telegram
→ Telegram → настоящее фото → Google Images
→ Google Images → LinkedIn → место работы

Итого: полное досье за 30 минут.

Часть 4: GEOINT — геолокация

Метод 1: EXIF данные

Каждое фото с телефона содержит метаданные — если автор их не вычистил.

from PIL import Image
from PIL.ExifTags import TAGS, GPSTAGS
import requests

def extract_exif(image_path):
    image = Image.open(image_path)
    exif_data = image._getexif()
    
    if not exif_data:
        return {"error": "EXIF данные удалены или отсутствуют"}
    
    data = {}
    for tag_id, value in exif_data.items():
        tag = TAGS.get(tag_id, tag_id)
        data[tag] = value
    
    # GPS координаты
    if "GPSInfo" in data:
        gps_info = data["GPSInfo"]
        gps = {}
        for key in gps_info:
            decode = GPSTAGS.get(key, key)
            gps[decode] = gps_info[key]
        
        # Конвертация в десятичные градусы
        def dms_to_decimal(dms, ref):
            degrees = float(dms[0])
            minutes = float(dms[1])
            seconds = float(dms[2])
            decimal = degrees + minutes/60 + seconds/3600
            if ref in ["S", "W"]:
                decimal = -decimal
            return decimal
        
 lat = dms_to_decimal(gps["GPSLatitude"], gps.get("GPSLatitudeRef", "N"))
 lon = dms_to_decimal(gps["GPSLongitude"], gps.get("GPSLongitudeRef", "E"))
        
        return {
            "coordinates": (lat, lon),
            "maps_link": f"https://maps.google.com/?q={lat},{lon}",
            "camera": data.get("Model"),
            "date": data.get("DateTimeOriginal"),
            "software": data.get("Software")
        }
    
    return {"gps": "нет GPS данных", "meta": data}

# Что даёт EXIF:
# точные координаты съёмки
# модель телефона/камеры
# дату и время
# настройки съёмки
# иногда — серийный номер устройства

Проверка онлайн (без установки):

• exif.tools — просто загрузил увидел всё
• fotoforensics.com — анализ + детект фотошопа
• metapicz — аналогично

Метод 2: Геолокация по фото без EXIF

Когда метаданные вычищены — включается дедукция. Это уже ремесло.

Что смотреть на фото:

• Таблички (названия улиц, номера домов)
• Вывески (магазины, рестораны, названия)
• Язык надписей и шрифты
• Номерные знаки машин (формат, цвет, регион)
• Сторона движения (левостороннее/правостороннее)
• Архитектурный стиль
• Тип фонарей и разметки
• Положение солнца (время + полушарие)
• Провода (есть/нет, над/под землёй)
• Горы/море/рельеф на горизонте
• Как уложена плитка/тротуар (положение/форма/материал/узор)

Пошаговый процесс:

1. Обрати внимание на уникальные объекты
2. Обратный поиск через Google Lens
3. Открой Google Maps в этом регионе
4. Включи Street View
5. Совмещай панорамы с фото
6. Ищи совпадения по ориентирам

Инструменты:

• Google Lens — распознавание объектов и мест
• Yandex Images — часто лучше Google для СНГ
• Bing Visual Search — третий источник
• GeoGuessr — тренировка навыка (игра)
• Mapillary — краудсорсинговый street view
• OpenStreetMap — детальные карты
• Sentinel Hub — спутниковые снимки
• SunCalc — положение солнца по времени/месту

Пример метода "солнце + тень":

Дано: фото без гео, с тенью от столба

1. Замерь угол тени относительно объекта
2. Солнце движется с востока на запад
3. Угол тени + время на фото (если есть) = широта
4. Сверяешь с картой

Пример метода "вывески":

Фото ресторана изнутри

1. Читаешь название на стакане "Coffee Like"
2. Ищешь "Coffee Like" на 2GIS в городе из контекста
3. Открываешь панораму у каждого филиала
4. Ищешь совпадение интерьера
5. Совпало → точная локация

Метод 3: Геолокация через поведение

Не фото, а цифровой след человека в пространстве.

Источники:

• Strava Heatmap — маршруты бегунов (палит военные базы)
• Instagram локации — чекины
• Fitness-трекеры — маршруты
• Фото по тегам города — где бывает
• Отзывы на картах — Google/Yandex отзывы = места посещения
• Объявления — геолокация на Avito

Strava Heatmap — классический пример:

Сервис публикует тепловую карту всех маршрутов пользователей. Через неё нашли:

• Секретные военные базы
• Маршруты охраны
• Личные адреса (дом → работа)

Метод 4: Спутниковые снимки

Инструменты:

• Google Earth Pro — бесплатно, история снимков
• Sentinel Playground — свежие снимки (обновление каждые 5 дней)
• Bing Maps — иногда снимки лучше Google
• Yandex Maps — для СНГ
• Terraserver — исторические снимки

Что можно определить по спутнику:

1. Размер объекта и планировку
2. Теневую сторону в разное время суток
3. Историю (Google Earth хранит архив за 20+ лет)
4. Транспорт и технику
5. Недавние изменения (стройка, снос)

Часть 5: IMINT — изображения

Обратный поиск изображений

Движки и их сильные стороны:

• Google Images — Универсальный, глобальный
• Yandex Images — СНГ, лица, лучше всех ищет по людям
• Bing Visual — Промтовары, продукты
• TinEye — Точное совпадение, история
• PimEyes — Поиск по лицу (найти все фото человека)
• FaceCheck.ID — Поиск по лицу в криминальном контексте
• 百度 (Baidu) — Азия

PimEyes — поиск лица:

Загружаешь фото человека

1. движок сканирует веб
2. показывает ВСЕ фото этого лица в открытом доступе
3. даже те, где нет тега или имени

Это самый мощный инструмент деанона через визуал. Есть и обратная сторона — работает в обе стороны.

Автоматизация обратного поиска:

# Яндекс Images — автоматический обратный поиск
import requests
from io import BytesIO

def yandex_reverse_search(image_path):
    url = "https://yandex.ru/images/search"
    
    files = {"upfile": ("image.jpg", open(image_path, "rb"), "image/jpeg")}
    params = {"rpt": "imageview", "cbird": "77"}
    
    session = requests.Session()
    response = session.post(url, params=params, files=files)
    
    
    return response.url  # ссылка на результаты поиска

# Для продакшена лучше использовать:
# - SerpAPI (платно, стабильно)
# - Browser automation (Playwright)

Часть 6: TECHINT — инфраструктура

Домены и IP

Инструменты:

• whois — владелец домена, регистратор
• DNSDumpster — вся DNS-структура
• Shodan — поисковик по устройствам в сети
• Censys — аналог Shodan
• SecurityTrails — история DNS, субдомены
• crt.sh — SSL сертификаты и субдомены
• ViewDNS — обратный IP (кто ещё на этом IP)
• Hunter.io — email на домене

Shodan — поиск устройств:

import shodan

api = shodan.Shodan("API_KEY")

# Поиск открытых камер
results = api.search('webcam city:Moscow')

for result in results['matches']:
    print(f"IP: {result['ip_str']}")
    print(f"Port: {result['port']}")
    print(f"Org: {result.get('org')}")
    print(f"Location: {result['location']}")
    print("---")

# Поиск незащищённых баз данных
results = api.search('mongodb port:27017')

# Поиск по IP — вся информация об устройстве
host = api.host('8.8.8.8')
print(host)

crt.sh — скрытые субдомены через SSL:

# Все SSL сертификаты, выданные для домена
curl -s "https://crt.sh/?q=%25.example.com&output=json" | \
  jq -r '.[].name_value' | sort -u

# Результат — все субдомены, которые когда-либо выпускали серт

Полный OSINT по домену:

import requests
import whois
from dns import resolver

def full_domain_recon(domain):
    report = {}
    
    # WHOIS
    try:
        w = whois.whois(domain)
        report["registrar"] = w.registrar
        report["created"] = str(w.creation_date)
        report["owner"] = w.name  # если не скрыт privacy
    except:
        pass
    
    # DNS записи
    for record_type in ["A", "MX", "NS", "TXT"]:
        try:
            answers = resolver.resolve(domain, record_type)
            report[record_type] = [str(r) for r in answers]
        except:
            pass
    
    # Субдомены через crt.sh
    try:
        resp = requests.get(
            f"https://crt.sh/?q=%25.{domain}&output=json",
            timeout=10
        )
        subdomains = set()
        for entry in resp.json():
            for name in entry["name_value"].split("\n"):
                if domain in name:
                    subdomains.add(name.strip())
        report["subdomains"] = list(subdomains)
    except:
        pass
    
    # Email через Hunter.io
    # (нужен API ключ, бесплатный тариф — 25 запросов/мес)
    
    return report

Часть 7: Утечки данных

Проверка своих данных

• HaveIBeenPwned — email + пароли (проверка по K-Anonymity)
• DeHashed — полный поиск по утечкам (email, имя, IP, телефон)
• LeakCheck — email/телефон/ник
• Snusbase — самый быстрый (платный)
• Intelligence X — darknet + утечки

Что дают утечки:

• Email + пароль → доступ к аккаунтам (если пароль не уникальный)
• Email + телефон → связка для деанона
• Email + адрес → физическая локация
• Email + паспортные данные → полный профиль

Пример работы с DeHashed API:

import requests
import base64

def dehashed_search(query, email, api_key):
    # Поиск по всем утечкам
    auth = base64.b64encode(f"{email}:{api_key}".encode()).decode()
    
    headers = {
        "Accept": "application/json",
        "Authorization": f"Basic {auth}"
    }
    
    # Поиск можно вести по:
    # email, username, name, address, phone, ip, hash
    
    response = requests.get(
        f"https://api.dehashed.com/search?query=email:{query}",
        headers=headers
    )
    return response.json()

# Результат содержит:
# - все пароли (в чистом/хешированном виде)
# - все email
# - имена
# - адреса
# - телефоны
# - IP

Часть 8: Транспорт и физический мир

Номера автомобилей

Формат российского номера:
А123ВС77 регион 77, Москва

Источники:

• ГИБДД (гибдд.рф) — история ДТП
• Автокод (avtocod.ru) — платный агрегатор
• Номер-база — платные Telegram-боты
• Реестр залогов (reestr-zalogov.ru) — залог
• ФССП — если есть долги владельца

Авиация

• Flightradar24 — все рейсы в реальном времени
• ADS-B Exchange — без фильтров (в отличие от FR24)
• OpenSky Network — открытое API

Отслеживание частного борта:

import requests

def track_aircraft(callsign):
    response = requests.get(
        f"https://opensky-network.org/api/states/all?callsign={callsign}"
    )
    data = response.json()
    
    if data.get("states"):
        for state in data["states"]:
            return {
                "callsign": state[1],
                "latitude": state[6],
                "longitude": state[5],
                "altitude": state[13],
                "velocity": state[9],
                "heading": state[10],
                "on_ground": state[8]
            }
    return None

Морской транспорт

• MarineTraffic — все суда
• VesselFinder — аналог

Часть 9: Автоматизация — фреймворки

SpiderFoot — автоматический OSINT-скан

# Установка
pip install spiderfoot

# Запуск веб-интерфейса
sf -l 127.0.0.1:5001

# Скан по email
sf -s target@example.com -t all

# Скан по IP
sf -s 8.8.8.8 -t all

# Скан по домену
sf -s example.com -t all

SpiderFoot автоматически прогоняет цель через 200+ модулей и собирает всё в один отчёт.

Maltego — визуальный OSINT

Построение графов связей:
Цель → запросы к разным источникам → визуальные связи

Пример графа:
  Email
  ├── Twitter аккаунт
  │   └── Подписки → другие аккаунты
  ├── Домены (whois)
  │   └── Другие домены на тот же whois
  ├── Утечки
  └── Соцсети

Платный, но Community-версия достаточна для старта.

TheHarvester — сбор email/субдоменов

# Сбор email с домена из публичных источников
theHarvester -d example.com -b all

# Источники:
# - поисковые системы
# - LinkedIn
# - сертификаты
# - DNS

Часть 10: OpSec исследователя

Пока ты копаешь — тебя тоже могут копать.

Правила гигиены:

• Никогда не логинься в свои аккаунты при исследовании
• Используй отдельный браузер (профиль) для OSINT
• SOCKS5 / VPN — не для анонимности, для смены IP
• Виртуалка для рискованных сайтов
• Не открывай ссылки напрямую — скрин через сервисы
• Не переходи по ссылкам из подозрительных сообщений
• Отключи синхронизацию браузера
• Отдельная почта для регистраций при исследовании

Инструменты безопасного просмотра:

• urlscan.io — скриншот сайта без захода на него
• archive.org — просмотр старой версии
• proxy — через прокси для смены IP
• whonix — виртуалка с Tor

Часть 11: Как НЕ надо

• Сталкинг бывших/близких — это незаконно и аморально XD)
• Скачивание данных из взломанных баз (кроме проверки своих)
• Попытки взлома на основе собранной информации
• Публикация собранных данных без согласия
• Пробив через "серые" Telegram-боты (палевно и небезопасно)
• Использование OSINT для шантажа

OSINT — это про понимание системы. Будь умнее чем просто шантажировать и публиковать просто так)

By Vatican

Мы верим, что:
Знание — это власть. Не доступ к власти. Не инструмент власти. Сама власть.

Тот, кто понимает механику системы — контролирует её. Тот, кто контролирует — не спрашивает разрешения.

Наши принципы:
1. Разбирай всё

Всё, что построено — можно разобрать. Всё, что работает — можно понять. Всё, что можно понять — можно воспроизвести. Нет "закрытых" систем. Есть системы, которые ты ещё не вскрыл.

2. Поверхность — это ложь

То, что показывают — витрина. То, что под ней — сущность. API скрыт? Значит есть. Данные "недоступны"? Значит просто не нашли endpoint. Реальность имеет слои, и большинство живёт на первом.

3. Слабость системы — не твоя проблема

Если их пароль — 123456. Если их API отдаёт всё без токена. Если их "защита" — проверка на фронте. Это не ты эксплуатируешь. Это они построили картонный дом.

4. Инструмент не выбирает цель

Молоток не решает, что строить. Скрипт не решает, что парсить. Тот, кто держит инструмент в руках — определяет применение.

5. Эффективность — единственная метрика

Работает / не работает. Быстро / медленно. Обнаружили / не обнаружили. Остальное — шум.

Три типа тех, кто в этой игре:

1. Играет по правилам, которые написал кто-то другой. Ждёт bug bounty. Отчитывается. Просит.
2. Берёт что находит. Не спрашивает. Не оглядывается. Иногда проигрывает.
3. Понимает обе стороны. Использует ту, которая даёт результат. Границу двигает под задачу.

Этот канал — не про этику. Не про закон. Не про "как правильно".
Этот канал — про то, как всё устроено на самом деле.
Система видит то, что показывает. Мы видим то, что она скрывает.

By Vatican

Всё, что ты видишь в браузере — это данные. Вопрос только в том, как их достать.

Если данные видны в браузере — их можно достать программно.

Часть 2: Уровни доступа к данным

Уровень 0 — Официальное API

Самое простое. Документация открыта, ключ бесплатный.

import requests
# Пример: публичное API

response = requests.get("https://api.example.com/v1/data")
data = response.json()

Плюсы: Стабильно, легально, документация
Минусы: Rate limits, неполные данные, ключ могут отозвать

Уровень 1 — Скрытый API (Reverse Engineering)

Сайты часто имеют внутренние API, которые фронтенд использует для получения данных. Документации нет, но endpoint работает.

Как найти:

1. Открой DevTools (F12)
2. Вкладка Network → XHR/Fetch
3. Обнови страницу
4. Смотри какие запросы летят
5. Найди endpoint с нужными данными

Пример — что видишь в Network:
GET https://site.com/api/v2/products?page=1&limit=50

Воспроизводим

import requests

headers = {
    "Authorization": "Bearer eyJhbGciOiJIUzI1...",
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)",
    "Accept": "application/json",
    "Referer": "https://site.com/catalog"
}

response = requests.get(
    "https://site.com/api/v2/products",
    params={"page": 1, "limit": 50},
    headers=headers
)
print(response.json())

Инструменты для реверса:

• DevTools (Network) — базовый
• mitmproxy — перехват трафика мобильных приложений
• Charles Proxy — то же, но с GUI
• Postman — тестирование найденных endpoints
• Frida — хук методов в мобильных приложениях
• Burp Suite — Позволяет перехватывать, анализировать и модифицировать HTTP- и HTTPS-трафик между браузером

Уровень 2 — GraphQL Endpoints

Многие современные сайты используют GraphQL. Он отдаёт ровно те данные, которые запросишь.

Как обнаружить:

1. В DevTools ищи POST-запросы на /graphql
2. Или /api/graphql
3. Или любые POST с query в body

Интроспекция — всей схемы:

# Запрос всей схемы API
{
  __schema {
    types {
      name
      fields {
        name
        type {
          name
        }
      }
    }
  }
}

Пример запроса данных:

import requests

query = """
{
  users(first: 100) {
    id
    username
    email
    posts {
      title
      createdAt
    }
  }
}
"""

response = requests.post(
    "https://site.com/graphql",
    json={"query": query},
    headers={"Content-Type": "application/json"}
)
print(response.json())

Инструменты:

• GraphiQL / Altair — IDE для GraphQL
• graphql-path-enum — перебор скрытых полей
• InQL (Burp extension) — автоматическая интроспекция

Уровень 3 — Парсинг HTML

Когда API нет или оно закрыто — парсим то, что видит браузер.

Базовый — requests + BeautifulSoup

import requests
from bs4 import BeautifulSoup

response = requests.get("https://example.com/products")
soup = BeautifulSoup(response.text, "html.parser")

products = soup.find_all("div", class_="product-card")

for product in products:
    title = product.find("h3").text.strip()
    price = product.find("span", class_="price").text
    link = product.find("a")["href"]
    
    print(f"{title} | {price} | {link}")

или когда например html динамический

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch(headless=True)
    page = browser.new_page()
    
    # Перехватываем API-запросы страницы
    responses = []
    page.on("response", lambda res: responses.append(res) 
            if "api" in res.url else None)
    
    page.goto("https://example.com/catalog")
    page.wait_for_load_state("networkidle")
    
    # Данные из перехваченных API-запросов
    for res in responses:
        print(res.url, res.json())
    
    # Или контент из DOM
    content = page.content()
    browser.close()

Селекторы — что использовать

# CSS селекторы (быстрее, чище)
soup.select("div.product-card > h3.title")
soup.select("a[href*='/product/']")
soup.select("span[data-price]")

# XPath (мощнее для сложной логики)
soup.xpath("//div[@class='item'][position() < 10]")
soup.xpath("//a[contains(@href, 'product')]/@href")

Уровень 4 — Headless Browser (эмуляция)

Когда сайт проверяет JS, куки, поведение — эмулируем реального пользователя.

Playwright — стандарт

from playwright.sync_api import sync_playwright
import time
import random

with sync_playwright() as p:
    browser = p.chromium.launch(
        headless=False,
        args=[
            "--disable-blink-features=AutomationControlled",
            "--no-sandbox"
        ]
    )
    
    context = browser.new_context(
        viewport={"width": 1920, "height": 1080},
        user_agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
        locale="ru-RU",
        timezone_id="Europe/Moscow"
    )
    
    page = context.new_page()
    
    # Убираем флаг webdriver
    page.add_init_script("""
        Object.defineProperty(navigator, 'webdriver', {
            get: () => undefined
        });
    """)
    
    page.goto("https://example.com")
    
    # Имитируем человека
    time.sleep(random.uniform(1, 3))
    page.mouse.move(random.randint(100, 800), random.randint(100, 600))
    
    # Скроллим как человек
    page.evaluate("""
        async () => {
            for (let i = 0; i < document.body.scrollHeight; i += 100) {
                window.scrollTo(0, i);
                await new Promise(r => setTimeout(r, 100));
            }
        }
    """)
    
    # Забираем контент
    html = page.content()
    
    browser.close()

Анти-детект: что проверяют сайты (зависит от фантазии создателя)

Основное

Уровень 5 — Мобильные API

Приложения часто используют API, недоступные через веб. Данные там чище и полнее.

Инструменты:

• mitmproxy — перехват HTTPS трафика
• Frida — инъекция кода в приложение
• Charles Proxy — GUI-альтернатива
• jadx — декомпиляция APK

Процесс:

1. Скачай APK (apkpure, apkmirror)
2. Декомпилируй (jadx)
3. Ищи строки с "api", "http", "endpoint"
4. Найди базовый URL и параметры
5. Перехвати трафик через mitmproxy
6. Воспроизведи запрос в Python

Часть 3: Защита и обход

Rate Limiting

Сайт ограничивает частоту запросов. Виды:

• IP-based → ротация прокси
• API Key-based → ротация ключей
• Session-based → ротация сессий
• Cookie-based → сброс куки
• Device fingerprint → подмена отпечатка

Подход:

import time
import random
from itertools import cycle

class RateLimiter:
    def __init__(self, min_delay=1.0, max_delay=3.0):
        self.min_delay = min_delay
        self.max_delay = max_delay
    
    def wait(self):
        delay = random.uniform(self.min_delay, self.max_delay)
        time.sleep(delay)

# Использование прокси
proxies = cycle([
    "http://proxy1:port",
    "http://proxy2:port",
    "http://proxy3:port",
])

limiter = RateLimiter(1, 3)

for url in urls:
    proxy = next(proxies)
    limiter.wait()
    
    response = requests.get(url, proxiДл": proxy})
    # Дальше ваша логика...

Теперь главный враг автоматизации CAPTCHA

CAPTCHA можно проходить самыми разными способами от солвером до обучения локальных ИИ-моделей

Интеграция с сервисом решения:

import requests
import time

API_KEY = "your_2captcha_key"

def solve_recaptcha(site_key, page_url):
    # Отправляем задачу
    response = requests.post("https://api.2captcha.com/in.php", data={
        "key": API_KEY,
        "method": "userrecaptcha",
        "googlekey": site_key,
        "pageurl": page_url,
        "json": 1
    })
    task_id = response.json()["request"]
    
    # Ждём решение
    for _ in range(30):
        time.sleep(5)
        result = requests.get("https://api.2captcha.com/res.php", params={
            "key": API_KEY,
            "action": "get",
            "id": task_id,
            "json": 1
        })
        if result.json()["status"] == 1:
            return result.json()["request"]
    
    return None

Часть 4: Инфраструктура

Прокси — виды и стратегии

1. HTTP прокси → обычные, для http запросов
2. SOCKS5 прокси → любой трафик
3. Резидентные → IP реальных людей (дорого, надёжно)
4. Датацентровые → IP серверов (дёшево, палевно)
5. Мобильные → IP мобильных операторов (самые надёжные)
6. Ротация → новый IP на каждый запрос
7. Стик → IP привязан к сессии

Правильная ротация:

import aiohttp
import asyncio
from itertools import cycle

class ProxyPool:
    def __init__(self, proxy_list):
        self.proxies = cycle(proxy_list)
        self.failed = set()
    
    def get_proxy(self):
        for _ in range(len(self.proxies)):
            proxy = next(self.proxies)
            if proxy not in self.failed:
                return proxy
        # Все прокси умерли — сбрасываем
        self.failed.clear()
        return next(self.proxies)
    
    def mark_failed(self, proxy):
        self.failed.add(proxy)

async def fetch(session, url, proxy):
    try:
        async with session.get(url, proxy=proxy, timeout=10) as resp:
            return await resp.json()
    except:
        pool.mark_failed(proxy)
        return None

async def main(urls):
    pool = ProxyPool([
        "http://proxy1:8080",
        "http://proxy2:8080",
    ])
    
    connector = aiohttp.TCPConnector(limit=20)
    async with aiohttp.ClientSession(connector=connector) as session:
        tasks = []
        for url in urls:
            proxy = pool.get_proxy()
            tasks.append(fetch(session, url, proxy))
        
        results = await asyncio.gather(*tasks)
    return [r for r in results if r is not None]

Часть 5: Практические схемы

Схема 1: Сбор данных с каталога

from playwright.sync_api import sync_playwright
from bs4 import BeautifulSoup
import json
import time
import random

class CatalogParser:
    def __init__(self, base_url):
        self.base_url = base_url
        self.results = []
    
    def parse_page(self, page, url):
        page.goto(url)
        page.wait_for_load_state("networkidle")
        
        # Ждём появления товаров
        page.wait_for_selector(".product-card", timeout=10000)
        
        html = page.content()
        soup = BeautifulSoup(html, "html.parser")
        
        products = soup.select(".product-card")
        
        for product in products:
            self.results.append({
                "title": product.select_one(".title")?.text.strip(),
                "price": product.select_one(".price")?.text.strip(),
                "url": product.select_one("a")?.get("href"),
                "parsed_at": time.strftime("%Y-%m-%d %H:%M")
            })
        
        # Случайная задержка
        time.sleep(random.uniform(2, 5))
    
    def run(self, pages=10):
        with sync_playwright() as p:
            browser = p.chromium.launch(headless=True)
            page = browser.new_page()
            
            for i in range(1, pages + 1):
                url = f"{self.base_url}?page={i}"
                print(f"Страница {i}/{pages}")
                self.parse_page(page, url)
            
            browser.close()
        
        return self.results
    
    def save(self, filename="data.json"):
        with open(filename, "w", encoding="utf-8") as f:
            json.dump(self.results, f, ensure_ascii=False, indent=2)

# Использование
parser = CatalogParser("https://example.com/catalog")
data = parser.run(pages=50)
parser.save()

Схема 2: Мониторинг изменений

import hashlib
import json
from datetime import datetime
from pathlib import Path

class ChangeMonitor:
    def __init__(self, state_file="state.json"):
        self.state_file = Path(state_file)
        self.state = self.load_state()
    
    def load_state(self):
        if self.state_file.exists():
            return json.loads(self.state_file.read_text())
        return {}
    
    def save_state(self):
        self.state_file.write_text(
            json.dumps(self.state, ensure_ascii=False, indent=2)
        )
    
    def get_hash(self, data):
        return hashlib.md5(json.dumps(data, sort_keys=True).encode()).hexdigest()
    
    def check(self, key, new_data):
        new_hash = self.get_hash(new_data)
        old_hash = self.state.get(key, {}).get("hash")
        
        if old_hash is None:
            self.state[key] = {"hash": new_hash, "data": new_data, "updated": datetime.now().isoformat()}
            return {"status": "new", "data": new_data}
        
        elif old_hash != new_hash:
            old = self.state[key]["data"]
            self.state[key] = {"hash": new_hash, "data": new_data, "updated": datetime.now().isoformat()}
            return {"status": "changed", "old": old, "new": new_data}
        
        return {"status": "unchanged"}

Схема 3: Распределённый парсер

import asyncio
import aiohttp
from dataclasses import dataclass, field
from typing import Optional
import json

@dataclass
class Task:
    url: str
    retries: int = 0
    max_retries: int = 3
    proxy: Optional[str] = None

@dataclass
class Worker:
    id: int
    session: aiohttp.ClientSession
    queue: asyncio.Queue
    results: list = field(default_factory=list)

class DistributedParser:
    def __init__(self, urls, num_workers=5, proxy_list=None):
        self.tasks = [Task(url=url) for url in urls]
        self.num_workers = num_workers
        self.proxy_list = proxy_list or []
        self.results = []
    
    async def worker(self, wid, queue, session):
        while True:
            try:
                task = await asyncio.wait_for(queue.get(), timeout=5)
            except asyncio.TimeoutError:
                break
            
            try:
                proxy = None
                if self.proxy_list:
                    proxy = self.proxy_list[task.retries % len(self.proxy_list)]
                
                async with session.get(
                    task.url, 
                    proxy=proxy,
                    timeout=aiohttp.ClientTimeout(total=15)
                ) as resp:
                    if resp.status == 200:
                        data = await resp.text()
                        self.results.append({
                            "url": task.url,
                            "data": data,
                            "worker": wid
                        })
                        print(f"[Worker {wid}] OK: {task.url}")
                    else:
                        raise Exception(f"Status {resp.status}")
                        
            except Exception as e:
                task.retries += 1
                if task.retries < task.max_retries:
                    await queue.put(task)
                else:
                    print(f"[Worker {wid}] FAILED: {task.url} - {e}")
            
            finally:
                queue.task_done()
    
    async def run(self):
        queue = asyncio.Queue()
        for task in self.tasks:
            queue.put(task)
        
        connector = aiohttp.TCPConnector(limit=self.num_workers * 2)
        
        async with aiohttp.ClientSession(connector=connector) as session:
            workers = [
                asyncio.create_task(self.worker(i, queue, session))
                for i in range(self.num_workers)
            ]
            await queue.join()
            for w in workers:
                w.cancel()
        
        return self.results

# Использование
urls = [f"https://example.com/item/{i}" for i in range(1000)]
parser = DistributedParser(
    urls=urls, 
    num_workers=10,
    proxy_list=["http://p1:8080", "http://p2:8080", "http://p3:8080"]
)
results = asyncio.run(parser.run())

Часть 6: Стек инструментов

Обязательный минимум

• requests — базовые HTTP запросы
• httpx — async HTTP, HTTP/2
• beautifulsoup4 — парсинг HTML
• lxml — быстрый парсер
• playwright — headless браузер
• scrapy — фреймворк для масштабных проектов

Стань лучше:

• curl_cffi — имитация TLS fingerprint браузера
• tls_client — обход Cloudflare через TLS
• camoufox — анти-детект Firefox
• undetected-chromedriver — анти-детект Chrome
• aiohttp — async для скорости
• celery — очереди задач
• redis — кэш и состояние
• postgresql — хранилище данных
• docker — изоляция окружения (на уровне базовый минимум)

Инфраструктура (Может не подойти)

Прокси-провайдеры:

• Bright Data (резидентные)
• SmartProxy (резидентные)
• Proxy-Seller (датацентровые)
• IPRoyal (мобильные)

Решение капчи:

• 2Captcha
• Anti-Captcha
• CapSolver

Мониторинг:

• Grafana + Prometheus
• Telegram-бот алерты

Часть 7: Как НЕ надо

• ДДОСить сайт парсером (1000 req/sec)
• Игнорировать ошибки и повторять бесконечно
• Хранить данные без структуры
• Не логировать — не понимаешь что происходит
• Хардкодить селекторы без фоллбеков
• Не обрабатывать изменение вёрстк
• Собирать всё подряд без цели
• Не кэшировать — один и тот же запрос 50 раз
• Писать всё в один файл без модульности
• Игнорировать robots.txt и уважение к серверу

На этом все с вами был Vatican.