phantomapi 1.0.1__tar.gz → 1.1.10__tar.gz

{phantomapi-1.0.1 → phantomapi-1.1.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: phantomapi
-Version: 1.0.1
+Version: 1.1.10
 Summary: Phone number OSINT library for Indonesia
 Author: TheZ4th
 Author-email: zethkaretjir@gmail.com

phantomapi-1.1.10/PhantomAPI/__init__.py

@@ -0,0 +1,17 @@
+from .core import PhoneOSINT
+from .provider import PROVIDERS
+from .database import AlcyoneusDB
+from .hunter import UsernameHunter
+from .validator import AntiFalsePositiveValidator
+from .exporter import DataExporter
+
+__all__ = [
+    'PhoneOSINT',
+    'PROVIDERS',
+    'AlcyoneusDB',
+    'UsernameHunter',
+    'AntiFalsePositiveValidator',
+    'DataExporter'
+]
+__version__ = "1.1.10"
+__author__ = "TheZ4th"

phantomapi-1.1.10/PhantomAPI/database.py

@@ -0,0 +1,259 @@
+# database.py
+"""
+The Alcyoneus DB Core Engine
+Load, save, query, and manage the OSINT database
+"""
+
+import json
+import os
+import threading
+from datetime import datetime
+from typing import Dict, List, Any, Optional, Union
+from collections import defaultdict
+import hashlib
+
+class AlcyoneusDB:
+    """Core database engine for The Alcyoneus DB"""
+    
+    def __init__(self, data_dir: str = None):
+        self.data_dir = data_dir or os.path.dirname(os.path.abspath(__file__))
+        self.platforms_file = os.path.join(self.data_dir, 'platforms.json')
+        self.results_file = os.path.join(self.data_dir, 'results.json')
+        self.lock = threading.Lock()
+        
+        # In-memory cache
+        self._platforms_cache = None
+        self._results_cache = None
+        self._stats = {
+            'total_queries': 0,
+            'total_finds': 0,
+            'last_update': None,
+            'db_size': 0
+        }
+        
+        # Initialize database
+        self._init_database()
+    
+    def _init_database(self):
+        """Initialize database files if not exist"""
+        if not os.path.exists(self.platforms_file):
+            self._create_default_platforms()
+        
+        if not os.path.exists(self.results_file):
+            with open(self.results_file, 'w') as f:
+                json.dump([], f, indent=2)
+    
+    def _create_default_platforms(self):
+        """Create default platforms database"""
+        default_platforms = {
+            "metadata": {
+                "version": "1.0.0",
+                "name": "The Alcyoneus DB",
+                "description": "Exceeding the average reasonable limits of databases",
+                "total_platforms": 0,
+                "last_updated": datetime.now().isoformat(),
+                "categories": 20,
+                "regions": 7
+            },
+            "platforms": []
+        }
+        
+        with open(self.platforms_file, 'w') as f:
+            json.dump(default_platforms, f, indent=2)
+    
+    def load_platforms(self) -> Dict:
+        """Load platforms database"""
+        if self._platforms_cache is None:
+            with self.lock:
+                with open(self.platforms_file, 'r') as f:
+                    self._platforms_cache = json.load(f)
+                    self._stats['db_size'] = os.path.getsize(self.platforms_file)
+        return self._platforms_cache
+    
+    def save_platforms(self, data: Dict):
+        """Save platforms database"""
+        with self.lock:
+            data['metadata']['last_updated'] = datetime.now().isoformat()
+            data['metadata']['total_platforms'] = len(data.get('platforms', []))
+            with open(self.platforms_file, 'w') as f:
+                json.dump(data, f, indent=2)
+            self._platforms_cache = data
+    
+    def add_platform(self, platform_data: Dict):
+        """Add a new platform to database"""
+        platforms_data = self.load_platforms()
+        
+        # Check if platform already exists
+        existing = [p for p in platforms_data['platforms'] if p.get('name') == platform_data.get('name')]
+        if existing:
+            return False
+        
+        # Add required fields if missing
+        required_fields = ['name', 'url_pattern', 'category', 'region', 'priority']
+        for field in required_fields:
+            if field not in platform_data:
+                platform_data[field] = 'unknown'
+        
+        # Add metadata
+        platform_data['added_at'] = datetime.now().isoformat()
+        platform_data['verified'] = False
+        platform_data['confidence'] = 50
+        
+        platforms_data['platforms'].append(platform_data)
+        self.save_platforms(platforms_data)
+        return True
+    
+    def search_platforms(self, query: str, field: str = 'name') -> List:
+        """Search platforms by field"""
+        platforms_data = self.load_platforms()
+        query_lower = query.lower()
+        
+        results = []
+        for platform in platforms_data['platforms']:
+            value = platform.get(field, '')
+            if query_lower in value.lower():
+                results.append(platform)
+        
+        return results
+    
+    def get_platforms_by_category(self, category: str) -> List:
+        """Get all platforms in a category"""
+        platforms_data = self.load_platforms()
+        return [p for p in platforms_data['platforms'] if p.get('category') == category]
+    
+    def get_platforms_by_region(self, region: str) -> List:
+        """Get all platforms in a region"""
+        platforms_data = self.load_platforms()
+        return [p for p in platforms_data['platforms'] if p.get('region') == region]
+    
+    def save_results(self, query: str, results: List[Dict], query_type: str = 'username'):
+        """Save search results to database"""
+        with self.lock:
+            # Load existing results
+            if os.path.exists(self.results_file):
+                with open(self.results_file, 'r') as f:
+                    all_results = json.load(f)
+            else:
+                all_results = []
+            
+            # Create result entry
+            result_entry = {
+                'query': query,
+                'query_type': query_type,
+                'timestamp': datetime.now().isoformat(),
+                'total_found': len(results),
+                'results': results,
+                'query_hash': hashlib.md5(f"{query}:{query_type}".encode()).hexdigest()
+            }
+            
+            # Check if query already exists
+            existing_idx = None
+            for idx, r in enumerate(all_results):
+                if r.get('query_hash') == result_entry['query_hash']:
+                    existing_idx = idx
+                    break
+            
+            if existing_idx is not None:
+                all_results[existing_idx] = result_entry
+            else:
+                all_results.append(result_entry)
+            
+            # Save
+            with open(self.results_file, 'w') as f:
+                json.dump(all_results, f, indent=2)
+            
+            # Update stats
+            self._stats['total_queries'] += 1
+            self._stats['total_finds'] += len(results)
+    
+    def get_query_history(self, limit: int = 100) -> List:
+        """Get query history"""
+        if not os.path.exists(self.results_file):
+            return []
+        
+        with open(self.results_file, 'r') as f:
+            results = json.load(f)
+        
+        # Sort by timestamp descending
+        results.sort(key=lambda x: x.get('timestamp', ''), reverse=True)
+        return results[:limit]
+    
+    def get_query_result(self, query: str, query_type: str = 'username') -> Optional[Dict]:
+        """Get specific query result"""
+        query_hash = hashlib.md5(f"{query}:{query_type}".encode()).hexdigest()
+        
+        if not os.path.exists(self.results_file):
+            return None
+        
+        with open(self.results_file, 'r') as f:
+            results = json.load(f)
+        
+        for result in results:
+            if result.get('query_hash') == query_hash:
+                return result
+        
+        return None
+    
+    def delete_query_result(self, query: str, query_type: str = 'username') -> bool:
+        """Delete specific query result"""
+        query_hash = hashlib.md5(f"{query}:{query_type}".encode()).hexdigest()
+        
+        if not os.path.exists(self.results_file):
+            return False
+        
+        with open(self.results_file, 'r') as f:
+            results = json.load(f)
+        
+        new_results = [r for r in results if r.get('query_hash') != query_hash]
+        
+        if len(new_results) == len(results):
+            return False
+        
+        with open(self.results_file, 'w') as f:
+            json.dump(new_results, f, indent=2)
+        
+        return True
+    
+    def get_stats(self) -> Dict:
+        """Get database statistics"""
+        platforms_data = self.load_platforms()
+        
+        # Count by category
+        category_counts = defaultdict(int)
+        for platform in platforms_data.get('platforms', []):
+            category = platform.get('category', 'unknown')
+            category_counts[category] += 1
+        
+        # Count by region
+        region_counts = defaultdict(int)
+        for platform in platforms_data.get('platforms', []):
+            region = platform.get('region', 'global')
+            region_counts[region] += 1
+        
+        return {
+            'total_platforms': len(platforms_data.get('platforms', [])),
+            'categories': dict(category_counts),
+            'regions': dict(region_counts),
+            'total_queries': self._stats['total_queries'],
+            'total_finds': self._stats['total_finds'],
+            'db_version': platforms_data.get('metadata', {}).get('version', '1.0.0'),
+            'last_updated': platforms_data.get('metadata', {}).get('last_updated'),
+            'db_size_bytes': self._stats['db_size']
+        }
+    
+    def export_platforms_json(self, filename: str = 'alcy_export.json'):
+        """Export platforms to JSON file"""
+        platforms_data = self.load_platforms()
+        with open(filename, 'w') as f:
+            json.dump(platforms_data, f, indent=2)
+        return filename
+    
+    def import_platforms_json(self, filename: str):
+        """Import platforms from JSON file"""
+        with open(filename, 'r') as f:
+            data = json.load(f)
+        
+        if 'platforms' in data:
+            self.save_platforms(data)
+            return True
+        return False

phantomapi-1.1.10/PhantomAPI/exporter.py

@@ -0,0 +1,329 @@
+# exporter.py
+"""
+The Alcyoneus DB - Data Exporter
+Export results to JSON, CSV, HTML, PDF formats
+"""
+
+import json
+import csv
+from datetime import datetime
+from typing import List, Dict, Any, Optional
+
+class DataExporter:
+    """Export OSINT results to various formats"""
+    
+    def __init__(self):
+        self.export_dir = 'exports'
+        self._ensure_export_dir()
+    
+    def _ensure_export_dir(self):
+        """Create export directory if not exists"""
+        import os
+        if not os.path.exists(self.export_dir):
+            os.makedirs(self.export_dir)
+    
+    def export_json(self, data: Dict, filename: str = None) -> str:
+        """Export to JSON format"""
+        if not filename:
+            filename = f"alcy_export_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+        
+        filepath = f"{self.export_dir}/{filename}"
+        with open(filepath, 'w', encoding='utf-8') as f:
+            json.dump(data, f, indent=2, ensure_ascii=False)
+        
+        return filepath
+    
+    def export_csv(self, results: List[Dict], filename: str = None) -> str:
+        """Export results to CSV format"""
+        if not filename:
+            filename = f"alcy_export_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv"
+        
+        if not results:
+            return None
+        
+        # Get all unique keys
+        fieldnames = set()
+        for result in results:
+            fieldnames.update(result.keys())
+        fieldnames = sorted(list(fieldnames))
+        
+        filepath = f"{self.export_dir}/{filename}"
+        with open(filepath, 'w', newline='', encoding='utf-8') as f:
+            writer = csv.DictWriter(f, fieldnames=fieldnames)
+            writer.writeheader()
+            for result in results:
+                # Flatten nested dicts
+                flat_result = {}
+                for key, value in result.items():
+                    if isinstance(value, dict):
+                        for sub_key, sub_value in value.items():
+                            flat_result[f"{key}_{sub_key}"] = sub_value
+                    else:
+                        flat_result[key] = value
+                writer.writerow(flat_result)
+        
+        return filepath
+    
+    def export_html(self, results: List[Dict], query: str = None, filename: str = None) -> str:
+        """Export results to HTML report"""
+        if not filename:
+            filename = f"alcy_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.html"
+        
+        html_template = f"""
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Alcyoneus DB - OSINT Report</title>
+    <style>
+        * {{ margin: 0; padding: 0; box-sizing: border-box; }}
+        body {{
+            font-family: 'Courier New', monospace;
+            background: linear-gradient(135deg, #0a0a0a 0%, #1a1a2e 100%);
+            color: #00ff9d;
+            padding: 20px;
+        }}
+        .container {{ max-width: 1200px; margin: 0 auto; }}
+        .header {{
+            text-align: center;
+            padding: 40px;
+            border: 2px solid #00ff9d;
+            border-radius: 10px;
+            margin-bottom: 30px;
+            background: rgba(0, 255, 157, 0.1);
+        }}
+        .header h1 {{
+            font-size: 48px;
+            text-shadow: 0 0 10px #00ff9d;
+        }}
+        .stats {{
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+            gap: 20px;
+            margin-bottom: 30px;
+        }}
+        .stat-card {{
+            background: rgba(0, 0, 0, 0.8);
+            border: 1px solid #00ff9d;
+            border-radius: 10px;
+            padding: 20px;
+            text-align: center;
+        }}
+        .stat-card h3 {{ color: #ff6b6b; margin-bottom: 10px; }}
+        .stat-card .number {{ font-size: 36px; font-weight: bold; }}
+        table {{
+            width: 100%;
+            border-collapse: collapse;
+            background: rgba(0, 0, 0, 0.8);
+            border-radius: 10px;
+            overflow: hidden;
+        }}
+        th, td {{
+            padding: 12px;
+            text-align: left;
+            border-bottom: 1px solid rgba(0, 255, 157, 0.3);
+        }}
+        th {{
+            background: #00ff9d;
+            color: #0a0a0a;
+            font-weight: bold;
+        }}
+        tr:hover {{ background: rgba(0, 255, 157, 0.1); }}
+        .high { color: #00ff9d; }
+        .medium {{ color: #ffd93d; }}
+        .low {{ color: #ff6b6b; }}
+        .footer {{
+            text-align: center;
+            padding: 20px;
+            margin-top: 30px;
+            color: rgba(0, 255, 157, 0.5);
+        }}
+    </style>
+</head>
+<body>
+    <div class="container">
+        <div class="header">
+            <h1>🔥 THE ALCYONEUS DB 🔥</h1>
+            <p>Exceeding the average reasonable limits of OSINT databases</p>
+            {f"<p><strong>Query:</strong> {query}</p>" if query else ""}
+            <p><strong>Generated:</strong> {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}</p>
+        </div>
+        
+        <div class="stats">
+            <div class="stat-card">
+                <h3>Total Results</h3>
+                <div class="number">{len(results)}</div>
+            </div>
+            <div class="stat-card">
+                <h3>High Confidence</h3>
+                <div class="number high">{sum(1 for r in results if r.get('confidence', 0) >= 80)}</div>
+            </div>
+            <div class="stat-card">
+                <h3>Medium Confidence</h3>
+                <div class="number medium">{sum(1 for r in results if 50 <= r.get('confidence', 0) < 80)}</div>
+            </div>
+            <div class="stat-card">
+                <h3>Categories</h3>
+                <div class="number">{len(set(r.get('category', 'unknown') for r in results))}</div>
+            </div>
+        </div>
+        
+        <h2>📊 Detailed Results</h2>
+        <table>
+            <thead>
+                <tr>
+                    <th>#</th>
+                    <th>Platform</th>
+                    <th>Category</th>
+                    <th>URL</th>
+                    <th>Confidence</th>
+                    <th>Status</th>
+                </tr>
+            </thead>
+            <tbody>
+                {self._generate_table_rows(results)}
+            </tbody>
+        </table>
+        
+        <div class="footer">
+            <p>The Alcyoneus DB - Power beyond limits | #ZK-Phantom</p>
+        </div>
+    </div>
+</body>
+</html>
+        """
+        
+        filepath = f"{self.export_dir}/{filename}"
+        with open(filepath, 'w', encoding='utf-8') as f:
+            f.write(html_template)
+        
+        return filepath
+    
+    def _generate_table_rows(self, results: List[Dict]) -> str:
+        """Generate HTML table rows"""
+        rows = []
+        for i, result in enumerate(results[:100], 1):
+            confidence = result.get('confidence', 0)
+            if confidence >= 80:
+                conf_class = 'high'
+            elif confidence >= 50:
+                conf_class = 'medium'
+            else:
+                conf_class = 'low'
+            
+            url = result.get('url', '#')
+            platform = result.get('platform', 'Unknown')
+            category = result.get('category', 'Unknown')
+            status = result.get('status_code', 0)
+            
+            rows.append(f"""
+                <tr>
+                    <td>{i}</td>
+                    <td>{platform}</td>
+                    <td>{category}</td>
+                    <td><a href="{url}" target="_blank">{url[:50]}...</a></td>
+                    <td class="{conf_class}">{confidence}%</td>
+                    <td>{status}</td>
+                </tr>
+            """)
+        
+        return "\n".join(rows)
+    
+    def export_pdf(self, results: List[Dict], filename: str = None) -> Optional[str]:
+        """Export to PDF (requires reportlab)"""
+        try:
+            from reportlab.lib import colors
+            from reportlab.lib.pagesizes import letter, landscape
+            from reportlab.platypus import SimpleDocTemplate, Table, TableStyle, Paragraph, Spacer
+            from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+            from reportlab.lib.units import inch
+            
+            if not filename:
+                filename = f"alcy_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.pdf"
+            
+            filepath = f"{self.export_dir}/{filename}"
+            doc = SimpleDocTemplate(filepath, pagesize=landscape(letter))
+            styles = getSampleStyleSheet()
+            story = []
+            
+            # Title
+            title_style = ParagraphStyle('CustomTitle', parent=styles['Heading1'], fontSize=24, textColor=colors.green)
+            story.append(Paragraph("The Alcyoneus DB - OSINT Report", title_style))
+            story.append(Spacer(1, 0.25*inch))
+            story.append(Paragraph(f"Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}", styles['Normal']))
+            story.append(Spacer(1, 0.25*inch))
+            
+            # Table data
+            table_data = [['Platform', 'Category', 'URL', 'Confidence', 'Status']]
+            for result in results[:50]:
+                table_data.append([
+                    result.get('platform', ''),
+                    result.get('category', ''),
+                    result.get('url', ''),
+                    f"{result.get('confidence', 0)}%",
+                    str(result.get('status_code', 0))
+                ])
+            
+            # Create table
+            table = Table(table_data, repeatRows=1)
+            table.setStyle(TableStyle([
+                ('BACKGROUND', (0, 0), (-1, 0), colors.green),
+                ('TEXTCOLOR', (0, 0), (-1, 0), colors.black),
+                ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
+                ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
+                ('FONTSIZE', (0, 0), (-1, 0), 10),
+                ('BOTTOMPADDING', (0, 0), (-1, 0), 12),
+                ('BACKGROUND', (0, 1), (-1, -1), colors.beige),
+                ('GRID', (0, 0), (-1, -1), 1, colors.black),
+                ('FONTSIZE', (0, 1), (-1, -1), 8),
+            ]))
+            
+            story.append(table)
+            doc.build(story)
+            
+            return filepath
+        
+        except ImportError:
+            print(f"{Y}[!] ReportLab not installed. PDF export requires: pip install reportlab{RESET}")
+            return None
+    
+    def export_markdown(self, results: List[Dict], query: str = None, filename: str = None) -> str:
+        """Export to Markdown format"""
+        if not filename:
+            filename = f"alcy_report_{datetime.now().strftime('%Y%m%d_%H%M%S')}.md"
+        
+        content = []
+        content.append(f"# 🔥 The Alcyoneus DB - OSINT Report\n")
+        content.append(f"**Generated:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+        if query:
+            content.append(f"**Query:** `{query}`")
+        
+        content.append(f"\n## 📊 Statistics")
+        content.append(f"- **Total Results:** {len(results)}")
+        content.append(f"- **High Confidence (80%+):** {sum(1 for r in results if r.get('confidence', 0) >= 80)}")
+        content.append(f"- **Medium Confidence (50-79%):** {sum(1 for r in results if 50 <= r.get('confidence', 0) < 80)}")
+        content.append(f"- **Low Confidence (<50%):** {sum(1 for r in results if r.get('confidence', 0) < 50)}")
+        
+        content.append(f"\n## 📍 Detailed Results\n")
+        content.append("| # | Platform | Category | URL | Confidence |")
+        content.append("|---|----------|----------|-----|------------|")
+        
+        for i, result in enumerate(results[:50], 1):
+            platform = result.get('platform', 'N/A')
+            category = result.get('category', 'N/A')
+            url = result.get('url', '#')
+            confidence = result.get('confidence', 0)
+            content.append(f"| {i} | {platform} | {category} | {url} | {confidence}% |")
+        
+        if len(results) > 50:
+            content.append(f"\n*... and {len(results) - 50} more results*")
+        
+        content.append(f"\n---")
+        content.append(f"*The Alcyoneus DB - Power beyond limits | #ZK-Phantom*")
+        
+        filepath = f"{self.export_dir}/{filename}"
+        with open(filepath, 'w', encoding='utf-8') as f:
+            f.write("\n".join(content))
+        
+        return filepath

phantomapi-1.1.10/PhantomAPI/hunter.py

@@ -0,0 +1,278 @@
+# hunter.py
+"""
+The Alcyoneus DB - Username Hunter
+Scans 500+ platforms for username existence with validation
+"""
+
+import requests
+import threading
+import time
+import json
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from typing import List, Dict, Any, Optional, Callable
+from urllib.parse import urlparse
+import random
+
+from .database import AlcyoneusDB
+from .validator import AntiFalsePositiveValidator
+from .utils import get_user_agent, retry_request
+
+class UsernameHunter:
+    """Advanced username hunter with multi-threading and validation"""
+    
+    def __init__(self, db: AlcyoneusDB = None, validation_level: str = 'strict', 
+                 max_threads: int = 30, timeout: int = 10):
+        self.db = db or AlcyoneusDB()
+        self.validator = AntiFalsePositiveValidator(validation_level=validation_level)
+        self.max_threads = max_threads
+        self.timeout = timeout
+        self.session = requests.Session()
+        self.results = []
+        self.total_platforms = 0
+        self.scanned = 0
+        self.found = 0
+        
+        # Load platforms
+        self.platforms = self._load_platforms()
+        
+    def _load_platforms(self) -> List[Dict]:
+        """Load platforms from database"""
+        platforms_data = self.db.load_platforms()
+        return platforms_data.get('platforms', [])
+    
+    def _check_platform(self, username: str, platform: Dict) -> Optional[Dict]:
+        """Check a single platform for username existence"""
+        url_pattern = platform.get('url_pattern', '')
+        if not url_pattern:
+            return None
+        
+        url = url_pattern.format(username=username)
+        method = platform.get('method', 'GET').upper()
+        expected_status = platform.get('expected_status', [200])
+        headers = {'User-Agent': get_user_agent()}
+        
+        start_time = time.time()
+        
+        try:
+            if method == 'GET':
+                response = self.session.get(url, headers=headers, timeout=self.timeout, allow_redirects=True)
+            elif method == 'HEAD':
+                response = self.session.head(url, headers=headers, timeout=self.timeout)
+            else:
+                return None
+            
+            response_time = time.time() - start_time
+            
+            # Determine if username exists
+            exists = response.status_code in expected_status
+            
+            # Additional check for custom patterns
+            if platform.get('exists_pattern'):
+                import re
+                if re.search(platform['exists_pattern'], response.text, re.IGNORECASE):
+                    exists = True
+                elif re.search(platform.get('not_exists_pattern', ''), response.text, re.IGNORECASE):
+                    exists = False
+            
+            result = {
+                'platform': platform.get('name', 'Unknown'),
+                'category': platform.get('category', 'unknown'),
+                'region': platform.get('region', 'global'),
+                'url': url,
+                'status_code': response.status_code,
+                'exists': exists,
+                'response_time': response_time,
+                'response_text': response.text[:500] if exists else '',
+                'timestamp': time.time()
+            }
+            
+            # Validate result
+            if exists:
+                validation = self.validator.validate_username_result(result)
+                result['validation'] = validation
+                result['exists'] = validation.get('valid', False)
+                result['confidence'] = validation.get('confidence', 0)
+            
+            return result
+            
+        except Exception as e:
+            return {
+                'platform': platform.get('name', 'Unknown'),
+                'category': platform.get('category', 'unknown'),
+                'url': url,
+                'exists': False,
+                'error': str(e),
+                'timestamp': time.time()
+            }
+    
+    def hunt(self, username: str, categories: List[str] = None, 
+             regions: List[str] = None, platform_filter: List[str] = None,
+             min_confidence: int = 60, callback: Callable = None) -> List[Dict]:
+        """
+        Hunt username across all platforms
+        
+        Args:
+            username: Username to search
+            categories: Filter by categories (e.g., ['social_media', 'coding'])
+            regions: Filter by regions (e.g., ['global', 'asia_pacific'])
+            platform_filter: Specific platforms to check
+            min_confidence: Minimum confidence for results
+            callback: Progress callback function
+        
+        Returns:
+            List of results
+        """
+        print(f"\n{C}{BOLD}🎯 Hunting username: {username}{RESET}")
+        
+        # Filter platforms
+        platforms_to_check = self.platforms
+        
+        if categories:
+            platforms_to_check = [p for p in platforms_to_check if p.get('category') in categories]
+        
+        if regions:
+            platforms_to_check = [p for p in platforms_to_check if p.get('region') in regions]
+        
+        if platform_filter:
+            platforms_to_check = [p for p in platforms_to_check if p.get('name') in platform_filter]
+        
+        # Sort by priority
+        platforms_to_check.sort(key=lambda x: x.get('priority', 5))
+        
+        self.total_platforms = len(platforms_to_check)
+        self.scanned = 0
+        self.found = 0
+        self.results = []
+        
+        print(f"{C}[*] Checking {self.total_platforms} platforms...{RESET}")
+        
+        # Multithreaded scanning
+        with ThreadPoolExecutor(max_workers=self.max_threads) as executor:
+            futures = {
+                executor.submit(self._check_platform, username, platform): platform 
+                for platform in platforms_to_check
+            }
+            
+            for future in as_completed(futures):
+                self.scanned += 1
+                result = future.result()
+                
+                if result and result.get('exists'):
+                    if result.get('confidence', 0) >= min_confidence:
+                        self.found += 1
+                        self.results.append(result)
+                        
+                        # Print found result
+                        confidence_color = G if result.get('confidence', 0) >= 80 else Y
+                        print(f"{confidence_color}[+] FOUND: {result['platform']} -> {result['url']} (conf: {result.get('confidence', 0)}%){RESET}")
+                
+                # Progress callback
+                if callback:
+                    callback({
+                        'scanned': self.scanned,
+                        'total': self.total_platforms,
+                        'found': self.found,
+                        'current': result
+                    })
+                
+                # Progress display
+                if self.scanned % 10 == 0:
+                    print(f"\r{C}[Progress] {self.scanned}/{self.total_platforms} | Found: {self.found}{RESET}", end='')
+        
+        print(f"\n\n{G}{BOLD}✅ Hunt completed!{RESET}")
+        print(f"{C}[*] Total platforms checked: {self.scanned}{RESET}")
+        print(f"{G}[*] Username found on: {self.found} platforms{RESET}")
+        
+        # Filter by confidence and sort
+        self.results = [r for r in self.results if r.get('confidence', 0) >= min_confidence]
+        self.results.sort(key=lambda x: x.get('confidence', 0), reverse=True)
+        
+        # Save to database
+        if self.results:
+            self.db.save_results(username, self.results, 'username')
+        
+        return self.results
+    
+    def hunt_batch(self, usernames: List[str], **kwargs) -> Dict[str, List[Dict]]:
+        """Hunt multiple usernames in batch"""
+        results = {}
+        
+        for username in usernames:
+            print(f"\n{Y}{'='*60}{RESET}")
+            results[username] = self.hunt(username, **kwargs)
+        
+        return results
+    
+    def get_platforms_summary(self) -> Dict:
+        """Get platforms summary statistics"""
+        platforms_data = self.db.load_platforms()
+        platforms = platforms_data.get('platforms', [])
+        
+        summary = {
+            'total': len(platforms),
+            'by_category': {},
+            'by_region': {},
+            'by_priority': {}
+        }
+        
+        for platform in platforms:
+            category = platform.get('category', 'unknown')
+            summary['by_category'][category] = summary['by_category'].get(category, 0) + 1
+            
+            region = platform.get('region', 'global')
+            summary['by_region'][region] = summary['by_region'].get(region, 0) + 1
+            
+            priority = platform.get('priority', 5)
+            summary['by_priority'][priority] = summary['by_priority'].get(priority, 0) + 1
+        
+        return summary
+    
+    def export_results(self, filename: str = 'hunt_results.json', format: str = 'json'):
+        """Export hunt results to file"""
+        if format == 'json':
+            with open(filename, 'w') as f:
+                json.dump({
+                    'timestamp': time.time(),
+                    'total_found': len(self.results),
+                    'results': self.results
+                }, f, indent=2)
+            print(f"{G}[+] Results saved to {filename}{RESET}")
+        
+        elif format == 'csv':
+            import csv
+            with open(filename, 'w', newline='', encoding='utf-8') as f:
+                writer = csv.writer(f)
+                writer.writerow(['Platform', 'Category', 'URL', 'Confidence', 'Status'])
+                for r in self.results:
+                    writer.writerow([
+                        r.get('platform', ''),
+                        r.get('category', ''),
+                        r.get('url', ''),
+                        r.get('confidence', 0),
+                        r.get('status_code', 0)
+                    ])
+            print(f"{G}[+] Results saved to {filename}{RESET}")
+    
+    def generate_report(self) -> str:
+        """Generate human-readable report"""
+        report = []
+        report.append("\n" + "="*60)
+        report.append(f"{BOLD}THE ALCYONEUS DB - HUNT REPORT{RESET}")
+        report.append("="*60)
+        report.append(f"\n📊 Statistics:")
+        report.append(f"   Total platforms checked: {self.scanned}")
+        report.append(f"   Username found on: {self.found} platforms")
+        report.append(f"   Filter rate: {self.validator.generate_validation_report(self.results).get('filter_rate', 0)}%")
+        
+        if self.results:
+            report.append(f"\n📍 FOUND ON:")
+            for i, r in enumerate(self.results[:20], 1):
+                conf_color = G if r.get('confidence', 0) >= 80 else Y
+                report.append(f"   {i}. {r['platform']} -> {r['url']} {conf_color}({r.get('confidence', 0)}%){RESET}")
+            
+            if len(self.results) > 20:
+                report.append(f"   ... and {len(self.results) - 20} more")
+        
+        report.append("\n" + "="*60)
+        
+        return "\n".join(report)

phantomapi-1.1.10/PhantomAPI/validator.py

@@ -0,0 +1,318 @@
+# validator.py
+"""
+The Alcyoneus DB - Anti-False-Positive Validator
+Validates OSINT results to ensure accuracy and reduce noise
+"""
+
+import re
+import json
+from datetime import datetime
+from typing import Dict, List, Any, Optional, Tuple
+
+class AntiFalsePositiveValidator:
+    """Advanced validation system for OSINT results"""
+    
+    def __init__(self, validation_level: str = 'strict', min_confidence: int = 60):
+        self.validation_level = validation_level
+        self.min_confidence = min_confidence
+        self.validation_cache = {}
+        
+        # False positive patterns (will be loaded from JSON)
+        self.fp_patterns = {
+            'status_codes': {
+                'valid': [200, 201, 202, 204],
+                'warning': [301, 302, 307, 308, 403, 429, 404],
+                'invalid': [400, 401, 500, 502, 503, 504]
+            },
+            'error_indicators': [
+                'not found', 'does not exist', 'no such user', 'user not found',
+                'profile not found', 'page not found', '404 error', '500 error',
+                'account suspended', 'user deleted', 'account not active',
+                'this profile is not available', 'sorry, nothing here'
+            ],
+            'placeholder_indicators': [
+                'under construction', 'coming soon', 'maintenance mode',
+                'default page', 'welcome to', 'test page', 'sample page',
+                'example domain', 'this domain is for sale'
+            ],
+            'bot_indicators': [
+                'captcha', 'challenge', 'verify you are human', 'robot check',
+                'access denied', 'blocked', 'rate limited', 'too many requests',
+                'our systems have detected', 'automated request'
+            ],
+            'valid_indicators': [
+                'joined', 'member since', 'followers', 'following', 'posts',
+                'profile', 'account', 'user', 'activity', 'dashboard',
+                'settings', 'logout', 'sign out', 'edit profile'
+            ]
+        }
+        
+        # Confidence weights
+        self.weights = {
+            'status_code': 30,
+            'content_analysis': 40,
+            'response_time': 10,
+            'url_pattern': 20
+        }
+    
+    def validate_username_result(self, result: Dict) -> Dict:
+        """Validate a username search result"""
+        url = result.get('url', '')
+        status_code = result.get('status_code', 0)
+        response_text = result.get('response_text', '').lower()
+        response_time = result.get('response_time', 0)
+        
+        validation_result = {
+            'url': url,
+            'valid': True,
+            'confidence': 100,
+            'errors': [],
+            'warnings': [],
+            'score_breakdown': {}
+        }
+        
+        # 1. Status code validation
+        status_score = self._validate_status_code(status_code)
+        validation_result['score_breakdown']['status_code'] = status_score
+        if status_score < 50:
+            validation_result['errors'].append(f"Invalid status code: {status_code}")
+        
+        # 2. Content analysis
+        content_score = self._analyze_content(response_text)
+        validation_result['score_breakdown']['content_analysis'] = content_score
+        if content_score < 40:
+            validation_result['errors'].append("Content indicates this is a false positive")
+        
+        # 3. Response time check (too fast = may be cached error page)
+        if response_time < 0.1:
+            validation_result['warnings'].append("Suspiciously fast response (possible cache/error page)")
+            validation_result['score_breakdown']['response_time'] = 30
+        elif response_time > 3:
+            validation_result['score_breakdown']['response_time'] = 80
+        else:
+            validation_result['score_breakdown']['response_time'] = 70
+        
+        # 4. URL pattern validation
+        url_score = self._validate_url_pattern(url)
+        validation_result['score_breakdown']['url_pattern'] = url_score
+        
+        # Calculate final confidence
+        total_weight = sum(self.weights.values())
+        weighted_score = sum(
+            validation_result['score_breakdown'].get(key, 0) * (self.weights[key] / 100)
+            for key in validation_result['score_breakdown']
+        )
+        
+        validation_result['confidence'] = int(weighted_score)
+        
+        # Apply validation level
+        if self.validation_level == 'paranoid':
+            validation_result['valid'] = validation_result['confidence'] >= self.min_confidence + 20
+        elif self.validation_level == 'strict':
+            validation_result['valid'] = validation_result['confidence'] >= self.min_confidence
+        else:  # basic
+            validation_result['valid'] = validation_result['confidence'] >= self.min_confidence - 20
+        
+        # Determine confidence level
+        if validation_result['confidence'] >= 80:
+            validation_result['confidence_level'] = 'HIGH'
+        elif validation_result['confidence'] >= 50:
+            validation_result['confidence_level'] = 'MEDIUM'
+        else:
+            validation_result['confidence_level'] = 'LOW'
+        
+        return validation_result
+    
+    def _validate_status_code(self, status_code: int) -> int:
+        """Validate HTTP status code"""
+        if status_code in self.fp_patterns['status_codes']['valid']:
+            return 100
+        elif status_code in self.fp_patterns['status_codes']['warning']:
+            return 50
+        else:
+            return 0
+    
+    def _analyze_content(self, text: str) -> int:
+        """Analyze response content for indicators"""
+        if not text:
+            return 0
+        
+        score = 100
+        
+        # Check for error indicators
+        for indicator in self.fp_patterns['error_indicators']:
+            if indicator in text:
+                score -= 20
+        
+        # Check for placeholder indicators
+        for indicator in self.fp_patterns['placeholder_indicators']:
+            if indicator in text:
+                score -= 15
+        
+        # Check for bot indicators (WAF, captcha)
+        for indicator in self.fp_patterns['bot_indicators']:
+            if indicator in text:
+                score -= 40
+                break  # Major deduction
+        
+        # Check for valid indicators (boost score)
+        for indicator in self.fp_patterns['valid_indicators']:
+            if indicator in text:
+                score = min(100, score + 10)
+        
+        # Analyze text length (too short = error page)
+        if len(text) < 100:
+            score -= 30
+        elif len(text) > 10000:
+            score += 10  # Substantial content = more likely valid
+        
+        return max(0, min(100, score))
+    
+    def _validate_url_pattern(self, url: str) -> int:
+        """Validate URL pattern for false positives"""
+        score = 100
+        
+        # Check for suspicious patterns
+        suspicious_patterns = [
+            r'\.\.\/', r'%2e%2e', r'%00', r'\\x00',
+            r'\/404', r'\/error', r'\/notfound'
+        ]
+        
+        for pattern in suspicious_patterns:
+            if re.search(pattern, url.lower()):
+                score -= 50
+                break
+        
+        # Check for valid profile patterns
+        valid_patterns = [
+            r'\/user\/', r'\/profile\/', r'\/@', r'\/u\/',
+            r'\/member\/', r'\/account\/', r'\/people\/'
+        ]
+        
+        for pattern in valid_patterns:
+            if re.search(pattern, url.lower()):
+                score = min(100, score + 20)
+                break
+        
+        return max(0, min(100, score))
+    
+    def validate_email(self, email: str, response_data: Dict) -> Dict:
+        """Validate email search results"""
+        result = {
+            'email': email,
+            'valid': True,
+            'confidence': 50,
+            'findings': []
+        }
+        
+        # Check email format
+        email_pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
+        if not re.match(email_pattern, email):
+            result['valid'] = False
+            result['findings'].append("Invalid email format")
+            result['confidence'] = 0
+            return result
+        
+        # Check if exposed in breaches
+        if response_data.get('breaches'):
+            result['confidence'] += 40
+            result['findings'].append(f"Found in {len(response_data['breaches'])} data breaches")
+        
+        # Check if verified
+        if response_data.get('verified'):
+            result['confidence'] += 30
+            result['findings'].append("Email is verified")
+        
+        result['confidence'] = min(100, result['confidence'])
+        
+        if result['confidence'] >= 70:
+            result['confidence_level'] = 'HIGH'
+        elif result['confidence'] >= 40:
+            result['confidence_level'] = 'MEDIUM'
+        else:
+            result['confidence_level'] = 'LOW'
+            result['valid'] = False
+        
+        return result
+    
+    def validate_phone(self, phone: str, response_data: Dict) -> Dict:
+        """Validate phone number search results"""
+        result = {
+            'phone': phone,
+            'valid': True,
+            'confidence': 50,
+            'carrier_verified': False,
+            'findings': []
+        }
+        
+        # Check phone format (E.164)
+        import re
+        phone_pattern = r'^\+?[1-9]\d{1,14}$'
+        if not re.match(phone_pattern, phone.replace(' ', '')):
+            result['valid'] = False
+            result['findings'].append("Invalid phone format (use E.164)")
+            result['confidence'] = 0
+            return result
+        
+        # Check carrier
+        if response_data.get('carrier') and response_data['carrier'] != 'Unknown':
+            result['carrier_verified'] = True
+            result['confidence'] += 30
+            result['findings'].append(f"Carrier: {response_data['carrier']}")
+        
+        # Check location
+        if response_data.get('location') and response_data['location'] != 'Unknown':
+            result['confidence'] += 20
+            result['findings'].append(f"Location: {response_data['location']}")
+        
+        # Check if active
+        if response_data.get('valid', False):
+            result['confidence'] += 20
+            result['findings'].append("Number is valid and active")
+        
+        result['confidence'] = min(100, result['confidence'])
+        
+        if result['confidence'] >= 70:
+            result['confidence_level'] = 'HIGH'
+        elif result['confidence'] >= 40:
+            result['confidence_level'] = 'MEDIUM'
+        else:
+            result['confidence_level'] = 'LOW'
+            result['valid'] = False
+        
+        return result
+    
+    def filter_results(self, results: List[Dict], min_confidence: int = None) -> List[Dict]:
+        """Filter results based on confidence score"""
+        if min_confidence is None:
+            min_confidence = self.min_confidence
+        
+        filtered = []
+        for result in results:
+            if result.get('validation', {}).get('confidence', 0) >= min_confidence:
+                filtered.append(result)
+        
+        return filtered
+    
+    def generate_validation_report(self, results: List[Dict]) -> Dict:
+        """Generate validation statistics report"""
+        total = len(results)
+        if total == 0:
+            return {'total': 0, 'valid': 0, 'filtered': 0}
+        
+        valid = sum(1 for r in results if r.get('validation', {}).get('valid', False))
+        high_conf = sum(1 for r in results if r.get('validation', {}).get('confidence', 0) >= 80)
+        medium_conf = sum(1 for r in results if 50 <= r.get('validation', {}).get('confidence', 0) < 80)
+        low_conf = sum(1 for r in results if r.get('validation', {}).get('confidence', 0) < 50)
+        
+        return {
+            'total': total,
+            'valid': valid,
+            'filtered': total - valid,
+            'high_confidence': high_conf,
+            'medium_confidence': medium_conf,
+            'low_confidence': low_conf,
+            'filter_rate': round((total - valid) / total * 100, 2),
+            'validation_level': self.validation_level,
+            'min_confidence': self.min_confidence
+        }

{phantomapi-1.0.1 → phantomapi-1.1.10}/phantomapi.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: phantomapi
-Version: 1.0.1
+Version: 1.1.10
 Summary: Phone number OSINT library for Indonesia
 Author: TheZ4th
 Author-email: zethkaretjir@gmail.com

{phantomapi-1.0.1 → phantomapi-1.1.10}/phantomapi.egg-info/SOURCES.txt

@@ -1,7 +1,11 @@
 setup.py
 PhantomAPI/__init__.py
 PhantomAPI/core.py
+PhantomAPI/database.py
+PhantomAPI/exporter.py
+PhantomAPI/hunter.py
 PhantomAPI/provider.py
+PhantomAPI/validator.py
 phantomapi.egg-info/PKG-INFO
 phantomapi.egg-info/SOURCES.txt
 phantomapi.egg-info/dependency_links.txt

{phantomapi-1.0.1 → phantomapi-1.1.10}/setup.py

@@ -1,10 +1,10 @@
 from setuptools import setup, find_packages
 
 setup(
-    name='phantomapi',                     # Nama unik (cek di pypi.org)
-    version='1.0.1',
-    author='TheZ4th',                      # Nama lo
-    author_email='zethkaretjir@gmail.com',   # Email lo
+    name='phantomapi',
+    version='1.1.10',
+    author='TheZ4th',
+    author_email='zethkaretjir@gmail.com',
     description='Phone number OSINT library for Indonesia',
     long_description_content_type='text/markdown',
     packages=find_packages(),
@@ -13,4 +13,8 @@ setup(
         'License :: OSI Approved :: MIT License',
     ],
     python_requires='>=3.6',
+    include_package_data=True,
+    package_data={
+        'phantomapi': ['platforms.json'],
+    },
 )

phantomapi-1.0.1/PhantomAPI/__init__.py

@@ -1,6 +0,0 @@
-from .core import PhoneOSINT
-from .provider import PROVIDERS
-
-__all__ = ['PhoneOSINT', 'PROVIDERS']
-__version__ = "1.0.1"
-__author__ = "TheZ4th"