PT0-002 Attacks and Exploits Practice Question

Answer analysis

Option-by-option breakdown

For each option: why learners choose it and why it is or isn't the right answer here.

• ✗

  JWT brute-force

  Why it's wrong here

  JWT brute-force is an offline attack that attempts to discover the HMAC secret key by trying many candidate passwords against the token's existing signature, typically using a dictionary or wordlist. While it is a valid attack vector, it focuses on guessing the secret rather than altering the token's algorithm header to eliminate verification. The discovery here is that the server trusts an unsigned token, so brute-force is not the correct characterization.

• ✓

  JWT algorithm confusion (alg:none)

  Why this is correct

  JWT algorithm confusion (alg:none) occurs when a server accepts a JWT whose header declares the "alg" parameter as "none" (or "None"/"NONE"), which instructs the verifier that the token has no digital signature. An attacker can modify the token's payload, set alg to none, and remove the signature entirely; if the library does not explicitly reject none, the token is trusted as if it were properly signed. This directly bypasses signature verification without the attacker knowing any secret key.

• ✗

  JWT kid injection

  Why it's wrong here

  JWT kid injection involves manipulating the "kid" (key ID) header, which the server uses to select which secret or public key to use for verification. An attacker may inject path traversal or SQLi payloads through kid to trick the server into using an attacker-controlled key file or database entry, but this does not involve setting alg to none. In this scenario, the discovered behavior is that the verifier simply skips signature checking, which is fundamentally different from manipulating key selection.

• ✗

  JWT injection

  Why it's wrong here

  "JWT injection" is not a recognized or standard attack name; it is a vague term that could refer to injecting claims into the payload, such as "role" or "admin", but doing so does not defeat signature verification. The actual attack demonstrated is algorithm confusion, specifically forcing the server to accept an unsigned token by changing the alg header. Unlike claim manipulation, this attack requires no secret and exploits a distinct protocol-level flaw.

Go deeper

Related to this question