Remove the unused crypto path and write the blob-ID hash step once (closes #151)

Production encryption and decryption already run through blobgen; the
crypto package (Encryptor, Decryptor, UpdateRecipients, the fx Module)
and Vaultik.GetEncryptor/GetDecryptor had no production caller. Delete
crypto and route verify --deep through the same blobgen reader restore
uses: it parses the age key once and reads both the database (still
streamed to a temp file) and every blob through blobgen.NewReader.

The second, blob-ID hash step is now one exported function,
blobgen.DoubleSHA256, called by the three former copies. Writer.Sum256
(the double hash) becomes Writer.ContentID so it no longer shares the
name Sum256 with Reader.Sum256 (the single plaintext hash). CompressData
and CompressStream, unused outside tests, are deleted.

Delete the unused, never-adopted secret/config newtypes in internal/types
(the redacting AgeSecretKey and AWSSecretAccessKey plus AgeRecipient,
S3Endpoint, BucketName, S3Prefix, AWSRegion, AWSAccessKeyID). Delete the
uncalled CleanupIncompleteSnapshots (and deleteSnapshot, its only caller,
now dead) and correct ARCHITECTURE.md. The only multi-recipient test
moves to blobgen; the pre-#131 encrypted-bytes hash test is removed.

Model: opus-4-8

internal/blobgen/compress.go

@@ -1,89 +0,0 @@
-// Package blobgen implements the blob data pipeline: streaming zstd
-// compression, age encryption, and SHA256 content hashing for blob
-// creation, plus the matching decrypt/decompress/verify reader.
-package blobgen
-
-import (
-	"bytes"
-	"encoding/hex"
-	"fmt"
-	"io"
-)
-
-// CompressResult contains the results of compression
-type CompressResult struct {
-	Data             []byte
-	UncompressedSize int64
-	CompressedSize   int64
-	SHA256           string
-}
-
-// CompressData compresses and encrypts data, returning the result with hash
-func CompressData(
-	data []byte, compressionLevel int, recipients []string,
-) (*CompressResult, error) {
-	var buf bytes.Buffer
-
-	// Create writer
-	w, err := NewWriter(&buf, compressionLevel, recipients)
-	if err != nil {
-		return nil, fmt.Errorf("creating writer: %w", err)
-	}
-
-	// Write data
-	_, err = w.Write(data)
-	if err != nil {
-		_ = w.Close()
-
-		return nil, fmt.Errorf("writing data: %w", err)
-	}
-
-	// Close to flush
-	err = w.Close()
-	if err != nil {
-		return nil, fmt.Errorf("closing writer: %w", err)
-	}
-
-	return &CompressResult{
-		Data:             buf.Bytes(),
-		UncompressedSize: int64(len(data)),
-		CompressedSize:   int64(buf.Len()),
-		SHA256:           hex.EncodeToString(w.Sum256()),
-	}, nil
-}
-
-// CompressStream compresses and encrypts from reader to writer, returning
-// the number of uncompressed bytes written and the content hash.
-func CompressStream(
-	dst io.Writer, src io.Reader, compressionLevel int, recipients []string,
-) (int64, string, error) {
-	// Create writer
-	w, err := NewWriter(dst, compressionLevel, recipients)
-	if err != nil {
-		return 0, "", fmt.Errorf("creating writer: %w", err)
-	}
-
-	closed := false
-
-	defer func() {
-		if !closed {
-			_ = w.Close()
-		}
-	}()
-
-	// Copy data
-	_, err = io.Copy(w, src)
-	if err != nil {
-		return 0, "", fmt.Errorf("copying data: %w", err)
-	}
-
-	// Close to flush
-	err = w.Close()
-	if err != nil {
-		return 0, "", fmt.Errorf("closing writer: %w", err)
-	}
-
-	closed = true
-
-	return w.BytesWritten(), hex.EncodeToString(w.Sum256()), nil
-}

internal/blobgen/compress_test.go

@@ -1,80 +0,0 @@
-package blobgen_test
-
-import (
-	"bytes"
-	"crypto/rand"
-	"strings"
-	"testing"
-
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
-	"sneak.berlin/go/vaultik/internal/blobgen"
-)
-
-// testRecipient is a static age recipient for tests.
-const testRecipient = "age1cplgrwj77ta54dnmydvvmzn64ltk83ankxl5sww04mrtmu62kv3s89gmvv"
-
-// TestCompressStreamNoDoubleClose is a regression test for issue #28.
-// It verifies that CompressStream does not panic or return an error due to
-// double-closing the underlying blobgen.Writer. Before the fix in PR #33,
-// the explicit Close() on the happy path combined with defer Close() would
-// cause a double close.
-func TestCompressStreamNoDoubleClose(t *testing.T) {
-	t.Parallel()
-
-	input := []byte("regression test data for issue #28 double-close fix")
-
-	var buf bytes.Buffer
-
-	written, hash, err := blobgen.CompressStream(
-		&buf, bytes.NewReader(input), 3, []string{testRecipient})
-	require.NoError(t, err, "CompressStream should not return an error")
-	assert.Positive(t, written, "expected bytes written > 0")
-	assert.NotEmpty(t, hash, "expected non-empty hash")
-	assert.Positive(t, buf.Len(), "expected non-empty output")
-}
-
-// TestCompressStreamLargeInput exercises CompressStream with a larger payload
-// to ensure no double-close issues surface under heavier I/O.
-func TestCompressStreamLargeInput(t *testing.T) {
-	t.Parallel()
-
-	data := make([]byte, 512*1024) // 512 KB
-	_, err := rand.Read(data)
-	require.NoError(t, err)
-
-	var buf bytes.Buffer
-
-	written, hash, err := blobgen.CompressStream(
-		&buf, bytes.NewReader(data), 3, []string{testRecipient})
-	require.NoError(t, err)
-	assert.Positive(t, written)
-	assert.NotEmpty(t, hash)
-}
-
-// TestCompressStreamEmptyInput verifies CompressStream handles empty input
-// without double-close issues.
-func TestCompressStreamEmptyInput(t *testing.T) {
-	t.Parallel()
-
-	var buf bytes.Buffer
-
-	_, hash, err := blobgen.CompressStream(
-		&buf, strings.NewReader(""), 3, []string{testRecipient})
-	require.NoError(t, err)
-	assert.NotEmpty(t, hash)
-}
-
-// TestCompressDataNoDoubleClose mirrors the stream test for CompressData,
-// ensuring the explicit Close + error-path Close pattern is also safe.
-func TestCompressDataNoDoubleClose(t *testing.T) {
-	t.Parallel()
-
-	input := []byte("CompressData regression test for double-close")
-
-	result, err := blobgen.CompressData(input, 3, []string{testRecipient})
-	require.NoError(t, err)
-	assert.Positive(t, result.CompressedSize)
-	assert.Equal(t, result.UncompressedSize, int64(len(input)))
-	assert.NotEmpty(t, result.SHA256)
-}

internal/blobgen/reader.go

@@ -64,7 +64,9 @@ func (r *Reader) Close() error {
 	return nil
 }
 
-// Sum256 returns the SHA256 hash of all data read
+// Sum256 returns the single SHA-256 of the plaintext read so far. This is the
+// first hash only; the stored object name is its double hash, which callers
+// obtain by passing this digest to DoubleSHA256.
 func (r *Reader) Sum256() []byte {
 	return r.hasher.Sum(nil)
 }

internal/blobgen/reader_test.go

@@ -0,0 +1,54 @@
+package blobgen_test
+
+import (
+	"bytes"
+	"io"
+	"testing"
+
+	"filippo.io/age"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"sneak.berlin/go/vaultik/internal/blobgen"
+)
+
+// TestMultipleRecipients verifies that data written for several recipients can
+// be read back by each recipient's identity. Moved from internal/crypto, which
+// held the only multi-recipient test; blobgen is now the sole encryption path.
+func TestMultipleRecipients(t *testing.T) {
+	t.Parallel()
+
+	identities := make([]*age.X25519Identity, 3)
+	recipients := make([]string, 3)
+
+	for i := range identities {
+		identity, err := age.GenerateX25519Identity()
+		require.NoError(t, err)
+
+		identities[i] = identity
+		recipients[i] = identity.Recipient().String()
+	}
+
+	plaintext := []byte("Secret message for multiple recipients")
+
+	var encrypted bytes.Buffer
+
+	writer, err := blobgen.NewWriter(&encrypted, 3, recipients)
+	require.NoError(t, err)
+	_, err = writer.Write(plaintext)
+	require.NoError(t, err)
+	require.NoError(t, writer.Close())
+
+	// Every recipient's identity must recover the original plaintext.
+	for i, identity := range identities {
+		reader, err := blobgen.NewReader(
+			bytes.NewReader(encrypted.Bytes()), identity)
+		require.NoError(t, err, "recipient %d should open the reader", i+1)
+
+		got, err := io.ReadAll(reader)
+		require.NoError(t, err, "recipient %d should read the plaintext", i+1)
+		require.NoError(t, reader.Close())
+
+		assert.Equal(t, plaintext, got,
+			"recipient %d should recover the original plaintext", i+1)
+	}
+}

internal/blobgen/writer.go

@@ -1,3 +1,6 @@
+// Package blobgen implements the blob data pipeline: streaming zstd
+// compression, age encryption, and SHA256 content hashing for blob
+// creation, plus the matching decrypt/decompress/verify reader.
 package blobgen
 
 import (
@@ -12,6 +15,18 @@ import (
 	"github.com/klauspost/compress/zstd"
 )
 
+// DoubleSHA256 returns the double SHA-256 of content whose single SHA-256
+// digest is sum: it hashes that digest once more. Stored objects are named by
+// this second hash so that a name never reveals whether known content is
+// present — an attacker who knows a plaintext, and thus its SHA-256, still
+// cannot derive the stored name without hashing the digest again. Both a blob
+// and the metadata database export are named this way.
+func DoubleSHA256(sum []byte) []byte {
+	h := sha256.Sum256(sum)
+
+	return h[:]
+}
+
 // Zstd compression level bounds accepted by NewWriter.
 const (
 	minCompressionLevel = 1
@@ -130,17 +145,12 @@ func (w *Writer) Close() error {
 	return nil
 }
 
-// Sum256 returns the double SHA256 hash of the uncompressed input data.
-// Double hashing (SHA256(SHA256(data))) prevents information leakage about
-// the plaintext - an attacker cannot confirm existence of known content
-// by computing its hash and checking for a matching blob filename.
-func (w *Writer) Sum256() []byte {
-	// First hash: SHA256(plaintext)
-	firstHash := w.hasher.Sum(nil)
-	// Second hash: SHA256(firstHash) - this is the blob ID
-	secondHash := sha256.Sum256(firstHash)
-
-	return secondHash[:]
+// ContentID returns the double SHA-256 of the uncompressed input data: the
+// name under which this content is stored. It is the second hash of the
+// running SHA-256, via DoubleSHA256; see that function for why content is
+// named this way rather than by its plain SHA-256.
+func (w *Writer) ContentID() []byte {
+	return DoubleSHA256(w.hasher.Sum(nil))
 }
 
 // BytesWritten returns the number of uncompressed bytes written

internal/blobgen/writer_test.go

@@ -12,7 +12,7 @@ import (
 	"sneak.berlin/go/vaultik/internal/blobgen"
 )
 
-// TestWriterHashIsDoubleHash verifies that Writer.Sum256() returns
+// TestWriterHashIsDoubleHash verifies that Writer.ContentID() returns
 // the double hash SHA256(SHA256(plaintext)) for security.
 // Double hashing prevents attackers from confirming existence of known content.
 func TestWriterHashIsDoubleHash(t *testing.T) {
@@ -43,7 +43,7 @@ func TestWriterHashIsDoubleHash(t *testing.T) {
 	require.NoError(t, err)
 
 	// Get the hash from the writer
-	writerHash := hex.EncodeToString(writer.Sum256())
+	writerHash := hex.EncodeToString(writer.ContentID())
 
 	// Calculate the expected double hash: SHA256(SHA256(plaintext))
 	firstHash := sha256.Sum256(testData)
@@ -60,7 +60,7 @@ func TestWriterHashIsDoubleHash(t *testing.T) {
 
 	// The writer hash should match the double hash
 	assert.Equal(t, expectedDoubleHash, writerHash,
-		"Writer.Sum256() should return SHA256(SHA256(plaintext)) for security")
+		"Writer.ContentID() should return SHA256(SHA256(plaintext)) for security")
 
 	// Verify it's NOT the single hash (would leak information)
 	assert.NotEqual(t, singleHashStr, writerHash,
@@ -93,8 +93,8 @@ func TestWriterDeterministicHash(t *testing.T) {
 	require.NoError(t, err)
 	require.NoError(t, writer2.Close())
 
-	hash1 := hex.EncodeToString(writer1.Sum256())
-	hash2 := hex.EncodeToString(writer2.Sum256())
+	hash1 := hex.EncodeToString(writer1.ContentID())
+	hash2 := hex.EncodeToString(writer2.ContentID())
 
 	// Hashes should be identical (deterministic)
 	assert.Equal(t, hash1, hash2, "Same input should produce same hash")