Common JWT Vulnerabilities

In our previous lesson, we implemented a secure JWT authentication system with best practices like password hashing, HTTP-only cookies, and token verification middleware. However, not all JWT implementations follow these principles. Today, we'll explore common JWT vulnerabilities that arise from implementation mistakes, not flaws in the JWT standard. These mistakes can lead to security holes, allowing attackers to bypass authentication or gain unauthorized access. By analyzing code with deliberate security flaws, you'll learn how these vulnerabilities work and how to defend against them, equipping you to build secure authentication systems.

Let's dive into some of the most common JWT security vulnerabilities and see how they can be exploited.

One of the most serious JWT vulnerabilities is the "none" algorithm attack. To understand this vulnerability, let's first recall how JWT verification works.

When a server receives a JWT, it needs to verify the signature to ensure the token hasn't been tampered with. This verification process relies on the algorithm specified in the token's header. The JWT standard supports several algorithms, including HMAC-based algorithms like HS256 and asymmetric algorithms like RS256.

However, the JWT specification also includes a "none" algorithm, which was intended for debugging purposes. When this algorithm is used, the token has no signature at all. If a server doesn't explicitly check and reject tokens using the "none" algorithm, an attacker can bypass signature verification entirely.

A JWT is composed of three parts: the header, the payload, and the signature. In the "none" algorithm attack, the header specifies "alg": "none", indicating no signature is used. This allows an attacker to manipulate the payload without needing a secret key, as the signature part is empty.

Let's look at a vulnerable implementation:

// 🚨 Vulnerable: JWT None Algorithm Attack
router.post('/vulnerable-login', async (req, res) => {
    const { username, password } = req.body;
    const user = await User.findOne({ where: { username } });
    if (user && await bcrypt.compare(password, user.password)) {
        const token = jwt.sign({ userId: user.id }, '', { algorithm: 'none' }); // 🚨 No signature
        return res.json({ token });
    }
    res.status(401).json({ error: 'Invalid credentials' });
});

In this code, the jwt.sign() function is called with an empty string as the secret key and 'none' specified as the algorithm. This creates a JWT with no signature, which means anyone can create or modify such tokens without knowing any secret key.

Here's what a token generated with the "none" algorithm might look like:

eyJhbGciOiJub25lIiwidHlwIjoiSldUIn0.eyJ1c2VySWQiOjEsImlhdCI6MTYxNjc2MjQ5OH0.

Notice that the third part (the signature) is empty, indicated by the trailing dot.

An attacker who understands this vulnerability could:

1. Decode an existing token to extract its payload.
2. Modify the payload (e.g., change the user ID to access another user's account).
3. Re-encode the token with the "none" algorithm.
4. Use this forged token to make authenticated requests.

To protect against this vulnerability, always explicitly verify the algorithm used for token verification and reject tokens that use the "none" algorithm. Here's how you can refactor the code to ensure security:

import { JWT_SECRET_KEY } from '../../config';

// ✅ Secure: Reject None Algorithm
router.post('/secure-login', async (req, res) => {
    const { username, password } = req.body;
    const user = await User.findOne({ where: { username } });
    if (user && await bcrypt.compare(password, user.password)) {
        const token = jwt.sign({ userId: user.id }, JWT_SECRET_KEY, { algorithm: 'HS256' });
        return res.json({ token });
    }
    res.status(401).json({ error: 'Invalid credentials' });
});

In this refactored code, the jwt.sign() function uses a strong secret key imported from the configuration file and specifies a secure algorithm like HS256. This ensures that the token is properly signed and verified, preventing the "none" algorithm attack.

Here's what a token generated with the secure implementation might look like:

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VySWQiOjEsImlhdCI6MTYxNjc2MjQ5OH0.4d5f1c2e3b4a5c6d7e8f9a0b1c2d3e4f5g6h7i8j9k0l1m2n3o4p5q6r7s8t9u0v

In this example, the third part (the signature) is now present and properly encoded, ensuring the token's integrity and authenticity can be verified by the server using the secret key.

In our previous lesson, we emphasized the importance of using strong, random secret keys for signing JWTs. Now, let's see what happens when this advice is ignored.

When a JWT is signed with a weak or predictable secret key, attackers can potentially guess or brute-force the key. Once they have the key, they can create valid tokens with any payload they want, effectively bypassing your authentication system entirely.

Here's an example of a vulnerable implementation using a weak secret key:

// 🚨 Vulnerable: JWT Signed with Weak Secret
const WEAK_SECRET = '1234'; // 🚨 Easily brute-forced
router.post('/weak-token', async (req, res) => {
    const { username } = req.body;
    const user = await User.findOne({ where: { username } });
    if (!user) return res.status(404).json({ error: 'User not found' });
    
    const token = jwt.sign({ userId: user.id }, WEAK_SECRET, { expiresIn: '1h' });
    return res.json({ token });
});

In this code, the JWT is signed with the secret key '1234', which is extremely weak and could be guessed or brute-forced very quickly. Common weak secrets include simple passwords, dictionary words, and predictable patterns.

An attacker could use a brute-force approach to try different secret keys until they find one that successfully verifies the token. Here's an example of how an attacker might implement such a brute-force attack:

// 🚨 Exploit: Brute-Force Weak Secret
router.post('/brute-force-token', async (req, res) => {
    const { token } = req.body;
    const commonSecrets = ['1234', 'password', 'jwtsecret', 'testkey'];
    
    for (const secret of commonSecrets) {
        try {
            const decoded = await verifyJwt(token, secret);
            return res.json({ success: true, secret, decoded });
        } catch (err) {
            continue;
        }
    }
    res.status(401).json({ error: 'Unable to brute-force token' });
});

This code attempts to verify a token using a list of common weak secrets. If any of these secrets successfully verify the token, the attacker has discovered the secret key and can now forge valid tokens.

In a real-world scenario, attackers might use much larger dictionaries or more sophisticated brute-force techniques, but the principle remains the same: if your secret key is weak, it can be discovered through brute force.

To protect against this vulnerability, always use strong, random secret keys that are at least 32 characters long and include a mix of letters, numbers, and special characters. Better yet, use a cryptographically secure random number generator to create your secret keys.

// 🚨 Insecure: Weak Secret Key
export const JWT_SECRET_KEY = 'jwt-secret-key'; // 🚨 Weak and predictable
export const API_BASE_URL = ''; // Empty string for same-origin requests
export const API_ENDPOINTS = {
  LOGIN: `/api/auth/login`,
  REGISTER: `/api/auth/register`,
  SNIPPETS: `/api/snippets`,
  SNIPPET: (id: string) => `/api/snippets/${id}`,
};

In this insecure implementation, the secret key 'jwt-secret-key' is weak and predictable, making it vulnerable to brute-force attacks.

import crypto from 'crypto';

// ✅ Secure: Strong Secret Key
export const JWT_SECRET_KEY = crypto.randomBytes(32).toString('hex'); // 32 bytes for a 256-bit key
export const API_BASE_URL = ''; // Empty string for same-origin requests
export const API_ENDPOINTS = {
  LOGIN: `/api/auth/login`,
  REGISTER: `/api/auth/register`,
  SNIPPETS: `/api/snippets`,
  SNIPPET: (id: string) => `/api/snippets/${id}`,
};

In the secure implementation, the secret key is generated using crypto.randomBytes(32).toString('hex'), ensuring it is strong and random. This approach significantly enhances the security of your JWT implementation by making the secret key resistant to brute-force attacks.

In this lesson, we explored two common JWT vulnerabilities: the "None" Algorithm Attack, which bypasses signature verification and allows token forgery, and Weak Secret Keys, which enable brute-force attacks to forge valid tokens. Understanding these vulnerabilities is crucial for building secure JWT systems. In the upcoming practice exercises, you'll identify vulnerable JWT code, exploit these vulnerabilities to understand their impact, modify the code to fix the security issues, and test your fixes. These exercises will reinforce your understanding and provide practical experience in securing JWT implementations. In the next lesson, "Defending Against JWT Attacks," we'll delve into techniques to secure your JWTs against these vulnerabilities.