Encryption #

// Enkripsi dan dekripsi AES-256-GCM
import (
	"crypto/aes"
	"crypto/cipher"
	"crypto/rand"
	"encoding/base64"
	"errors"
)

func encryptData(plaintext []byte, key []byte) (map[string]string, error) {
	if len(key) != 32 {
		return nil, errors.New("key harus 256 bit (32 byte)")
	}

	// Generate nonce baru untuk setiap enkripsi
	// KRITIS: jangan pernah reuse nonce dengan key yang sama!
	nonce := make([]byte, 12) // 96-bit nonce — standar GCM
	if _, err := rand.Read(nonce); err != nil {
		return nil, err
	}

	block, err := aes.NewCipher(key)
	if err != nil {
		return nil, err
	}
	aesgcm, err := cipher.NewGCM(block)
	if err != nil {
		return nil, err
	}

	// Enkripsi + autentikasi
	// GCM menghasilkan ciphertext + authentication tag (16 byte)
	ciphertext := aesgcm.Seal(nil, nonce, plaintext, nil)

	return map[string]string{
		"nonce":      base64.StdEncoding.EncodeToString(nonce),
		"ciphertext": base64.StdEncoding.EncodeToString(ciphertext),
		"algorithm":  "AES-256-GCM",
	}, nil
}

func decryptData(encrypted map[string]string, key []byte) ([]byte, error) {
	nonce, err := base64.StdEncoding.DecodeString(encrypted["nonce"])
	if err != nil {
		return nil, err
	}
	ciphertext, err := base64.StdEncoding.DecodeString(encrypted["ciphertext"])
	if err != nil {
		return nil, err
	}

	block, err := aes.NewCipher(key)
	if err != nil {
		return nil, err
	}
	aesgcm, err := cipher.NewGCM(block)
	if err != nil {
		return nil, err
	}

	// GCM otomatis memverifikasi authentication tag
	// Jika data dimodifikasi, error dikembalikan
	plaintext, err := aesgcm.Open(nil, nonce, ciphertext, nil)
	if err != nil {
		return nil, errors.New("dekripsi gagal: data mungkin telah dimodifikasi")
	}
	return plaintext, nil
}

// Penggunaan:
// key := make([]byte, 32) // 256-bit key — simpan dengan aman!
// plaintext := []byte("Data sensitif yang perlu dienkripsi")
// encrypted, _ := encryptData(plaintext, key)
// decrypted, _ := decryptData(encrypted, key)

// 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)
import (
	"crypto/aes"
	"crypto/cipher"
	"crypto/rand"
	"encoding/base64"
	"errors"
)

type EnvelopeEncryption struct {
	kekCipher cipher.AEAD
}

// NewEnvelopeEncryption menerima 256-bit Key Encryption Key dari KMS atau HSM.
func NewEnvelopeEncryption(kek []byte) (*EnvelopeEncryption, error) {
	if len(kek) != 32 {
		return nil, errors.New("KEK harus 256-bit")
	}
	block, err := aes.NewCipher(kek)
	if err != nil {
		return nil, err
	}
	aead, err := cipher.NewGCM(block)
	if err != nil {
		return nil, err
	}
	return &EnvelopeEncryption{kekCipher: aead}, nil
}

// Enkripsi data menggunakan envelope encryption.
// Setiap call menghasilkan DEK baru.
func (e *EnvelopeEncryption) Encrypt(plaintext []byte) (map[string]string, error) {
	// 1. Generate Data Encryption Key (DEK) baru
	dek := make([]byte, 32) // 256-bit DEK
	if _, err := rand.Read(dek); err != nil {
		return nil, err
	}

	// 2. Enkripsi data dengan DEK
	dataNonce := make([]byte, 12)
	if _, err := rand.Read(dataNonce); err != nil {
		return nil, err
	}
	dataBlock, _ := aes.NewCipher(dek)
	dataCipher, _ := cipher.NewGCM(dataBlock)
	encryptedData := dataCipher.Seal(nil, dataNonce, plaintext, nil)

	// 3. Enkripsi DEK dengan KEK (wrapping)
	keyNonce := make([]byte, 12)
	if _, err := rand.Read(keyNonce); err != nil {
		return nil, err
	}
	encryptedDek := e.kekCipher.Seal(nil, keyNonce, dek, nil)

	return map[string]string{
		"encrypted_dek":  base64.StdEncoding.EncodeToString(encryptedDek),
		"key_nonce":      base64.StdEncoding.EncodeToString(keyNonce),
		"encrypted_data": base64.StdEncoding.EncodeToString(encryptedData),
		"data_nonce":     base64.StdEncoding.EncodeToString(dataNonce),
	}, nil
}

// Decrypt data dari envelope.
func (e *EnvelopeEncryption) Decrypt(envelope map[string]string) ([]byte, error) {
	// 1. Unwrap DEK menggunakan KEK
	encryptedDek, _ := base64.StdEncoding.DecodeString(envelope["encrypted_dek"])
	keyNonce, _ := base64.StdEncoding.DecodeString(envelope["key_nonce"])
	dek, err := e.kekCipher.Open(nil, keyNonce, encryptedDek, nil)
	if err != nil {
		return nil, err
	}

	// 2. Decrypt data menggunakan DEK
	encryptedData, _ := base64.StdEncoding.DecodeString(envelope["encrypted_data"])
	dataNonce, _ := base64.StdEncoding.DecodeString(envelope["data_nonce"])
	dataBlock, _ := aes.NewCipher(dek)
	dataCipher, _ := cipher.NewGCM(dataBlock)
	return dataCipher.Open(nil, dataNonce, encryptedData, nil)
}

// Rotasi KEK: decrypt dengan KEK lama, re-encrypt DEK dengan KEK baru.
// Data tidak perlu di-decrypt dan re-encrypt!
func (e *EnvelopeEncryption) RotateKek(newKek []byte, envelope map[string]string) (map[string]string, error) {
	oldEncryptedDek, _ := base64.StdEncoding.DecodeString(envelope["encrypted_dek"])
	oldKeyNonce, _ := base64.StdEncoding.DecodeString(envelope["key_nonce"])
	dek, err := e.kekCipher.Open(nil, oldKeyNonce, oldEncryptedDek, nil)
	if err != nil {
		return nil, err
	}

	// Re-encrypt DEK dengan KEK baru
	newKekBlock, _ := aes.NewCipher(newKek)
	newKekCipher, _ := cipher.NewGCM(newKekBlock)
	newKeyNonce := make([]byte, 12)
	if _, err := rand.Read(newKeyNonce); err != nil {
		return nil, err
	}
	newEncryptedDek := newKekCipher.Seal(nil, newKeyNonce, dek, nil)

	// encrypted_data dan data_nonce tidak berubah
	envelope["encrypted_dek"] = base64.StdEncoding.EncodeToString(newEncryptedDek)
	envelope["key_nonce"] = base64.StdEncoding.EncodeToString(newKeyNonce)
	return envelope, nil
}

// Field database yang dienkripsi secara transparan
// Padanan Go dari TypeDecorator SQLAlchemy: tipe yang mengimplementasikan
// interface Scanner dan Valuer dari database/sql
import (
	"crypto/sha256"
	"database/sql"
	"database/sql/driver"
	"encoding/hex"
	"encoding/json"
	"os"
)

type EncryptedString struct {
	Value string
	key   []byte
}

// Enkripsi sebelum simpan ke database.
func (e EncryptedString) Value() (driver.Value, error) {
	if e.Value == "" {
		return nil, nil
	}
	encrypted, err := encryptData([]byte(e.Value), e.key)
	if err != nil {
		return nil, err
	}
	return json.Marshal(encrypted)
}

// Decrypt saat baca dari database.
func (e *EncryptedString) Scan(value interface{}) error {
	if value == nil {
		e.Value = ""
		return nil
	}
	var encrypted map[string]string
	if err := json.Unmarshal(value.([]byte), &encrypted); err != nil {
		return err
	}
	plaintext, err := decryptData(encrypted, e.key)
	if err != nil {
		return err
	}
	e.Value = string(plaintext)
	return nil
}

// Konfigurasi
var fieldEncryptionKey = []byte(os.Getenv("FIELD_ENCRYPTION_KEY"))

type User struct {
	ID          int64
	Email       string
	PhoneNumber EncryptedString // Field sensitif yang dienkripsi
	TaxID       EncryptedString
	DateOfBirth EncryptedString

	// TIDAK dienkripsi — dibutuhkan untuk search/filter
	// Untuk field yang perlu di-search, simpan hash terpisah
	PhoneHash string
}

type UserRepository struct{ db *sql.DB }

func (r UserRepository) CreateUser(email string, phone, taxID, dob *string) error {
	user := User{Email: email}
	if phone != nil {
		// dienkripsi otomatis oleh EncryptedString
		user.PhoneNumber = EncryptedString{Value: *phone, key: fieldEncryptionKey}
		// Simpan hash untuk keperluan search
		sum := sha256.Sum256([]byte(*phone))
		user.PhoneHash = hex.EncodeToString(sum[:])
	}
	// ... insert user; field terenkripsi diserialisasi oleh Value()
	return nil
}

// Cari user berdasarkan nomor HP.
func (r UserRepository) FindByPhone(phone string) (*User, error) {
	sum := sha256.Sum256([]byte(phone))
	hash := hex.EncodeToString(sum[:])
	// ... SELECT * FROM users WHERE phone_hash = ? DAN scan dengan EncryptedString
	return nil, nil
}

// Password hashing — BUKAN enkripsi
// Menggunakan golang.org/x/crypto/argon2 (password KDF yang teruji)
import (
	"crypto/rand"
	"encoding/base64"
	"fmt"

	"golang.org/x/crypto/argon2"
)

// Hash password — tidak bisa di-reverse ke password asli.
func storePassword(password string) string {
	salt := make([]byte, 16)
	if _, err := rand.Read(salt); err != nil {
		panic(err)
	}
	// Argon2id dengan parameter yang sama dengan contoh Python
	hash := argon2.IDKey([]byte(password), salt, 3, 64*1024, 2, 32)
	return fmt.Sprintf("$argon2id$v=19$m=65536,t=3,p=2$%s$%s",
		base64.RawStdEncoding.EncodeToString(salt),
		base64.RawStdEncoding.EncodeToString(hash))
}

// Verifikasi hash password tersimpan.
func verifyPassword(storedHash string, password string) bool {
	// ... parse hash, hitung ulang argon2.IDKey dengan salt tersimpan,
	// dan bandingkan secara constant time (misal subtle.ConstantTimeCompare)
	return false
}

// Enkripsi data sensitif — BUKAN hashing
// Enkripsi — bisa di-decrypt untuk memproses pembayaran.
func storeCreditCard(cardNumber string, key []byte) (map[string]string, error) {
	return encryptData([]byte(cardNumber), key)
}

// ANTI-PATTERN: hardcode kunci di source code
// const secretKey = "mysecretkey123" // JANGAN — source code bisa bocor di git

// ANTI-PATTERN: kunci yang terlalu pendek atau lemah
// key := []byte("password") // 64-bit — mudah di-brute force

// ANTI-PATTERN: kunci yang sama untuk semua tujuan
// masterKey := make([]byte, 32) // satu kunci untuk semua → satu bocor, semua bocor

// BENAR: kunci dari environment variable atau secret manager
import (
	"encoding/hex"
	"fmt"
	"os"
)

// Ambil kunci dari environment atau secret manager.
func getEncryptionKey() ([]byte, error) {
	keyHex := os.Getenv("ENCRYPTION_KEY")
	if keyHex == "" {
		return nil, fmt.Errorf("ENCRYPTION_KEY tidak dikonfigurasi")
	}

	key, err := hex.DecodeString(keyHex)
	if err != nil {
		return nil, err
	}
	if len(key) != 32 {
		return nil, fmt.Errorf("ENCRYPTION_KEY harus 256-bit (64 hex chars)")
	}
	return key, nil
}

// Kunci yang berbeda untuk tujuan yang berbeda
func setupKeys() map[string][]byte {
	return map[string][]byte{
		"user_pii_key": []byte(os.Getenv("USER_PII_ENCRYPTION_KEY")),
		"payment_key":  []byte(os.Getenv("PAYMENT_ENCRYPTION_KEY")),
		"session_key":  []byte(os.Getenv("SESSION_ENCRYPTION_KEY")),
	}
}

// Tanda tangan digital dengan Ed25519 (membuktikan keaslian, bukan kerahasiaan)
import (
	"crypto/ed25519"
	"crypto/rand"
)

// Generate keypair Ed25519 untuk digital signature.
func generateSigningKeypair() (ed25519.PrivateKey, ed25519.PublicKey) {
	publicKey, privateKey, err := ed25519.GenerateKey(rand.Reader)
	if err != nil {
		panic(err)
	}
	return privateKey, publicKey
}

// Tandatangani payload untuk membuktikan keaslian.
func signPayload(payload []byte, privateKey ed25519.PrivateKey) []byte {
	return ed25519.Sign(privateKey, payload)
}

// Verifikasi tanda tangan.
func verifySignature(payload []byte, signature []byte, publicKey ed25519.PublicKey) bool {
	return ed25519.Verify(publicKey, payload, signature)
}

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

// ✗ Anti-pattern 2: reuse nonce/IV
// nonce := make([]byte, 12) // static nonce — FATAL untuk GCM!
// Reuse nonce dengan key yang sama menghancurkan keamanan GCM
// ✓ Solusi: crypto/rand untuk setiap enkripsi

// ✗ Anti-pattern 3: kunci dari password yang lemah tanpa KDF
// key := []byte(password)[: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
// block, _ := aes.NewCipher(key)
// ciphertext := cipher.NewCBCEncrypter(block, iv).CryptBlocks(...)
// ✓ Solusi: gunakan AES-GCM yang memberikan authenticated encryption

// ✗ Anti-pattern 6: mengimplementasi sendiri algoritma kriptografi
func myEncrypt(data, key []byte) []byte {
	// Implementasi custom XOR atau sejenisnya
	out := make([]byte, len(data))
	for i := range data {
		out[i] = data[i] ^ key[i%len(key)]
	}
	return out
}
// Sangat tidak aman — gunakan library yang sudah teruji
// ✓ Solusi: crypto/aes (Go), BouncyCastle (Java), WebCrypto API (JS)