1  package main
  2  
  3  import (
  4  	"context"
  5  	"crypto/sha256"
  6  	"fmt"
  7  	"log"
  8  
  9  	"keepSync/internal/security/crypto"
 10  	"keepSync/internal/security/tpm/hardware"
 11  	"keepSync/internal/security/tpm/interfaces"
 12  	"keepSync/internal/storage/metadata"
 13  )
 14  
 15  func main() {
 16  	fmt.Println("🧪 Testing Metadata Embedding System...")
 17  
 18  	// Initialize TPM provider
 19  	tpmProvider := hardware.NewHardwareProvider("")
 20  	ctx := context.Background()
 21  	err := tpmProvider.Initialize(ctx)
 22  	if err != nil {
 23  		log.Fatalf("Failed to initialize TPM provider: %v", err)
 24  	}
 25  	defer tpmProvider.Close()
 26  
 27  	// Get or create a master key
 28  	masterKey, err := tpmProvider.GetKey(ctx, "test-metadata-key")
 29  	if err != nil {
 30  		fmt.Println("Creating new master key...")
 31  		masterKey, err = tpmProvider.GenerateKey(ctx, "test-metadata-key", interfaces.KeyOptions{
 32  			Algorithm: "AES",
 33  			KeySize:   256,
 34  			Protected: true,
 35  			Usage:     "encryption",
 36  		})
 37  		if err != nil {
 38  			log.Fatalf("Failed to generate master key: %v", err)
 39  		}
 40  	}
 41  
 42  	// Create secure key derivation
 43  	secureDerivation := crypto.NewSecureKeyDerivation(masterKey)
 44  	defer secureDerivation.Close()
 45  
 46  	// Create metadata embedder
 47  	embedder := metadata.NewMetadataEmbedder(secureDerivation)
 48  
 49  	// Test data
 50  	testFilename := "test-document.txt"
 51  	testFileSize := int64(1024)
 52  	testChunkData := []byte("This is a test chunk of data that will be embedded with metadata for cross-machine recovery testing.")
 53  	testContentHash := sha256.Sum256([]byte("full file content hash"))
 54  
 55  	fmt.Printf("📄 Test file: %s (%d bytes)\n", testFilename, testFileSize)
 56  	fmt.Printf("📦 Chunk size: %d bytes\n", len(testChunkData))
 57  
 58  	// Test metadata embedding
 59  	fmt.Println("\n🔐 Testing metadata embedding...")
 60  	embeddedChunk, err := embedder.EmbedMetadata(
 61  		testChunkData,
 62  		testFilename,
 63  		testFileSize,
 64  		0, // chunk index
 65  		1, // total chunks
 66  		testContentHash[:],
 67  	)
 68  	if err != nil {
 69  		log.Fatalf("Failed to embed metadata: %v", err)
 70  	}
 71  
 72  	fmt.Printf("✅ Metadata embedded successfully!\n")
 73  	fmt.Printf("   - Outer header: %d bytes\n", len(embeddedChunk.EncryptedOuterHeader))
 74  	fmt.Printf("   - Inner header: %d bytes\n", len(embeddedChunk.EncryptedInnerHeader))
 75  	fmt.Printf("   - Chunk data: %d bytes\n", len(embeddedChunk.ChunkData))
 76  
 77  	// Test serialization
 78  	fmt.Println("\n📦 Testing chunk serialization...")
 79  	serializedChunk, err := embedder.SerializeChunkWithMetadata(embeddedChunk)
 80  	if err != nil {
 81  		log.Fatalf("Failed to serialize chunk: %v", err)
 82  	}
 83  
 84  	fmt.Printf("✅ Chunk serialized successfully!\n")
 85  	fmt.Printf("   - Total serialized size: %d bytes\n", len(serializedChunk))
 86  	fmt.Printf("   - Overhead: %d bytes (%.1f%%)\n",
 87  		len(serializedChunk)-len(testChunkData),
 88  		float64(len(serializedChunk)-len(testChunkData))/float64(len(testChunkData))*100)
 89  
 90  	// Test format detection
 91  	fmt.Println("\n🔍 Testing format detection...")
 92  	format := metadata.DetectChunkFormat(serializedChunk)
 93  	switch format {
 94  	case metadata.FormatEmbeddedMetadata:
 95  		fmt.Println("✅ Format detected: Embedded Metadata (new format)")
 96  	case metadata.FormatLegacy:
 97  		fmt.Println("⚠️  Format detected: Legacy format")
 98  	default:
 99  		fmt.Println("❌ Format detected: Unknown")
100  	}
101  
102  	// Test file identifier consistency
103  	fmt.Println("\n🔑 Testing file identifier consistency...")
104  	fileId1, err := secureDerivation.GenerateConsistentFileIdentifier(testFilename, testFileSize)
105  	if err != nil {
106  		log.Fatalf("Failed to generate file identifier 1: %v", err)
107  	}
108  
109  	fileId2, err := secureDerivation.GenerateConsistentFileIdentifier(testFilename, testFileSize)
110  	if err != nil {
111  		log.Fatalf("Failed to generate file identifier 2: %v", err)
112  	}
113  
114  	if fileId1 == fileId2 {
115  		fmt.Println("✅ File identifiers are consistent across calls")
116  		fmt.Printf("   - File ID: %x\n", fileId1[:8]) // Show first 8 bytes
117  	} else {
118  		fmt.Println("❌ File identifiers are inconsistent!")
119  	}
120  
121  	// Test header validation
122  	fmt.Println("\n🛡️  Testing header validation...")
123  	if embeddedChunk.OuterHeader.ValidateChecksum() {
124  		fmt.Println("✅ Outer header checksum is valid")
125  	} else {
126  		fmt.Println("❌ Outer header checksum is invalid!")
127  	}
128  
129  	// Display metadata information
130  	fmt.Println("\n📋 Embedded Metadata Summary:")
131  	fmt.Printf("   - Original filename: %s\n", embeddedChunk.InnerHeader.OriginalFilename)
132  	fmt.Printf("   - Original size: %d bytes\n", embeddedChunk.InnerHeader.OriginalSize)
133  	fmt.Printf("   - Timestamp: %d\n", embeddedChunk.InnerHeader.Timestamp)
134  	fmt.Printf("   - Chunk sequence: %d/%d\n",
135  		embeddedChunk.OuterHeader.ChunkSequence+1,
136  		embeddedChunk.OuterHeader.TotalChunks)
137  	fmt.Printf("   - File identifier: %x\n", embeddedChunk.OuterHeader.FileIdentifier[:8])
138  	fmt.Printf("   - Filename hash: %x\n", embeddedChunk.OuterHeader.FilenameHash[:8])
139  
140  	fmt.Println("\n🎉 Metadata embedding test completed successfully!")
141  	fmt.Println("\n📊 Key Benefits Demonstrated:")
142  	fmt.Println("   ✅ Cross-machine file identification")
143  	fmt.Println("   ✅ Encrypted metadata headers")
144  	fmt.Println("   ✅ Chunk sequence tracking")
145  	fmt.Println("   ✅ Integrity verification")
146  	fmt.Println("   ✅ Backward compatibility detection")
147  	fmt.Println("\n🚀 Ready for Phase 4.2: Recovery Engine Implementation!")
148  }