Cryptography

Cryptography

What I Do

I provide guidance on correctly applying cryptographic primitives to protect data confidentiality, integrity, and authenticity. This includes symmetric and asymmetric encryption, secure hashing, digital signatures, key management, TLS configuration, and avoiding common cryptographic pitfalls.

When to Use Me

• Choosing encryption algorithms and modes for data at rest or in transit
• Implementing password hashing or token generation
• Setting up TLS/mTLS configuration for services
• Designing key management and rotation strategies
• Implementing digital signatures for data integrity
• Reviewing code for cryptographic misuse

Core Concepts

1. Symmetric Encryption: Single-key encryption (AES-256-GCM) for bulk data encryption with authenticated encryption modes.
2. Asymmetric Encryption: Public/private key pairs (RSA, ECDSA, Ed25519) for key exchange, encryption, and signatures.
3. Hashing: One-way functions (SHA-256, SHA-3, BLAKE2) for data integrity verification.
4. Password Hashing: Memory-hard functions (Argon2id, bcrypt, scrypt) designed to resist brute-force attacks.
5. Digital Signatures: Cryptographic proof of data origin and integrity using private keys.
6. Key Management: Secure generation, storage, rotation, and destruction of cryptographic keys.
7. TLS Configuration: Secure transport layer setup including cipher suite selection, certificate management, and protocol version enforcement.
8. Authenticated Encryption: Modes (GCM, ChaCha20-Poly1305) that provide both confidentiality and integrity in a single operation.

Code Examples

1. AES-256-GCM Encryption (Python)

import os
from cryptography.hazmat.primitives.ciphers.aead import AESGCM
from typing import Tuple

def generate_key() -> bytes:
    return AESGCM.generate_key(bit_length=256)

def encrypt(key: bytes, plaintext: bytes, associated_data: bytes = b"") -> Tuple[bytes, bytes]:
    nonce = os.urandom(12)
    aesgcm = AESGCM(key)
    ciphertext = aesgcm.encrypt(nonce, plaintext, associated_data)
    return nonce, ciphertext

def decrypt(key: bytes, nonce: bytes, ciphertext: bytes, associated_data: bytes = b"") -> bytes:
    aesgcm = AESGCM(key)
    return aesgcm.decrypt(nonce, ciphertext, associated_data)

2. Password Hashing with Argon2 (Python)

from argon2 import PasswordHasher
from argon2.exceptions import VerifyMismatchError

ph = PasswordHasher(
    time_cost=3,
    memory_cost=65536,
    parallelism=4,
    hash_len=32,
    salt_len=16,
)

def hash_password(password: str) -> str:
    return ph.hash(password)

def verify_password(password: str, stored_hash: str) -> bool:
    try:
        return ph.verify(stored_hash, password)
    except VerifyMismatchError:
        return False

def needs_rehash(stored_hash: str) -> bool:
    return ph.check_needs_rehash(stored_hash)

3. Ed25519 Digital Signatures (Python)

from cryptography.hazmat.primitives.asymmetric.ed25519 import (
    Ed25519PrivateKey,
    Ed25519PublicKey,
)
from cryptography.hazmat.primitives import serialization

def generate_signing_keypair() -> tuple:
    private_key = Ed25519PrivateKey.generate()
    public_key = private_key.public_key()
    return private_key, public_key

def sign_data(private_key: Ed25519PrivateKey, data: bytes) -> bytes:
    return private_key.sign(data)

def verify_signature(public_key: Ed25519PublicKey, data: bytes, signature: bytes) -> bool:
    try:
        public_key.verify(signature, data)
        return True
    except Exception:
        return False

4. Secure TLS Configuration (Python)

import ssl

def create_secure_ssl_context() -> ssl.SSLContext:
    ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
    ctx.minimum_version = ssl.TLSVersion.TLSv1_2
    ctx.set_ciphers(
        "ECDHE+AESGCM:ECDHE+CHACHA20:DHE+AESGCM:DHE+CHACHA20:!aNULL:!MD5:!DSS"
    )
    ctx.check_hostname = True
    ctx.verify_mode = ssl.CERT_REQUIRED
    return ctx

Best Practices

1. Use authenticated encryption (AES-256-GCM, ChaCha20-Poly1305) instead of unauthenticated modes (ECB, CBC without HMAC).
2. Never roll your own cryptography; use well-audited libraries (cryptography, libsodium, BouncyCastle).
3. Use Argon2id for password hashing with tuned parameters; never use MD5, SHA-1, or plain SHA-256 for passwords.
4. Generate random values with CSPRNGs (os.urandom, secrets module) not math.random or similar.
5. Never reuse nonces/IVs with the same key; generate a fresh random nonce for each encryption operation.
6. Rotate keys regularly and implement key versioning to support decryption of data encrypted with older keys.
7. Enforce TLS 1.2+ with strong cipher suites and disable SSLv3, TLS 1.0, and TLS 1.1.
8. Store keys in HSMs or KMS rather than in application configuration files or environment variables.
9. Use constant-time comparison for MAC verification and other security-sensitive comparisons.
10. Validate certificates properly with hostname verification and trusted CA chains; never disable verification.