From c3242e2f54a6571d1d54cf630c2e73b9b01e48be Mon Sep 17 00:00:00 2001 From: Mert Durukan Date: Tue, 17 Nov 2026 10:54:37 +0300 Subject: [PATCH] core: report a malformed policy signature as tampering, not bad JSON readStore treated every VerifyDocument error as a JSON syntax error, so a policy.json with a corrupted _sig was reported as "not valid JSON". VerifyDocument now returns an exported ErrMalformedSignature for that case, and readStore lets it fall through to the signature-verification error. Signed-off-by: Mert Durukan --- packages/core/client/localstore.go | 4 ++- packages/core/client/localstore_test.go | 33 +++++++++++++++++++++++++ packages/crypto/crypto_test.go | 16 ++++++++++++ packages/crypto/sign.go | 7 +++++- 4 files changed, 58 insertions(+), 2 deletions(-) diff --git a/packages/core/client/localstore.go b/packages/core/client/localstore.go index 107e9843..4501bd53 100644 --- a/packages/core/client/localstore.go +++ b/packages/core/client/localstore.go @@ -99,7 +99,9 @@ func readStore() (stored, error) { return stored{}, fmt.Errorf("cannot load the machine signing key: %w", err) } _, signed, valid, err := pcrypto.VerifyDocument(b, kp.Public) - if err != nil { + // A malformed signature comes back as signed && !valid and is reported + // as tampering below, not as a JSON syntax error. + if err != nil && !errors.Is(err, pcrypto.ErrMalformedSignature) { return stored{}, fmt.Errorf("%s is not valid JSON: %w", PolicyPath(), err) } if signed && !valid { diff --git a/packages/core/client/localstore_test.go b/packages/core/client/localstore_test.go index 5d67da76..426e0b55 100644 --- a/packages/core/client/localstore_test.go +++ b/packages/core/client/localstore_test.go @@ -110,6 +110,39 @@ func TestReadStoreRefusesATamperedFile(t *testing.T) { } } +func TestReadStoreReportsAMalformedSignatureAsTampering(t *testing.T) { + newHome(t) + policy := &PolicySet{ID: "local", Name: "local"} + if err := writeStore(stored{Policy: policy, envelope: true}); err != nil { + t.Fatalf("writeStore: %v", err) + } + + raw, err := os.ReadFile(PolicyPath()) + if err != nil { + t.Fatal(err) + } + var doc map[string]any + if err := json.Unmarshal(raw, &doc); err != nil { + t.Fatal(err) + } + doc["_sig"] = "not base64!" + corrupted, err := json.Marshal(doc) + if err != nil { + t.Fatal(err) + } + if err := os.WriteFile(PolicyPath(), corrupted, 0o600); err != nil { + t.Fatal(err) + } + + _, err = readStore() + if err == nil { + t.Fatal("a file with a corrupted signature was accepted without complaint") + } + if strings.Contains(err.Error(), "not valid JSON") || !strings.Contains(err.Error(), "failed signature verification") { + t.Errorf("valid JSON with a corrupted signature should be reported as a signature failure, got: %v", err) + } +} + func TestToLayersWithNoSecurityIsEverythingOff(t *testing.T) { l := toLayers(nil) if l.RateLimit.Mode != LayerOff { diff --git a/packages/crypto/crypto_test.go b/packages/crypto/crypto_test.go index 377e804b..d197ddbe 100644 --- a/packages/crypto/crypto_test.go +++ b/packages/crypto/crypto_test.go @@ -6,6 +6,7 @@ package crypto import ( "bytes" "encoding/json" + "errors" "os" "path/filepath" "runtime" @@ -150,6 +151,21 @@ func TestVerifyDocumentDetectsTamper(t *testing.T) { } } +func TestVerifyDocumentReportsMalformedSignature(t *testing.T) { + kp, err := GenerateKeyPair() + if err != nil { + t.Fatal(err) + } + raw := []byte(`{"_sig":"not base64!","policy":"default"}`) + _, signed, valid, err := VerifyDocument(raw, kp.Public) + if !errors.Is(err, ErrMalformedSignature) { + t.Fatalf("expected ErrMalformedSignature, got %v", err) + } + if !signed || valid { + t.Fatalf("expected signed=true valid=false for a malformed signature, got signed=%v valid=%v", signed, valid) + } +} + func TestVerifyDocumentTreatsMissingSignatureAsUnsigned(t *testing.T) { kp, err := GenerateKeyPair() if err != nil { diff --git a/packages/crypto/sign.go b/packages/crypto/sign.go index d73e7656..3589256f 100644 --- a/packages/crypto/sign.go +++ b/packages/crypto/sign.go @@ -15,6 +15,11 @@ const ( sigPubField = "_sig_pub" ) +// ErrMalformedSignature is returned by VerifyDocument when the document is +// valid JSON but its _sig field is not valid base64. Callers can tell it apart +// from a JSON syntax error and report it as tampering. +var ErrMalformedSignature = errors.New("crypto: malformed signature encoding") + // Sign returns the Ed25519 signature of payload under priv. func Sign(priv ed25519.PrivateKey, payload []byte) []byte { return ed25519.Sign(priv, payload) @@ -66,7 +71,7 @@ func VerifyDocument(raw []byte, trusted ed25519.PublicKey) (payload map[string]a } sig, err := base64.StdEncoding.DecodeString(sigStr) if err != nil { - return nil, true, false, errors.New("crypto: malformed signature encoding") + return nil, true, false, ErrMalformedSignature } clean := stripSigFields(doc)