package server import ( "archive/zip" "bytes" "crypto/ed25519" "crypto/rand" "testing" ) // withTestAuditKey swaps the embedded trusted key for a freshly generated // keypair for the duration of the test, so tests can sign payloads without // needing the real AUDIT-SP private key. func withTestAuditKey(t *testing.T) ed25519.PrivateKey { t.Helper() pub, priv, err := ed25519.GenerateKey(rand.Reader) if err != nil { t.Fatalf("generate test key: %v", err) } orig := auditSigningPublicKey auditSigningPublicKey = pub t.Cleanup(func() { auditSigningPublicKey = orig }) return priv } func auditPackageJSON() []byte { return []byte(`{"format":"audit.raw-export.v1","exported_at":"2026-10-08T08:11:40.529667Z","source":{"kind":"live_redfish","protocol":"redfish","target_host":"172.16.41.43"}}`) } func TestParseRawExportPackage_AuditFormatValidSignature(t *testing.T) { priv := withTestAuditKey(t) body := auditPackageJSON() sig := ed25519.Sign(priv, body) pkg, ok, err := parseRawExportPackage(body, sig) if err != nil || !ok { t.Fatalf("expected ok parse, got ok=%v err=%v", ok, err) } if !pkg.SignatureChecked { t.Fatal("expected SignatureChecked=true for audit format") } if !pkg.SignatureVerified { t.Fatal("expected SignatureVerified=true for a correctly signed payload") } } func TestParseRawExportPackage_AuditFormatTamperedPayload(t *testing.T) { priv := withTestAuditKey(t) body := auditPackageJSON() sig := ed25519.Sign(priv, body) tampered := append([]byte(nil), body...) tampered = bytes.Replace(tampered, []byte("172.16.41.43"), []byte("172.16.41.99"), 1) pkg, ok, err := parseRawExportPackage(tampered, sig) if err != nil || !ok { t.Fatalf("expected the bundle to still import, got ok=%v err=%v", ok, err) } if !pkg.SignatureChecked { t.Fatal("expected SignatureChecked=true") } if pkg.SignatureVerified { t.Fatal("expected SignatureVerified=false for a tampered payload") } } func TestParseRawExportPackage_AuditFormatMissingSignature(t *testing.T) { withTestAuditKey(t) body := auditPackageJSON() pkg, ok, err := parseRawExportPackage(body, nil) if err != nil || !ok { t.Fatalf("expected the bundle to still import without a signature, got ok=%v err=%v", ok, err) } if !pkg.SignatureChecked { t.Fatal("expected SignatureChecked=true") } if pkg.SignatureVerified { t.Fatal("expected SignatureVerified=false when no raw_export.sig is present") } } func TestParseRawExportPackage_LegacyFormatUnaffected(t *testing.T) { body := []byte(`{"format":"logpile.raw-export.v1","exported_at":"2026-10-08T08:11:40.529667Z","source":{"kind":"live_redfish","protocol":"redfish","target_host":"172.16.41.43"}}`) pkg, ok, err := parseRawExportPackage(body, nil) if err != nil || !ok { t.Fatalf("expected ok parse, got ok=%v err=%v", ok, err) } if pkg.SignatureChecked { t.Fatal("expected SignatureChecked=false for the unsigned legacy format") } if pkg.SignatureVerified { t.Fatal("expected SignatureVerified=false for the unsigned legacy format") } } func TestVerifyAuditSignature_RejectsWrongSizeSignature(t *testing.T) { withTestAuditKey(t) if verifyAuditSignature([]byte("payload"), []byte("too-short")) { t.Fatal("expected a non-64-byte signature to be rejected") } } func buildAuditBundleZip(t *testing.T, entries map[string][]byte) []byte { t.Helper() var buf bytes.Buffer zw := zip.NewWriter(&buf) for name, content := range entries { w, err := zw.Create(name) if err != nil { t.Fatalf("create %s: %v", name, err) } if _, err := w.Write(content); err != nil { t.Fatalf("write %s: %v", name, err) } } if err := zw.Close(); err != nil { t.Fatalf("close zip: %v", err) } return buf.Bytes() } func TestParseRawExportBundle_AuditFormatEndToEnd(t *testing.T) { priv := withTestAuditKey(t) body := auditPackageJSON() sig := ed25519.Sign(priv, body) payload := buildAuditBundleZip(t, map[string][]byte{ rawExportBundlePackageFile: body, rawExportBundleSignatureFile: sig, rawExportBundleLogFile: []byte("Audit 1.3.0\n"), }) pkg, ok, err := parseRawExportBundle(payload) if err != nil || !ok { t.Fatalf("expected ok parse, got ok=%v err=%v", ok, err) } if !pkg.SignatureChecked || !pkg.SignatureVerified { t.Fatalf("expected signature checked+verified, got checked=%v verified=%v", pkg.SignatureChecked, pkg.SignatureVerified) } } func TestParseRawExportBundle_RejectsDuplicatePackageFile(t *testing.T) { withTestAuditKey(t) body := auditPackageJSON() var buf bytes.Buffer zw := zip.NewWriter(&buf) for i := 0; i < 2; i++ { w, err := zw.Create(rawExportBundlePackageFile) if err != nil { t.Fatal(err) } if _, err := w.Write(body); err != nil { t.Fatal(err) } } if err := zw.Close(); err != nil { t.Fatal(err) } _, ok, err := parseRawExportBundle(buf.Bytes()) if err == nil { t.Fatalf("expected an error for duplicate %s entries, got ok=%v", rawExportBundlePackageFile, ok) } } func TestParseRawExportBundle_RejectsDuplicateSignatureFile(t *testing.T) { priv := withTestAuditKey(t) body := auditPackageJSON() sig := ed25519.Sign(priv, body) var buf bytes.Buffer zw := zip.NewWriter(&buf) w, err := zw.Create(rawExportBundlePackageFile) if err != nil { t.Fatal(err) } if _, err := w.Write(body); err != nil { t.Fatal(err) } for i := 0; i < 2; i++ { sw, err := zw.Create(rawExportBundleSignatureFile) if err != nil { t.Fatal(err) } if _, err := sw.Write(sig); err != nil { t.Fatal(err) } } if err := zw.Close(); err != nil { t.Fatal(err) } _, ok, err := parseRawExportBundle(buf.Bytes()) if err == nil { t.Fatalf("expected an error for duplicate %s entries, got ok=%v", rawExportBundleSignatureFile, ok) } }