Encryption at Rest & in Transit

AES-256-GCM encryption in TypeScript with Node crypto

import { randomBytes, createCipheriv, createDecipheriv } from 'crypto';

const ALGORITHM = 'aes-256-gcm';
const KEY_LEN = 32; // 256 bits
const IV_LEN = 12;  // 96 bits recommended for GCM
const AUTH_TAG_LEN = 16;

export function encrypt(plaintext: string, keyHex: string): string {
  const key = Buffer.from(keyHex, 'hex');
  if (key.length !== KEY_LEN) throw new Error('Key must be 32 bytes (256 bits)');
  const iv = randomBytes(IV_LEN);
  const cipher = createCipheriv(ALGORITHM, key, iv);
  const encrypted = Buffer.concat([
    cipher.update(plaintext, 'utf8'),
    cipher.final(),
  ]);
  const authTag = cipher.getAuthTag();
  // Prepend iv and authTag so the receiver can decrypt without side-channel
  return Buffer.concat([iv, authTag, encrypted]).toString('base64');
}

export function decrypt(ciphertext: string, keyHex: string): string {
  const key = Buffer.from(keyHex, 'hex');
  const buf = Buffer.from(ciphertext, 'base64');
  const iv = buf.subarray(0, IV_LEN);
  const authTag = buf.subarray(IV_LEN, IV_LEN + AUTH_TAG_LEN);
  const encrypted = buf.subarray(IV_LEN + AUTH_TAG_LEN);
  const decipher = createDecipheriv(ALGORITHM, key, iv);
  decipher.setAuthTag(authTag);
  return decipher.update(encrypted) + decipher.final('utf8');
}

GCM (Galois/Counter Mode) provides authenticated encryption: it detects tampering via the auth tag, not just confidentiality. IV must be unique per encryption but need not be secret; prepending it to the ciphertext is standard. Key must come from a KMS or secrets manager, not hardcoded.

Field-level encryption for sensitive database columns in Ruby

# Rails 7+ Active Record Encryption
# config/application.rb
# config.active_record.encryption.primary_key = Rails.application.credentials.active_record_encryption[:primary_key]
# config.active_record.encryption.deterministic_key = Rails.application.credentials.active_record_encryption[:deterministic_key]
# config.active_record.encryption.key_derivation_salt = Rails.application.credentials.active_record_encryption[:key_derivation_salt]

class Patient < ApplicationRecord
  # Non-deterministic: encrypted differently each write; cannot query directly
  encrypts :medical_notes
  encrypts :ssn

  # Deterministic: same plaintext = same ciphertext; allows WHERE queries
  encrypts :email, deterministic: true

  # Validates before encryption, queries after encryption
  validates :email, uniqueness: true
end

# Querying works transparently with deterministic encryption
Patient.find_by(email: 'alice@example.com')

# Non-deterministic encrypted columns cannot be queried
# Patient.where(ssn: '123-45-6789') would raise an error

Rails 7 Active Record Encryption (merged from rails/rails#41659) encrypts column values using AES-256-GCM before storing. Deterministic encryption (like SIV mode) enables indexed lookups at the cost of leaking if the same plaintext appears in multiple rows.