zerocheck 1.0.0__tar.gz

zerocheck-1.0.0/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.4
+Name: zerocheck
+Version: 1.0.0
+Summary: Blazing fast Spotify Cookie Checker with hardware-locked licensing
+Author-email: Zyco <zyco@zyco1.com>
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: textual>=0.40.0
+Requires-Dist: requests>=2.28.0
+Requires-Dist: beautifulsoup4>=4.11.0
+
+# ZeroChecker 🎧
+
+Blazing fast Spotify Cookie Checker with a sleek terminal UI and hardware-locked licensing.
+
+## Installation
+
+```bash
+pip install zerocheck

zerocheck-1.0.0/README.md

@@ -0,0 +1,8 @@
+# ZeroChecker 🎧
+
+Blazing fast Spotify Cookie Checker with a sleek terminal UI and hardware-locked licensing.
+
+## Installation
+
+```bash
+pip install zerocheck

zerocheck-1.0.0/pyproject.toml

@@ -0,0 +1,25 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "zerocheck"
+version = "1.0.0"
+description = "Blazing fast Spotify Cookie Checker with hardware-locked licensing"
+readme = "README.md"
+requires-python = ">=3.8"
+authors = [
+    {name = "Zyco", email = "zyco@zyco1.com"}
+]
+dependencies = [
+    "textual>=0.40.0",
+    "requests>=2.28.0",
+    "beautifulsoup4>=4.11.0",
+]
+
+[project.scripts]
+zerocheck = "zerocheck.app:main"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["zerocheck*"]

zerocheck-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

zerocheck-1.0.0/zerocheck/__init__.py

@@ -0,0 +1,2 @@
+"""ZeroChecker - Spotify Cookie Checker TUI"""
+__version__ = "1.0.0"

zerocheck-1.0.0/zerocheck/__main__.py

@@ -0,0 +1,5 @@
+"""Allows running via `python -m zerocheck`"""
+from .app import main
+
+if __name__ == "__main__":
+    main()

zerocheck-1.0.0/zerocheck/app.py

@@ -0,0 +1,515 @@
+"""Main ZeroChecker TUI application"""
+
+import os
+import sys
+import time
+import threading
+from datetime import datetime
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+try:
+    import tkinter as tk
+    from tkinter import filedialog
+    GUI_AVAILABLE = True
+except ImportError:
+    GUI_AVAILABLE = False
+
+from textual.app import App, ComposeResult
+from textual.containers import Container, Horizontal, Vertical, ScrollableContainer
+from textual.widgets import Header, Footer, Static, Label, Input, Button, RichLog, Checkbox
+from textual.screen import ModalScreen
+from textual.reactive import reactive
+
+from .backend import process_one_cookie, parse_proxy_file
+from .auth import validate_license_key
+
+
+def resize_terminal(rows: int = 34, cols: int = 110):
+    """Attempt to resize the terminal window."""
+    try:
+        sys.stdout.write(f"\033[8;{rows};{cols}t")
+        sys.stdout.flush()
+    except Exception:
+        pass
+
+
+def gui_select_folder(title="Select a folder"):
+    """Open folder selection dialog."""
+    if not GUI_AVAILABLE: return None
+    try:
+        root = tk.Tk(); root.withdraw(); root.attributes("-topmost", True); root.update()
+        folder = filedialog.askdirectory(parent=root, title=title); root.destroy(); return folder
+    except Exception:
+        try: root.destroy()
+        except Exception: pass
+        return None
+
+
+def gui_select_file(title="Select a file"):
+    """Open file selection dialog."""
+    if not GUI_AVAILABLE: return None
+    try:
+        root = tk.Tk(); root.withdraw(); root.attributes("-topmost", True); root.update()
+        filepath = filedialog.askopenfilename(parent=root, title=title); root.destroy(); return filepath
+    except Exception:
+        try: root.destroy()
+        except Exception: pass
+        return None
+
+
+class LicenseScreen(ModalScreen):
+    """Modal license key entry screen."""
+    
+    DEFAULT_CSS = """
+    LicenseScreen {
+        align: center middle;
+    }
+    
+    #license_container {
+        width: 70;
+        height: 15;
+        background: #0a150e;
+        border: thick #1DB954;
+        padding: 1;
+    }
+    
+    #license_container Label {
+        color: #1DB954;
+        text-style: bold;
+        margin-bottom: 1;
+    }
+    
+    #license_container Input {
+        margin-bottom: 1;
+        border: solid #1DB954;
+    }
+    
+    #license_container Button {
+        width: 100%;
+        margin-top: 1;
+        background: #1DB954;
+        color: #000000;
+        text-style: bold;
+    }
+    
+    #license_container Button:hover {
+        background: #1ED760;
+    }
+    
+    #license_message {
+        color: #ff4444;
+        text-style: bold;
+        margin-top: 1;
+    }
+    """
+    
+    def compose(self):
+        with Vertical(id="license_container"):
+            yield Label("🔐 LICENSE KEY REQUIRED")
+            yield Label("Enter your license key to activate:")
+            yield Input(placeholder="ZC-XXXX-XXXX-XXXX", id="license_input")
+            yield Button("ACTIVATE", id="activate_button")
+            yield Label("", id="license_message")
+    
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        if event.button.id == "activate_button":
+            license_key = self.query_one("#license_input", Input).value
+            message_label = self.query_one("#license_message", Label)
+            
+            if not license_key:
+                message_label.update("Please enter a license key")
+                return
+            
+            message_label.update("Validating...")
+            
+            # Validate with Keygen
+            success, message = validate_license_key(license_key)
+            
+            if success:
+                message_label.styles.color = "#1ED760"
+                message_label.update(f"✅ {message}")
+                self.dismiss(True)
+            else:
+                message_label.styles.color = "#ff4444"
+                message_label.update(f"❌ {message}")
+
+
+class ZeroHeader(Static):
+    def render(self) -> str:
+        return (
+            "[bold #1DB954]"
+            "  ███████╗███████╗██████╗  ██████╗  ██████╗██╗  ██╗███████╗ ██████╗██╗  ██╗███████╗██████╗\n"
+            "  ╚══███╔╝██╔════╝██╔══██╗██╔═══██╗██╔════╝██║  ██║██╔════╝██╔════╝██║ ██╔╝██╔════╝██╔══██╗\n"
+            "    ███╔╝ █████╗  ██████╔╝██║   ██║██║     ███████║█████╗  ██║     █████╔╝ █████╗  ██████╔╝\n"
+            "   ███╔╝  ██╔══╝  ██╔══██╗██║   ██║██║     ██╔══██║██╔══╝  ██║     ██╔═██╗ ██╔══╝  ██╔══██╗\n"
+            "  ███████╗███████╗██║  ██║╚██████╔╝╚██████╗██║  ██║███████╗╚██████╗██║  ██╗███████╗██║  ██║\n"
+            "  ╚══════╝╚══════╝╚═╝  ╚═╝ ╚═════╝  ╚═════╝╚═╝  ╚═╝╚══════╝ ╚═════╝╚═╝  ╚═╝╚══════╝╚═╝  ╚═╝\n"
+            "  ════════════════════════════════════════════════════════════════════════════════════════[/]"
+        )
+
+
+class Dashboard(Static):
+    total = reactive(0)
+    success = reactive(0)
+    failed = reactive(0)
+    rate = reactive(0.0)
+    output_dir = reactive("")
+    proxies = reactive(0)
+    elapsed = reactive("00:00:00")
+
+    def render(self) -> str:
+        return (
+            f"📁 TOTAL: {self.total}    "
+            f"✅ WORKING: {self.success}    "
+            f"❌ INVALID: {self.failed}    "
+            f"🚀 RATE: {self.rate:.1f}/s    "
+            f"🌐 PROXIES: {self.proxies}    "
+            f"⏱ {self.elapsed}"
+        )
+
+
+class LogPanel(RichLog):
+    pass
+
+
+class ZeroCheckerApp(App):
+    CSS = """
+    Screen { background: #000000; color: #eeeeee; }
+
+    #zeroheader { height: 7; min-height: 7; width: 100%; background: #000000; color: #1DB954; content-align: center middle; padding: 0; }
+
+    #dashboard { height: auto; min-height: 3; width: 100%; margin: 0 1; padding: 0 1; border: round #1DB954; background: #0a150e; color: #ffffff; content-align: left middle; }
+
+    #main_area { height: 1fr; width: 100%; }
+
+    #left_column { width: 45%; min-width: 42; height: 1fr; layout: vertical; }
+
+    #setup_container { height: 1fr; width: 100%; margin: 0 1; border: round #1DB954; background: #0a150e; overflow-y: auto; }
+
+    #setup_panel { width: 100%; height: auto; padding: 0 1; background: #0a150e; }
+
+    #setup_panel > Label:first-child { height: 2; color: #1DB954; text-style: bold; content-align: left middle; }
+
+    #setup_panel Horizontal { width: 100%; height: 3; margin: 0; align: left middle; }
+
+    #setup_panel Horizontal > Label { width: 16; min-width: 16; color: #1DB954; text-style: bold; content-align: left middle; }
+
+    #setup_panel Button { width: 12; min-width: 12; height: 3; margin: 0 1 0 0; background: #1DB954; color: #000000; text-style: bold; }
+    #setup_panel Button:hover { background: #1ED760; color: #000000; }
+
+    #setup_panel Input { width: 12; height: 3; margin: 0 1 0 0; border: solid #1DB954; }
+    #setup_panel Input:focus { border: tall #1ED760; }
+
+    #setup_panel Checkbox { width: 16; min-width: 16; height: 3; margin: 0 1 0 0; }
+
+    #start_button_container { height: 4; min-height: 4; width: 100%; margin: 0 1; align: center middle; }
+    
+    #start_button_container Horizontal {
+        width: 100%;
+        height: 3;
+        align: center middle;
+    }
+
+    #btn_start { 
+        width: 1fr; 
+        height: 3; 
+        margin-right: 1;
+        background: #1DB954; 
+        color: #000000; 
+        text-style: bold; 
+        content-align: center middle; 
+    }
+    #btn_start:hover { background: #1ED760; }
+    #btn_start:disabled { background: #145A2A; color: #8FD9A6; }
+
+    #btn_stop { 
+        width: 1fr; 
+        height: 3; 
+        margin-left: 1;
+        background: #ff4444; 
+        color: #ffffff; 
+        text-style: bold; 
+        content-align: center middle; 
+    }
+    #btn_stop:hover { background: #ff6666; }
+    #btn_stop:disabled { background: #5a1414; color: #a68f8f; }
+
+    #log { height: 1fr; width: 55%; min-width: 42; margin: 0 1 0 0; padding: 0 1; border: round #1DB954; background: #050d08; scrollbar-size: 1 1; scrollbar-color: #1DB954 #0a150e; }
+
+    Footer { height: 1; background: #000000; color: #888888; }
+
+    .success { color: #1ED760; text-style: bold; }
+    .error { color: #ff4444; text-style: bold; }
+    .info { color: #1DB954; text-style: bold; }
+    .warning { color: #ffcc00; text-style: bold; }
+    .dim { color: #888888; }
+    """
+
+    def compose(self) -> ComposeResult:
+        yield ZeroHeader(id="zeroheader")
+        yield Dashboard(id="dashboard")
+
+        with Horizontal(id="main_area"):
+            with Vertical(id="left_column"):
+                with ScrollableContainer(id="setup_container"):
+                    with Container(id="setup_panel"):
+                        yield Label("⚙  SETUP", classes="info")
+
+                        with Horizontal():
+                            yield Label("Cookie Folder :")
+                            yield Button("SELECT", id="btn_cookie_folder", variant="default")
+                            yield Label("", id="lbl_cookie_folder", classes="dim")
+
+                        with Horizontal():
+                            yield Label("Output Folder :")
+                            yield Button("SELECT", id="btn_output_folder", variant="default")
+                            yield Label("", id="lbl_output_folder", classes="dim")
+
+                        with Horizontal():
+                            yield Label("Threads       :")
+                            yield Input(value="10", id="input_threads", type="integer")
+
+                        with Horizontal():
+                            yield Label("Proxy File    :")
+                            yield Button("SELECT", id="btn_proxy_file", variant="default")
+                            yield Label("", id="lbl_proxy_file", classes="dim")
+
+                        with Horizontal():
+                            yield Label("Use Proxies   :")
+                            yield Checkbox("Disabled", id="chk_use_proxy")
+                
+                with Container(id="start_button_container"):
+                    with Horizontal():
+                        yield Button("▶ START", id="btn_start", variant="success")
+                        yield Button("⏹ STOP", id="btn_stop", variant="error")
+
+            yield LogPanel(id="log", markup=True, wrap=True)
+
+        yield Footer()
+
+    def on_mount(self) -> None:
+        # Show license screen first
+        self.push_screen(LicenseScreen(), callback=self.on_license_complete)
+        
+        self.dashboard = self.query_one("#dashboard", Dashboard)
+        self.log_panel = self.query_one("#log", LogPanel)
+        self.btn_start = self.query_one("#btn_start", Button)
+        self.btn_stop = self.query_one("#btn_stop", Button)
+
+        self.lbl_cookie = self.query_one("#lbl_cookie_folder", Label)
+        self.lbl_output = self.query_one("#lbl_output_folder", Label)
+        self.lbl_proxy = self.query_one("#lbl_proxy_file", Label)
+        self.input_threads = self.query_one("#input_threads", Input)
+        self.chk_use_proxy = self.query_one("#chk_use_proxy", Checkbox)
+
+        self.cookie_folder = ""
+        self.output_base = ""
+        self.proxy_file = ""
+        self.proxy_list = []
+
+        self.total_files = 0
+        self.processed = 0
+        self.success_count = 0
+        self.fail_count = 0
+        self.start_time = None
+        self.running = False
+
+        self.btn_stop.disabled = True
+
+        self.log_panel.write("[dim]Welcome to ZeroChecker[/]")
+        self.log_panel.write("[dim]1. Select a cookie folder containing .txt cookie files.[/]")
+        self.log_panel.write("[dim]2. Select an output folder for results.[/]")
+        self.log_panel.write("[dim]3. (Optional) Select a proxy file and check the box to use proxies.[/]")
+        self.log_panel.write("[dim]4. Set threads and click '▶ START'. Use '⏹ STOP' or auto-429 protection to halt.[/]")
+        self.update_dashboard()
+
+    def on_license_complete(self, success: bool) -> None:
+        if success:
+            self.log_panel.write("[success]✅ License activated! Welcome.[/]")
+        else:
+            self.log_panel.write("[error]❌ License validation failed. Exiting.[/]")
+            self.exit()
+
+    def on_checkbox_changed(self, event: Checkbox.Changed) -> None:
+        if event.checkbox.id == "chk_use_proxy":
+            event.checkbox.label = "Enabled" if event.value else "Disabled"
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        button_id = event.button.id
+
+        try:
+            if button_id == "btn_cookie_folder":
+                folder = gui_select_folder("Select folder with .txt cookie files")
+                if folder:
+                    self.cookie_folder = folder
+                    self.lbl_cookie.update(f"📁 {os.path.basename(folder)}")
+                    self.log_panel.write(f"[info]Cookie folder set to: {folder}[/]")
+                else:
+                    self.log_panel.write("[dim]Folder selection cancelled.[/]")
+
+            elif button_id == "btn_output_folder":
+                folder = gui_select_folder("Select output base folder")
+                if folder:
+                    self.output_base = folder
+                    self.lbl_output.update(f"📁 {os.path.basename(folder)}")
+                    self.log_panel.write(f"[info]Output folder set to: {folder}[/]")
+                else:
+                    self.log_panel.write("[dim]Output folder selection cancelled.[/]")
+
+            elif button_id == "btn_proxy_file":
+                filepath = gui_select_file("Select proxy file")
+                if filepath:
+                    self.proxy_file = filepath
+                    self.lbl_proxy.update(f"📄 {os.path.basename(filepath)}")
+                    self.proxy_list = parse_proxy_file(filepath)
+                    self.log_panel.write(f"[info]Loaded {len(self.proxy_list)} proxies.[/]")
+                else:
+                    self.log_panel.write("[dim]File selection cancelled.[/]")
+
+            elif button_id == "btn_start":
+                self.start_checking()
+                
+            elif button_id == "btn_stop":
+                self.log_panel.write("[warning]⏹ Manual stop requested! Halting all threads...[/]")
+                self.running = False
+
+        except Exception as exc:
+            self.log_panel.write(f"[error]UI error: {exc}[/]")
+
+    def update_dashboard(self):
+        if self.start_time:
+            elapsed_seconds = int(time.time() - self.start_time)
+            hours = elapsed_seconds // 3600
+            minutes = (elapsed_seconds % 3600) // 60
+            seconds = elapsed_seconds % 60
+            elapsed_str = f"{hours:02d}:{minutes:02d}:{seconds:02d}"
+        else:
+            elapsed_str = "00:00:00"
+        rate = self.processed / (time.time() - self.start_time) if self.start_time and (time.time() - self.start_time) > 0 else 0.0
+        self.dashboard.total = self.total_files
+        self.dashboard.success = self.success_count
+        self.dashboard.failed = self.fail_count
+        self.dashboard.rate = rate
+        self.dashboard.output_dir = self.output_base
+        self.dashboard.proxies = len(self.proxy_list) if self.chk_use_proxy.value else 0
+        self.dashboard.elapsed = elapsed_str
+
+    def start_checking(self):
+        if not self.cookie_folder or not os.path.isdir(self.cookie_folder):
+            self.log_panel.write("[error]Please select a valid cookie folder.[/]")
+            return
+        if not self.output_base:
+            self.log_panel.write("[error]Please select an output folder.[/]")
+            return
+
+        try:
+            threads = int(self.input_threads.value)
+            if threads < 1:
+                raise ValueError
+        except Exception:
+            self.log_panel.write("[error]Please enter a valid number of threads.[/]")
+            return
+
+        use_proxy = self.chk_use_proxy.value
+        if use_proxy and not self.proxy_list:
+            self.log_panel.write("[warning]Proxy file selected but no proxies loaded. Continuing without proxies.[/]")
+            use_proxy = False
+
+        proxy_list = self.proxy_list if use_proxy else []
+
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        output_dir = os.path.join(self.output_base, timestamp)
+        os.makedirs(output_dir, exist_ok=True)
+        os.makedirs(os.path.join(output_dir, "not_working"), exist_ok=True)
+        self.output_base = output_dir
+
+        cookie_files = [f for f in os.listdir(self.cookie_folder) if f.endswith(".txt")]
+        self.total_files = len(cookie_files)
+        if self.total_files == 0:
+            self.log_panel.write("[error]No .txt files found in the cookie folder.[/]")
+            return
+
+        self.btn_start.disabled = True
+        self.btn_start.label = "⏳ RUNNING"
+        self.btn_stop.disabled = False
+        self.running = True
+        self.start_time = time.time()
+        self.processed = 0
+        self.success_count = 0
+        self.fail_count = 0
+        self.update_dashboard()
+
+        self.log_panel.write(f"[info]Starting with {threads} threads, {len(proxy_list)} proxies.[/]")
+        self.log_panel.write(f"[info]Output directory: {output_dir}[/]")
+
+        threading.Thread(target=self.run_checker, args=(cookie_files, threads, proxy_list), daemon=True).start()
+
+    def _finish_ui(self):
+        self.btn_start.disabled = False
+        self.btn_start.label = "▶ START"
+        self.btn_stop.disabled = True
+        self.log_panel.write("[info]✅ Process halted/completed.[/]")
+        self.update_dashboard()
+
+    def run_checker(self, cookie_files, threads, proxy_list):
+        with ThreadPoolExecutor(max_workers=threads) as executor:
+            futures = {}
+            for idx, fname in enumerate(cookie_files):
+                filepath = os.path.join(self.cookie_folder, fname)
+                proxy = proxy_list[idx % len(proxy_list)] if proxy_list else None
+                future = executor.submit(process_one_cookie, filepath, self.output_base, proxy)
+                futures[future] = fname
+
+            for future in as_completed(futures):
+                if not self.running:
+                    break
+                fname = futures[future]
+                try:
+                    ok, username, plan, err, content = future.result()
+                except Exception as e:
+                    ok, username, plan, err, content = False, None, None, f"Exception: {str(e)}", None
+
+                if err and "429" in err:
+                    self.call_from_thread(self.log_panel.write, f"[warning]⚠️ 429 Rate Limit detected on {fname}! Halting all threads immediately to protect your setup.[/]")
+                    self.running = False
+                
+                if ok:
+                    self.success_count += 1
+                    self.call_from_thread(self.log_panel.write, f"[success]✅ {fname} -> {username} ({plan})[/]")
+                    safe_plan = "".join(c for c in plan if c.isalnum() or c in " _-").strip()
+                    if not safe_plan: safe_plan = "UnknownPlan"
+                    plan_folder = os.path.join(self.output_base, "plans", safe_plan)
+                    os.makedirs(plan_folder, exist_ok=True)
+                    out_path = os.path.join(plan_folder, f"{plan}_{username}.txt")
+                    with open(out_path, "w", encoding="utf-8") as f: f.write(content)
+                else:
+                    self.fail_count += 1
+                    self.call_from_thread(self.log_panel.write, f"[error]❌ {fname} -> FAILED: {err}[/]")
+                    fail_file = os.path.join(self.output_base, "not_working", f"{fname}.txt")
+                    try:
+                        with open(os.path.join(self.cookie_folder, fname), 'r', encoding='utf-8') as orig:
+                            with open(fail_file, "w", encoding="utf-8") as ff: ff.write(orig.read())
+                    except Exception:
+                        with open(fail_file, "w", encoding="utf-8") as ff: ff.write(f"Original content unavailable.\nError: {err}")
+
+                self.processed += 1
+                self.call_from_thread(self.update_dashboard)
+                
+                if not self.running:
+                    break
+            
+            executor.shutdown(wait=False, cancel_futures=True)
+
+        self.running = False
+        self.call_from_thread(self._finish_ui)
+
+
+def main():
+    """Entry point for the zerocheck command."""
+    resize_terminal(rows=34, cols=110)
+    app = ZeroCheckerApp()
+    app.run()
+
+
+if __name__ == "__main__":
+    main()

zerocheck-1.0.0/zerocheck/auth.py

@@ -0,0 +1,162 @@
+"""Keygen.sh license validation with hardware fingerprinting"""
+
+import platform
+import uuid
+import hashlib
+import requests
+from .config import KEYGEN_ACCOUNT_ID, KEYGEN_ADMIN_TOKEN, KEYGEN_API_URL
+
+
+def get_hardware_fingerprint() -> str:
+    """Generate a unique hardware fingerprint from multiple system identifiers."""
+    identifiers = []
+    
+    # MAC Address
+    try:
+        mac = ':'.join(['{:02x}'.format((uuid.getnode() >> i) & 0xff) 
+                       for i in range(0, 2*6, 8)][::-1])
+        identifiers.append(f"MAC:{mac}")
+    except:
+        pass
+    
+    # Computer Name
+    identifiers.append(f"PC:{platform.node()}")
+    
+    # Processor
+    identifiers.append(f"CPU:{platform.processor()}")
+    
+    # Platform/OS
+    identifiers.append(f"OS:{platform.platform()}")
+    
+    # Combine and hash all identifiers
+    combined = '|'.join(identifiers)
+    fingerprint = hashlib.sha256(combined.encode()).hexdigest()
+    
+    return fingerprint
+
+
+def validate_license_key(license_key: str) -> tuple[bool, str]:
+    """Validate license key with hardware fingerprint using admin token."""
+    fingerprint = get_hardware_fingerprint()
+    
+    try:
+        # Validate the license key
+        response = requests.post(
+            f"{KEYGEN_API_URL}/accounts/{KEYGEN_ACCOUNT_ID}/licenses/actions/validate-key",
+            headers={
+                "Authorization": f"Bearer {KEYGEN_ADMIN_TOKEN}",
+                "Content-Type": "application/vnd.api+json",
+                "Accept": "application/vnd.api+json"
+            },
+            json={
+                "meta": {
+                    "key": license_key,
+                    "scope": {
+                        "fingerprint": fingerprint
+                    }
+                }
+            },
+            timeout=10
+        )
+        
+        data = response.json()
+        
+        # Check if valid
+        if data.get("meta", {}).get("valid", False):
+            return True, "License validated successfully"
+        else:
+            code = data.get("meta", {}).get("code", "INVALID")
+            
+            # Handle different validation codes
+            if code in ["NO_MACHINE", "NO_MACHINES", "FINGERPRINT_SCOPE_MISMATCH"]:
+                # First time using this key on this hardware - activate it
+                return activate_license(license_key, fingerprint)
+            elif code == "OVERDUE":
+                return False, "License is overdue"
+            elif code == "EXPIRED":
+                return False, "License has expired"
+            elif code == "SUSPENDED":
+                return False, "License is suspended"
+            elif code == "TOO_MANY_MACHINES":
+                return False, "License already in use on another device"
+            else:
+                return False, f"License validation failed: {code}"
+                
+    except requests.exceptions.Timeout:
+        return False, "Connection timeout. Check your internet."
+    except requests.exceptions.ConnectionError:
+        return False, "Cannot connect to license server"
+    except Exception as e:
+        return False, f"Validation error: {str(e)}"
+
+
+def activate_license(license_key: str, fingerprint: str) -> tuple[bool, str]:
+    """Activate license for this hardware (first-time use)."""
+    try:
+        # First, get the license ID using admin token
+        response = requests.get(
+            f"{KEYGEN_API_URL}/accounts/{KEYGEN_ACCOUNT_ID}/licenses",
+            headers={
+                "Authorization": f"Bearer {KEYGEN_ADMIN_TOKEN}",
+                "Accept": "application/vnd.api+json"
+            },
+            params={
+                "key": license_key
+            },
+            timeout=10
+        )
+        
+        if response.status_code != 200:
+            return False, "Invalid license key"
+        
+        data = response.json()
+        licenses = data.get("data", [])
+        
+        if not licenses:
+            return False, "License key not found"
+        
+        license_id = licenses[0]["id"]
+        
+        # Activate the license for this machine
+        response = requests.post(
+            f"{KEYGEN_API_URL}/accounts/{KEYGEN_ACCOUNT_ID}/machines",
+            headers={
+                "Authorization": f"Bearer {KEYGEN_ADMIN_TOKEN}",
+                "Content-Type": "application/vnd.api+json",
+                "Accept": "application/vnd.api+json"
+            },
+            json={
+                "data": {
+                    "type": "machines",
+                    "attributes": {
+                        "fingerprint": fingerprint,
+                        "name": platform.node()
+                    },
+                    "relationships": {
+                        "license": {
+                            "data": {
+                                "type": "licenses",
+                                "id": license_id
+                            }
+                        }
+                    }
+                }
+            },
+            timeout=10
+        )
+        
+        if response.status_code in [200, 201]:
+            return True, "License activated for this device"
+        elif response.status_code == 422:
+            error_data = response.json()
+            detail = error_data.get("errors", [{}])[0].get("detail", "Activation failed")
+            return False, f"Activation failed: {detail}"
+        else:
+            return False, f"Activation failed with status {response.status_code}"
+            
+    except requests.exceptions.Timeout:
+        return False, "Connection timeout during activation"
+    except requests.exceptions.ConnectionError:
+        return False, "Cannot connect to license server"
+    except Exception as e:
+        return False, f"Activation error: {str(e)}"

zerocheck-1.0.0/zerocheck/backend.py

@@ -0,0 +1,139 @@
+"""Spotify cookie checking backend"""
+
+import os
+import re
+import json
+import requests
+from bs4 import BeautifulSoup
+from urllib.parse import urlparse
+from .config import SPOTIFY_URL, USER_AGENT, TIMEOUT
+
+
+def parse_cookie_file(filepath):
+    """Bulletproof manual cookie parser. No strict header requirements."""
+    session = requests.Session()
+    session.headers.update({
+        "User-Agent": USER_AGENT,
+        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8",
+        "Accept-Language": "en-US,en;q=0.9",
+    })
+    adapter = requests.adapters.HTTPAdapter(pool_connections=100, pool_maxsize=100)
+    session.mount('https://', adapter)
+    session.mount('http://', adapter)
+    
+    try:
+        with open(filepath, 'r', encoding='utf-8') as f:
+            for line in f:
+                line = line.strip()
+                if not line or line.startswith('#'):
+                    continue
+                parts = line.split('\t')
+                if len(parts) >= 7:
+                    domain = parts[0]
+                    path = parts[2]
+                    secure_flag = parts[3].upper() == 'TRUE'
+                    name = parts[5]
+                    value = parts[6]
+                    session.cookies.set(name, value, domain=domain, path=path, secure=secure_flag)
+    except Exception:
+        return None
+        
+    if len(session.cookies) == 0:
+        return None
+        
+    return session
+
+
+def extract_info(html):
+    """Extract username and plan from Spotify account page."""
+    soup = BeautifulSoup(html, "html.parser")
+    username = None
+    constants = soup.find("div", id="constants")
+    if constants and constants.has_attr("data-username"):
+        username = constants["data-username"]
+    plan = "Unknown"
+    plan_elem = soup.find(attrs={"data-testid": "plan-name-title"})
+    if plan_elem:
+        plan = plan_elem.get_text(strip=True)
+    else:
+        next_data = soup.find("script", id="__NEXT_DATA__")
+        if next_data and next_data.string:
+            try:
+                data = json.loads(next_data.string)
+                widgets = data.get("props", {}).get("pageProps", {}).get("dynamicWidgets", {})
+                plan_cards = widgets.get("PlanCard", [])
+                for card in plan_cards:
+                    if "props" in card and "planName" in card["props"]:
+                        plan = card["props"]["planName"]
+                        break
+            except Exception:
+                pass
+    if not plan or plan == "":
+        match = re.search(r'"planName"\s*:\s*"([^"]+)"', html)
+        if match:
+            plan = match.group(1)
+    return username, plan
+
+
+def is_logged_in(html):
+    """Check if the HTML indicates a logged-in state."""
+    if re.search(r'data-anonymous\s*=\s*"false"', html): return True
+    if re.search(r'"loggedIn"\s*:\s*true', html): return True
+    if re.search(r'data-username\s*=\s*"[^"]+"', html): return True
+    if re.search(r'<title>Account Overview - Spotify</title>', html): return True
+    if re.search(r'<form[^>]*action="[^"]*login[^"]*"', html, re.IGNORECASE): return False
+    return False
+
+
+def process_one_cookie(filepath, output_base, proxy=None):
+    """Process a single cookie file and check if it's valid."""
+    filename = os.path.basename(filepath)
+    session = parse_cookie_file(filepath)
+    if session is None: 
+        return False, None, None, "Failed to parse cookies", None
+    if proxy: 
+        session.proxies = {"http": proxy, "https": proxy}
+    
+    try:
+        resp = session.get(SPOTIFY_URL, timeout=TIMEOUT, allow_redirects=True)
+        if resp.status_code == 429:
+            return False, None, None, "429 Too Many Requests (Rate Limited)", None
+        resp.raise_for_status()
+    except requests.exceptions.HTTPError as e:
+        if "429" in str(e):
+            return False, None, None, "429 Too Many Requests (Rate Limited)", None
+        return False, None, None, f"Request error: {str(e)}", None
+    except Exception as e: 
+        return False, None, None, f"Request error: {str(e)}", None
+        
+    html = resp.text
+    if not is_logged_in(html): 
+        return False, None, None, "Not logged in", None
+        
+    username, plan = extract_info(html)
+    if not username:
+        debug_dir = os.path.join(output_base, "debug")
+        os.makedirs(debug_dir, exist_ok=True)
+        with open(os.path.join(debug_dir, f"{filename}.html"), "w", encoding="utf-8") as f: 
+            f.write(html)
+        return False, None, None, "Could not extract username", None
+        
+    with open(filepath, 'r', encoding='utf-8') as f: 
+        original_content = f.read()
+    return True, username, plan, None, original_content
+
+
+def parse_proxy_file(filepath):
+    """Parse proxy file and return list of proxies."""
+    proxies = []
+    with open(filepath, 'r', encoding='utf-8') as f:
+        for line in f:
+            line = line.strip()
+            if not line or line.startswith('#'): continue
+            if '://' not in line: line = 'http://' + line
+            try:
+                parsed = urlparse(line)
+                if parsed.scheme not in ('http', 'https', 'socks5'): line = 'http://' + line
+                proxies.append(line)
+            except Exception: continue
+    return proxies

zerocheck-1.0.0/zerocheck/config.py

@@ -0,0 +1,11 @@
+"""Configuration constants for ZeroChecker"""
+
+# Keygen.sh Configuration
+KEYGEN_ACCOUNT_ID = "ea5034cf-1ed4-4d54-b08c-1d406dea1d99"  # ← Replace with your Keygen Account ID
+KEYGEN_ADMIN_TOKEN = "admin-124b528ab6edf7c3342da4d64bbd18cf850875483e8f95b13a5df9367b4610e9v3"  # ← Replace with your admin token
+KEYGEN_API_URL = "https://api.keygen.sh/v1"
+
+# Spotify Checker Configuration
+SPOTIFY_URL = "https://www.spotify.com/in-en/account/overview/?utm_source=spotify&utm_medium=menu&utm_campaign=your_account"
+USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+TIMEOUT = 10

zerocheck-1.0.0/zerocheck.egg-info/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.4
+Name: zerocheck
+Version: 1.0.0
+Summary: Blazing fast Spotify Cookie Checker with hardware-locked licensing
+Author-email: Zyco <zyco@zyco1.com>
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: textual>=0.40.0
+Requires-Dist: requests>=2.28.0
+Requires-Dist: beautifulsoup4>=4.11.0
+
+# ZeroChecker 🎧
+
+Blazing fast Spotify Cookie Checker with a sleek terminal UI and hardware-locked licensing.
+
+## Installation
+
+```bash
+pip install zerocheck

zerocheck-1.0.0/zerocheck.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+zerocheck/__init__.py
+zerocheck/__main__.py
+zerocheck/app.py
+zerocheck/auth.py
+zerocheck/backend.py
+zerocheck/config.py
+zerocheck.egg-info/PKG-INFO
+zerocheck.egg-info/SOURCES.txt
+zerocheck.egg-info/dependency_links.txt
+zerocheck.egg-info/entry_points.txt
+zerocheck.egg-info/requires.txt
+zerocheck.egg-info/top_level.txt

zerocheck-1.0.0/zerocheck.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

zerocheck-1.0.0/zerocheck.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+zerocheck = zerocheck.app:main

zerocheck-1.0.0/zerocheck.egg-info/requires.txt

@@ -0,0 +1,3 @@
+textual>=0.40.0
+requests>=2.28.0
+beautifulsoup4>=4.11.0

zerocheck-1.0.0/zerocheck.egg-info/top_level.txt

@@ -0,0 +1 @@
+zerocheck