В поисках секторов в современных SPA

import subprocess
import threading
from concurrent.futures import ThreadPoolExecutor, as_completed
from pathlib import Path
import logging
from datetime import datetime

logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler('detector.log', encoding='utf-8'),
        logging.StreamHandler()
    ]
)
logger = logging.getLogger(__name__)

def make_curl_request(url):
    return subprocess.run(
        ["curl", "-s", "-i", "-L", "--max-redirs", str(5), url.strip()],
        capture_output=True,
        text=True,
        encoding='utf-8',
        errors='replace',
        timeout=10
    )

def detect_react(html):
    """Детектит React"""
    return '<div id="root"></div>' in html or '<div id="root">' in html

def detect_nextjs(html):
    """Детектит next.js"""
    return '/_next' in html

def process_url(url, react_file, next_file, lock):
    """Обрабатывает один URL"""
    url = url.strip()
    if not url:
        return
    
    logger.info(f"Проверяю: {url}")
    
    try:
        result = make_curl_request(url)
        html = result.stdout + result.stderr 
        
        detected = []
        
        if detect_react(html):
            detected.append("React")
            with lock:
                react_file.write(url + '\n')
                react_file.flush()
        
        if detect_nextjs(html):
            detected.append("Next.js")
            with lock:
                next_file.write(url + '\n')
                next_file.flush()
        
        if detected:
            logger.info(f"✅ {url} - Найдено: {', '.join(detected)}")
        else:
            logger.info(f"❌ {url} - Ничего не найдено")
            
    except subprocess.TimeoutExpired:
        logger.error(f"⏰ {url} - Таймаут")
    except Exception as e:
        logger.error(f"💥 {url} - Ошибка: {str(e)}")

def main():
    input_file = Path('urls.txt')
    react_file = Path('react.txt')
    next_file = Path('next.txt')
    
    if not input_file.exists():
        logger.error(f"Файл {input_file} не найден!")
        return
    
    with open(input_file, 'r', encoding='utf-8') as f:
        urls = [line.strip() for line in f if line.strip()]
    
    logger.info(f"Загружено {len(urls)} URL для проверки")
    
    lock = threading.Lock()
    
    with open(react_file, 'w', encoding='utf-8') as rf, \
         open(next_file, 'w', encoding='utf-8') as nf:
        
        max_workers = min(30, len(urls))  # Максимум 10 потоков
        logger.info(f"Запускаю проверку в {max_workers} потоков")
        
        with ThreadPoolExecutor(max_workers=max_workers) as executor:
            futures = {
                executor.submit(process_url, url, rf, nf, lock): url
                for url in urls
            }
            
            for future in as_completed(futures):
                url = futures[future]
                try:
                    future.result()
                except Exception as e:
                    logger.error(f"Ошибка в потоке для {url}: {e}")
    
    react_count = sum(1 for _ in open(react_file, 'r', encoding='utf-8'))
    next_count = sum(1 for _ in open(next_file, 'r', encoding='utf-8'))
    
    logger.info("="*50)
    logger.info("СКАНИРОВАНИЕ ЗАВЕРШЕНО!")
    logger.info(f"React найден на {react_count} сайтах → react.txt")
    logger.info(f"Next.js найден на {next_count} сайтах → next.txt")
    logger.info(f"Логи сохранены в detector.log")

if __name__ == "__main__":
    main()

import json
import urllib.request
import urllib.error

def check_token_simple(token):
    token = token.strip()
    url = f"https://api.telegram.org/bot{token}/getMe"
    
    try:
        req = urllib.request.Request(url)
        with urllib.request.urlopen(req, timeout=10) as response:
            data = json.loads(response.read().decode('utf-8'))
            
            if data.get('ok'):
                bot_info = data['result']
                return {
                    'valid': True,
                    'username': f"@{bot_info.get('username', 'Неизвестно')}",
                    'name': bot_info.get('first_name', 'Неизвестно'),
                    'id': bot_info.get('id')
                }
    except:
        pass
    
    return {'valid': False}

with open('tokens.txt', 'r', encoding='utf-8') as f:
    tokens = f.readlines()

for token in tokens:
    token = token.strip()
    if not token:
        continue
    
    result = check_token_simple(token)
    
    if result['valid']:
        print(f"✓ ВАЛИДНЫЙ: {result['username']} - {result['name']} (ID: {result['id']})")
    else:
        print(f"✗ НЕВАЛИДНЫЙ: {token[:15]}...")

max_workers = min(30, len(urls))  # Максимум 10 потоков

host.services.endpoints.http.headers:(key="X-Powered-By" and value:"Express")

import subprocess
import threading
import logging
from pathlib import Path
from concurrent.futures import ThreadPoolExecutor, as_completed

logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s - %(levelname)s - %(message)s",
    handlers=[
        logging.FileHandler("detector.log", encoding="utf-8"),
        logging.StreamHandler()
    ]
)

logger = logging.getLogger(__name__)


def process_url(url, react_file, next_file, lock):
    try:
        result = subprocess.run(
            ["curl", "-s", "-i", "-L", "--max-redirs", "5", url],
            capture_output=True,
            text=True,
            encoding="utf-8",
            errors="replace",
            timeout=10
        )

        html = result.stdout + result.stderr

        if '<div id="root"></div>' in html or '<div id="root">' in html:
            with lock:
                react_file.write(url + '\n')

        if '/_next' in html:
            with lock:
                next_file.write(url + '\n')

    except subprocess.TimeoutExpired:
        logger.warning(f"Таймаут: {url}")
    except Exception as e:
        logger.error(f"Ошибка {url}: {e}")


def main():
    input_file = Path("urls.txt")

    if not input_file.exists():
        logger.error("Файл urls.txt не найден")
        return

    urls = [
        line.strip()
        for line in input_file.read_text(encoding="utf-8").splitlines()
        if line.strip()
    ]

    logger.info(f"Загружено URL: {len(urls)}")

    lock = threading.Lock()

    with open("react.txt", "w", encoding="utf-8") as react_file, \
         open("next.txt", "w", encoding="utf-8") as next_file:

        with ThreadPoolExecutor(max_workers=min(30, len(urls))) as executor:
            futures = [
                executor.submit(process_url, url, react_file, next_file, lock)
                for url in urls
            ]

            for future in as_completed(futures):
                future.result()

    logger.info("Сканирование завершено")


if __name__ == "__main__":
    main()