Encryption #

# Konfigurasi Nginx untuk TLS yang aman

server {
    listen 443 ssl http2;
    server_name app.contoh.com;

    # Certificate dan private key
    ssl_certificate     /etc/ssl/certs/app.contoh.com.crt;
    ssl_certificate_key /etc/ssl/private/app.contoh.com.key;

    # Hanya TLS 1.2 dan 1.3 — TLS 1.0 dan 1.1 sudah deprecated
    ssl_protocols TLSv1.2 TLSv1.3;

    # Cipher suite yang kuat — prioritaskan forward secrecy
    ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384;
    ssl_prefer_server_ciphers off;  # TLS 1.3 handles this

    # Session resumption — performa tanpa mengorbankan keamanan
    ssl_session_timeout 1d;
    ssl_session_cache shared:SSL:10m;
    ssl_session_tickets off;  # matikan session tickets (forward secrecy)

    # OCSP Stapling — validasi certificate lebih cepat
    ssl_stapling on;
    ssl_stapling_verify on;

    # HSTS — paksa HTTPS untuk 1 tahun ke depan
    add_header Strict-Transport-Security "max-age=31536000; includeSubDomains; preload" always;

    # Redirect HTTP ke HTTPS
    # (di server block port 80 yang terpisah)
}

server {
    listen 80;
    server_name app.contoh.com;
    return 301 https://$host$request_uri;
}

from cryptography.hazmat.primitives.ciphers.aead import AESGCM
import os
import base64

def encrypt_data(plaintext: bytes, key: bytes) -> dict:
    """
    Enkripsi data dengan AES-256-GCM.

    Returns dict dengan nonce dan ciphertext yang bisa disimpan bersama.
    """
    if len(key) != 32:
        raise ValueError("Key harus 256 bit (32 byte)")

    # Generate nonce baru untuk setiap enkripsi
    # KRITIS: jangan pernah reuse nonce dengan key yang sama!
    nonce = os.urandom(12)  # 96-bit nonce — standar untuk GCM

    aesgcm = AESGCM(key)

    # Encrypt + authenticate
    # GCM menghasilkan ciphertext + authentication tag (16 byte)
    ciphertext = aesgcm.encrypt(nonce, plaintext, None)

    return {
        'nonce': base64.b64encode(nonce).decode(),
        'ciphertext': base64.b64encode(ciphertext).decode(),
        'algorithm': 'AES-256-GCM',
    }

def decrypt_data(encrypted: dict, key: bytes) -> bytes:
    """
    Decrypt data yang dienkripsi dengan encrypt_data().
    Raise exception jika data telah dimodifikasi (integrity check).
    """
    nonce = base64.b64decode(encrypted['nonce'])
    ciphertext = base64.b64decode(encrypted['ciphertext'])

    aesgcm = AESGCM(key)

    try:
        # GCM otomatis memverifikasi authentication tag
        # Jika data dimodifikasi, InvalidTag exception dilempar
        return aesgcm.decrypt(nonce, ciphertext, None)
    except Exception:
        raise ValueError("Dekripsi gagal: data mungkin telah dimodifikasi")

# Penggunaan:
key = os.urandom(32)  # 256-bit key — simpan dengan aman!

plaintext = b"Data sensitif yang perlu dienkripsi"
encrypted = encrypt_data(plaintext, key)
# encrypted = {
#   'nonce': 'base64...',
#   'ciphertext': 'base64...',
#   'algorithm': 'AES-256-GCM'
# }

decrypted = decrypt_data(encrypted, key)
assert decrypted == plaintext

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

class EnvelopeEncryption:
    """
    Envelope encryption pattern:
    KEK (Key Encryption Key) → mengenkripsi DEK
    DEK (Data Encryption Key) → mengenkripsi data

    KEK disimpan di secure location (HSM, KMS)
    DEK disimpan bersama data yang dienkripsi (dalam bentuk terenkripsi)
    """

    def __init__(self, kek: bytes):
        """kek: 256-bit Key Encryption Key dari KMS atau HSM."""
        if len(kek) != 32:
            raise ValueError("KEK harus 256-bit")
        self.kek = kek
        self._kek_cipher = AESGCM(kek)

    def encrypt(self, plaintext: bytes) -> dict:
        """
        Enkripsi data menggunakan envelope encryption.
        Setiap call menghasilkan DEK baru.
        """
        # 1. Generate Data Encryption Key (DEK) baru
        dek = os.urandom(32)  # 256-bit DEK

        # 2. Enkripsi data dengan DEK
        data_nonce = os.urandom(12)
        data_cipher = AESGCM(dek)
        encrypted_data = data_cipher.encrypt(data_nonce, plaintext, None)

        # 3. Enkripsi DEK dengan KEK (wrapping)
        key_nonce = os.urandom(12)
        encrypted_dek = self._kek_cipher.encrypt(key_nonce, dek, None)

        # DEK bisa di-hapus dari memory sekarang
        dek = b'\x00' * 32  # zero out

        return {
            'encrypted_dek': base64.b64encode(encrypted_dek).decode(),
            'key_nonce': base64.b64encode(key_nonce).decode(),
            'encrypted_data': base64.b64encode(encrypted_data).decode(),
            'data_nonce': base64.b64encode(data_nonce).decode(),
        }

    def decrypt(self, envelope: dict) -> bytes:
        """Decrypt data dari envelope."""
        # 1. Unwrap DEK menggunakan KEK
        encrypted_dek = base64.b64decode(envelope['encrypted_dek'])
        key_nonce = base64.b64decode(envelope['key_nonce'])
        dek = self._kek_cipher.decrypt(key_nonce, encrypted_dek, None)

        # 2. Decrypt data menggunakan DEK
        encrypted_data = base64.b64decode(envelope['encrypted_data'])
        data_nonce = base64.b64decode(envelope['data_nonce'])
        data_cipher = AESGCM(dek)
        return data_cipher.decrypt(data_nonce, encrypted_data, None)

    def rotate_kek(self, new_kek: bytes, envelope: dict) -> dict:
        """
        Rotasi KEK: decrypt dengan KEK lama, re-encrypt DEK dengan KEK baru.
        Data tidak perlu di-decrypt dan re-encrypt!
        """
        # Decrypt DEK dengan KEK lama
        old_encrypted_dek = base64.b64decode(envelope['encrypted_dek'])
        old_key_nonce = base64.b64decode(envelope['key_nonce'])
        dek = self._kek_cipher.decrypt(old_key_nonce, old_encrypted_dek, None)

        # Re-encrypt DEK dengan KEK baru
        new_kek_cipher = AESGCM(new_kek)
        new_key_nonce = os.urandom(12)
        new_encrypted_dek = new_kek_cipher.encrypt(new_key_nonce, dek, None)

        return {
            **envelope,  # encrypted_data dan data_nonce tidak berubah
            'encrypted_dek': base64.b64encode(new_encrypted_dek).decode(),
            'key_nonce': base64.b64encode(new_key_nonce).decode(),
        }

from sqlalchemy import Column, String, TypeDecorator
import json

class EncryptedString(TypeDecorator):
    """
    SQLAlchemy type untuk field yang dienkripsi secara transparan.
    Nilai dienkripsi sebelum disimpan, didekripsi saat dibaca.
    """
    impl = String
    cache_ok = True

    def __init__(self, encryption_key: bytes, *args, **kwargs):
        self.key = encryption_key
        super().__init__(*args, **kwargs)

    def process_bind_param(self, value, dialect):
        """Enkripsi sebelum simpan ke database."""
        if value is None:
            return None
        encrypted = encrypt_data(value.encode(), self.key)
        return json.dumps(encrypted)

    def process_result_value(self, value, dialect):
        """Decrypt saat baca dari database."""
        if value is None:
            return None
        encrypted = json.loads(value)
        return decrypt_data(encrypted, self.key).decode()

# Konfigurasi
FIELD_ENCRYPTION_KEY = bytes.fromhex(os.environ['FIELD_ENCRYPTION_KEY'])

class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    email = db.Column(db.String(255), unique=True, nullable=False)

    # Field sensitif yang dienkripsi
    phone_number = db.Column(
        EncryptedString(FIELD_ENCRYPTION_KEY, 500),
        nullable=True
    )
    tax_id = db.Column(
        EncryptedString(FIELD_ENCRYPTION_KEY, 500),
        nullable=True
    )
    date_of_birth = db.Column(
        EncryptedString(FIELD_ENCRYPTION_KEY, 500),
        nullable=True
    )

    # TIDAK dienkripsi — dibutuhkan untuk search/filter
    # email di-hash untuk search (lihat bawah)
    # name mungkin tidak perlu enkripsi

    # Untuk field yang perlu di-search, simpan hash terpisah
    phone_hash = db.Column(db.String(64), index=True, nullable=True)

class UserRepository:
    def create_user(self, email, phone=None, tax_id=None, dob=None):
        user = User(
            email=email,
            phone_number=phone,  # dienkripsi otomatis oleh EncryptedString
            tax_id=tax_id,
            date_of_birth=dob,
        )
        if phone:
            # Simpan hash untuk keperluan search
            user.phone_hash = hashlib.sha256(
                phone.encode()
            ).hexdigest()
        db.session.add(user)
        db.session.commit()
        return user

    def find_by_phone(self, phone: str):
        """Cari user berdasarkan nomor HP."""
        phone_hash = hashlib.sha256(phone.encode()).hexdigest()
        return User.query.filter_by(phone_hash=phone_hash).first()

# Password hashing — BUKAN enkripsi
from argon2 import PasswordHasher
ph = PasswordHasher(time_cost=3, memory_cost=65536, parallelism=2)

def store_password(password: str) -> str:
    """Hash password — tidak bisa di-reverse ke password asli."""
    return ph.hash(password)

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

# Enkripsi data sensitif — BUKAN hashing
def store_credit_card(card_number: str, key: bytes) -> dict:
    """Enkripsi — bisa di-decrypt untuk memproses pembayaran."""
    return encrypt_data(card_number.encode(), key)

# ANTI-PATTERN: hardcode kunci di source code
SECRET_KEY = "mysecretkey123"  # JANGAN — source code bisa bocor di git

# ANTI-PATTERN: kunci yang terlalu pendek atau lemah
key = b"password"  # 64-bit — mudah di-brute force

# ANTI-PATTERN: kunci yang sama untuk semua tujuan
MASTER_KEY = os.urandom(32)  # satu kunci untuk semua → satu bocor, semua bocor

# BENAR: kunci dari environment variable atau secret manager
import os

def get_encryption_key() -> bytes:
    """Ambil kunci dari environment atau secret manager."""
    key_hex = os.environ.get('ENCRYPTION_KEY')
    if not key_hex:
        raise EnvironmentError("ENCRYPTION_KEY tidak dikonfigurasi")

    key = bytes.fromhex(key_hex)
    if len(key) != 32:
        raise ValueError("ENCRYPTION_KEY harus 256-bit (64 hex chars)")
    return key

# Kunci yang berbeda untuk tujuan yang berbeda
def setup_keys():
    return {
        'user_pii_key': bytes.fromhex(os.environ['USER_PII_ENCRYPTION_KEY']),
        'payment_key': bytes.fromhex(os.environ['PAYMENT_ENCRYPTION_KEY']),
        'session_key': bytes.fromhex(os.environ['SESSION_ENCRYPTION_KEY']),
    }

# Ketika mengkomunikasikan data sensitif via API:
# 1. TLS sudah mengenkripsi traffic — tidak perlu enkripsi payload lagi
#    untuk kerahasiaan (double encryption tidak menambah keamanan)
# 2. Kecuali ada requirement end-to-end encryption spesifik

# Untuk tanda tangan digital (membuktikan keaslian, bukan kerahasiaan):
from cryptography.hazmat.primitives.asymmetric import ed25519
from cryptography.hazmat.primitives import serialization

def generate_signing_keypair():
    """Generate Ed25519 keypair untuk digital signature."""
    private_key = ed25519.Ed25519PrivateKey.generate()
    public_key = private_key.public_key()
    return private_key, public_key

def sign_payload(payload: bytes, private_key) -> bytes:
    """Tandatangani payload untuk membuktikan keaslian."""
    return private_key.sign(payload)

def verify_signature(payload: bytes, signature: bytes, public_key) -> bool:
    """Verifikasi tanda tangan."""
    try:
        public_key.verify(signature, payload)
        return True
    except Exception:
        return False

# Enkripsi backup sebelum upload ke cloud storage
# Gunakan GPG dengan symmetric encryption

# Enkripsi backup:
gpg --symmetric \
    --cipher-algo AES256 \
    --batch \
    --passphrase-file /secure/location/backup.passphrase \
    database_backup.sql.gz

# Upload ke S3 (sudah terenkripsi):
aws s3 cp database_backup.sql.gz.gpg s3://backup-bucket/

# Verifikasi: bahkan jika S3 bucket dikompromikan,
# file masih terenkripsi dengan AES-256

# ✗ Anti-pattern 1: enkripsi password
encrypted_password = encrypt(password, key)
# Jika key bocor, semua password terdekripsi
# ✓ Solusi: hash dengan Argon2id, bcrypt, atau scrypt

# ✗ Anti-pattern 2: reuse nonce/IV
nonce = b'\x00' * 12  # static nonce — FATAL untuk GCM!
# Reuse nonce dengan key yang sama menghancurkan keamanan GCM
# ✓ Solusi: os.urandom(12) untuk setiap enkripsi

# ✗ Anti-pattern 3: kunci dari password yang lemah tanpa KDF
key = password.encode()[:32]  # bukan key yang baik
# Password pendek → key lemah
# ✓ Solusi: gunakan PBKDF2/Argon2 untuk derive key dari password

# ✗ Anti-pattern 4: menyimpan kunci di database
# Kunci dan data terenkripsi di tempat yang sama
# Jika database bocor, keduanya ikut bocor
# ✓ Solusi: kunci di secret manager atau environment variable

# ✗ Anti-pattern 5: CBC mode tanpa authentication
# AES-CBC tanpa HMAC rentan padding oracle attack
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
cipher = Cipher(algorithms.AES(key), modes.CBC(iv))
# ✓ Solusi: gunakan AES-GCM yang memberikan authenticated encryption

# ✗ Anti-pattern 6: mengimplementasi sendiri algoritma kriptografi
def my_encrypt(data, key):
    # Implementasi custom XOR atau sejenisnya
    return bytes(a ^ b for a, b in zip(data, key * (len(data) // len(key) + 1)))
# Sangat tidak aman — gunakan library yang sudah teruji
# ✓ Solusi: cryptography (Python), BouncyCastle (Java), WebCrypto API (JS)