milenium 0.4.2__tar.gz → 0.5.1__tar.gz

{milenium-0.4.2 → milenium-0.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: milenium
-Version: 0.4.2
+Version: 0.5.1
 Summary: OSINT / dox / deanon toolkit
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
@@ -13,3 +13,4 @@ Requires-Dist: click
 Requires-Dist: python-whois
 
 # milenium
+# exiftool

milenium-0.5.1/README.md

@@ -0,0 +1,2 @@
+# milenium
+# exiftool

{milenium-0.4.2 → milenium-0.5.1}/milenium/cli.py

@@ -84,6 +84,73 @@ def user(nick, permutations, dorks):
     console.print(f"[bold cyan]Лог:[/bold cyan] {logger.path}")
     logger.close()
 
+@main.command()
+@click.argument("email")
+def email_check(email):
+    """SMTP-валидация email + Gravatar + PGP + GitHub"""
+    logger = _init_logger()
+    from milenium.modules import email_validator, gravatar, pgp_lookup, github_search
+    res = {
+        "smtp": email_validator.check(email),
+        "gravatar": gravatar.check(email),
+        "pgp": pgp_lookup.check(email),
+        "github": github_search.check_email(email),
+    }
+    for k, v in res.items():
+        console.print(f"[bold]{k}:[/bold] {v}")
+    logger.close()
+
+
+@main.command()
+@click.argument("image_path")
+def exif(image_path):
+    """Извлечь EXIF/GPS из фото"""
+    logger = _init_logger()
+    from milenium.modules import exif_extractor
+    res = exif_extractor.check(image_path)
+    for k, v in res.items():
+        console.print(f"[bold]{k}:[/bold] {v}")
+    logger.close()
+
+
+@main.command()
+@click.argument("domain")
+def whois_rev(domain):
+    """Reverse WHOIS по домену"""
+    logger = _init_logger()
+    from milenium.modules import reverse_whois
+    res = reverse_whois.check(domain)
+    for d in res.get("domains", []):
+        console.print(d)
+    logger.close()
+
+
+@main.command()
+@click.option("--name", default=None)
+@click.option("--surname", default=None)
+@click.option("--year", default=None)
+@click.option("--nick", default=None)
+def pwgen(name, surname, year, nick):
+    """Генератор вероятных паролей по данным жертвы"""
+    logger = _init_logger()
+    from milenium.modules import password_pattern
+    res = password_pattern.generate(name=name, surname=surname, birth_year=year, nick=nick)
+    for p in res["passwords"][:50]:
+        console.print(p)
+    console.print(f"\n[bold]Всего:[/bold] {res['count']}")
+    logger.close()
+
+
+@main.command()
+@click.argument("image_path")
+def exif_cmd(image_path):
+    """EXIF из фото"""
+    logger = _init_logger()
+    from milenium.modules import exif_extractor
+    res = exif_extractor.check(image_path)
+    for k, v in res.items():
+        console.print(f"[bold]{k}:[/bold] {v}")
+    logger.close()
 
 @main.command()
 @click.argument("mail")

milenium-0.5.1/milenium/modules/aggregator.py

@@ -0,0 +1,41 @@
+from milenium.modules import (
+    pwned_passwords, breach_local, hibp, dehashed, leakcheck,
+    email_validator, gravatar, pgp_lookup, github_search,
+    wayback, reverse_whois, password_pattern,
+    ip_geo_advanced, tg_parser,
+)
+
+def run(email=None, username=None, phone=None, password=None, db_path=None, domain=None):
+    out = {}
+
+    if password:
+        out["pwned_passwords"] = pwned_passwords.check_password(password)
+
+    if email:
+        out["hibp"] = hibp.check_email(email)
+        out["dehashed_email"] = dehashed.search(f'email:"{email}"')
+        out["leakcheck_email"] = leakcheck.search(email)
+        out["gravatar"] = gravatar.check(email)
+        out["pgp"] = pgp_lookup.check(email)
+        out["github_email"] = github_search.check_email(email)
+        out["email_valid"] = email_validator.check(email)
+
+    if username:
+        out["dehashed_username"] = dehashed.search(f'username:"{username}"')
+        out["leakcheck_username"] = leakcheck.search(username)
+        out["github_user"] = github_search.check_username(username)
+        out["telegram"] = tg_parser.channel_info(username)
+
+    if phone:
+        out["leakcheck_phone"] = leakcheck.search(phone)
+
+    if domain:
+        out["wayback"] = wayback.check(f"http://{domain}")
+        out["reverse_whois"] = reverse_whois.check(domain)
+
+    if db_path:
+        q = email or username or phone
+        if q:
+            out["breach_local"] = breach_local.search(q, db_path)
+
+    return out

milenium-0.5.1/milenium/modules/email_validator.py

@@ -0,0 +1,22 @@
+import smtplib
+import dns.resolver
+
+def check(email):
+    """Проверка существования email через SMTP RCPT TO (без отправки письма)."""
+    domain = email.split("@")[1]
+    try:
+        mx_records = dns.resolver.resolve(domain, "MX")
+        mx_host = str(sorted(mx_records, key=lambda r: r.preference)[0].exchange).rstrip(".")
+    except Exception as e:
+        return {"error": f"MX lookup failed: {e}"}
+
+    try:
+        server = smtplib.SMTP(timeout=10)
+        server.connect(mx_host, 25)
+        server.helo("milenium.local")
+        server.mail("check@milenium.local")
+        code, _ = server.rcpt(email)
+        server.quit()
+        return {"exists": code in (250, 251), "code": code, "mx": mx_host}
+    except Exception as e:
+        return {"error": str(e), "mx": mx_host}

milenium-0.5.1/milenium/modules/exif_extractor.py

@@ -0,0 +1,22 @@
+import subprocess
+import os
+
+def check(image_path):
+    """Требует exiftool в PATH. Установка: apt install libimage-exiftool-perl / choco install exiftool."""
+    if not os.path.exists(image_path):
+        return {"error": "file not found"}
+    try:
+        r = subprocess.run(
+            ["exiftool", "-j", image_path],
+            capture_output=True, text=True, timeout=20
+        )
+        if r.returncode != 0:
+            return {"error": r.stderr.strip() or "exiftool failed"}
+        import json
+        data = json.loads(r.stdout)[0]
+        keys = ["GPSLatitude", "GPSLongitude", "Model", "Make", "DateTimeOriginal", "Software"]
+        return {k: data.get(k) for k in keys if data.get(k)}
+    except FileNotFoundError:
+        return {"error": "exiftool not installed"}
+    except Exception as e:
+        return {"error": str(e)}

milenium-0.5.1/milenium/modules/github_search.py

@@ -0,0 +1,29 @@
+import requests
+
+def check_email(email):
+    try:
+        r = requests.get(
+            f"https://api.github.com/search/users?q={email}+in:email",
+            headers={"Accept": "application/vnd.github+json"},
+            timeout=10,
+        )
+        if r.status_code == 200:
+            items = r.json().get("items", [])
+            return {"users": [{"login": u["login"], "url": u["html_url"]} for u in items]}
+        return {"error": f"HTTP {r.status_code}"}
+    except Exception as e:
+        return {"error": str(e)}
+
+def check_username(username):
+    try:
+        r = requests.get(
+            f"https://api.github.com/search/users?q={username}+in:login",
+            headers={"Accept": "application/vnd.github+json"},
+            timeout=10,
+        )
+        if r.status_code == 200:
+            items = r.json().get("items", [])
+            return {"users": [{"login": u["login"], "url": u["html_url"]} for u in items]}
+        return {"error": f"HTTP {r.status_code}"}
+    except Exception as e:
+        return {"error": str(e)}

milenium-0.5.1/milenium/modules/gravatar.py

@@ -0,0 +1,13 @@
+import hashlib
+import requests
+
+def check(email):
+    h = hashlib.md5(email.strip().lower().encode()).hexdigest()
+    url = f"https://www.gravatar.com/avatar/{h}?d=404"
+    try:
+        r = requests.get(url, timeout=10)
+        if r.status_code == 200:
+            return {"exists": True, "url": f"https://www.gravatar.com/{h}"}
+        return {"exists": False}
+    except Exception as e:
+        return {"error": str(e)}

milenium-0.5.1/milenium/modules/instagram_osint.py

@@ -0,0 +1,25 @@
+import requests
+import re
+
+def check(username):
+    """Парсит публичный профиль Instagram без API (может ломаться при защите)."""
+    headers = {"User-Agent": "Mozilla/5.0"}
+    try:
+        r = requests.get(f"https://www.instagram.com/{username}/", headers=headers, timeout=15)
+        if r.status_code != 200:
+            return {"error": f"HTTP {r.status_code}"}
+        m = re.search(r'"edge_followed_by":\{"count":(\d+)\}', r.text)
+        followers = m.group(1) if m else None
+        m2 = re.search(r'"edge_follow":\{"count":(\d+)\}', r.text)
+        following = m2.group(1) if m2 else None
+        m3 = re.search(r'"biography":"(.*?)"', r.text)
+        bio = m3.group(1) if m3 else None
+        return {
+            "exists": True,
+            "followers": followers,
+            "following": following,
+            "bio": bio,
+            "url": f"https://instagram.com/{username}",
+        }
+    except Exception as e:
+        return {"error": str(e)}

milenium-0.5.1/milenium/modules/ip_geo_advanced.py

@@ -0,0 +1,16 @@
+import requests
+
+def check(ip):
+    out = {}
+    try:
+        r = requests.get(f"https://ipapi.co/{ip}/json/", timeout=10).json()
+        out["ipapi"] = {k: r.get(k) for k in ["city", "region", "country_name", "org", "asn", "timezone"]}
+    except Exception as e:
+        out["ipapi_error"] = str(e)
+
+    try:
+        r = requests.get(f"https://ipwho.is/{ip}", timeout=10).json()
+        out["ipwhois"] = {k: r.get(k) for k in ["city", "region", "country", "connection"]}
+    except Exception as e:
+        out["ipwhois_error"] = str(e)
+    return out

milenium-0.5.1/milenium/modules/password_pattern.py

@@ -0,0 +1,32 @@
+import itertools
+from datetime import datetime
+
+def generate(name=None, surname=None, birth_year=None, nick=None, limit=500):
+    """Генерит вероятные пароли по данным жертвы."""
+    base = []
+    if name: base.append(name.lower())
+    if surname: base.append(surname.lower())
+    if nick: base.append(nick.lower())
+    if name and surname:
+        base.append(f"{name.lower()}{surname.lower()}")
+        base.append(f"{name.lower()}.{surname.lower()}")
+        base.append(f"{name.lower()}_{surname.lower()}")
+
+    suffixes = ["", "123", "1234", "12345", "2024", "2025", "!", "@", "#", "_"]
+    if birth_year:
+        suffixes += [str(birth_year), str(birth_year)[-2:], f"{birth_year}!"]
+
+    out = set()
+    for b in base:
+        for s in suffixes:
+            out.add(b + s)
+            out.add(b.capitalize() + s)
+            out.add(b.upper() + s)
+
+    # leet
+    leet_map = {"a": "4", "e": "3", "i": "1", "o": "0", "s": "5"}
+    for b in list(out)[:100]:
+        leet = "".join(leet_map.get(c, c) for c in b)
+        out.add(leet)
+
+    return {"passwords": list(out)[:limit], "count": len(out)}

milenium-0.5.1/milenium/modules/pgp_lookup.py

@@ -0,0 +1,10 @@
+import requests
+
+def check(email):
+    try:
+        r = requests.get(f"https://keys.openpgp.org/vks/v1/by-email/{email}", timeout=10)
+        if r.status_code == 200:
+            return {"found": True, "key": r.text[:500]}
+        return {"found": False}
+    except Exception as e:
+        return {"error": str(e)}

milenium-0.5.1/milenium/modules/reverse_whois.py

@@ -0,0 +1,24 @@
+import requests
+from bs4 import BeautifulSoup
+
+def check(query):
+    """Парсит viewdns.info — бесплатно, без API-ключа."""
+    try:
+        r = requests.get(
+            "https://viewdns.info/reversewhois/",
+            params={"q": query},
+            headers={"User-Agent": "Mozilla/5.0"},
+            timeout=20,
+        )
+        soup = BeautifulSoup(r.text, "html.parser")
+        table = soup.find("table", {"border": "1"})
+        if not table:
+            return {"domains": []}
+        domains = []
+        for row in table.find_all("tr")[1:]:
+            cols = row.find_all("td")
+            if cols:
+                domains.append(cols[0].text.strip())
+        return {"domains": domains[:100]}
+    except Exception as e:
+        return {"error": str(e)}

milenium-0.5.1/milenium/modules/tg_parser.py

@@ -0,0 +1,20 @@
+import requests
+from bs4 import BeautifulSoup
+
+def channel_info(username):
+    try:
+        r = requests.get(f"https://t.me/{username}", timeout=10)
+        if r.status_code != 200:
+            return {"error": f"HTTP {r.status_code}"}
+        soup = BeautifulSoup(r.text, "html.parser")
+        title = soup.find("meta", property="og:title")
+        desc = soup.find("meta", property="og:description")
+        members = soup.find("div", class_="tgme_page_extra")
+        return {
+            "title": title["content"] if title else None,
+            "description": desc["content"] if desc else None,
+            "extra": members.text.strip() if members else None,
+            "url": f"https://t.me/{username}",
+        }
+    except Exception as e:
+        return {"error": str(e)}

milenium-0.5.1/milenium/modules/twitter_osint.py

@@ -0,0 +1,13 @@
+import requests
+
+def check(username):
+    """Через nitter-зеркало (может не работать, зеркала меняются)."""
+    mirrors = ["https://nitter.net", "https://nitter.privacydev.net"]
+    for base in mirrors:
+        try:
+            r = requests.get(f"{base}/{username}", timeout=10)
+            if r.status_code == 200 and "user-profile" in r.text:
+                return {"exists": True, "url": f"https://twitter.com/{username}", "mirror": base}
+        except Exception:
+            continue
+    return {"exists": False}

milenium-0.5.1/milenium/modules/vk_osint.py

@@ -0,0 +1,23 @@
+import requests
+
+def check(user_id, token=""):
+    """VK API: нужен сервисный токен. Без него вернёт ошибку."""
+    if not token:
+        return {"error": "no VK token"}
+    try:
+        r = requests.get(
+            "https://api.vk.com/method/users.get",
+            params={
+                "user_ids": user_id,
+                "fields": "followers_count,country,city,photo_max,bdate",
+                "access_token": token,
+                "v": "5.199",
+            },
+            timeout=15,
+        )
+        data = r.json()
+        if "response" in data:
+            return data["response"][0]
+        return {"error": data.get("error", {}).get("error_msg")}
+    except Exception as e:
+        return {"error": str(e)}

milenium-0.5.1/milenium/modules/wayback.py

@@ -0,0 +1,18 @@
+import requests
+
+def check(url):
+    try:
+        r = requests.get(
+            "http://archive.org/wayback/available",
+            params={"url": url},
+            timeout=15,
+        )
+        if r.status_code == 200:
+            data = r.json()
+            snap = data.get("archived_snapshots", {}).get("closest")
+            if snap:
+                return {"available": True, "snapshot": snap["url"], "timestamp": snap["timestamp"]}
+            return {"available": False}
+        return {"error": f"HTTP {r.status_code}"}
+    except Exception as e:
+        return {"error": str(e)}

milenium-0.5.1/milenium/modules/wifi_geolocation.py

@@ -0,0 +1,27 @@
+import requests
+
+def check(bssid):
+    """Wi-Fi геолокация через wigle.net (нужен API-токен)."""
+    try:
+        r = requests.get(
+            "https://api.wigle.net/api/v2/network/search",
+            params={"netid": bssid},
+            headers={"Authorization": "Basic YOUR_BASE64_TOKEN"},
+            timeout=15,
+        )
+        if r.status_code == 200:
+            data = r.json()
+            results = data.get("results", [])
+            if results:
+                first = results[0]
+                return {
+                    "lat": first.get("trilat"),
+                    "lon": first.get("trilong"),
+                    "ssid": first.get("ssid"),
+                    "country": first.get("country"),
+                    "city": first.get("city"),
+                }
+            return {"found": False}
+        return {"error": f"HTTP {r.status_code}"}
+    except Exception as e:
+        return {"error": str(e)}

{milenium-0.4.2 → milenium-0.5.1}/milenium/tui.py

@@ -53,6 +53,39 @@ SESSION = {
     "db_loaded": False,
 }
 
+OUTPUT_LOG = []  # буфер вывода последних строк
+
+def push_output(text):
+    ts = datetime.now().strftime("%H:%M:%S")
+    OUTPUT_LOG.append(f"[red]{ts}[/red] [white]{text}[/white]")
+    if len(OUTPUT_LOG) > 20:
+        OUTPUT_LOG.pop(0)
+
+
+def clear_output():
+    OUTPUT_LOG.clear()
+
+def render_output():
+    lines = []
+    lines.append("[bold red]=== ВЫВОД КОМАНДЫ ===[/bold red]")
+    if OUTPUT_LOG:
+        lines.extend(OUTPUT_LOG[-10:])
+    else:
+        lines.append("[white]Пока ничего. Введи команду ниже.[/white]")
+    return Panel(
+        "\n".join(lines),
+        title="[bold red]ПРОЦЕСС[/bold red]",
+        border_style="red",
+    )
+
+
+def render_input():
+    return Panel(
+        "[bold red]milenium[/bold red] [white]@[/white] [red]VexxDev200[/red] [white]~[/white] [bold white]введи команду ниже[/bold white]",
+        title="[bold red]ВВОД[/bold red]",
+        border_style="red",
+    )
+
 
 def log_result(text):
     ts = datetime.now().strftime("%H:%M:%S")
@@ -65,7 +98,9 @@ def build_layout():
     layout = Layout()
     layout.split_column(
         Layout(name="header", size=10),
-        Layout(name="body"),
+        Layout(name="body", ratio=2),
+        Layout(name="output", size=12),
+        Layout(name="input", size=3),
         Layout(name="footer", size=3),
     )
     layout["body"].split_row(
@@ -76,6 +111,14 @@ def build_layout():
     return layout
 
 
+def render_input():
+    return Panel(
+        "[bold red]milenium[/bold red] [white]@[/white] [red]VexxDev200[/red] [white]~[/white] [bold white]введи команду ниже[/bold white]",
+        title="[bold red]ВВОД[/bold red]",
+        border_style="red",
+    )
+
+
 def render_header():
     logo = Text.from_markup(ASCII_LOGO)
     banner = Text.from_markup(BANNER)
@@ -160,30 +203,48 @@ def draw():
     layout["left"].update(render_left())
     layout["center"].update(render_center())
     layout["right"].update(render_right())
+    layout["output"].update(render_output())
+    layout["input"].update(render_input())
     layout["footer"].update(render_footer())
     return layout
 
 
 def interactive():
     console.clear()
-    with Live(draw(), refresh_per_second=4, screen=True) as live:
+    push_output("сессия запущена")
+    with Live(draw(), refresh_per_second=4) as live:
         while True:
             try:
+                live.stop()
                 cmd = Prompt.ask("[bold red]milenium[/bold red] [white]@[/white] [red]VexxDev200[/red] [white]~[/white]")
+                live.start()
+
                 if cmd.strip().lower() in ("exit", "quit", "q"):
                     break
                 if not cmd.strip():
+                    live.update(draw())
                     continue
+
                 SESSION["queries"] += 1
+                push_output(f"выполняю: {cmd}")
+
                 import shlex
+                import io
+                import contextlib
                 from milenium.cli import main
+
                 args = shlex.split(cmd)
+                buf = io.StringIO()
                 try:
-                    main(args, standalone_mode=False)
+                    with contextlib.redirect_stdout(buf):
+                        main(args, standalone_mode=False)
+                    for line in buf.getvalue().splitlines():
+                        if line.strip():
+                            push_output(line)
                 except SystemExit:
                     pass
                 except Exception as e:
-                    console.print(f"[bold red]Ошибка:[/bold red] {e}")
+                    push_output(f"[red]ошибка: {e}[/red]")
                 live.update(draw())
             except KeyboardInterrupt:
                 break

{milenium-0.4.2 → milenium-0.5.1}/milenium.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: milenium
-Version: 0.4.2
+Version: 0.5.1
 Summary: OSINT / dox / deanon toolkit
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
@@ -13,3 +13,4 @@ Requires-Dist: click
 Requires-Dist: python-whois
 
 # milenium
+# exiftool

{milenium-0.4.2 → milenium-0.5.1}/milenium.egg-info/SOURCES.txt

@@ -18,16 +18,30 @@ milenium/modules/dns_history.py
 milenium/modules/domain.py
 milenium/modules/dorker.py
 milenium/modules/email.py
+milenium/modules/email_validator.py
+milenium/modules/exif_extractor.py
+milenium/modules/github_search.py
+milenium/modules/gravatar.py
 milenium/modules/hibp.py
+milenium/modules/instagram_osint.py
 milenium/modules/ip.py
+milenium/modules/ip_geo_advanced.py
 milenium/modules/ip_reputation.py
 milenium/modules/leakcheck.py
 milenium/modules/logger.py
+milenium/modules/password_pattern.py
 milenium/modules/permutator.py
+milenium/modules/pgp_lookup.py
 milenium/modules/phone.py
 milenium/modules/pwned_passwords.py
 milenium/modules/report.py
+milenium/modules/reverse_whois.py
 milenium/modules/shodan_lite.py
 milenium/modules/social.py
 milenium/modules/telegram_osint.py
-milenium/modules/username.py
+milenium/modules/tg_parser.py
+milenium/modules/twitter_osint.py
+milenium/modules/username.py
+milenium/modules/vk_osint.py
+milenium/modules/wayback.py
+milenium/modules/wifi_geolocation.py

{milenium-0.4.2 → milenium-0.5.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "milenium"
-version = "0.4.2"
+version = "0.5.1"
 description = "OSINT / dox / deanon toolkit"
 readme = "README.md"
 requires-python = ">=3.9"

milenium-0.4.2/README.md

@@ -1 +0,0 @@
-# milenium

milenium-0.4.2/milenium/modules/aggregator.py

@@ -1,26 +0,0 @@
-from milenium.modules import pwned_passwords, breach_local, hibp, dehashed, leakcheck
-
-def run(email=None, username=None, phone=None, password=None, db_path=None):
-    out = {}
-
-    if password:
-        out["pwned_passwords"] = pwned_passwords.check_password(password)
-
-    if email:
-        out["hibp"] = hibp.check_email(email)
-        out["dehashed_email"] = dehashed.search(f'email:"{email}"')
-        out["leakcheck_email"] = leakcheck.search(email)
-
-    if username:
-        out["dehashed_username"] = dehashed.search(f'username:"{username}"')
-        out["leakcheck_username"] = leakcheck.search(username)
-
-    if phone:
-        out["leakcheck_phone"] = leakcheck.search(phone)
-
-    if db_path:
-        q = email or username or phone
-        if q:
-            out["breach_local"] = breach_local.search(q, db_path)
-
-    return out