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>
201 lines
5.6 KiB
Go
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)
|
|
}
|
|
}
|