Bots web

import requests
from bs4 import BeautifulSoup
import re
from urllib.parse import urljoin

HEADERS = {"User-Agent": "Mozilla/5.0 (compatible; Bot/1.0)"}
TIMEOUT = 10

RE_TOKEN = re.compile(r'(\d{5,20}:[A-Za-z0-9_-]{35,})')
RE_ID_KV = re.compile(
    r'(?:["\']?(?:chat_id|user_id|tg_id|telegram_id)["\']?\s*[:=]\s*["\']?(-?\d{5,20})["\']?)',
    re.IGNORECASE
)
RE_SUSPECT_ID = re.compile(r'(-?100\d{7,12}|-?\d{6,15})')
RE_AT_USERNAME = re.compile(r'@([A-Za-z0-9_]{5,32})(?!\.)')
RE_TME = re.compile(r'(?:t\.me\/|tg:\/\/resolve\?domain=)([A-Za-z0-9_]{5,32})', re.IGNORECASE)

KEYWORDS_FOR_SUSPECT = re.compile(r'\btelegram\b|\bbot\b|\bchat_id\b|\buser_id\b|\bsendMessage\b', re.IGNORECASE)

def get_context(text, span, radius=60):
    start, end = span
    s = max(0, start - radius)
    e = min(len(text), end + radius)
    prefix = "..." if s > 0 else ""
    suffix = "..." if e < len(text) else ""
    return prefix + text[s:e].replace("\n", " ") + suffix

def extraer_de_codigo(js_code):
    tokens = set(RE_TOKEN.findall(js_code))
    ids = set(m.group(1) for m in RE_ID_KV.finditer(js_code))
    sospechosos = set()
    usernames = set(m.group(1) for m in RE_AT_USERNAME.finditer(js_code))
    tme_users = set(m.group(1) for m in RE_TME.finditer(js_code))

    # extraer coincidencias con contexto
    context = {
        "tokens": [],
        "ids": [],
        "sospechosos": [],
        "usernames": [],
        "tme_users": []
    }

    for m in RE_TOKEN.finditer(js_code):
        context["tokens"].append((m.group(1), get_context(js_code, m.span())))
    for m in RE_ID_KV.finditer(js_code):
        context["ids"].append((m.group(1), get_context(js_code, m.span())))
    for m in RE_AT_USERNAME.finditer(js_code):
        context["usernames"].append((m.group(1), get_context(js_code, m.span())))
    for m in RE_TME.finditer(js_code):
        context["tme_users"].append((m.group(1), get_context(js_code, m.span())))

    if not ids:
        if KEYWORDS_FOR_SUSPECT.search(js_code):
            for m in RE_SUSPECT_ID.finditer(js_code):
                sospechosos.add(m.group(1))
                context["sospechosos"].append((m.group(1), get_context(js_code, m.span())))

    return tokens, ids, sospechosos, usernames, tme_users, context

def obtener_js_desde_src(base_url, src):
    src_full = urljoin(base_url, src)
    try:
        r = requests.get(src_full, headers=HEADERS, timeout=TIMEOUT)
        r.raise_for_status()
        return src_full, r.text
    except requests.RequestException:
        return src_full, None

def analizar_url(url):
    try:
        r = requests.get(url, headers=HEADERS, timeout=TIMEOUT)
        r.raise_for_status()
    except requests.RequestException as e:
        print(f"❌ Error al acceder a {url}: {e}")
        return

    soup = BeautifulSoup(r.text, "html.parser")
    scripts = soup.find_all("script")

    resumen = {
        "tokens": [],
        "ids": [],
        "sospechosos": [],
        "usernames": [],
        "tme_users": []
    }

    for i, script in enumerate(scripts):
        js_code = ""
        source = ""

        if script.get("src"):
            source, js_code = obtener_js_desde_src(url, script["src"])
            if js_code is None:
                continue
        else:
            js_code = script.string or script.text or ""
            source = f"[INLINE #{i}]"

        tokens, ids, sospechosos, usernames, tme_users, context = extraer_de_codigo(js_code)

        if tokens or ids or sospechosos or usernames or tme_users:
            print("\n====================")
            print("Fuente:", source)
            if context["tokens"]:
                print("\n🧾 Tokens encontrados:")
                for t, ctx in context["tokens"]:
                    print(" -", t)
                    print("   contexto:", ctx)
            if context["ids"]:
                print("\n🆔 IDs explícitos:")
                for id_, ctx in context["ids"]:
                    print(" -", id_)
                    print("   contexto:", ctx)
            if context["sospechosos"]:
                print("\n❓ IDs sospechosos:")
                for s, ctx in context["sospechosos"]:
                    print(" -", s)
                    print("   contexto:", ctx)
            if context["usernames"]:
                print("\n📣 Usernames con @:")
                for u, ctx in context["usernames"]:
                    print(" - @"+u)
                    print("   contexto:", ctx)
            if context["tme_users"]:
                print("\n🔗 Enlaces t.me / tg resolve:")
                for u, ctx in context["tme_users"]:
                    print(" -", u)
                    print("   contexto:", ctx)

            # actualizar resumen global (sin contexto)
            resumen["tokens"].extend(list(tokens))
            resumen["ids"].extend(list(ids))
            resumen["sospechosos"].extend(list(sospechosos))
            resumen["usernames"].extend(list(usernames))
            resumen["tme_users"].extend(list(tme_users))

    # imprimir resumen único
    print("\n====================")
    print("RESUMEN ÚNICO (solo valores detectados):")
    if resumen["tokens"]:
        print("Tokens:", sorted(set(resumen["tokens"])))
    if resumen["ids"]:
        print("IDs:", sorted(set(resumen["ids"])))
    if resumen["sospechosos"]:
        print("IDs sospechosos:", sorted(set(resumen["sospechosos"])))
    if resumen["usernames"]:
        print("Usernames @:", ["@"+u for u in sorted(set(resumen["usernames"]))])
    if resumen["tme_users"]:
        print("t.me / tg resolve:", sorted(set(resumen["tme_users"])))
    if not any(resumen.values()):
        print("✅ No se encontraron tokens, IDs ni usernames relacionados con Telegram.")

if __name__ == "__main__":
    url = input("🌐 Ingresa la URL a analizar: ").strip()
    analizar_url(url)