Bleichenbacher Attack in Feathersjs with Jwt Tokens

A Bleichenbacher attack is a cryptographic padding oracle attack against RSA-based encryption or signature schemes. In a Feathers.js application that uses JWT tokens with an RSA-based algorithm such as RS256, this attack can manifest when error handling during token verification is not consistent. If the server returns distinct validation errors for malformed signatures versus invalid padding, an attacker can iteratively submit modified tokens and use timing or error differences to recover the private key or forge tokens.

Feathers.js does not enforce a specific JWT library, but common integrations use jsonwebtoken. When using RS256, the server must load the public key to verify signatures. A vulnerable implementation might expose low-level verification errors:

const jwt = require('jsonwebtoken');
const fs = require('fs');

const publicKey = fs.readFileSync('public.key');

app.service('auth').hooks({
  before: {
    create: [context => {
      const token = context.data.token;
      try {
        const decoded = jwt.verify(token, publicKey, { algorithms: ['RS256'] });
        context.params.account = decoded;
      } catch (err) {
        context.result = { error: err.message };
        throw new Error('Invalid token');
      }
    }]
  }
});

If the catch block returns different messages for "invalid signature" versus "invalid padding" (or throws distinct errors), it can act as an oracle. In a Feathers.js service, this can happen when hooks or custom logic surface verification failures directly. An attacker can automate requests, observing response differences or timing to perform the Bleichenbacher adaptive chosen-ciphertext attack. This compromises the integrity of authentication, allowing token forgery or private key extraction without needing to compromise the server directly.

middleBrick scans detect inconsistencies in error handling and unauthenticated endpoints that may amplify oracle behavior. By testing the authentication surface without credentials, it identifies whether error messages or timing variations could support adaptive attacks, even when using strong algorithms like RS256.

Remediation focuses on making token verification constant-time and opaque, ensuring errors do not leak information about why verification failed. Avoid returning specific JWT validation errors to the client. Instead, use a generic authentication failure response and log details server-side for investigation.

Use a consistent verification flow with a try/catch that always throws the same error type and message. Prefer high-level libraries and options that minimize low-level exposure. For RS256, ensure you are using a maintained key source and that algorithms are explicitly restricted.

const jwt = require('jsonwebtoken');
const fs = require('fs');

const publicKey = fs.readFileSync('public.key');

function verifyTokenConstant(token) {
  try {
    // Enforce allowed algorithms and ignore asymmetric key confusion risks
    const decoded = jwt.verify(token, publicKey, {
      algorithms: ['RS256'],
      clockTolerance: 2 // small tolerance to avoid timing edge cases
    });
    return decoded;
  } catch (err) {
    // Always throw a generic error to prevent oracle behavior
    throw new Error('invalid_token');
  }
}

app.service('auth').hooks({
  before: {
    create: [context => {
      const token = context.data.token;
      const decoded = verifyTokenConstant(token);
      context.params.account = decoded;
    }]
  }
});

Additionally, consider using JSON Web Key Set (JWKS) retrieval with caching to manage keys securely and avoid local file exposure. Ensure public keys are pinned or fetched over TLS. For production, combine this with rate limiting and monitoring to detect abnormal request patterns indicative of active probing.

middleBrick’s LLM/AI Security checks can identify whether your endpoints inadvertently expose system prompts or are susceptible to prompt injection, which is orthogonal but relevant if your API includes AI-assisted token validation. Its scan reports map findings to frameworks like OWASP API Top 10 and provide prioritized remediation guidance without claiming to fix issues directly.