Poodle Attack in Express with Dynamodb

The Poodle attack (Padding Oracle On Downgraded Legacy Encryption) targets systems that negotiate SSL 3.0 and rely on block ciphers in CBC mode without proper integrity verification. In an Express application, if the server or a downstream TLS termination point still supports SSL 3.0, an attacker can iteratively decrypt secure HTTP cookies by observing whether requests succeed or fail. When Express routes interact with Amazon DynamoDB, the vulnerability surface expands if session identifiers or authorization tokens stored client-side (e.g., in cookies) are used to gate access to DynamoDB operations.

Consider an Express route that reads a user identifier from a cookie and directly queries DynamoDB to fetch profile data:

app.get('/profile', (req, res) => {
  const userId = req.cookies.userId;
  const params = {
    TableName: 'Users',
    Key: { userId: { S: userId } }
  };
  dynamodb.get(params, (err, data) => {
    if (err) return res.status(500).send('Error');
    res.json(data.Item);
  });
});

If an attacker can force a user’s browser to use SSL 3.0 (e.g., via a man-in-the-middle network), they can exploit Poodle to recover the session cookie. The attacker then uses that cookie to call the /profile endpoint, causing the application to perform authorized-looking DynamoDB queries on behalf of the victim. The DynamoDB access pattern—keyed by the user-controlled cookie value—becomes an oracle: successful queries confirm guessed cookie bytes. Because DynamoDB itself enforces authentication at the API level (via AWS credentials), the TLS-layer weakness translates into unauthorized data reads, bypassing intended application-level checks.

Additionally, if the Express app uses AWS SDK calls that depend on credentials exposed to the client (for example, embedding temporary tokens in JavaScript), a Poodle-recovered token may provide direct access to DynamoDB operations. This cross-layer chain—SSL 3.0 downgrade in Express, cookie exposure, and DynamoDB authorization—illustrates how legacy protocol support can amplify data exposure even when the database enforces its own access controls.

Remediation focuses on removing SSL 3.0 support in the TLS layer and ensuring DynamoDB access is never gated by client-controlled values alone. Below are concrete Express patterns that reduce Poodle risk when integrating with DynamoDB.

1. Disable SSL 3.0 in the Node.js HTTPS server

When creating an HTTPS server in Express, explicitly disable insecure protocols:

const https = require('https');
const fs = require('fs');
const express = require('express');
const app = express();

const server = https.createServer({
  key: fs.readFileSync('server.key'),
  cert: fs.readFileSync('server.cert'),
  minVersion: 'TLSv1.2',
  ciphers: 'TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256'
}, app);

server.listen(443);

By setting minVersion to TLSv1.2, SSL 3.0 and TLS 1.0/1.1 are disabled, mitigating the Poodle vector.

2. Validate and sanitize DynamoDB keys using server-side session identifiers

Avoid using raw cookie values as DynamoDB key inputs. Instead, map a server-side session to a user identifier:

const sessions = new Map(); // In production, use a secure store

app.post('/login', (req, res) => {
  const { userId } = req.body;
  const sessionId = require('crypto').randomBytes(16).toString('hex');
  sessions.set(sessionId, userId);
  res.cookie('sessionId', sessionId, { httpOnly: true, secure: true, sameSite: 'strict' });
  res.send('OK');
});

app.get('/profile', (req, res) => {
  const sessionId = req.cookies.sessionId;
  const userId = sessions.get(sessionId);
  if (!userId) return res.status(401).send('Unauthorized');

  const params = {
    TableName: 'Users',
    Key: { userId: { S: userId } }
  };
  dynamodb.get(params, (err, data) => {
    if (err) return res.status(500).send('Error');
    res.json(data.Item);
  });
});

This ensures the DynamoDB key is derived from a server-side mapping, not directly from a client-controlled cookie, removing the oracle component of the Poodle attack.

3. Enforce strict transport security and use AWS SDK best practices

Set HTTP Strict Transport Security headers and ensure AWS SDK calls use signed requests over TLS:

app.use((req, res, next) => {
  res.setHeader('Strict-Transport-Security', 'max-age=31536000; includeSubDomains');
  next();
});

// AWS SDK v3 example with explicit region and TLS
const { DynamoDBClient, GetItemCommand } = require('@aws-sdk/client-dynamodb');
const client = new DynamoDBClient({ region: 'us-east-1', requestHandler: { httpsAgent: new (require('https').Agent) { rejectUnauthorized: true } } });

app.get('/profile-safe', async (req, res) => {
  const sessionId = req.cookies.sessionId;
  const userId = sessions.get(sessionId);
  if (!userId) return res.status(401).send('Unauthorized');

  const command = new GetItemCommand({
    TableName: 'Users',
    Key: { userId: { S: userId } }
  });
  try {
    const response = await client.send(command);
    res.json(response.Item);
  } catch (err) {
    res.status(500).send('Error');
  }
});

These practices align with the broader advantage of quick, unauthenticated scans using middleBrick: you can validate that TLS configurations reject SSL 3.0 and that DynamoDB-related endpoints do not expose key derivation to the client. The CLI (middlebrick scan <url>) and the GitHub Action can be integrated into CI/CD to fail builds if insecure protocols are detected.