Prerequisites

What Encryption Provides

Encryption transforms readable data into a form that is unintelligible without the correct key. Its purpose is confidentiality: ensuring that data exposed to an unauthorized party remains unusable.

Here \(P\) is plaintext, \(C\) is ciphertext, \(k\) is the key, and \(E\) and \(D\) are the encryption and decryption functions. The security of the scheme rests entirely on the secrecy of \(k\), never on the secrecy of the algorithm.

What Encryption Does Not Provide

Encryption is frequently treated as a general-purpose answer to security requirements. It addresses a narrow, specific concern.

Symmetric Encryption

Symmetric encryption uses one key for both encryption and decryption. It is fast, well suited to bulk data, and forms the basis of nearly all storage and transport protection.

Asymmetric Encryption

Asymmetric encryption uses a mathematically related key pair. The public key may be distributed freely, while the private key remains secret. Data encrypted with one can be decrypted only with the other.

Hashing Is Not Encryption

Hashing produces a fixed-length digest from input of any size and is deliberately irreversible. It answers a different question than encryption and must never be substituted for it.

Authenticated Encryption

Encryption alone hides content but does not prove that ciphertext arrived unmodified. An attacker may be unable to read the data yet still able to alter it in meaningful ways.

Authenticated encryption combines confidentiality with integrity, producing an authentication tag that fails verification if anything was tampered with.

Encryption in Transit

Data moving across a network is exposed to interception and modification. Transport Layer Security protects it by establishing an authenticated, encrypted channel.

Internal Traffic Is Not Exempt

Encryption at Rest

Stored data may be exposed through stolen media, misconfigured storage, copied backups, or decommissioned hardware. Encryption at rest addresses these physical and configuration exposures.

Envelope Encryption

Envelope encryption solves a practical problem: encrypting large volumes of data while keeping master keys tightly controlled and rotation feasible.

1. A unique data key is generated for the item being protected.
2. The data is encrypted locally using that data key.
3. The data key is encrypted by a master key held in a key service.
4. The encrypted data key is stored alongside the ciphertext.
5. The plaintext data key is discarded from memory.
6. Decryption reverses the process through the key service.

{
    "recordId": "customer-4821",
    "ciphertext": "base64-encoded-encrypted-payload",
    "encryptedDataKey": "base64-encoded-wrapped-key",
    "nonce": "base64-encoded-unique-value",
    "authTag": "base64-encoded-authentication-tag",
    "masterKeyId": "key-customer-pii-2026-09",
    "algorithm": "AES-256-GCM",
    "encryptedAt": "2026-09-24T04:12:00Z"
}

Key Hierarchy

A layered key structure limits how much data any single key protects and makes rotation practical.

Key Rotation

Rotation limits the quantity of data protected by any single key and bounds the damage if a key is exposed. It must be designed in, because retrofitting it is considerably harder.

CREATE TABLE encryption_keys (
    key_id          VARCHAR(80) PRIMARY KEY,
    key_purpose     VARCHAR(60)  NOT NULL,
    algorithm       VARCHAR(40)  NOT NULL,
    status          VARCHAR(20)  NOT NULL,
    created_at      TIMESTAMP    NOT NULL,
    activated_at    TIMESTAMP    NULL,
    deprecated_at   TIMESTAMP    NULL,
    destroyed_at    TIMESTAMP    NULL
);

SELECT key_id,
       key_purpose,
       status,
       created_at
FROM encryption_keys
WHERE status = 'active'
  AND created_at < CURRENT_TIMESTAMP - INTERVAL '365 days'
ORDER BY created_at;

async function rotateRecordEncryption(recordId) {
    const record = await repository.findEncrypted(recordId);

    const plaintext = await cryptoService.decrypt({
        ciphertext: record.ciphertext,
        encryptedDataKey: record.encryptedDataKey,
        nonce: record.nonce,
        authTag: record.authTag,
        masterKeyId: record.masterKeyId
    });

    const reEncrypted = await cryptoService.encrypt({
        plaintext: plaintext,
        masterKeyId: await keyService.getActiveKeyId("customer-pii")
    });

    await repository.updateEncrypted(recordId, {
        ciphertext: reEncrypted.ciphertext,
        encryptedDataKey: reEncrypted.encryptedDataKey,
        nonce: reEncrypted.nonce,
        authTag: reEncrypted.authTag,
        masterKeyId: reEncrypted.masterKeyId,
        rotatedAt: new Date().toISOString()
    });

    plaintext.fill(0);
}

Crypto-Shredding

The irreversibility of key destruction can be used deliberately. Encrypting each tenant or subject with a distinct key means destroying that key effectively erases their data everywhere it was replicated.

Field-Level Encryption in Practice

Encrypting specific fields protects them from anyone with broad database access, but it constrains how those fields can be queried.

CREATE TABLE customers (
    customer_id         BIGINT PRIMARY KEY,
    display_name        VARCHAR(200) NOT NULL,
    email_hash          VARCHAR(64)  NOT NULL,
    email_encrypted     VARBINARY(512) NOT NULL,
    phone_encrypted     VARBINARY(512) NULL,
    tax_id_encrypted    VARBINARY(512) NULL,
    encryption_key_id   VARCHAR(80)  NOT NULL,
    created_at          TIMESTAMP    NOT NULL
);

CREATE UNIQUE INDEX idx_customers_email_hash
    ON customers (email_hash);

The separate hash column enables exact-match lookup without decryption. Encrypted values cannot be searched by pattern, sorted meaningfully, or compared by range.

Alternatives to Encrypting Everything

Encryption in Use

Data must generally be decrypted to be processed, creating a window where plaintext exists in memory. Several approaches narrow that window.

Threats and Mitigations

Monitoring and Auditing

Common Design Mistakes

System Design Interview Discussion

Implementation Checklist

Knowledge Check

Summary

Encryption provides confidentiality, transforming readable data into a form that requires a key to recover. Symmetric encryption handles bulk data efficiently, asymmetric encryption solves key distribution and enables signatures, and authenticated encryption adds tamper detection.

Encryption in transit protects data crossing networks, including internal service calls. Encryption at rest protects stored data against stolen media, misconfigured storage, and copied backups, but not against queries issued through a compromised application.

Envelope encryption and a layered key hierarchy make large-scale protection practical while keeping master keys inside a key service. Rotation must be designed in, and key destruction is irreversible, which crypto-shredding turns into a deletion mechanism.

Field-level encryption constrains querying, so hash columns, tokenization, masking, and minimization are often better answers than encrypting every attribute. Throughout, key management determines whether the encryption achieves anything at all.