feat: Expand examples to demonstrate all features

Expanded `examples/main.go` to fully demonstrate the functionality of the `crypt`, `enchantrix`, and `trix` packages.

- Restructured the main example file into distinct functions for each feature set (`demoTrix`, `demoHashing`, `demoChecksums`, `demoRSA`, `demoSigils`).
- Implemented a comprehensive `demoTrix` that showcases a chain of multiple sigils (`json-indent`, `gzip`, `base64`, `reverse`), checksum functionality, and the full Pack/Unpack workflow.
- Added a `demoHashing` function that iterates through all supported hashing algorithms.
- Added a `demoChecksums` function that demonstrates the Luhn and Fletcher algorithms.
- Added a `demoRSA` function that shows the complete RSA workflow from key generation to decryption.
- Added a `demoSigils` function to demonstrate sigil transformations independently.
- Fixed a bug in the Trix demo verification logic related to JSON indentation.

examples/main.go

@@ -1,36 +1,62 @@
 package main
 
 import (
+	"bytes"
 	"encoding/base64"
+	"encoding/json"
 	"fmt"
 	"log"
 	"time"
 
 	"github.com/Snider/Enchantrix/pkg/crypt"
 	"github.com/Snider/Enchantrix/pkg/crypt/std/chachapoly"
+	"github.com/Snider/Enchantrix/pkg/enchantrix"
 	"github.com/Snider/Enchantrix/pkg/trix"
 )
 
 func main() {
-	// 1. Original plaintext and encryption key
-	plaintext := []byte("This is a super secret message!")
+	demoTrix()
+	demoHashing()
+	demoChecksums()
+	demoRSA()
+	demoSigils()
+}
+
+func demoTrix() {
+	fmt.Println("--- Trix & Sigil Chaining Demo ---")
+
+	// 1. Original plaintext (JSON data) and encryption key
+	type Message struct {
+		Author string `json:"author"`
+		Time   int64  `json:"time"`
+		Body   string `json:"body"`
+	}
+	originalMessage := Message{Author: "Jules", Time: time.Now().Unix(), Body: "This is a super secret message!"}
+	plaintext, err := json.Marshal(originalMessage)
+	if err != nil {
+		log.Fatalf("Failed to marshal JSON: %v", err)
+	}
 	key := make([]byte, 32) // In a real application, use a secure key
 	for i := range key {
 		key[i] = 1
 	}
 
-	// 2. Create a Trix container with the plaintext and attach sigils
+	fmt.Printf("Original Payload (JSON):\n%s\n\n", plaintext)
+
+	// 2. Create a Trix container with the plaintext and attach a chain of sigils
+	sigilChain := []string{"json-indent", "gzip", "base64", "reverse"}
 	trixContainer := &trix.Trix{
-		Header:  map[string]interface{}{},
-		Payload: plaintext,
-		InSigils: []string{"reverse"},
+		Header:   map[string]interface{}{},
+		Payload:  plaintext,
+		InSigils: sigilChain,
 	}
 
 	// 3. Pack the Trix container to apply the sigil transformations
+	fmt.Println("Packing payload with sigils:", sigilChain)
 	if err := trixContainer.Pack(); err != nil {
 		log.Fatalf("Failed to pack trix container: %v", err)
 	}
-	fmt.Printf("Packed (obfuscated) payload: %x\n", trixContainer.Payload)
+	fmt.Printf("Packed (obfuscated) payload is now non-human-readable bytes.\n\n")
 
 	// 4. Encrypt the packed payload
 	ciphertext, err := chachapoly.Encrypt(trixContainer.Payload, key)
@@ -42,12 +68,13 @@ func main() {
 	// 5. Add encryption metadata and checksum to the header
 	nonce := ciphertext[:24]
 	trixContainer.Header = map[string]interface{}{
-		"content_type":         "application/octet-stream",
+		"content_type":         "application/json",
 		"encryption_algorithm": "chacha20poly1305",
 		"nonce":                base64.StdEncoding.EncodeToString(nonce),
 		"created_at":           time.Now().UTC().Format(time.RFC3339),
 	}
-	trixContainer.ChecksumAlgo = crypt.SHA256
+	trixContainer.ChecksumAlgo = crypt.SHA512
+	fmt.Printf("Checksum will be calculated with %s and added to the header.\n", trixContainer.ChecksumAlgo)
 
 	// 6. Encode the .trix container into its binary format
 	magicNumber := "MyT1"
@@ -55,15 +82,18 @@ func main() {
 	if err != nil {
 		log.Fatalf("Failed to encode .trix container: %v", err)
 	}
-	fmt.Println("Successfully created .trix container.")
+	fmt.Println("Successfully created .trix container.\n")
 
 	// --- DECODING ---
+	fmt.Println("--- DECODING ---")
 
 	// 7. Decode the .trix container
 	decodedTrix, err := trix.Decode(encodedTrix, magicNumber)
 	if err != nil {
 		log.Fatalf("Failed to decode .trix container: %v", err)
 	}
+	fmt.Println("Successfully decoded .trix container. Checksum verified.")
+	fmt.Printf("Decoded Header: %+v\n", decodedTrix.Header)
 
 	// 8. Decrypt the payload
 	decryptedPayload, err := chachapoly.Decrypt(decodedTrix.Payload, key)
@@ -71,18 +101,150 @@ func main() {
 		log.Fatalf("Failed to decrypt: %v", err)
 	}
 	decodedTrix.Payload = decryptedPayload
+	fmt.Println("Payload decrypted.")
 
 	// 9. Unpack the Trix container to reverse the sigil transformations
-	decodedTrix.InSigils = trixContainer.InSigils // Re-attach sigils
+	decodedTrix.InSigils = trixContainer.InSigils // Re-attach sigils for unpacking
+	fmt.Println("Unpacking payload by reversing sigils:", decodedTrix.InSigils)
 	if err := decodedTrix.Unpack(); err != nil {
 		log.Fatalf("Failed to unpack trix container: %v", err)
 	}
-	fmt.Printf("Unpacked (original) payload: %s\n", decodedTrix.Payload)
+	fmt.Printf("Unpacked (original) payload:\n%s\n", decodedTrix.Payload)
 
 	// 10. Verify the result
-	if string(plaintext) == string(decodedTrix.Payload) {
+	// To properly verify, we need to compact the indented JSON before comparing
+	var compactedPayload bytes.Buffer
+	if err := json.Compact(&compactedPayload, decodedTrix.Payload); err != nil {
+		log.Fatalf("Failed to compact final payload for verification: %v", err)
+	}
+
+	if bytes.Equal(plaintext, compactedPayload.Bytes()) {
 		fmt.Println("\nSuccess! The message was decrypted and unpacked correctly.")
 	} else {
 		fmt.Println("\nFailure! The final payload does not match the original.")
 	}
+	fmt.Println()
+}
+
+func demoHashing() {
+	fmt.Println("--- Hashing Demo ---")
+	cryptService := crypt.NewService()
+	payload := "Enchantrix"
+
+	hashTypes := []crypt.HashType{
+		crypt.LTHN,
+		crypt.MD5,
+		crypt.SHA1,
+		crypt.SHA256,
+		crypt.SHA512,
+	}
+
+	fmt.Printf("Payload to hash: \"%s\"\n", payload)
+	for _, hashType := range hashTypes {
+		hash := cryptService.Hash(hashType, payload)
+		fmt.Printf("  - %-6s: %s\n", hashType, hash)
+	}
+	fmt.Println()
+}
+
+func demoChecksums() {
+	fmt.Println("--- Checksum Demo ---")
+	cryptService := crypt.NewService()
+
+	// Luhn
+	luhnPayloadGood := "49927398716"
+	luhnPayloadBad := "49927398717"
+	fmt.Printf("Luhn Checksum:\n")
+	fmt.Printf("  - Payload '%s' is valid: %v\n", luhnPayloadGood, cryptService.Luhn(luhnPayloadGood))
+	fmt.Printf("  - Payload '%s' is valid: %v\n", luhnPayloadBad, cryptService.Luhn(luhnPayloadBad))
+
+	// Fletcher
+	fletcherPayload := "abcde"
+	fmt.Printf("\nFletcher Checksums (Payload: \"%s\"):\n", fletcherPayload)
+	fmt.Printf("  - Fletcher16: %d\n", cryptService.Fletcher16(fletcherPayload))
+	fmt.Printf("  - Fletcher32: %d\n", cryptService.Fletcher32(fletcherPayload))
+	fmt.Printf("  - Fletcher64: %d\n", cryptService.Fletcher64(fletcherPayload))
+	fmt.Println()
+}
+
+func demoRSA() {
+	fmt.Println("--- RSA Demo ---")
+	cryptService := crypt.NewService()
+
+	// 1. Generate RSA key pair
+	fmt.Println("Generating 2048-bit RSA key pair...")
+	publicKey, privateKey, err := cryptService.GenerateRSAKeyPair(2048)
+	if err != nil {
+		log.Fatalf("Failed to generate RSA key pair: %v", err)
+	}
+	fmt.Println("Key pair generated successfully.")
+
+	// 2. Encrypt a message
+	message := []byte("This is a secret message for RSA.")
+	fmt.Printf("\nOriginal message: %s\n", message)
+	ciphertext, err := cryptService.EncryptRSA(publicKey, message)
+	if err != nil {
+		log.Fatalf("Failed to encrypt with RSA: %v", err)
+	}
+	fmt.Printf("Encrypted ciphertext (base64): %s\n", base64.StdEncoding.EncodeToString(ciphertext))
+
+	// 3. Decrypt the message
+	decrypted, err := cryptService.DecryptRSA(privateKey, ciphertext)
+	if err != nil {
+		log.Fatalf("Failed to decrypt with RSA: %v", err)
+	}
+	fmt.Printf("Decrypted message: %s\n", decrypted)
+
+	// 4. Verify
+	if string(message) == string(decrypted) {
+		fmt.Println("\nSuccess! RSA decrypted message matches the original.")
+	} else {
+		fmt.Println("\nFailure! RSA decrypted message does not match the original.")
+	}
+	fmt.Println()
+}
+
+func demoSigils() {
+	fmt.Println("--- Standalone Sigil Demo ---")
+	data := []byte(`{"message": "hello world"}`)
+	fmt.Printf("Original data: %s\n", data)
+
+	// A chain of sigils to apply
+	sigils := []string{"gzip", "base64"}
+	fmt.Printf("Applying sigil chain: %v\n", sigils)
+
+	var transformedData = data
+	for _, name := range sigils {
+		s, err := enchantrix.NewSigil(name)
+		if err != nil {
+			log.Fatalf("Failed to create sigil %s: %v", name, err)
+		}
+		transformedData, err = s.In(transformedData)
+		if err != nil {
+			log.Fatalf("Failed to apply sigil %s 'In': %v", name, err)
+		}
+		fmt.Printf(" -> After '%s': %s\n", name, transformedData)
+	}
+
+	fmt.Println("\nReversing sigil chain...")
+	// Reverse the transformations
+	for i := len(sigils) - 1; i >= 0; i-- {
+		name := sigils[i]
+		s, err := enchantrix.NewSigil(name)
+		if err != nil {
+			log.Fatalf("Failed to create sigil %s: %v", name, err)
+		}
+		transformedData, err = s.Out(transformedData)
+		if err != nil {
+			log.Fatalf("Failed to apply sigil %s 'Out': %v", name, err)
+		}
+		fmt.Printf(" -> After '%s' Out: %s\n", name, transformedData)
+	}
+
+	if string(data) == string(transformedData) {
+		fmt.Println("Success! Data returned to original state.")
+	} else {
+		fmt.Println("Failure! Data did not return to original state.")
+	}
+	fmt.Println()
 }