TLS, enkripsi & rahasia

Kriptografi di Go tersedia lengkap di pustaka standar dan defaultnya sudah aman. Yang menghasilkan kerentanan bukan algoritmanya, melainkan memilih alat yang salah untuk pekerjaan yang salah.

Memilih alatnya

Enkripsi yang benar

func Enkripsi(kunci, teks []byte) ([]byte, error) {
	blok, err := aes.NewCipher(kunci)     // kunci 32 byte = AES-256
	if err != nil {
		return nil, err
	}
	gcm, err := cipher.NewGCM(blok)
	if err != nil {
		return nil, err
	}

	// Nonce WAJIB unik per pesan untuk kunci yang sama. Memakai ulang
	// nonce di GCM membocorkan plaintext — ini bukan kelemahan teoretis.
	nonce := make([]byte, gcm.NonceSize())
	if _, err := rand.Read(nonce); err != nil {
		return nil, err
	}

	// Nonce disimpan di depan ciphertext — ia tidak rahasia.
	return gcm.Seal(nonce, nonce, teks, nil), nil
}

func Dekripsi(kunci, data []byte) ([]byte, error) {
	blok, err := aes.NewCipher(kunci)
	if err != nil {
		return nil, err
	}
	gcm, err := cipher.NewGCM(blok)
	if err != nil {
		return nil, err
	}
	if len(data) < gcm.NonceSize() {
		return nil, errors.New("ciphertext terlalu pendek")
	}

	nonce, isi := data[:gcm.NonceSize()], data[gcm.NonceSize():]
	// Open sekaligus MEMVERIFIKASI: data yang diubah penyerang gagal di sini.
	return gcm.Open(nil, nonce, isi, nil)
}

Rotasi kunci

// Simpan ID kunci bersama ciphertext. Tanpa ini, mengganti kunci berarti
// harus mendekripsi dan mengenkripsi ulang seluruh tabel dalam satu operasi.
type Terenkripsi struct {
	KunciID string `json:"k"`
	Data    []byte `json:"d"`
}

type Kotak struct {
	aktif string
	kunci map[string][]byte   // id → kunci; yang lama tetap ada untuk dekripsi
}

func (k *Kotak) Enkripsi(teks []byte) (Terenkripsi, error) {
	c, err := Enkripsi(k.kunci[k.aktif], teks)
	return Terenkripsi{KunciID: k.aktif, Data: c}, err
}

func (k *Kotak) Dekripsi(t Terenkripsi) ([]byte, error) {
	kunci, ada := k.kunci[t.KunciID]
	if !ada {
		return nil, fmt.Errorf("kunci %q tidak dikenal", t.KunciID)
	}
	return Dekripsi(kunci, t.Data)
}

TLS di sisi klien

// Default Go sudah aman: TLS 1.2+ dengan suite modern, verifikasi penuh.
klien := &http.Client{Timeout: 10 * time.Second}

// Kalau memang perlu memperketat:
tr := http.DefaultTransport.(*http.Transport).Clone()
tr.TLSClientConfig = &tls.Config{
	MinVersion: tls.VersionTLS13,
	RootCAs:    caKhusus,        // mis. sertifikat CA RDS
}

// ❌ JANGAN PERNAH di produksi
&tls.Config{InsecureSkipVerify: true}

Di mana TLS diterminasi

Browser ──TLS──► CloudFront ──TLS──► ALB ──HTTP──► ECS task (aplikasi Go)
                                          └─ di dalam VPC, jaringan privat

Rahasia: aturan yang tidak bisa ditawar

1. Jangan pernah masuk git — pasang pre-commit hook pemindai rahasia.
2. Jangan pernah masuk image Docker — lapisan image bertahan selamanya.
3. Jangan pernah masuk log — pakai tipe yang menyensor dirinya (Fase 5).
4. Disuntikkan saat runtime dari Secrets Manager lewat secrets ECS.
5. Diputar berkala, dan aplikasinya harus tahan saat rotasi terjadi.
6. Berbeda per lingkungan — rahasia staging tidak pernah sama dengan produksi.

# Kalau rahasia terlanjur ter-commit, menghapusnya dari riwayat TIDAK CUKUP.
# Ia sudah ada di klon orang lain, di cache CI, dan mungkin sudah terindeks.
# Urutan yang benar: PUTAR RAHASIANYA DULU, baru bersihkan riwayat.