Files
logpile/internal/server/raw_export_audit_signature_test.go
T
Mikhail ChusavitinandClaude Sonnet 5 2b0a2cb562 feat(raw-export): accept AUDIT-SP's signed audit.raw-export.v1 format
The AUDIT-SP collector (rebrand of the logpile collection tool) now stamps
raw_export.json with format "audit.raw-export.v1" instead of
"logpile.raw-export.v1" and ships a raw_export.sig alongside it, which broke
import entirely ("no parser found for this archive format").

- accept both format strings when parsing a raw-export bundle
- for the audit format, verify raw_export.sig (Ed25519, 64 bytes) against the
  exact bytes of raw_export.json using a trusted public key embedded in the
  binary (keys/audit-signing-public.pem); raw_export.sha256 is not consulted
- reject bundles with duplicate raw_export.json or raw_export.sig entries
- import proceeds even if the signature is missing or invalid, but the result
  is marked unverified rather than silently trusted
- expose GET /api/signature-status and show a "Signed" badge in the header
  when the signature verifies

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
2026-10-08 11:55:42 +03:00

201 lines
5.6 KiB
Go

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)
}
}