Cryptographic Hashing and AES Encryption

package main

import (
	"crypto/aes"
	"crypto/cipher"
	"crypto/rand"
	"crypto/sha256"
	"encoding/base64"
	"errors"
	"fmt"
	"io"
	"log"

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

// HashPassword securely hashes a password using bcrypt (industry standard)
func HashPassword(password string) (string, error) {
	// Generate a bcrypt hash with cost factor 12 (balance of security/speed)
	hashBytes, err := bcrypt.GenerateFromPassword([]byte(password), 12)
	if err != nil {
		return "", fmt.Errorf("failed to hash password: %w", err)
	}
	return string(hashBytes), nil
}

// VerifyPassword checks if a password matches a bcrypt hash
func VerifyPassword(password, hash string) bool {
	// Compare password with hash (constant time comparison to prevent timing attacks)
	err := bcrypt.CompareHashAndPassword([]byte(hash), []byte(password))
	return err == nil
}

// GenerateRandomSalt creates a cryptographically secure random salt
func GenerateRandomSalt(size int) ([]byte, error) {
	salt := make([]byte, size)
	_, err := rand.Read(salt)
	if err != nil {
		return nil, fmt.Errorf("failed to generate salt: %w", err)
	}
	return salt, nil
}

// SHA256HashWithSalt creates a SHA-256 hash of data with a random salt
func SHA256HashWithSalt(data []byte) (hash string, salt string, err error) {
	// Generate 16-byte salt (128 bits)
	saltBytes, err := GenerateRandomSalt(16)
	if err != nil {
		return "", "", err
	}

	// Combine data and salt
	combined := append(data, saltBytes...)

	// Compute SHA-256 hash
	hashBytes := sha256.Sum256(combined)

	// Encode hash and salt to base64 for easy storage/transmission
	return base64.StdEncoding.EncodeToString(hashBytes[:]),
		base64.StdEncoding.EncodeToString(saltBytes),
		nil
}

// VerifySHA256HashWithSalt verifies data against a hash and salt
func VerifySHA256HashWithSalt(data []byte, hash, salt string) (bool, error) {
	// Decode salt from base64
	saltBytes, err := base64.StdEncoding.DecodeString(salt)
	if err != nil {
		return false, fmt.Errorf("failed to decode salt: %w", err)
	}

	// Combine data and salt
	combined := append(data, saltBytes...)

	// Compute hash
	hashBytes := sha256.Sum256(combined)
	computedHash := base64.StdEncoding.EncodeToString(hashBytes[:])

	// Compare hashes (constant time comparison would be better for production)
	return computedHash == hash, nil
}

// GenerateAESKey creates a cryptographically secure 256-bit AES key
func GenerateAESKey() ([]byte, error) {
	key := make([]byte, 32) // 32 bytes = 256 bits
	_, err := rand.Read(key)
	if err != nil {
		return nil, fmt.Errorf("failed to generate AES key: %w", err)
	}
	return key, nil
}

// AESEncrypt encrypts data using AES-GCM (authenticated encryption)
func AESEncrypt(key, plaintext []byte) (string, error) {
	// Create AES cipher block
	block, err := aes.NewCipher(key)
	if err != nil {
		return "", fmt.Errorf("failed to create AES cipher: %w", err)
	}

	// Create GCM mode (authenticated encryption)
	gcm, err := cipher.NewGCM(block)
	if err != nil {
		return "", fmt.Errorf("failed to create GCM mode: %w", err)
	}

	// Generate nonce (12 bytes recommended for GCM)
	nonce := make([]byte, gcm.NonceSize())
	if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
		return "", fmt.Errorf("failed to generate nonce: %w", err)
	}

	// Encrypt data (GCM automatically adds authentication tag)
	ciphertext := gcm.Seal(nil, nonce, plaintext, nil)

	// Combine nonce and ciphertext (nonce is not secret, just needs to be unique)
	fullCiphertext := append(nonce, ciphertext...)

	// Encode to base64 for easy storage/transmission
	return base64.StdEncoding.EncodeToString(fullCiphertext), nil
}

// AESDecrypt decrypts data encrypted with AESEncrypt
func AESDecrypt(key []byte, ciphertextBase64 string) ([]byte, error) {
	// Decode from base64
	fullCiphertext, err := base64.StdEncoding.DecodeString(ciphertextBase64)
	if err != nil {
		return nil, fmt.Errorf("failed to decode ciphertext: %w", err)
	}

	// Create AES cipher block
	block, err := aes.NewCipher(key)
	if err != nil {
		return nil, fmt.Errorf("failed to create AES cipher: %w", err)
	}

	// Create GCM mode
	gcm, err := cipher.NewGCM(block)
	if err != nil {
		return nil, fmt.Errorf("failed to create GCM mode: %w", err)
	}

	// Extract nonce from the beginning of the ciphertext
	nonceSize := gcm.NonceSize()
	if len(fullCiphertext) < nonceSize {
		return nil, errors.New("ciphertext too short")
	}
	nonce := fullCiphertext[:nonceSize]
	ciphertext := fullCiphertext[nonceSize:]

	// Decrypt and verify authentication tag
	plaintext, err := gcm.Open(nil, nonce, ciphertext, nil)
	if err != nil {
		return nil, fmt.Errorf("decryption failed (invalid key or tampered data): %w", err)
	}

	return plaintext, nil
}

func main() {
	// Example 1: Bcrypt password hashing
	password := "my_secure_password123"
	hash, err := HashPassword(password)
	if err != nil {
		log.Fatalf("Failed to hash password: %v", err)
	}
	fmt.Println("Bcrypt Hash:", hash)

	// Verify password
	isValid := VerifyPassword(password, hash)
	fmt.Println("Password valid:", isValid)
	isValid = VerifyPassword("wrong_password", hash)
	fmt.Println("Wrong password valid:", isValid)

	fmt.Println("---")

	// Example 2: SHA-256 with salt
	data := []byte("sensitive_data_123")
	hash256, salt, err := SHA256HashWithSalt(data)
	if err != nil {
		log.Fatalf("Failed to hash data: %v", err)
	}
	fmt.Println("SHA-256 Hash:", hash256)
	fmt.Println("Salt:", salt)

	// Verify hash
	isValidHash, err := VerifySHA256HashWithSalt(data, hash256, salt)
	if err != nil {
		log.Fatalf("Failed to verify hash: %v", err)
	}
	fmt.Println("Hash valid:", isValidHash)

	fmt.Println("---")

	// Example 3: AES-GCM encryption/decryption
	key, err := GenerateAESKey()
	if err != nil {
		log.Fatalf("Failed to generate AES key: %v", err)
	}
	fmt.Println("AES Key (base64):", base64.StdEncoding.EncodeToString(key))

	secretData := []byte("my super secret message")
	encrypted, err := AESEncrypt(key, secretData)
	if err != nil {
		log.Fatalf("Failed to encrypt data: %v", err)
	}
	fmt.Println("Encrypted Data:", encrypted)

	decrypted, err := AESDecrypt(key, encrypted)
	if err != nil {
		log.Fatalf("Failed to decrypt data: %v", err)
	}
	fmt.Println("Decrypted Data:", string(decrypted))

	// Test tampered data (should fail)
	tamperedEncrypted := encrypted + "tampered"
	_, err = AESDecrypt(key, tamperedEncrypted)
	fmt.Println("Decrypt tampered data error:", err != nil)
}