Bleichenbacher Attack in Express with Cockroachdb

A Bleichenbacher attack is a cryptographic padding oracle attack originally described against PKCS#1 v1.5–style RSA encryption. In an Express API that uses CockroachDB as the data store, the vulnerability arises when error handling leaks information about decryption or signature verification outcomes. If your application decrypts or verifies values (for example, API keys, JWTs, or encrypted identifiers) and the database or crypto library returns distinct errors for padding failures versus other failures, an attacker can iteratively query the endpoint and infer whether a ciphertext is valid. Over many requests, this allows recovery of the plaintext without knowing the key.

With CockroachDB, this typically maps to how errors from SQL queries are surfaced. Suppose an Express route accepts an encrypted identifier, decrypts it in Node.js, and then queries CockroachDB using the resulting user ID. If the decryption fails and the code does not use constant-time checks or uniform error handling, the response time or message can differ between a padding error and a SQL error or no-match error. An attacker who can control the ciphertext and observe timing or error differences can mount a Bleichenbacher-style adaptive chosen-ciphertext attack. This is compounded when the same key is used across multiple endpoints or when nonces/IVs are reused, which can expose patterns in the encrypted data.

In a real-world scenario, an attacker might send modified JWTs or encrypted cookies to an Express route that calls CockroachDB to look up a user. If the route returns 401 with a message like “invalid token” for bad padding and “user not found” for valid padding but nonexistent user, the distinction constitutes an oracle. The attacker uses the oracle to gradually decrypt traffic or forge valid tokens. Because CockroachDB is often deployed in distributed setups with strict SQL semantics, developers might assume that errors are safe to expose; however, the application layer must ensure that all failure paths are handled uniformly to avoid leaking decrypted information through status codes, response lengths, or timing.

To detect this with middleBrick, you can scan your Express endpoint that interacts with CockroachDB. The LLM/AI Security checks include active prompt injection testing and system prompt leakage detection, but the relevant security check here is Input Validation and Authentication: the scanner verifies whether error messages and timing differ based on invalid ciphertexts. A high-risk finding would indicate that distinct errors or timing differences are observable, which aligns with a Bleichenbacher-style oracle. middleBrick reports such findings with severity and remediation guidance, helping you confirm whether your error handling and crypto usage expose an oracle.

Remediation focuses on ensuring that all operations involving decryption, SQL queries, and responses to the client are uniform in timing and error messaging. Use constant-time comparison for any sensitive tokens, and ensure that database errors are caught and mapped to generic responses. Below are concrete patterns and code examples for Express with CockroachDB.

1. Use constant-time crypto operations and uniform error handling

When decrypting or verifying values, do not branch on sensitive data. Handle success and failure with the same code path and avoid returning stack traces or internal messages to the client.

const crypto = require('crypto');
const { Client } = require('pg'); // CockroachDB wire-compatible client

function timingSafeEqual(a, b) {
  return crypto.timingSafeEqual(Buffer.from(a), Buffer.from(b));
}

app.post('/api/login', async (req, res) => {
  const { encryptedToken } = req.body;
  try {
    const plaintext = decryptToken(encryptedToken); // throws on padding error
    const user = await getUserFromCockroach(plaintext.userId);
    if (!user) {
      // Generic response to avoid user enumeration
      return res.status(401).json({ error: 'Invalid credentials' });
    }
    // proceed with login
    res.json({ ok: true });
  } catch (err) {
    // Always return the same generic error
    console.error('Auth error:', err);
    return res.status(401).json({ error: 'Invalid credentials' });
  }
});

function decryptToken(token) {
  const decipher = crypto.createDecipheriv('aes-256-gcm', KEY, IV);
  let decrypted = decipher.update(token, 'base64', 'utf8');
  decrypted += decipher.final('utf8');
  // If padding is wrong, this can throw; ensure it's caught upstream
  return JSON.parse(decrypted);
}

2. Parameterized queries with CockroachDB to avoid SQL-side errors leaking info

Always use parameterized statements. This prevents SQL injection and ensures that error paths remain consistent regardless of input.

const { Client } = require('pg');

async function getUserFromCockroach(userId) {
  const client = new Client({ connectionString: process.env.COCKRACKERDB_URL });
  await client.connect();
  try {
    const result = await client.query('SELECT id, username FROM users WHERE id = $1', [userId]);
    return result.rows[0] || null;
  } finally {
    await client.end();
  }
}

3. Avoid branching on decryption failures

If you must verify a token or ciphertext, compute a MAC or use an AEAD mode that fails cleanly. Do not try to compare hashes or strings manually when handling secrets.

// Prefer an AEAD that does not require manual padding checks
const crypto = require('crypto');
function verifyToken(token) {
  const [base64Data, base64Iv, base64Tag] = token.split(':');
  const decipher = crypto.createDecipheriv('aes-256-gcm', KEY, Buffer.from(base64Iv, 'base64'));
  decipher.setAuthTag(Buffer.from(base64Tag, 'base64'));
  let decrypted;
  try {
    decrypted = Buffer.concat([decipher.update(Buffer.from(base64Data, 'base64')), decipher.final()]);
  } catch (err) {
    throw new Error('invalid'); // swallow details, caller handles uniformly
  }
  return JSON.parse(decrypted.toString());
}

4. Logging and monitoring without sensitive data

Log failed attempts without leaking whether the failure was due to padding, SQL, or missing user. Correlate request IDs for auditability while ensuring logs do not store decrypted secrets.

app.use((err, req, res, next) => {
  // Generic response
  res.status(400).json({ error: 'Bad request' });
});

By applying these CockroachDB-aware practices in Express, you remove the conditions that enable a Bleichenbacher-style oracle: uniform responses, constant-time crypto operations, parameterized queries, and careful error handling. middleBrick scans can validate that your endpoints do not expose timing or error distinctions that would allow an attacker to iteratively decrypt or forge data.