跳至正文
OpenAgentSkill
浏览已开放 · 目录记录日期 2026-11-21 · 自动更新和账户服务暂时关闭。
安全

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

  1. Find the JWT. In each captured request, read the Authorization header. Strip a leading Bearer if present. A JWT is three base64url segments joined by dots (header.payload.signature) and the header segment almost always starts with ey (that is {" base64url-encoded). Tokens also appear in cookies and in access_token / id_token body or query params - check those too. Skip any auth header whose value does not start with ey; after ~3 non-JWT auth values on a host, move on.
  2. Decode it (passive). base64url-decode segment 1 (header) and segment 2 (payload). Note alg, kid, jku, jwk in the header and exp, iat, roles/scopes/sub in the payload - these drive both the crack and the forgeries.
  3. 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 kid to ../../../../../../../dev/null (and, for parsers that read a k field, set k to empty or the base64 of a null byte, AA==), then HMAC-sign the token with an empty key. If the server loads /dev/null as 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
阅读完整来源 ↗