first commit

backend/internal/infrastructure/security/encryption.go

@@ -0,0 +1,79 @@
+package security
+
+import (
+	"crypto/aes"
+	"crypto/cipher"
+	"crypto/rand"
+	"encoding/base64"
+	"errors"
+	"io"
+)
+
+// Encryptor provides encryption/decryption for sensitive data
+type Encryptor struct {
+	key []byte
+}
+
+// NewEncryptor creates a new encryptor with the given key
+// The key must be 32 bytes for AES-256
+func NewEncryptor(key string) (*Encryptor, error) {
+	if len(key) != 32 {
+		return nil, errors.New("encryption key must be 32 bytes (256 bits)")
+	}
+	return &Encryptor{
+		key: []byte(key),
+	}, nil
+}
+
+// Encrypt encrypts data using AES-256-GCM
+func (e *Encryptor) Encrypt(plaintext string) (string, error) {
+	block, err := aes.NewCipher(e.key)
+	if err != nil {
+		return "", err
+	}
+
+	gcm, err := cipher.NewGCM(block)
+	if err != nil {
+		return "", err
+	}
+
+	nonce := make([]byte, gcm.NonceSize())
+	if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
+		return "", err
+	}
+
+	ciphertext := gcm.Seal(nonce, nonce, []byte(plaintext), nil)
+	return base64.StdEncoding.EncodeToString(ciphertext), nil
+}
+
+// Decrypt decrypts data encrypted with Encrypt
+func (e *Encryptor) Decrypt(ciphertext string) (string, error) {
+	data, err := base64.StdEncoding.DecodeString(ciphertext)
+	if err != nil {
+		return "", err
+	}
+
+	block, err := aes.NewCipher(e.key)
+	if err != nil {
+		return "", err
+	}
+
+	gcm, err := cipher.NewGCM(block)
+	if err != nil {
+		return "", err
+	}
+
+	nonceSize := gcm.NonceSize()
+	if len(data) < nonceSize {
+		return "", errors.New("ciphertext too short")
+	}
+
+	nonce := data[:nonceSize]
+	ciphertextBytes := data[nonceSize:]
+	plaintext, err := gcm.Open(nil, nonce, ciphertextBytes, nil)
+	if err != nil {
+		return "", err
+	}
+
+	return string(plaintext), nil
+}

backend/internal/infrastructure/security/password.go

@@ -0,0 +1,121 @@
+package security
+
+import (
+	"crypto/rand"
+	"crypto/subtle"
+	"encoding/hex"
+	"errors"
+	"fmt"
+	"strconv"
+	"strings"
+
+	"golang.org/x/crypto/argon2"
+	"golang.org/x/crypto/bcrypt"
+)
+
+// PasswordHasher provides password hashing and verification
+type PasswordHasher struct {
+	time    uint32
+	memory  uint32
+	threads uint8
+	keyLen  uint32
+	saltLen int
+}
+
+// NewPasswordHasher creates a new password hasher with sensible defaults
+func NewPasswordHasher() *PasswordHasher {
+	return &PasswordHasher{
+		time:    1,
+		memory:  64 * 1024, // 64 MB
+		threads: 4,
+		keyLen:  32,
+		saltLen: 16,
+	}
+}
+
+// HashPassword hashes a password using Argon2id
+// Returns hash in format "$argon2id$v=19$m=65536,t=1,p=4$salt$hash"
+func (ph *PasswordHasher) HashPassword(password string) (string, error) {
+	salt := make([]byte, ph.saltLen)
+	if _, err := rand.Read(salt); err != nil {
+		return "", err
+	}
+
+	hash := argon2.IDKey(
+		[]byte(password),
+		salt,
+		ph.time,
+		ph.memory,
+		ph.threads,
+		ph.keyLen,
+	)
+
+	hashStr := fmt.Sprintf(
+		"$argon2id$v=%d$m=%d,t=%d,p=%d$%s$%s",
+		19,
+		ph.memory,
+		ph.time,
+		ph.threads,
+		hex.EncodeToString(salt),
+		hex.EncodeToString(hash),
+	)
+
+	return hashStr, nil
+}
+
+// VerifyPassword verifies a password against a hash
+func (ph *PasswordHasher) VerifyPassword(password, hash string) (bool, error) {
+	// Backward compatibility: accept legacy bcrypt hashes.
+	if strings.HasPrefix(hash, "$2a$") || strings.HasPrefix(hash, "$2b$") || strings.HasPrefix(hash, "$2y$") {
+		if err := bcrypt.CompareHashAndPassword([]byte(hash), []byte(password)); err != nil {
+			return false, nil
+		}
+		return true, nil
+	}
+
+	parts := strings.Split(hash, "$")
+	if len(parts) != 6 || parts[1] != "argon2id" {
+		return false, errors.New("invalid password hash format")
+	}
+
+	versionPart := strings.TrimPrefix(parts[2], "v=")
+	version, err := strconv.Atoi(versionPart)
+	if err != nil || version != 19 {
+		return false, errors.New("invalid password hash version")
+	}
+
+	var memory, timeCost uint32
+	var threads uint8
+	if _, err := fmt.Sscanf(parts[3], "m=%d,t=%d,p=%d", &memory, &timeCost, &threads); err != nil {
+		return false, errors.New("invalid password hash parameters")
+	}
+
+	saltStr := parts[4]
+	hashStr := parts[5]
+
+	salt, err := hex.DecodeString(saltStr)
+	if err != nil {
+		return false, errors.New("invalid salt in password hash")
+	}
+
+	expectedHashBytes, err := hex.DecodeString(hashStr)
+	if err != nil {
+		return false, errors.New("invalid hash in password hash")
+	}
+
+	// Hash the input password with the extracted parameters
+	computedHash := argon2.IDKey(
+		[]byte(password),
+		salt,
+		timeCost,
+		memory,
+		threads,
+		uint32(len(expectedHashBytes)),
+	)
+
+	if subtle.ConstantTimeCompare(computedHash, expectedHashBytes) == 1 {
+		return true, nil
+	}
+
+	return false, nil
+}