jwt-attacks
Forge and re-sign captured JWTs to test signature validation - algorithm confusion (alg:none, RS256 to HS256), key injection, and secret cracking. Use when testing JWT or bearer-token auth.
forefy · 已有 AI 审核记录
安装与使用
运行命令前先阅读来源与依赖说明。复制命令不会自动安装或执行。
npx skills add forefy/.context --skill jwt-attacks技能说明
name: jwt-attacks description: Forge and re-sign captured JWTs to test signature validation - algorithm confusion (alg:none, RS256 to HS256), key injection, and secret cracking. Use when testing JWT or bearer-token auth.
Contents
- Scope & authorization
- Step 0 - locate the token and establish a baseline
- Step 1 - offline HMAC secret crack (passive)
- Step 2 - signature stripping (active)
- Step 3 - alg:none family (active)
- Step 4 - kid manipulation (active)
- Step 5 - self-signed key injection: jwk / jku (active)
- Step 6 - RS256->HS256 algorithm confusion (active)
- Runnable snippets
- Output
Scope & authorization
Only run against an application you own or are engaged to test. The offline secret-cracking step (Step 1) is fully passive - it only analyzes a token you already captured and makes no network requests, so it is always safe to run. Every forgery step after it is active: it replays a tampered token against the live server, which mutates the authenticated session and appears in the target's logs. Do not run the active steps against third-party or out-of-scope hosts.
Inputs are the JWTs you already hold - captured from proxy history, a browser session, or an Authorization header the app issued to you. Outputs are "report a finding when the server accepts a token you forged."
Step 0 - locate the token and establish a baseline
- Find the JWT. In each captured request, read the
Authorizationheader. Strip a leadingBearerif present. A JWT is three base64url segments joined by dots (header.payload.signature) and the header segment almost always starts withey(that is{"base64url-encoded). Tokens also appear in cookies and inaccess_token/id_tokenbody or query params - check those too. Skip any auth header whose value does not start withey; after ~3 non-JWT auth values on a host, move on. - Decode it (passive). base64url-decode segment 1 (header) and segment 2 (payload). Note
alg,kid,jku,jwkin the header andexp,iat, roles/scopes/subin the payload - these drive both the crack and the forgeries. - Establish the rejection baseline (active). Before forging anything, confirm the endpoint actually enforces the token: replay the request with a deliberately invalid token (original token with its last signature character changed) and confirm the server answers
401 Unauthorized. Only endpoints that reject a bad token are worth attacking - if an endpoint returns 200 for garbage, it never checked the token and the "forgery accepted" signal is meaningless. Rate-limit yourself: after ~5 filtered requests that fail to return 401 to an invalid token, stop on that host.
Throughout the active steps, the finding condition is identical: you send a token you forged (one you could never have signed legitimately) and the server responds with anything other than Unauthorized - it verified nothing, or verified against something you control.
Step 1 - offline HMAC secret crack (passive)
If the token uses a symmetric algorithm (HS256 / HS384 / HS512), its signature is an HMAC keyed by a server secret. A weak/default secret can be recovered offline with zero requests: for each candidate key in a wordlist, attempt to verify the captured token; the key that verifies is the server's signing secret. Once you hold it you can mint arbitrary valid tokens (any sub, any role, any exp).
Report a finding when: any candidate key successfully verifies the captured token's signature. Record the recovered key.
Use the bundled references/jwt-secrets.txt (~1,600 weak/default/leaked HMAC secrets) as the primary wordlist - pass it to the cracker below or to hashcat -m 16500 for a GPU run. Always add app-specific candidates too: project name, domain, and the SECRET_KEY defaults of the framework in use. Extend further with the jwt.secrets.list from the wallarm/jwt-secrets collection.
The short list below is only an at-a-glance sample of what references/jwt-secrets.txt covers:
secret
password
changeme
default
jwt
jwtsecret
jwt_secret
jwtSecret
your-256-bit-secret
your_jwt_secret
mysecret
supersecret
secretkey
secret_key
key
private
admin
test
qwerty
123456
0000000000000000
Step 2 - signature stripping (active)
Send the token as header.payload. - both original segments unchanged, the signature segment emptied (trailing dot, nothing after it). This tests servers that split on . and only verify a signature when the third segment is non-empty. Report a finding when the server accepts the empty-signature token.
Step 3 - alg:none family (active)
The none algorithm declares "unsigned"; a spec-compliant verifier must reject it on a protected endpoint. Forge an unsigned token: take the original header, set alg, take the original payload, and push exp ~12 hours into the future (so a stale-but-otherwise-valid token isn't rejected merely for expiry). Re-encode header.payload. with an empty signature. Try each casing variant separately - naive blocklists only match one:
none(lowercase)None(title-case)NONE(upper)nOnE/noNE(mixed case)
Report a finding when the server accepts any casing of an unsigned token with the alg set to a none variant.
Step 4 - kid manipulation (active)
If the header carries a kid (key-id), the server uses it to select the verification key - which makes it an injection point. Forge a token whose kid points somewhere predictable, then sign with a key you control:
- Path traversal to a null/empty file: set
kidto../../../../../../../dev/null(and, for parsers that read akfield, setkto empty or the base64 of a null byte,AA==), then HMAC-sign the token with an empty key. If the server loads/dev/nullas the key material, it verifies your token against an empty key - which you used - and it passes. - SQL-injection / other traversal targets in
kid(e.g.' UNION SELECT 'known-key'--) follow the s