Cryptography Skill

Purpose

This skill enforces cryptographic requirements as defined in the Hack23 ISMS Cryptographic Controls Policy. It ensures that all cryptographic operations use approved algorithms and follow best practices for key management.

Rules

Approved Algorithms

Symmetric Encryption - MUST USE:

• AES-256 (Advanced Encryption Standard, 256-bit key)
• AES-128 (minimum, prefer AES-256)
• ChaCha20-Poly1305 (for authenticated encryption)

Asymmetric Encryption - MUST USE:

• RSA-2048 or higher (minimum 2048-bit key, prefer 3072 or 4096)
• ECDSA with P-256, P-384, or P-521 curves
• Ed25519 (EdDSA with Curve25519)

Hashing - MUST USE:

• SHA-256 (minimum)
• SHA-384
• SHA-512
• SHA-3 family
• BLAKE2 (for high-performance applications)

Password Hashing - MUST USE:

• bcrypt (cost factor 12 minimum)
• scrypt
• Argon2id (preferred)
• PBKDF2 with SHA-256, minimum 100,000 iterations

Message Authentication - MUST USE:

• HMAC-SHA256 (minimum)
• HMAC-SHA512

MUST NOT USE (Deprecated/Broken):

• DES, 3DES
• MD5, SHA-1 (except for non-security purposes like checksums)
• RC4
• RSA < 2048 bits
• CBC mode without authenticated encryption
• ECB mode (ever)

TLS/SSL Requirements

MUST:

• Use TLS 1.2 as minimum
• Prefer TLS 1.3
• Use strong cipher suites only
• Verify server certificates
• Use certificate pinning for high-security applications
• Enforce HSTS (HTTP Strict Transport Security)
• Use Perfect Forward Secrecy (PFS) cipher suites

TLS 1.2 Approved Cipher Suites (in order of preference):

TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384
TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256
TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384
TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256
TLS_DHE_RSA_WITH_AES_256_GCM_SHA384
TLS_DHE_RSA_WITH_AES_128_GCM_SHA256

TLS 1.3 Approved Cipher Suites:

TLS_AES_256_GCM_SHA384
TLS_AES_128_GCM_SHA256
TLS_CHACHA20_POLY1305_SHA256

MUST NOT:

• Use SSL 2.0, SSL 3.0, TLS 1.0, TLS 1.1
• Use export-grade ciphers
• Use NULL cipher suites
• Use anonymous cipher suites
• Accept self-signed certificates in production (except for explicitly trusted CAs)

Key Management

MUST:

• Generate keys using cryptographically secure random number generators (CSPRNGs)
• Store keys securely (use key management systems, HSMs for highly sensitive keys)
• Never hardcode keys in source code
• Use environment variables or secret management systems
• Rotate keys according to schedule:
  • TLS certificates: Annually or before expiry
  • Symmetric keys: Annually for CONFIDENTIAL data, quarterly for RESTRICTED
  • API keys: Annually or on compromise
  • Passwords: 90 days for privileged accounts
• Destroy keys securely when no longer needed
• Log key lifecycle events (creation, rotation, destruction)
• Separate key generation from key usage
• Use different keys for different purposes
• Implement key escrow for business continuity (with strict controls)

Key Length Requirements:

• AES: 256 bits (128 minimum)
• RSA: 2048 bits minimum (prefer 3072 or 4096)
• ECDSA: P-256 minimum (prefer P-384 or P-521)
• HMAC: 256 bits minimum

MUST NOT:

• Store keys in plaintext
• Commit keys to version control
• Send keys via email or unencrypted channels
• Reuse keys across different applications or contexts
• Use weak key derivation functions
• Share private keys

Random Number Generation

MUST:

• Use cryptographically secure PRNGs (CSPRNGs)
• For Node.js: crypto.randomBytes(), crypto.randomInt()
• For Python: secrets module, os.urandom()
• For Java: SecureRandom
• For browser: window.crypto.getRandomValues()

MUST NOT:

• Use Math.random() for security purposes
• Use predictable seeds
• Use non-cryptographic PRNGs for security tokens, keys, or IVs

Initialization Vectors (IVs) and Nonces

MUST:

• Generate unique IV/nonce for each encryption operation
• Use cryptographically random IVs for CBC mode
• Use sequential nonces for CTR/GCM modes (ensure uniqueness)
• Store IV with ciphertext (IVs are not secret)
• Never reuse IV with same key

MUST NOT:

• Use predictable or sequential IVs with CBC mode
• Reuse nonces with same key in CTR/GCM modes
• Treat IVs as secrets (they should be random but can be public)

Certificate Management

MUST:

• Use certificates from trusted Certificate Authorities (CAs)
• Validate certificate chains
• Check certificate revocation status (CRL/OCSP)
• Use Subject Alternative Names (SANs) for multiple domains
• Implement certificate expiry monitoring and alerting
• Renew certificates before expiry (30-day minimum buffer)
• Use automated certificate management (e.g., Let's Encrypt with auto-renewal)
• Store private keys securely (encrypted, access-controlled)
• Use separate certificates for different services/environments

Certificate Validity:

• Production: Maximum 1 year
• Development/Testing: Maximum 90 days
• Internal CA: Maximum 2 years

MUST NOT:

• Use self-signed certificates in production (except for internal CA)
• Share private keys between certificates
• Use wildcard certificates without proper access controls
• Ignore certificate warnings or errors

Encryption at Rest

MUST:

• Encrypt CONFIDENTIAL and RESTRICTED data at rest
• Use full disk encryption for laptops and mobile devices
• Use database encryption (TDE) for sensitive databases
• Encrypt sensitive files before storage in cloud services
• Use envelope encryption (encrypt data key with master key)
• Store encryption keys separately from encrypted data

MUST NOT:

• Store unencrypted CONFIDENTIAL or RESTRICTED data
• Use same key for encryption and authentication
• Use deterministic encryption for high-sensitivity data

Encryption in Transit

MUST:

• Use TLS 1.2+ for all network communications
• Encrypt email containing CONFIDENTIAL or RESTRICTED data (S/MIME or PGP)
• Use VPN for remote access to internal systems
• Use SSH (not Telnet) for remote administration
• Use HTTPS for all web applications
• Use secure protocols (SFTP, FTPS, not FTP)

MUST NOT:

• Transmit RESTRICTED data over unencrypted channels
• Use unencrypted protocols (HTTP, FTP, Telnet, SMTP without TLS)
• Disable certificate verification

Examples

Example 1: Symmetric Encryption (Node.js)

const crypto = require('crypto');

// GOOD: AES-256-GCM encryption
function encrypt(plaintext, key) {
  // Generate random IV (12 bytes for GCM)
  const iv = crypto.randomBytes(12);
  
  // Create cipher
  const cipher = crypto.createCipheriv('aes-256-gcm', key, iv);
  
  // Encrypt
  let ciphertext = cipher.update(plaintext, 'utf8', 'hex');
  ciphertext += cipher.final('hex');
  
  // Get authentication tag
  const authTag = cipher.getAuthTag();
  
  // Return IV + authTag + ciphertext
  return {
    iv: iv.toString('hex'),
    authTag: authTag.toString('hex'),
    ciphertext: ciphertext
  };
}

function decrypt(encrypted, key) {
  // Create decipher
  const decipher = crypto.createDecipheriv(
    'aes-256-gcm',
    key,
    Buffer.from(encrypted.iv, 'hex')
  );
  
  // Set authentication tag
  decipher.setAuthTag(Buffer.from(encrypted.authTag, 'hex'));
  
  // Decrypt
  let plaintext = decipher.update(encrypted.ciphertext, 'hex', 'utf8');
  plaintext += decipher.final('utf8');
  
  return plaintext;
}

// Generate secure key (store securely, don't hardcode!)
const key = crypto.randomBytes(32); // 256 bits

// Usage
const encrypted = encrypt('Sensitive data', key);
console.log('Encrypted:', encrypted);

const decrypted = decrypt(encrypted, key);
console.log('Decrypted:', decrypted);

// BAD: Using deprecated algorithm
function encryptBad(plaintext, key) {
  // NEVER use DES!
  const cipher = crypto.createCipheriv('des-ede3-cbc', key, iv);
  return cipher.update(plaintext, 'utf8', 'hex') + cipher.final('hex');
}

Example 2: Password Hashing (Node.js with bcrypt)

const bcrypt = require('bcrypt');

// GOOD: bcrypt with appropriate cost factor
async function hashPassword(password) {
  // Cost factor 12 = 2^12 iterations (minimum)
  const saltRounds = 12;
  const hash = await bcrypt.hash(password, saltRounds);
  return hash;
}

async function verifyPassword(password, hash) {
  return await bcrypt.compare(password, hash);
}

// Usage
const password = 'MySecurePassword123!';
const hash = await hashPassword(password);
console.log('Hash:', hash);

const isValid = await verifyPassword(password, hash);
console.log('Valid:', isValid);

// BAD: Using weak hashing
function hashPasswordBad(password) {
  // NEVER use MD5 or SHA-1 for passwords!
  return crypto.createHash('md5').update(password).digest('hex');
}

// BAD: Insufficient iterations
async function hashPasswordWeak(password) {
  // Cost factor 4 is too weak!
  return await bcrypt.hash(password, 4);
}

Example 3: Secure Random Generation

const crypto = require('crypto');

// GOOD: Cryptographically secure random
function generateToken(length = 32) {
  return crypto.randomBytes(length).toString('hex');
}

function generateApiKey() {
  return crypto.randomBytes(32).toString('base64');
}

function generateSecurePin(digits = 6) {
  const max = Math.pow(10, digits);
  return crypto.randomInt(0, max).toString().padStart(digits, '0');
}

// Usage
const sessionToken = generateToken();
const apiKey = generateApiKey();
const pin = generateSecurePin(6);

// BAD: Using Math.random() for security
function generateTokenBad() {
  // NEVER use Math.random() for security!
  return Math.random().toString(36).substring(2);
}

Example 4: TLS Configuration (Node.js HTTPS Server)

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

// GOOD: Secure TLS configuration
const options = {
  key: fs.readFileSync('/path/to/private-key.pem'),
  cert: fs.readFileSync('/path/to/certificate.pem'),
  ca: fs.readFileSync('/path/to/ca-bundle.pem'),
  
  // TLS 1.2 minimum
  minVersion: 'TLSv1.2',
  
  // Prefer TLS 1.3
  maxVersion: 'TLSv1.3',
  
  // Strong cipher suites only
  ciphers: [
    'TLS_AES_256_GCM_SHA384',
    'TLS_AES_128_GCM_SHA256',
    'TLS_CHACHA20_POLY1305_SHA256',
    'ECDHE-RSA-AES256-GCM-SHA384',
    'ECDHE-RSA-AES128-GCM-SHA256',
    'ECDHE-ECDSA-AES256-GCM-SHA384',
    'ECDHE-ECDSA-AES128-GCM-SHA256'
  ].join(':'),
  
  // Prefer server cipher order
  honorCipherOrder: true,
  
  // Enable Perfect Forward Secrecy
  ecdhCurve: 'prime256v1:secp384r1:secp521r1',
  
  // Require client certificate (if needed)
  requestCert: false,
  rejectUnauthorized: true
};

const server = https.createServer(options, (req, res) => {
  // Set security headers
  res.setHeader('Strict-Transport-Security', 'max-age=31536000; includeSubDomains; preload');
  res.setHeader('X-Content-Type-Options', 'nosniff');
  res.setHeader('X-Frame-Options', 'DENY');
  
  res.writeHead(200);
  res.end('Secure connection');
});

server.listen(443);

// BAD: Weak TLS configuration
const optionsBad = {
  key: fs.readFileSync('/path/to/private-key.pem'),
  cert: fs.readFileSync('/path/to/certificate.pem'),
  
  // NEVER allow TLS 1.0/1.1
  minVersion: 'TLSv1.0', // TOO WEAK!
  
  // Allowing weak ciphers
  ciphers: 'ALL', // INSECURE!
  
  // Not rejecting unauthorized
  rejectUnauthorized: false // DANGEROUS!
};

Example 5: Key Derivation (PBKDF2)

const crypto = require('crypto');

// Derive encryption key from password
function deriveKey(password, salt, keyLength = 32) {
  // Use PBKDF2 with SHA-256, 100,000 iterations minimum
  return crypto.pbkdf2Sync(
    password,
    salt,
    100000, // iterations (minimum)
    keyLength,
    'sha256'
  );
}

// Usage
const password = 'UserPassword123!';
const salt = crypto.randomBytes(16); // Store salt with encrypted data
const key = deriveKey(password, salt, 32); // 256-bit key

console.log('Derived key:', key.toString('hex'));

// BAD: Weak key derivation
function deriveKeyWeak(password) {
  // NEVER use simple hashing for key derivation!
  return crypto.createHash('sha256').update(password).digest();
}

Example 6: Secure File Encryption

const crypto = require('crypto');
const fs = require('fs').promises;

async function encryptFile(inputPath, outputPath, key) {
  // Read file
  const plaintext = await fs.readFile(inputPath);
  
  // Generate IV
  const iv = crypto.randomBytes(12);
  
  // Encrypt
  const cipher = crypto.createCipheriv('aes-256-gcm', key, iv);
  const ciphertext = Buffer.concat([
    cipher.update(plaintext),
    cipher.final()
  ]);
  
  // Get auth tag
  const authTag = cipher.getAuthTag();
  
  // Write IV + authTag + ciphertext
  const encrypted = Buffer.concat([iv, authTag, ciphertext]);
  await fs.writeFile(outputPath, encrypted);
}

async function decryptFile(inputPath, outputPath, key) {
  // Read encrypted file
  const encrypted = await fs.readFile(inputPath);
  
  // Extract IV, auth tag, and ciphertext
  const iv = encrypted.slice(0, 12);
  const authTag = encrypted.slice(12, 28);
  const ciphertext = encrypted.slice(28);
  
  // Decrypt
  const decipher = crypto.createDecipheriv('aes-256-gcm', key, iv);
  decipher.setAuthTag(authTag);
  
  const plaintext = Buffer.concat([
    decipher.update(ciphertext),
    decipher.final()
  ]);
  
  // Write decrypted file
  await fs.writeFile(outputPath, plaintext);
}

// Usage
const key = crypto.randomBytes(32);
await encryptFile('sensitive.pdf', 'sensitive.pdf.enc', key);
await decryptFile('sensitive.pdf.enc', 'sensitive-decrypted.pdf', key);

Example 7: Certificate Validation

const https = require('https');
const tls = require('tls');

// GOOD: Verify certificate
function makeSecureRequest(url) {
  return new Promise((resolve, reject) => {
    https.get(url, {
      // Verify certificate chain
      rejectUnauthorized: true,
      
      // Check hostname
      checkServerIdentity: (hostname, cert) => {
        const err = tls.checkServerIdentity(hostname, cert);
        if (err) {
          return err;
        }
        
        // Additional checks
        const now = new Date();
        const notBefore = new Date(cert.valid_from);
        const notAfter = new Date(cert.valid_to);
        
        if (now < notBefore || now > notAfter) {
          return new Error('Certificate not valid for current date');
        }
        
        return undefined;
      }
    }, (res) => {
      let data = '';
      res.on('data', chunk => data += chunk);
      res.on('end', () => resolve(data));
    }).on('error', reject);
  });
}

// BAD: Skipping certificate verification
function makeInsecureRequest(url) {
  return new Promise((resolve, reject) => {
    https.get(url, {
      // NEVER disable certificate verification!
      rejectUnauthorized: false // DANGEROUS!
    }, (res) => {
      let data = '';
      res.on('data', chunk => data += chunk);
      res.on('end', () => resolve(data));
    }).on('error', reject);
  });
}

Related ISMS Policies

• Cryptographic Controls Policy - Primary policy for cryptography
• Data Classification Policy - Data classification and encryption requirements
• Secure Development Policy - Cryptographic implementation in code

Related Documentation

• SECURITY_ARCHITECTURE.md - Cryptographic controls in architecture
• secure-development SKILL.md - Secure coding practices
• data-classification SKILL.md - Encryption requirements by classification

Compliance Mapping

ISO 27001:2022

• A.8.24 Use of cryptography

NIST Cybersecurity Framework

• PR.DS-1: Data-at-rest is protected
• PR.DS-2: Data-in-transit is protected

CIS Controls

• Control 3: Data Protection
  • 3.10 Encrypt Sensitive Data in Transit
  • 3.11 Encrypt Sensitive Data at Rest

Key Rotation Schedule

Key Type	Rotation Frequency	Trigger for Immediate Rotation
TLS Certificates	Annually	Compromise, algorithm weakness
Symmetric Keys (RESTRICTED)	Quarterly	Compromise, employee departure
Symmetric Keys (CONFIDENTIAL)	Annually	Compromise
API Keys	Annually	Compromise, employee departure
SSH Keys	2 years	Compromise
Root CA Keys	10 years	Compromise
Database Encryption Keys	2 years	Compromise

Enforcement

Violations of cryptographic requirements:

• Critical (use of banned algorithms, hardcoded keys): Block deployment
• High (weak configurations, missing encryption): Require immediate remediation
• Medium (suboptimal configurations): Remediate within sprint