Encryption vs Encoding vs Hashing: Understanding Data Security Methods

// Base64 Encoding - NOT SECURE!
const text = 'Hello World';
const encoded = btoa(text);
console.log(encoded);  // 'SGVsbG8gV29ybGQ='

// Easily decoded
const decoded = atob(encoded);
console.log(decoded);  // 'Hello World'

// ANYONE can decode Base64 - no security!
// Don't use for passwords or sensitive data

// URL Encoding
const url = 'https://example.com/search?q=hello world&name=John Doe';

// Encode query parameters
const encoded = encodeURIComponent('hello world');
console.log(encoded);  // 'hello%20world'

// Decode
const decoded = decodeURIComponent(encoded);
console.log(decoded);  // 'hello world'

// Full URL encoding
const fullUrl = encodeURI(url);
console.log(fullUrl);

// HTML Entity Encoding
function escapeHtml(text) {
  return text
    .replace(/&/g, '&')
    .replace(/</g, '&lt;')
    .replace(/>/g, '&gt;')
    .replace(/"/g, '&quot;')
    .replace(/'/g, '&#039;');
}

const userInput = '<script>alert("XSS")</script>';
const safe = escapeHtml(userInput);
console.log(safe);
// '&lt;script&gt;alert(&quot;XSS&quot;)&lt;/script&gt;'

// Base64
const text = 'Hello World';
const base64 = btoa(text);
const decoded = atob(base64);

// URL Encoding
const urlEncoded = encodeURIComponent('hello world');
const urlDecoded = decodeURIComponent(urlEncoded);

// JSON
const obj = { name: 'John', age: 30 };
const json = JSON.stringify(obj);
const parsed = JSON.parse(json);

// Hex
function toHex(str) {
  return Array.from(str)
    .map(c => c.charCodeAt(0).toString(16).padStart(2, '0'))
    .join('');
}

function fromHex(hex) {
  return hex.match(/.{1,2}/g)
    .map(byte => String.fromCharCode(parseInt(byte, 16)))
    .join('');
}

import base64
import urllib.parse
import html

# Base64
text = b'Hello World'
encoded = base64.b64encode(text)
decoded = base64.b64decode(encoded)

# URL Encoding
url_encoded = urllib.parse.quote('hello world')
url_decoded = urllib.parse.unquote(url_encoded)

# HTML Encoding
html_encoded = html.escape('<script>alert("XSS")</script>')
html_decoded = html.unescape(html_encoded)

# Hex
hex_encoded = text.hex()
hex_decoded = bytes.fromhex(hex_encoded)

<?php
// Base64
$text = 'Hello World';
$encoded = base64_encode($text);
$decoded = base64_decode($encoded);

// URL Encoding
$urlEncoded = urlencode('hello world');
$urlDecoded = urldecode($urlEncoded);

// HTML Encoding
$htmlEncoded = htmlspecialchars('<script>alert("XSS")</script>');
$htmlDecoded = htmlspecialchars_decode($htmlEncoded);

// JSON
$array = ['name' => 'John', 'age' => 30];
$json = json_encode($array);
$decoded = json_decode($json, true);
?>

const crypto = require('crypto');

// AES-256-GCM Encryption
function encrypt(plaintext, key) {
  // Generate random IV
  const iv = crypto.randomBytes(16);

  // 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 {
    ciphertext,
    iv: iv.toString('hex'),
    authTag: authTag.toString('hex')
  };
}

function decrypt(ciphertext, key, iv, authTag) {
  const decipher = crypto.createDecipheriv(
    'aes-256-gcm',
    key,
    Buffer.from(iv, 'hex')
  );

  decipher.setAuthTag(Buffer.from(authTag, 'hex'));

  let plaintext = decipher.update(ciphertext, 'hex', 'utf8');
  plaintext += decipher.final('utf8');

  return plaintext;
}

// Usage
const key = crypto.randomBytes(32);  // 256-bit key
const message = 'Secret message';

const encrypted = encrypt(message, key);
console.log('Encrypted:', encrypted);

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

const crypto = require('crypto');

// Generate RSA key pair
const { publicKey, privateKey } = crypto.generateKeyPairSync('rsa', {
  modulusLength: 2048,
  publicKeyEncoding: {
    type: 'spki',
    format: 'pem'
  },
  privateKeyEncoding: {
    type: 'pkcs8',
    format: 'pem'
  }
});

// Encrypt with public key
function encrypt(plaintext, publicKey) {
  return crypto.publicEncrypt(
    {
      key: publicKey,
      padding: crypto.constants.RSA_PKCS1_OAEP_PADDING,
      oaepHash: 'sha256'
    },
    Buffer.from(plaintext)
  ).toString('base64');
}

// Decrypt with private key
function decrypt(ciphertext, privateKey) {
  return crypto.privateDecrypt(
    {
      key: privateKey,
      padding: crypto.constants.RSA_PKCS1_OAEP_PADDING,
      oaepHash: 'sha256'
    },
    Buffer.from(ciphertext, 'base64')
  ).toString('utf8');
}

// Usage
const message = 'Secret message';
const encrypted = encrypt(message, publicKey);
console.log('Encrypted:', encrypted);

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

// Web Crypto API (browser)
async function encryptData(plaintext, password) {
  // Derive key from password
  const enc = new TextEncoder();
  const keyMaterial = await crypto.subtle.importKey(
    'raw',
    enc.encode(password),
    'PBKDF2',
    false,
    ['deriveKey']
  );

  const salt = crypto.getRandomValues(new Uint8Array(16));

  const key = await crypto.subtle.deriveKey(
    {
      name: 'PBKDF2',
      salt: salt,
      iterations: 100000,
      hash: 'SHA-256'
    },
    keyMaterial,
    { name: 'AES-GCM', length: 256 },
    false,
    ['encrypt', 'decrypt']
  );

  // Encrypt
  const iv = crypto.getRandomValues(new Uint8Array(12));
  const ciphertext = await crypto.subtle.encrypt(
    { name: 'AES-GCM', iv: iv },
    key,
    enc.encode(plaintext)
  );

  return {
    ciphertext: Array.from(new Uint8Array(ciphertext)),
    iv: Array.from(iv),
    salt: Array.from(salt)
  };
}

async function decryptData(encryptedData, password) {
  const enc = new TextEncoder();
  const dec = new TextDecoder();

  // Derive key
  const keyMaterial = await crypto.subtle.importKey(
    'raw',
    enc.encode(password),
    'PBKDF2',
    false,
    ['deriveKey']
  );

  const key = await crypto.subtle.deriveKey(
    {
      name: 'PBKDF2',
      salt: new Uint8Array(encryptedData.salt),
      iterations: 100000,
      hash: 'SHA-256'
    },
    keyMaterial,
    { name: 'AES-GCM', length: 256 },
    false,
    ['encrypt', 'decrypt']
  );

  // Decrypt
  const plaintext = await crypto.subtle.decrypt(
    {
      name: 'AES-GCM',
      iv: new Uint8Array(encryptedData.iv)
    },
    key,
    new Uint8Array(encryptedData.ciphertext)
  );

  return dec.decode(plaintext);
}

const crypto = require('crypto');

class Encryptor {
  constructor(password) {
    // Derive key from password
    this.salt = crypto.randomBytes(32);
    this.key = crypto.scryptSync(password, this.salt, 32);
  }

  encrypt(plaintext) {
    const iv = crypto.randomBytes(16);
    const cipher = crypto.createCipheriv('aes-256-gcm', this.key, iv);

    let ciphertext = cipher.update(plaintext, 'utf8', 'hex');
    ciphertext += cipher.final('hex');

    return {
      ciphertext,
      iv: iv.toString('hex'),
      salt: this.salt.toString('hex'),
      authTag: cipher.getAuthTag().toString('hex')
    };
  }

  decrypt(encrypted) {
    const decipher = crypto.createDecipheriv(
      'aes-256-gcm',
      this.key,
      Buffer.from(encrypted.iv, 'hex')
    );

    decipher.setAuthTag(Buffer.from(encrypted.authTag, 'hex'));

    let plaintext = decipher.update(encrypted.ciphertext, 'hex', 'utf8');
    plaintext += decipher.final('utf8');

    return plaintext;
  }
}

// Usage
const encryptor = new Encryptor('my-strong-password');
const encrypted = encryptor.encrypt('Secret data');
const decrypted = encryptor.decrypt(encrypted);

from cryptography.fernet import Fernet
from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
from cryptography.hazmat.primitives import hashes
import base64
import os

class Encryptor:
    def __init__(self, password: str):
        # Derive key from password
        self.salt = os.urandom(16)
        kdf = PBKDF2HMAC(
            algorithm=hashes.SHA256(),
            length=32,
            salt=self.salt,
            iterations=100000
        )
        key = base64.urlsafe_b64encode(kdf.derive(password.encode()))
        self.fernet = Fernet(key)

    def encrypt(self, plaintext: str) -> bytes:
        return self.fernet.encrypt(plaintext.encode())

    def decrypt(self, ciphertext: bytes) -> str:
        return self.fernet.decrypt(ciphertext).decode()

# Usage
encryptor = Encryptor('my-strong-password')
encrypted = encryptor.encrypt('Secret data')
decrypted = encryptor.decrypt(encrypted)

print(f'Encrypted: {encrypted}')
print(f'Decrypted: {decrypted}')

import javax.crypto.*;
import javax.crypto.spec.*;
import java.security.*;

public class Encryptor {
    private static final String ALGORITHM = "AES/GCM/NoPadding";

    public static byte[] encrypt(String plaintext, SecretKey key)
            throws Exception {
        Cipher cipher = Cipher.getInstance(ALGORITHM);

        // Generate random IV
        byte[] iv = new byte[12];
        SecureRandom random = new SecureRandom();
        random.nextBytes(iv);
        GCMParameterSpec spec = new GCMParameterSpec(128, iv);

        cipher.init(Cipher.ENCRYPT_MODE, key, spec);
        byte[] ciphertext = cipher.doFinal(plaintext.getBytes());

        // Combine IV and ciphertext
        byte[] combined = new byte[iv.length + ciphertext.length];
        System.arraycopy(iv, 0, combined, 0, iv.length);
        System.arraycopy(ciphertext, 0, combined, iv.length, ciphertext.length);

        return combined;
    }

    public static String decrypt(byte[] combined, SecretKey key)
            throws Exception {
        Cipher cipher = Cipher.getInstance(ALGORITHM);

        // Extract IV and ciphertext
        byte[] iv = new byte[12];
        byte[] ciphertext = new byte[combined.length - 12];
        System.arraycopy(combined, 0, iv, 0, 12);
        System.arraycopy(combined, 12, ciphertext, 0, ciphertext.length);

        GCMParameterSpec spec = new GCMParameterSpec(128, iv);
        cipher.init(Cipher.DECRYPT_MODE, key, spec);

        return new String(cipher.doFinal(ciphertext));
    }

    public static void main(String[] args) throws Exception {
        KeyGenerator keyGen = KeyGenerator.getInstance("AES");
        keyGen.init(256);
        SecretKey key = keyGen.generateKey();

        byte[] encrypted = encrypt("Secret message", key);
        String decrypted = decrypt(encrypted, key);
        System.out.println("Decrypted: " + decrypted);
    }
}

const crypto = require('crypto');

// MD5 (broken, don't use for security)
const md5 = crypto.createHash('md5').update('hello').digest('hex');
console.log('MD5:', md5);

// SHA-1 (deprecated)
const sha1 = crypto.createHash('sha1').update('hello').digest('hex');
console.log('SHA-1:', sha1);

// SHA-256 (recommended)
const sha256 = crypto.createHash('sha256').update('hello').digest('hex');
console.log('SHA-256:', sha256);

// SHA-512
const sha512 = crypto.createHash('sha512').update('hello').digest('hex');
console.log('SHA-512:', sha512);

// Properties
console.log('MD5 length:', md5.length);       // 32 chars
console.log('SHA-256 length:', sha256.length); // 64 chars
console.log('SHA-512 length:', sha512.length); // 128 chars

// Same input always produces same hash
const hash1 = crypto.createHash('sha256').update('test').digest('hex');
const hash2 = crypto.createHash('sha256').update('test').digest('hex');
console.log('Same?', hash1 === hash2);  // true

const crypto = require('crypto');

function hashPassword(password) {
  // Generate random salt
  const salt = crypto.randomBytes(16).toString('hex');

  // Hash password with salt
  const hash = crypto
    .createHash('sha256')
    .update(password + salt)
    .digest('hex');

  // Store both hash and salt
  return { hash, salt };
}

function verifyPassword(password, storedHash, salt) {
  const hash = crypto
    .createHash('sha256')
    .update(password + salt)
    .digest('hex');

  return hash === storedHash;
}

// Usage
const password = 'mySecretPassword';
const { hash, salt } = hashPassword(password);

console.log('Hash:', hash);
console.log('Salt:', salt);

// Verify
const isValid = verifyPassword('mySecretPassword', hash, salt);
console.log('Valid?', isValid);  // true

// Note: This is still not secure enough for passwords!
// Use bcrypt, scrypt, or Argon2 instead

const bcrypt = require('bcrypt');

// Hash password
async function hashPassword(password) {
  const saltRounds = 12;
  const hash = await bcrypt.hash(password, saltRounds);
  return hash;
}

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

// Usage
(async () => {
  const password = 'mySecretPassword';

  // Hash (includes salt automatically)
  const hash = await hashPassword(password);
  console.log('Hash:', hash);
  // $2b$12$xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

  // Verify correct password
  const isValid = await verifyPassword('mySecretPassword', hash);
  console.log('Correct password?', isValid);  // true

  // Verify wrong password
  const isInvalid = await verifyPassword('wrongPassword', hash);
  console.log('Wrong password?', isInvalid);  // false
})();

const bcrypt = require('bcrypt');

// Configuration
const SALT_ROUNDS = 12;  // Cost factor (2^12 iterations)

class PasswordManager {
  static async hash(password) {
    // bcrypt generates salt and hashes in one step
    const hash = await bcrypt.hash(password, SALT_ROUNDS);
    return hash;
  }

  static async verify(password, hash) {
    // Compare returns boolean
    return await bcrypt.compare(password, hash);
  }

  static async needsRehash(hash) {
    // Check if hash uses outdated cost factor
    const currentRounds = parseInt(hash.split('$')[2]);
    return currentRounds < SALT_ROUNDS;
  }
}

// Usage
(async () => {
  // Registration
  const password = 'user-password';
  const hash = await PasswordManager.hash(password);

  // Store hash in database
  console.log('Stored hash:', hash);

  // Login
  const isValid = await PasswordManager.verify('user-password', hash);
  console.log('Login successful?', isValid);

  // Check if needs rehashing (after increasing SALT_ROUNDS)
  const rehash = await PasswordManager.needsRehash(hash);
  if (rehash) {
    const newHash = await PasswordManager.hash(password);
    // Update database with new hash
  }
})();

const argon2 = require('argon2');

class PasswordManager {
  static async hash(password) {
    // Argon2id (recommended variant)
    const hash = await argon2.hash(password, {
      type: argon2.argon2id,
      memoryCost: 65536,  // 64 MB
      timeCost: 3,        // 3 iterations
      parallelism: 4      // 4 parallel threads
    });
    return hash;
  }

  static async verify(password, hash) {
    try {
      return await argon2.verify(hash, password);
    } catch (err) {
      return false;
    }
  }

  static async needsRehash(hash) {
    return argon2.needsRehash(hash, {
      type: argon2.argon2id,
      memoryCost: 65536,
      timeCost: 3,
      parallelism: 4
    });
  }
}

// Usage
(async () => {
  const password = 'user-password';
  const hash = await PasswordManager.hash(password);
  console.log('Hash:', hash);

  const isValid = await PasswordManager.verify('user-password', hash);
  console.log('Valid?', isValid);
})();

// Browser (Web Crypto API)
async function sha256(message) {
  const msgBuffer = new TextEncoder().encode(message);
  const hashBuffer = await crypto.subtle.digest('SHA-256', msgBuffer);
  const hashArray = Array.from(new Uint8Array(hashBuffer));
  const hashHex = hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
  return hashHex;
}

// Usage
(async () => {
  const hash = await sha256('hello world');
  console.log('SHA-256:', hash);
})();

const crypto = require('crypto');

function hash(algorithm, data) {
  return crypto.createHash(algorithm).update(data).digest('hex');
}

// Various hash algorithms
console.log('MD5:', hash('md5', 'hello'));
console.log('SHA-1:', hash('sha1', 'hello'));
console.log('SHA-256:', hash('sha256', 'hello'));
console.log('SHA-512:', hash('sha512', 'hello'));

// HMAC (keyed hash)
function hmac(algorithm, data, key) {
  return crypto.createHmac(algorithm, key).update(data).digest('hex');
}

const key = 'secret-key';
const signature = hmac('sha256', 'message', key);
console.log('HMAC-SHA256:', signature);

// File hashing (for checksums)
const fs = require('fs');

function hashFile(filename) {
  return new Promise((resolve, reject) => {
    const hash = crypto.createHash('sha256');
    const stream = fs.createReadStream(filename);

    stream.on('data', data => hash.update(data));
    stream.on('end', () => resolve(hash.digest('hex')));
    stream.on('error', reject);
  });
}

import hashlib
import hmac

# Basic hashing
def hash_data(algorithm, data):
    h = hashlib.new(algorithm)
    h.update(data.encode())
    return h.hexdigest()

print('MD5:', hash_data('md5', 'hello'))
print('SHA-1:', hash_data('sha1', 'hello'))
print('SHA-256:', hash_data('sha256', 'hello'))
print('SHA-512:', hash_data('sha512', 'hello'))

# HMAC
key = b'secret-key'
message = b'message'
signature = hmac.new(key, message, hashlib.sha256).hexdigest()
print('HMAC-SHA256:', signature)

# Password hashing with bcrypt
import bcrypt

password = b'my-password'
salt = bcrypt.gensalt(rounds=12)
hashed = bcrypt.hashpw(password, salt)

# Verify
is_valid = bcrypt.checkpw(b'my-password', hashed)
print('Valid?', is_valid)

<?php
// Basic hashing
$hash_md5 = md5('hello');
$hash_sha1 = sha1('hello');
$hash_sha256 = hash('sha256', 'hello');
$hash_sha512 = hash('sha512', 'hello');

echo "MD5: $hash_md5\n";
echo "SHA-256: $hash_sha256\n";

// Password hashing (recommended)
$password = 'user-password';

// Hash
$hash = password_hash($password, PASSWORD_ARGON2ID, [
    'memory_cost' => 65536,
    'time_cost' => 4,
    'threads' => 3
]);

echo "Hash: $hash\n";

// Verify
$is_valid = password_verify('user-password', $hash);
echo "Valid? " . ($is_valid ? 'true' : 'false') . "\n";

// Check if needs rehash
if (password_needs_rehash($hash, PASSWORD_ARGON2ID)) {
    $new_hash = password_hash($password, PASSWORD_ARGON2ID);
    // Update database
}

// HMAC
$key = 'secret-key';
$message = 'data';
$signature = hash_hmac('sha256', $message, $key);
echo "HMAC: $signature\n";
?>

const bcrypt = require('bcrypt');

async function registerUser(username, password, email) {
  // 1. Validate input (encoding for display)
  const safeUsername = escapeHtml(username);

  // 2. Hash password (NEVER store plaintext!)
  const passwordHash = await bcrypt.hash(password, 12);

  // 3. Store in database
  await db.users.insert({
    username: safeUsername,
    password_hash: passwordHash,  // Hashed
    email: email,                  // Store as-is or encrypted
    created_at: new Date()
  });

  return { success: true };
}

function escapeHtml(text) {
  return text
    .replace(/&/g, '&')
    .replace(/</g, '&lt;')
    .replace(/>/g, '&gt;');
}

const crypto = require('crypto');

class ApiTokenManager {
  // Generate token
  static generate(userId) {
    const token = crypto.randomBytes(32).toString('hex');

    // Hash token before storing
    const tokenHash = crypto
      .createHash('sha256')
      .update(token)
      .digest('hex');

    // Store hash, not token
    db.tokens.insert({
      user_id: userId,
      token_hash: tokenHash,
      created_at: new Date()
    });

    // Return unhashed token to user (only time they see it)
    return token;
  }

  // Verify token
  static async verify(token) {
    const tokenHash = crypto
      .createHash('sha256')
      .update(token)
      .digest('hex');

    const stored = await db.tokens.findOne({ token_hash: tokenHash });
    return stored ? stored.user_id : null;
  }
}

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

async function handleFileUpload(file) {
  // 1. Calculate hash for integrity
  const hash = await calculateFileHash(file.path);

  // 2. Encrypt sensitive files
  let storagePath = file.path;
  if (file.sensitive) {
    const encrypted = await encryptFile(file.path);
    storagePath = encrypted.path;
  }

  // 3. Store metadata
  await db.files.insert({
    filename: file.name,
    path: storagePath,
    hash: hash,              // For integrity verification
    encrypted: file.sensitive,
    uploaded_at: new Date()
  });

  return { hash, success: true };
}

function calculateFileHash(filePath) {
  return new Promise((resolve, reject) => {
    const hash = crypto.createHash('sha256');
    const stream = fs.createReadStream(filePath);

    stream.on('data', data => hash.update(data));
    stream.on('end', () => resolve(hash.digest('hex')));
    stream.on('error', reject);
  });
}

const crypto = require('crypto');

class CreditCardManager {
  constructor(encryptionKey) {
    this.key = Buffer.from(encryptionKey, 'hex');
  }

  // Encrypt card number (PCI-DSS requirement)
  encrypt(cardNumber) {
    const iv = crypto.randomBytes(16);
    const cipher = crypto.createCipheriv('aes-256-gcm', this.key, iv);

    let encrypted = cipher.update(cardNumber, 'utf8', 'hex');
    encrypted += cipher.final('hex');

    const authTag = cipher.getAuthTag();

    return {
      encrypted,
      iv: iv.toString('hex'),
      authTag: authTag.toString('hex')
    };
  }

  // Decrypt for payment processing
  decrypt(encrypted, iv, authTag) {
    const decipher = crypto.createDecipheriv(
      'aes-256-gcm',
      this.key,
      Buffer.from(iv, 'hex')
    );

    decipher.setAuthTag(Buffer.from(authTag, 'hex'));

    let decrypted = decipher.update(encrypted, 'hex', 'utf8');
    decrypted += decipher.final('utf8');

    return decrypted;
  }

  // Store only last 4 digits in plaintext
  maskCard(cardNumber) {
    return '**<strong> </strong><strong> </strong>** ' + cardNumber.slice(-4);
  }
}

// Usage
const manager = new CreditCardManager(process.env.ENCRYPTION_KEY);
const card = '4111111111111111';

// Encrypt for storage
const encrypted = manager.encrypt(card);

// Store encrypted data and masked version
db.cards.insert({
  encrypted_number: encrypted.encrypted,
  iv: encrypted.iv,
  auth_tag: encrypted.authTag,
  masked_number: manager.maskCard(card)  // For display
});

const bcrypt = require('bcrypt');
const crypto = require('crypto');

class AuthSystem {
  // Register user
  static async register(username, password, email) {
    // Hash password
    const passwordHash = await bcrypt.hash(password, 12);

    // Create user
    const user = await db.users.insert({
      username,
      password_hash: passwordHash,
      email,
      created_at: new Date()
    });

    return { userId: user.id, success: true };
  }

  // Login
  static async login(username, password) {
    // Find user
    const user = await db.users.findOne({ username });
    if (!user) return { success: false, error: 'Invalid credentials' };

    // Verify password
    const valid = await bcrypt.compare(password, user.password_hash);
    if (!valid) return { success: false, error: 'Invalid credentials' };

    // Generate session token
    const sessionToken = crypto.randomBytes(32).toString('hex');
    const tokenHash = crypto.createHash('sha256')
      .update(sessionToken)
      .digest('hex');

    // Store session
    await db.sessions.insert({
      user_id: user.id,
      token_hash: tokenHash,
      created_at: new Date(),
      expires_at: new Date(Date.now() + 24 * 60 * 60 * 1000)  // 24 hours
    });

    return { success: true, token: sessionToken };
  }

  // Verify session
  static async verifySession(token) {
    const tokenHash = crypto.createHash('sha256')
      .update(token)
      .digest('hex');

    const session = await db.sessions.findOne({
      token_hash: tokenHash,
      expires_at: { $gt: new Date() }
    });

    return session ? session.user_id : null;
  }

  // Change password
  static async changePassword(userId, oldPassword, newPassword) {
    const user = await db.users.findById(userId);

    // Verify old password
    const valid = await bcrypt.compare(oldPassword, user.password_hash);
    if (!valid) return { success: false, error: 'Invalid password' };

    // Hash new password
    const newHash = await bcrypt.hash(newPassword, 12);

    // Update
    await db.users.update(userId, { password_hash: newHash });

    // Invalidate all sessions
    await db.sessions.deleteMany({ user_id: userId });

    return { success: true };
  }
}

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

class SecureFileStorage {
  constructor(masterKey) {
    this.masterKey = Buffer.from(masterKey, 'hex');
  }

  async encryptFile(inputPath, outputPath) {
    // Read file
    const data = await fs.readFile(inputPath);

    // Generate file key
    const fileKey = crypto.randomBytes(32);

    // Encrypt file with file key
    const iv = crypto.randomBytes(16);
    const cipher = crypto.createCipheriv('aes-256-gcm', fileKey, iv);

    const encrypted = Buffer.concat([
      cipher.update(data),
      cipher.final()
    ]);

    const authTag = cipher.getAuthTag();

    // Encrypt file key with master key
    const keyIv = crypto.randomBytes(16);
    const keyCipher = crypto.createCipheriv('aes-256-gcm', this.masterKey, keyIv);

    const encryptedKey = Buffer.concat([
      keyCipher.update(fileKey),
      keyCipher.final()
    ]);

    const keyAuthTag = keyCipher.getAuthTag();

    // Save encrypted file and metadata
    await fs.writeFile(outputPath, encrypted);

    return {
      iv: iv.toString('hex'),
      authTag: authTag.toString('hex'),
      encryptedKey: encryptedKey.toString('hex'),
      keyIv: keyIv.toString('hex'),
      keyAuthTag: keyAuthTag.toString('hex'),
      hash: crypto.createHash('sha256').update(data).digest('hex')
    };
  }

  async decryptFile(inputPath, metadata) {
    // Decrypt file key
    const keyDecipher = crypto.createDecipheriv(
      'aes-256-gcm',
      this.masterKey,
      Buffer.from(metadata.keyIv, 'hex')
    );

    keyDecipher.setAuthTag(Buffer.from(metadata.keyAuthTag, 'hex'));

    const fileKey = Buffer.concat([
      keyDecipher.update(Buffer.from(metadata.encryptedKey, 'hex')),
      keyDecipher.final()
    ]);

    // Decrypt file
    const encrypted = await fs.readFile(inputPath);
    const decipher = crypto.createDecipheriv(
      'aes-256-gcm',
      fileKey,
      Buffer.from(metadata.iv, 'hex')
    );

    decipher.setAuthTag(Buffer.from(metadata.authTag, 'hex'));

    const decrypted = Buffer.concat([
      decipher.update(encrypted),
      decipher.final()
    ]);

    // Verify hash
    const hash = crypto.createHash('sha256').update(decrypted).digest('hex');
    if (hash !== metadata.hash) {
      throw new Error('File integrity check failed');
    }

    return decrypted;
  }
}

const crypto = require('crypto');

class ApiRequestSigner {
  constructor(apiKey, apiSecret) {
    this.apiKey = apiKey;
    this.apiSecret = apiSecret;
  }

  // Sign API request
  signRequest(method, path, body = {}) {
    const timestamp = Date.now();
    const nonce = crypto.randomBytes(16).toString('hex');

    // Create signature payload
    const payload = [
      method.toUpperCase(),
      path,
      timestamp,
      nonce,
      JSON.stringify(body)
    ].join('\n');

    // Create HMAC signature
    const signature = crypto
      .createHmac('sha256', this.apiSecret)
      .update(payload)
      .digest('hex');

    return {
      headers: {
        'X-API-Key': this.apiKey,
        'X-Timestamp': timestamp,
        'X-Nonce': nonce,
        'X-Signature': signature
      },
      body
    };
  }

  // Verify signature (server-side)
  static verifyRequest(req, apiSecret) {
    const { method, path, body } = req;
    const timestamp = req.headers['x-timestamp'];
    const nonce = req.headers['x-nonce'];
    const signature = req.headers['x-signature'];

    // Check timestamp (prevent replay attacks)
    const age = Date.now() - parseInt(timestamp);
    if (age > 5 * 60 * 1000) {  // 5 minutes
      throw new Error('Request expired');
    }

    // Recreate payload
    const payload = [
      method.toUpperCase(),
      path,
      timestamp,
      nonce,
      JSON.stringify(body)
    ].join('\n');

    // Calculate expected signature
    const expectedSignature = crypto
      .createHmac('sha256', apiSecret)
      .update(payload)
      .digest('hex');

    // Compare in constant time
    return crypto.timingSafeEqual(
      Buffer.from(signature, 'hex'),
      Buffer.from(expectedSignature, 'hex')
    );
  }
}

// Usage
const signer = new ApiRequestSigner('my-api-key', 'my-api-secret');
const signed = signer.signRequest('POST', '/api/users', {
  name: 'John Doe',
  email: '[email protected]'
});

// Send with headers
fetch('https://api.example.com/users', {
  method: 'POST',
  headers: {
    ...signed.headers,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify(signed.body)
});