Bleichenbacher Attack in Sails with Cockroachdb

A Bleichenbacher attack is a chosen-ciphertext attack against asymmetric encryption schemes that use PKCS#1 v1.5 padding, most commonly RSA. In a Sails application that uses CockroachDB as the data store, the risk arises when the app performs decryption or signature verification on user-supplied data without strict validation. Sails does not enforce any particular encryption library, so developers commonly use Node.js packages such as node-rsa or crypto. If these are used to decrypt tokens or API responses that originate from a Cockroachdb-stored key or encrypted blob, an attacker can iteratively submit modified ciphertexts and observe differences in error messages or timing to gradually recover the plaintext.

Consider a Sails model that stores encrypted API keys in Cockroachdb. A developer might write a service that retrieves the encrypted row, decrypts the payload with a private key, and then uses the result. If the decryption function leaks whether a padding error occurred versus a valid decryption, an attacker can mount a Bleichenbacher attack by sending many ciphertexts and observing HTTP status codes, response times, or error messages. Cockroachdb itself is not vulnerable to the cryptographic flaw, but its role as the persistence layer means that encrypted material and keys can be reliably fetched, enabling the attacker to build an oracle. Because Sails applications often expose REST or GraphQL endpoints that perform these operations without strict error handling, the unauthenticated attack surface described by middleBrick’s BOLA/IDOR and Input Validation checks can highlight such weak points.

In practice, an attacker does not need access to the database schema; they only need an endpoint that takes an encrypted input, sends it to a decryption routine backed by a Cockroachdb-stored key, and reveals whether the ciphertext was well-formed. middleBrick’s LLM/AI Security checks would not directly detect this, but its Input Validation and Authentication checks can flag endpoints that process unvalidated encrypted data without proper padding verification. This is consistent with the OWASP API Top 10:2023 A05 – Security Misconfiguration and A02 – Cryptographic Failures. Real-world variants of this attack have been seen against TLS implementations and web services that incorrectly handle RSA-OAEP or PKCS#1 v1.5 padding, and similar patterns can manifest when Sails apps rely on ad hoc decryption rather than authenticated encryption.

To mitigate Bleichenbacher-style attacks in a Sails app using Cockroachdb, centralize cryptographic operations and ensure constant-time validation. Do not branch logic on padding errors; instead, use libraries that provide verified decryption with built-in protections, and store only encrypted-at-rest data in Cockroachdb while keeping keys in a secure external vault.

Below are concrete, working examples for a Sails service that interacts with Cockroachdb using the @cockroachdb/nodejs client. The first example shows insecure decryption that should be avoided, and the second shows a hardened approach using authenticated encryption with AES-GCM, where the RSA-encrypted key is only used to wrap the AES key and never directly decrypt application data.

Insecure pattern (illustrative — do not use)

// api/services/CryptoService.js — vulnerable to Bleichenbacher-style oracle
const crypto = require('crypto');
const NodeRSA = require('node-rsa');

module.exports = {
  decryptPayload: async function(ciphertextBase64) {
    const key = new NodeRSA({ b: 2048 });
    // Insecure: key loaded per call and decrypted without strict error handling
    key.importKey(await sails.getDatastore().query('SELECT encrypted_key FROM secrets WHERE id = 1'), 'pkcs8-public-pem');
    try {
      const decrypted = key.decrypt(ciphertextBase64, 'utf8'); // PKCS#1 v1.5 — padding oracle risk
      return JSON.parse(decrypted);
    } catch (err) {
      // Leaks: different errors for bad padding vs invalid JSON
      throw err;
    }
  }
};

Hardened pattern using AES-GCM with RSA key wrapping

// api/services/CryptoService.js — constant-time, authenticated flow
const crypto = require('crypto');
const { Client } = require('@cockroachdb/nodejs');

const client = new Client({ connectionString: process.env.COCKROACH_CONNECTION_STRING });

module.exports = {
  async getDecryptedData(tokenCipherBase64) {
    await client.connect();
    try {
      // 1) Fetch encrypted AES key and nonce + ciphertext from Cockroachdb
      const result = await client.query(`
        SELECT encrypted_aes_key, nonce, ciphertext, auth_tag
        FROM encrypted_records
        WHERE id = $1
      `, [tokenCipherBase64]); // Note: token here is an opaque reference, not the ciphertext to decrypt

      if (result.rowCount === 0) {
        throw new Error('Not found');
      }

      const row = result.rows[0];
      const encryptedAesKey = Buffer.from(row.encrypted_aes_key, 'base64');
      const nonce = Buffer.from(row.nonce, 'base64');
      const ciphertext = Buffer.from(row.ciphertext, 'base64');
      const authTag = Buffer.from(row.auth_tag, 'base64');

      // 2) Decrypt AES key with RSA (private key from secure vault, not DB)
      const privateKeyPem = process.env.RSA_PRIVATE_KEY_PEM; // Load from secrets manager
      const privateKey = crypto.createPrivateKey({ key: privateKeyPem, format: 'pem', type: 'pkcs8' });
      const aesKey = crypto.privateDecrypt({
        key: privateKey,
        padding: crypto.constants.RSA_PKCS1_OAEP_PADDING,
        oaepHash: 'sha256'
      }, encryptedAesKey);

      // 3) Decrypt data with AES-GCM — constant-time and authenticated
      const decipher = crypto.createDecipheriv('aes-256-gcm', aesKey, nonce);
      decipher.setAuthTag(authTag);
      let plaintext = decipher.update(ciphertext);
      plaintext = Buffer.concat([plaintext, decipher.final()]);

      return JSON.parse(plaintext.toString('utf8'));
    } catch (err) {
      // Do not leak error details; return a generic failure
      throw new Error('Decryption failed');
    } finally {
      await client.end();
    }
  }
};

This hardened pattern ensures that errors from Cockroachdb or crypto operations do not reveal padding validity, uses OAEP for RSA key unwrapping, and relies on AES-GCM for authenticated symmetric decryption. It aligns with middleBrick’s findings by providing concrete remediation guidance that maps to compliance frameworks such as OWASP API Top 10 and PCI-DSS requirements for key management.