Cryptographic Failures in Hapi
How Cryptographic Failures Manifests in Hapi
Cryptographic failures in Hapi applications typically stem from improper configuration of encryption mechanisms, weak algorithm choices, and mishandling of sensitive data. These vulnerabilities can expose credentials, session tokens, API keys, and other critical information to attackers.
The most common manifestation occurs in Hapi's built-in authentication and encryption workflows. When developers use Hapi's server.auth.strategy() with default or weak encryption settings, they create attack vectors that compromise the entire authentication system. For example, using outdated hashing algorithms like MD5 or SHA-1 for password storage, or failing to implement proper salting mechanisms, leaves applications vulnerable to rainbow table attacks.
Session management represents another critical failure point. Hapi applications often store session data in cookies without proper encryption or integrity checks. An attacker can intercept these cookies and extract sensitive information if the session data isn't encrypted with strong algorithms like AES-256-GCM. Additionally, using predictable session IDs or failing to implement secure cookie flags (HttpOnly, Secure, SameSite) enables session hijacking attacks.
API key management in Hapi applications frequently suffers from cryptographic failures. Developers might store API keys in configuration files without encryption, transmit them over unencrypted channels, or use weak key derivation functions. This becomes particularly problematic when Hapi applications integrate with third-party services or handle payment processing.
Transport layer security misconfigurations are also prevalent. Hapi applications might accept weak TLS versions, use outdated cipher suites, or fail to implement certificate pinning. These configuration errors allow man-in-the-middle attacks, exposing data in transit between clients and the server.
Database encryption failures occur when Hapi applications store sensitive data without proper encryption at rest. While Hapi itself doesn't directly control database encryption, applications built on Hapi often fail to implement field-level encryption for sensitive data like credit card numbers, social security numbers, or personal health information.
Another manifestation involves improper implementation of cryptographic operations in route handlers. Developers might use Node.js's crypto module incorrectly, implement custom encryption algorithms, or fail to use authenticated encryption modes. These mistakes can lead to padding oracle attacks, timing attacks, or complete cryptographic failures.
Hapi-Specific Detection
Detecting cryptographic failures in Hapi applications requires examining both configuration files and runtime behavior. The first step involves analyzing Hapi's authentication configuration, typically found in the server initialization code or separate configuration modules.
Look for authentication strategies that use weak algorithms or improper key management. In Hapi, this might appear as:
server.auth.strategy('simple', 'basic', {
validate: async (request, username, password) => {
// Weak password comparison without timing attack protection
return { isValid: password === process.env.PASSWORD };
}This pattern is vulnerable because it uses direct string comparison without constant-time comparison functions, making it susceptible to timing attacks.
Session configuration requires careful examination. Check for:
server.state('session', {
encoding: 'base64', // Insecure encoding instead of encryption
isSecure: false, // Missing secure flag for HTTPS
isHttpOnly: false, // Missing HttpOnly flag
ignoreErrors: trueDatabase connection strings and configuration files often contain hardcoded credentials or API keys. Search for patterns like:
const dbConfig = {
user: 'admin',
password: 'password123', // Hardcoded credentials
host: process.env.DB_HOST || 'localhost'
}; Transport security configuration should be verified. Check TLS settings in Hapi's server initialization:
const server = Hapi.server({
port: 3000,
tls: {
minVersion: 'TLSv1.1', // Too weak, should be TLSv1.2+
ciphers: 'ALL:!ADH:!LOW:!EXP:!MD5:@STRENGTH' // Insecure cipher list
middleBrick's API security scanner can automatically detect these cryptographic failures in Hapi applications. The scanner examines authentication configurations, session management implementations, and transport security settings without requiring access to source code. It tests for weak algorithms, improper key management, and missing security headers.
The scanner also performs active testing to identify cryptographic weaknesses that static analysis might miss. This includes attempting to intercept session cookies, testing for weak password hashing, and verifying proper implementation of secure cookie flags.
Hapi-Specific Remediation
Remediating cryptographic failures in Hapi applications requires implementing industry-standard security practices using Hapi's built-in features and Node.js cryptographic libraries. The following code examples demonstrate proper implementations for common cryptographic scenarios.
Authentication should use strong, proven algorithms with proper salting and timing attack protection:
const bcrypt = require('bcrypt');
server.auth.strategy('secure', 'basic', {
validate: async (request, username, password) => {
const user = await db.getUser(username);
if (!user) return { isValid: false };
// Use bcrypt with proper salting and timing-safe comparison
const isValid = await bcrypt.compare(password, user.passwordHash);
return { isValid, credentials: user };
}For session management, implement encrypted cookie storage with proper security flags:
const crypto = require('crypto');
const encryptSessionData = (data, key) => {
const iv = crypto.randomBytes(16);
const cipher = crypto.createCipheriv('aes-256-gcm', key, iv);
const encrypted = Buffer.concat([cipher.update(data), cipher.final()]);
return Buffer.concat([iv, cipher.getAuthTag(), encrypted]).toString('base64');
};
server.state('session', {
encoding: 'none', // Disable default encoding
isSecure: true, // Require HTTPS
isHttpOnly: true, // Prevent JS access
isSameSite: 'Strict', // Prevent CSRF
clearInvalid: true,
strictHeader: true,
encoding: (data) => encryptSessionData(JSON.stringify(data), process.env.SESSION_KEY)
});API key management should use environment variables with encrypted storage:
const secureConfig = {
getApiKey: (service) => {
const encryptedKey = process.env[`${service}_KEY`];
if (!encryptedKey) throw new Error(`Missing key for ${service}`);
// Decrypt using a secure key management service or HSM
return decryptKey(encryptedKey, process.env.ENCRYPTION_MASTER_KEY);
}Transport security requires proper TLS configuration:
const server = Hapi.server({
port: 3000,
tls: {
minVersion: 'TLSv1.2',
maxVersion: 'TLSv1.3',
ciphers: 'ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384',
honorCipherOrder: true,
requestCert: false,
rejectUnauthorized: true
}For database encryption, implement field-level encryption for sensitive data:
const encryptField = (data, key) => {
const algorithm = 'aes-256-gcm';
const iv = crypto.randomBytes(16);
const cipher = crypto.createCipheriv(algorithm, key, iv);
const encrypted = cipher.update(data, 'utf8', 'hex') + cipher.final('hex');
const authTag = cipher.getAuthTag();
return `${iv.toString('hex')}:${authTag.toString('hex')}:${encrypted}`;
};
const decryptField = (encryptedData, key) => {
const [ivHex, authTagHex, encryptedHex] = encryptedData.split(':');
const iv = Buffer.from(ivHex, 'hex');
const authTag = Buffer.from(authTagHex, 'hex');
const encrypted = Buffer.from(encryptedHex, 'hex');
const decipher = crypto.createDecipheriv('aes-256-gcm', key, iv);
decipher.setAuthTag(authTag);
return decipher.update(encrypted, 'hex', 'utf8') + decipher.final('utf8');
};
// Usage in route handlers
server.route({
method: 'POST',
path: '/users',
handler: async (request, h) => {
const userData = request.payload;
// Encrypt sensitive fields before storage
userData.ssn = encryptField(userData.ssn, process.env.FIELD_ENCRYPTION_KEY);
userData.creditCard = encryptField(userData.creditCard, process.env.FIELD_ENCRYPTION_KEY);
await db.users.insert(userData);
return h.response({ success: true }).code(201);
}middleBrick's CLI tool can verify these remediations by scanning your Hapi application endpoints. After implementing the fixes, run:
middlebrick scan https://your-hapi-app.com/api --output jsonThe scan will check for proper encryption implementations, secure cookie configurations, and correct TLS settings. middleBrick provides specific findings with severity levels and remediation guidance, helping you verify that cryptographic failures have been properly addressed.