Use age for message encryption

Author: rubiojr

configs/hashup.toml

@@ -1,6 +1,11 @@
 [main]
 nats_server_url = "http://user:secret@localhost:4222"
-encryption_key  = "super-secret-key"
+# IMPORTANT: replace this key
+#
+# `hashup keygen` or `age-keygen` (https://github.com/FiloSottile/age)
+# can be used to generate it.
+#
+encryption_key  = "AGE-SECRET-KEY-1FDQ7Q24T2Q3CC6SFLS33PV5P3A59RH89PCQ0PAU6FQ8GNWD9HNASTSQP57"
 nats_stream    = "HASHUP"
 nats_subject   = "FILES"
 

go.mod

@@ -3,6 +3,7 @@ module github.com/rubiojr/hashup
 go 1.23.4
 
 require (
+	filippo.io/age v1.2.1
 	github.com/BurntSushi/toml v1.4.0
 	github.com/VictoriaMetrics/fastcache v1.12.2
 	github.com/a-h/templ v0.3.856
@@ -16,6 +17,7 @@ require (
 	github.com/stretchr/testify v1.10.0
 	github.com/urfave/cli/v2 v2.27.5
 	github.com/vmihailenco/msgpack/v5 v5.4.1
+	golang.org/x/term v0.30.0
 )
 
 require (
@@ -35,7 +37,6 @@ require (
 	github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1 // indirect
 	golang.org/x/crypto v0.36.0 // indirect
 	golang.org/x/sys v0.31.0 // indirect
-	golang.org/x/text v0.23.0 // indirect
 	golang.org/x/time v0.11.0 // indirect
 	gopkg.in/yaml.v3 v3.0.1 // indirect
 )

go.sum

@@ -1,3 +1,7 @@
+c2sp.org/CCTV/age v0.0.0-20240306222714-3ec4d716e805 h1:u2qwJeEvnypw+OCPUHmoZE3IqwfuN5kgDfo5MLzpNM0=
+c2sp.org/CCTV/age v0.0.0-20240306222714-3ec4d716e805/go.mod h1:FomMrUJ2Lxt5jCLmZkG3FHa72zUprnhd3v/Z18Snm4w=
+filippo.io/age v1.2.1 h1:X0TZjehAZylOIj4DubWYU1vWQxv9bJpo+Uu2/LGhi1o=
+filippo.io/age v1.2.1/go.mod h1:JL9ew2lTN+Pyft4RiNGguFfOpewKwSHm5ayKD/A4004=
 github.com/BurntSushi/toml v1.4.0 h1:kuoIxZQy2WRRk1pttg9asf+WVv6tWQuBNVmK8+nqPr0=
 github.com/BurntSushi/toml v1.4.0/go.mod h1:ukJfTF/6rtPPRCnwkur4qwRxa8vTRFBF0uk2lLoLwho=
 github.com/VictoriaMetrics/fastcache v1.12.2 h1:N0y9ASrJ0F6h0QaC3o6uJb3NIZ9VKLjCM7NQbSmF7WI=
@@ -68,8 +72,8 @@ golang.org/x/sys v0.14.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/sys v0.21.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
 golang.org/x/sys v0.31.0 h1:ioabZlmFYtWhL+TRYpcnNlLwhyxaM9kWTDEmfnprqik=
 golang.org/x/sys v0.31.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k=
-golang.org/x/text v0.23.0 h1:D71I7dUrlY+VX0gQShAThNGHFxZ13dGLBHQLVl1mJlY=
-golang.org/x/text v0.23.0/go.mod h1:/BLNzu4aZCJ1+kcD0DNRotWKage4q2rGVAg4o22unh4=
+golang.org/x/term v0.30.0 h1:PQ39fJZ+mfadBm0y5WlL4vlM7Sx1Hgf13sMIY2+QS9Y=
+golang.org/x/term v0.30.0/go.mod h1:NYYFdzHoI5wRh/h5tDMdMqCqPJZEuNqVR5xJLd/n67g=
 golang.org/x/time v0.11.0 h1:/bpjEDfN9tkoN/ryeYHnv5hcMlc8ncjMcM4XBk5NWV0=
 golang.org/x/time v0.11.0/go.mod h1:CDIdPxbZBQxdj6cxyCIdrNogrJKMJ7pr37NYpMcMDSg=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=

internal/crypto/aes.go

@@ -0,0 +1,82 @@
+package crypto
+
+import (
+	"crypto/aes"
+	"crypto/cipher"
+	"crypto/rand"
+	"crypto/sha256"
+	"fmt"
+	"io"
+)
+
+type aesMachine struct {
+	key []byte
+}
+
+// NewEncryptor creates a new Encryptor instance with the given key
+func NewAES(key []byte) (Machine, error) {
+	// Derive a 32-byte key for AES-256 from the encryption key
+	hasher := sha256.New()
+	hasher.Write(key)
+	ek := hasher.Sum(nil)
+	if len(ek) != 32 {
+		return nil, fmt.Errorf("invalid key length")
+	}
+	return &aesMachine{key: ek}, nil
+}
+
+// encrypt uses AES-GCM to encrypt data with the processor's key
+func (e *aesMachine) Encrypt(data []byte) ([]byte, error) {
+	// Create a new cipher block from the key
+	block, err := aes.NewCipher(e.key)
+	if err != nil {
+		return nil, err
+	}
+
+	// Create a new GCM
+	gcm, err := cipher.NewGCM(block)
+	if err != nil {
+		return nil, err
+	}
+
+	// Create a nonce (12 bytes for GCM)
+	nonce := make([]byte, gcm.NonceSize())
+	if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
+		return nil, err
+	}
+
+	// Encrypt and seal the data
+	ciphertext := gcm.Seal(nonce, nonce, data, nil)
+	return ciphertext, nil
+}
+
+// decrypt uses AES-GCM to decrypt data with the processor's key
+func (e *aesMachine) Decrypt(data []byte) ([]byte, error) {
+	block, err := aes.NewCipher(e.key)
+	if err != nil {
+		return nil, err
+	}
+
+	// Create a new GCM
+	gcm, err := cipher.NewGCM(block)
+	if err != nil {
+		return nil, err
+	}
+
+	// Get the nonce size
+	nonceSize := gcm.NonceSize()
+	if len(data) < nonceSize {
+		return nil, fmt.Errorf("ciphertext too short")
+	}
+
+	// Extract the nonce and ciphertext
+	nonce, ciphertext := data[:nonceSize], data[nonceSize:]
+
+	// Decrypt the data
+	plaintext, err := gcm.Open(nil, nonce, ciphertext, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return plaintext, nil
+}

internal/crypto/age.go

@@ -0,0 +1,86 @@
+package crypto
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+
+	"filippo.io/age"
+	"filippo.io/age/armor"
+)
+
+type ageX25519Machine struct {
+	recipient age.Recipient
+	identity  age.Identity
+}
+
+func NewAge(privateKey string) (Machine, error) {
+	identity, err := age.ParseX25519Identity(privateKey)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse private key: %w", err)
+	}
+
+	return &ageX25519Machine{
+		recipient: identity.Recipient(),
+		identity:  identity,
+	}, nil
+}
+
+func GenerateAgeKeyPair() (publicKey string, privateKey string, err error) {
+	identity, err := age.GenerateX25519Identity()
+	if err != nil {
+		return "", "", err
+	}
+
+	return identity.Recipient().String(), identity.String(), nil
+}
+
+func DerivePublicKey(privateKey string) (string, error) {
+	identity, err := age.ParseX25519Identity(privateKey)
+	if err != nil {
+		return "", fmt.Errorf("failed to parse private key: %w", err)
+	}
+
+	return identity.Recipient().String(), nil
+}
+
+func (a *ageX25519Machine) Encrypt(data []byte) ([]byte, error) {
+	var buf bytes.Buffer
+
+	armorWriter := armor.NewWriter(&buf)
+	ageWriter, err := age.Encrypt(armorWriter, a.recipient)
+	if err != nil {
+		return nil, err
+	}
+
+	if _, err := ageWriter.Write(data); err != nil {
+		return nil, err
+	}
+
+	if err := ageWriter.Close(); err != nil {
+		return nil, err
+	}
+
+	if err := armorWriter.Close(); err != nil {
+		return nil, err
+	}
+
+	return buf.Bytes(), nil
+}
+
+func (a *ageX25519Machine) Decrypt(data []byte) ([]byte, error) {
+	reader := bytes.NewReader(data)
+
+	armorReader := armor.NewReader(reader)
+	ageReader, err := age.Decrypt(armorReader, a.identity)
+	if err != nil {
+		return nil, err
+	}
+
+	var buf bytes.Buffer
+	if _, err := io.Copy(&buf, ageReader); err != nil {
+		return nil, err
+	}
+
+	return buf.Bytes(), nil
+}

internal/crypto/crypto.go

@@ -1,77 +1,6 @@
 package crypto
 
-import (
-	"crypto/aes"
-	"crypto/cipher"
-	"crypto/rand"
-	"fmt"
-	"io"
-)
-
-type Machine struct {
-	key []byte
-}
-
-// NewEncryptor creates a new Encryptor instance with the given key
-func New(key []byte) (*Machine, error) {
-	if len(key) != 32 {
-		return nil, fmt.Errorf("invalid key length")
-	}
-	return &Machine{key: key}, nil
-}
-
-// encrypt uses AES-GCM to encrypt data with the processor's key
-func (e *Machine) Encrypt(data []byte) ([]byte, error) {
-	// Create a new cipher block from the key
-	block, err := aes.NewCipher(e.key)
-	if err != nil {
-		return nil, err
-	}
-
-	// Create a new GCM
-	gcm, err := cipher.NewGCM(block)
-	if err != nil {
-		return nil, err
-	}
-
-	// Create a nonce (12 bytes for GCM)
-	nonce := make([]byte, gcm.NonceSize())
-	if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
-		return nil, err
-	}
-
-	// Encrypt and seal the data
-	ciphertext := gcm.Seal(nonce, nonce, data, nil)
-	return ciphertext, nil
-}
-
-// decrypt uses AES-GCM to decrypt data with the processor's key
-func (e *Machine) Decrypt(data []byte) ([]byte, error) {
-	block, err := aes.NewCipher(e.key)
-	if err != nil {
-		return nil, err
-	}
-
-	// Create a new GCM
-	gcm, err := cipher.NewGCM(block)
-	if err != nil {
-		return nil, err
-	}
-
-	// Get the nonce size
-	nonceSize := gcm.NonceSize()
-	if len(data) < nonceSize {
-		return nil, fmt.Errorf("ciphertext too short")
-	}
-
-	// Extract the nonce and ciphertext
-	nonce, ciphertext := data[:nonceSize], data[nonceSize:]
-
-	// Decrypt the data
-	plaintext, err := gcm.Open(nil, nonce, ciphertext, nil)
-	if err != nil {
-		return nil, err
-	}
-
-	return plaintext, nil
+type Machine interface {
+	Encrypt(data []byte) ([]byte, error)
+	Decrypt(data []byte) ([]byte, error)
 }

internal/processors/nats/nats.go

@@ -2,7 +2,6 @@ package nats
 
 import (
 	"context"
-	"crypto/sha256"
 	"fmt"
 	"time"
 
@@ -29,7 +28,7 @@ type natsProcessor struct {
 	encrypt     bool   // field to control encryption behavior
 	cache       *cache.FileCache
 	statsChan   chan Stats
-	crypto      *crypto.Machine
+	crypto      crypto.Machine
 	clientCert  string
 	clientKey   string
 	caCert      string
@@ -47,10 +46,7 @@ func WithStatsChannel(ch chan Stats) Option {
 // WithEncryptionKey sets a specific encryption key
 func WithEncryptionKey(key string) Option {
 	return func(np *natsProcessor) {
-		// Convert the key to a fixed length by hashing it
-		hasher := sha256.New()
-		hasher.Write([]byte(key))
-		np.encryptKey = hasher.Sum(nil)
+		np.encryptKey = []byte(key)
 	}
 }
 func WithClientCert(cert string) Option {
@@ -137,7 +133,7 @@ func NewNATSProcessor(ctx context.Context, url, streamName, subject string, time
 		return nil, fmt.Errorf("encryption enabled but no key provided")
 	}
 
-	processor.crypto, err = crypto.New(processor.encryptKey)
+	processor.crypto, err = crypto.NewAge(string(processor.encryptKey))
 	if err != nil {
 		return nil, err
 	}

internal/store/listener.go

@@ -2,7 +2,6 @@ package store
 
 import (
 	"context"
-	"crypto/sha256"
 	"fmt"
 	"time"
 
@@ -146,13 +145,7 @@ func (l *natsListener) Listen(ctx context.Context) error {
 	}
 	defer sub.Unsubscribe()
 
-	var ek []byte
-
-	// Derive a 32-byte key for AES-256 from the encryption key
-	hasher := sha256.New()
-	hasher.Write([]byte(l.natsEncryptionKey))
-	ek = hasher.Sum(nil)
-	cryptom, err := crypto.New(ek)
+	cryptom, err := crypto.NewAge(l.natsEncryptionKey)
 	if err != nil {
 		return fmt.Errorf("failed to create crypto instance: %v", err)
 	}