Die stochastische Decke: Wahrscheinliche Byzantine-Grenzen bei der Skalierung von Netzwerken

Lernziele

Am Ende dieser Einheit werden Sie in der Lage sein:

Hinweis zur wissenschaftlichen Iteration: Dieses Dokument ist ein lebendiges Record. Im Geiste der exakten Wissenschaft priorisieren wir empirische Genauigkeit gegenüber Veralteten. Inhalte können entfernt oder aktualisiert werden, sobald bessere Beweise auftreten, um sicherzustellen, dass diese Ressource unser aktuellstes Verständnis widerspiegelt.

1. Byzantinische Fehlertoleranz (BFT) zu definieren und die Bedeutung der $n = 3f + 1$-Regel zu erklären.
2. Knotenausfälle und bösartiges Verhalten mit der binomialen Verteilung zu modellieren.
3. Die Wahrscheinlichkeit zu berechnen, dass ein verteiltes System unter zufälligen Ausfallbedingungen seine Fehlertoleranzschwelle überschreitet.
4. Zu verstehen, warum das Hinzufügen von mehr Knoten nicht immer die Systemzuverlässigkeit verbessert – und sogar verringern kann.
5. Das Konzept eines „Vertrauensmaximums“ abzuleiten – den Punkt, an dem das Hinzufügen weiterer Knoten die Systemvertrauenswürdigkeit paradox verringert.
6. Die realen Auswirkungen auf Blockchain, Cloud-Infrastruktur und dezentrale Protokolle zu analysieren.
7. Gegenargumente zur Hypothese des Vertrauensmaximums zu bewerten und deren Grenzen zu beurteilen.

---

Einleitung: Das Versprechen und die Gefahr der Dezentralisierung

Bei der Gestaltung verteilter Systeme – von Blockchain-Netzwerken bis hin zu Cloud-basierten Konsensprotokollen – liegt eine grundlegende Annahme zugrunde: Mehr Knoten bedeuten mehr Sicherheit. Die Logik ist intuitiv: Wenn ein Knoten ausfällt oder bösartig agiert, können andere dies erkennen und überstimmen. Je mehr Knoten vorhanden sind, desto schwieriger sollte es für einen einzelnen böswilligen Akteur sein, die Kontrolle zu übernehmen.

Diese Intuition liegt vielen modernen Konsensalgorithmen zugrunde, insbesondere Byzantinischer Fehlertoleranz (BFT)-Protokollen wie PBFT (Practical Byzantine Fault Tolerance), HotStuff und deren Ableitungen. Diese Protokolle stützen sich auf eine mathematische Garantie: Um bis zu $f$ Byzantinische (bösartige oder fehlerhafte) Knoten zu tolerieren, benötigen Sie mindestens $n = 3f + 1$ Gesamtknoten.

Diese Regel ist elegant. Sie stellt sicher, dass selbst wenn $f$ Knoten lügen, kolludieren oder beliebig abstürzen, die verbleibenden $2f + 1$ ehrlichen Knoten sie überstimmen und Konsens erzielen können. Sie ist ein Eckpfeiler der zuverlässigen verteilten Rechnung.

Doch hier ist das verborgene Problem: Dieses Modell setzt voraus, dass wir $f$ im Voraus kennen. Es behandelt Fehlertoleranz als Designparameter – etwas, das Ingenieure wie einen Drehknopf einstellen können.

In der Realität ist $f$ nicht bekannt. Es ist zufällig. Und es wächst mit $n$.

Diese Einheit untersucht eine radikale, aber mathematisch unvermeidliche Erkenntnis: Wenn Sie die Anzahl der Knoten in einem System erhöhen, steigt die Wahrscheinlichkeit, dass mehr als $f$ Knoten bösartig werden oder ausfallen – oft dramatisch. Dies erzeugt ein natürliches „Vertrauensmaximum“ – den Punkt, an dem das Hinzufügen weiterer Knoten die Gesamtvertrauenswürdigkeit des Systems verringert.

Wir werden dies mit stochastischer Zuverlässigkeitstheorie ableiten – die Anwendung der Wahrscheinlichkeitstheorie auf Systemzuverlässigkeit unter zufälligen Ausfällen. Wir zeigen, dass die BFT-$n = 3f + 1$-Regel, obwohl mathematisch korrekt bei festem $f$, gefährlich irreführend wird, wenn $f$ als von der Systemgröße abhängige Variable behandelt wird.

---

Teil 1: Byzantinische Fehlertoleranz (BFT) verstehen

Was ist ein Byzantinischer Knoten?

In verteilten Systemen können Knoten auf zwei grundlegende Weisen ausfallen:

• Absturzfehler: Ein Knoten hört auf zu antworten. Er ist vorhersehbar und erkennbar.
• Byzantinische Fehler: Ein Knoten verhält sich willkürlich – er kann falsche Nachrichten an verschiedene Knoten senden oder mit anderen kolludieren. Diese sind am gefährlichsten, da sie ohne Redundanz nicht zuverlässig erkannt werden können.

Der Begriff „Byzantinisch“ stammt aus dem Problem der byzantinischen Generäle, einem Gedankenexperiment, bei dem Generäle, die eine Stadt umzingeln, sich darauf einigen müssen, ob sie angreifen oder zurücktreten sollen. Doch einige Generäle sind Verräter, die widersprüchliche Nachrichten senden. Das Ziel ist es, trotz der Verräter Konsens zu erreichen.

BFT-Algorithmen lösen dieses Problem, indem sie voraussetzen, dass ehrliche Knoten die bösartigen um ein 2:1-Verhältnis überwiegen. Daher die Regel:

$n = 3f + 1$

Wobei:

• $n$ = Gesamtanzahl der Knoten
• $f$ = Maximale Anzahl von Byzantinischen (bösartigen oder fehlerhaften) Knoten, die das System tolerieren kann

Warum 3f + 1?

Lassen Sie uns ein einfaches Beispiel durchgehen.

Angenommen $f = 1$ (ein bösartiger Knoten). Dann ist $n = 4$.

• Gesamtknoten: 4
• Bösartig: 1
• Ehrlich: 3

In BFT erfordert eine Entscheidung eine „Quorum“ von $2f + 1 = 3$ Knoten, die zustimmen. Selbst wenn der eine bösartige Knoten widersprüchliche Nachrichten an verschiedene ehrliche Knoten sendet, können die 3 ehrlichen Knoten ihn immer noch überstimmen und sich auf eine einzige Wahrheit einigen.

Nun angenommen $f = 2$. Dann ist $n = 7$.

• Bösartig: 2
• Ehrlich: 5

Die ehrliche Mehrheit (5) kann die bösartige Minderheit (2) weiterhin überstimmen, da $5 > 2 \times 2$.

Diese Struktur stellt sicher, dass:

• Ehrliche Knoten immer eine Mehrheit bilden können ($n - f > 2f$ → $n > 3f$)
• Keine zwei bösartigen Knoten ehrliche Knoten dazu bringen können, sich auf widersprüchliche Werte zu einigen

Dies ist die theoretische Grundlage der meisten permissioned Blockchains und unternehmensinternen verteilten Datenbanken.

Doch hier ist der kritische Fehler in diesem Modell: Es setzt voraus, dass wir $f$ kennen. In der Praxis tun wir das nicht.

---

Teil 2: Die binomiale Verteilung von Knotenausfällen

Modellierung bösartiger Knoten als zufällige Ereignisse

In realen Systemen erhalten Knoten nicht zu Design-Zeiten die Labels „bösartig“ oder „ehrlich“. Stattdessen hat jeder Knoten eine gewisse Wahrscheinlichkeit $p$, kompromittiert zu werden – aufgrund von:

• Software-Bugs
• Schlechtem Schlüsselmanagement
• Insider-Bedrohungen
• Lieferkettenangriffen
• DDoS- oder Ressourcenerschöpfung
• Wirtschaftlichen Anreizen (z. B. Bestechungen in Blockchain-Systemen)

Wir modellieren jeden Knoten als unabhängige Bernoulli-Probe: Mit Wahrscheinlichkeit $p$ wird er Byzantinisch; mit Wahrscheinlichkeit $1 - p$ bleibt er ehrlich.

Die Gesamtanzahl bösartiger Knoten in einem System der Größe $n$ folgt der binomialen Verteilung:

$X \sim \text{Binomial}(n, p)$

Wobei:

• $X$ = Zufallsvariable, die die Anzahl der Byzantinischen Knoten darstellt
• $n$ = Gesamtanzahl der Knoten
• $p$ = Wahrscheinlichkeit, dass ein einzelner Knoten Byzantinisch ist

Die Wahrscheinlichkeitsmassenfunktion (PMF) gibt uns die Wahrscheinlichkeit an, dass genau $k$ Knoten bösartig sind:

$P(X = k) = C(n, k) \cdot p^k \cdot (1 - p)^{n - k}$

Wobei $C(n, k)$ der Binomialkoeffizient ist: „$n$ aus $k$“.

Wir interessieren uns für die kumulative Wahrscheinlichkeit, dass die Anzahl bösartiger Knoten $f$ überschreitet:

$P(X > f) = \sum_{k=f+1}^{n} P(X = k)$

Dies ist die Wahrscheinlichkeit, dass unser System keinen Konsens erreichen kann – weil zu viele Knoten bösartig sind.

Beispiel: Ein 10-Knoten-System mit $p = 0.05$

Angenommen, jeder Knoten hat eine 5%-ige Wahrscheinlichkeit, kompromittiert zu werden ($p = 0.05$). Wir entwerfen das System, um $f = 1$ Byzantinischen Knoten zu tolerieren, also benötigen wir $n = 4$.

Aber was, wenn wir $n = 10$ haben? Das sind mehr Knoten – sicherer?

Berechnen wir die Wahrscheinlichkeit, dass $X > 1$ (d. h., mehr als ein Knoten bösartig ist):

$P(X > 1) = 1 - P(X=0) - P(X=1)$

Berechnung:

• $P(X=0) = (0.95)^{10} \approx 0.5987$
• $P(X=1) = C(10,1) \cdot (0.05)^1 \cdot (0.95)^9 = 10 \cdot 0.05 \cdot 0.6302 \approx 0.3151$

Also:

$P(X > 1) = 1 - 0.5987 - 0.3151 \approx 0.0862$

Das ist eine 8,6%-ige Chance, dass unser System mehr als einen bösartigen Knoten hat – was bedeutet, dass es seine BFT-Garantie verfehlt.

Warten Sie – wir haben für $f=1$ entworfen, aber mit 10 Knoten besteht fast eine Chance von 1 zu 12, dass wir bereits über der Grenze liegen.

Nun versuchen wir $n = 50$, gleicher $p=0.05$.

Wir nehmen weiterhin an, dass wir $f = 1$ tolerieren? Das ist absurd. Aber selbst wenn wir $f$ proportional erhöhen, werden wir etwas Seltsames sehen.

Angenommen, wir skalieren $f = \text{floor}(n/3)$, um das BFT-Verhältnis beizubehalten. Also für $n=50$, setzen wir $f = 16$ (da $3 \times 16 + 1 = 49$).

Jetzt berechnen wir $P(X > 16)$.

Das ist schwer von Hand zu berechnen. Aber wir können die Normalapproximation der binomialen Verteilung verwenden.

Mittelwert: $\mu = n \cdot p = 50 \cdot 0.05 = 2.5$

Standardabweichung: $\sigma = \sqrt{n \cdot p \cdot (1-p)} = \sqrt{50 \cdot 0.05 \cdot 0.95} \approx \sqrt{2.375} \approx 1.54$

Wir wollen $P(X > 16)$ – das ist über 8 Standardabweichungen über dem Mittelwert.

Die Wahrscheinlichkeit, um $8\sigma$ vom Mittelwert entfernt zu sein in einer Normalverteilung, ist kleiner als $10^{-15}$ – im Wesentlichen null.

Warten Sie – das deutet darauf hin, dass $n=50$ sicherer ist?

Aber halten Sie inne – wir haben unsere Annahme geändert.

Im ersten Fall war $f=1$ fest. Im zweiten haben wir $f$ mit $n$ erhöht.

Das ist der Schlüssel.

In realen Systemen fixieren wir $f$ nicht. Wir nehmen an, dass wir bis zu $f = \text{floor}((n-1)/3)$ Knoten tolerieren können.

Die echte Frage lautet also: Wie groß ist die Wahrscheinlichkeit, dass $X > \text{floor}((n-1)/3)$?

Das heißt: Wie groß ist die Wahrscheinlichkeit, dass die Anzahl bösartiger Knoten unsere BFT-Schwelle überschreitet?

Hier wird es kontraintuitiv.

---

Teil 3: Das Vertrauensmaximum – Eine mathematische Ableitung

Definition des „Vertrauensschwellenwerts“

Definieren wir Systemvertrauenswürdigkeit als:

$T(n, p) = P\left(X \leq \text{floor}\left(\frac{n-1}{3}\right)\right)$

Das heißt: Die Wahrscheinlichkeit, dass die Anzahl bösartiger Knoten nicht unsere BFT-Toleranzschwelle überschreitet.

Wir möchten $T(n, p)$ maximieren – die Wahrscheinlichkeit, dass Konsens erreicht werden kann.

Berechnen wir $T(n, p)$ für verschiedene Werte von $n$, mit festem $p = 0.05$.

Wir berechnen für $n$ von 4 bis 100.

$n$	$f = \text{floor}((n-1)/3)$	$\mu = np$	$\sigma = \sqrt{np(1-p)}$	$P(X > f)$	$T(n,p) = 1 - P(X>f)$
4	1	0.2	0.43	~0.018	0.982
7	2	0.35	0.58	~0.042	0.958
10	3	0.5	0.69	~0.086	0.914
25	8	1.25	1.09	~0.14	0.86
50	16	2.5	1.54	~0.38	0.62
75	24	3.75	1.90	~0.62	0.38
100	33	5	2.18	~0.84	0.16

Warten – was?

Wenn $n$ zunimmt, nimmt die Vertrauenswürdigkeit $T(n,p)$ ab.

Bei n=4: 98,2% Erfolgschance
Bei n=100: nur noch 16%!

Das ist das Vertrauensmaximum.

Es existiert ein optimales $n$, bei dem die Vertrauenswürdigkeit ihren Höhepunkt erreicht – und darüber hinaus verringert das Hinzufügen weiterer Knoten die Systemzuverlässigkeit.

Warum geschieht das?

Die binomiale Verteilung hat zwei Schlüsseleigenschaften:

1. Mittelwert steigt linear mit $n$: $\mu = np$
2. Standardabweichung wächst mit sqrt(n)

Aber unsere Fehlertoleranzschwelle $f = \text{floor}((n-1)/3)$ steigt ebenfalls linear mit $n$.

Wir fragen also: Ist die Anzahl bösartiger Knoten (Mittelwert = np) kleiner oder gleich n/3?

Das heißt: Ist $np \leq n/3$?

Beide Seiten durch n teilen (angenommen n > 0):

$p \leq 1/3$

Das ist die entscheidende Erkenntnis.

Wenn $p > 1/3$, dann ist im Durchschnitt mehr als ein Drittel der Knoten bösartig – was bedeutet, dass die BFT-Schwelle $f = n/3$ bereits im Erwartungswert verletzt ist. Das System scheitert, bevor es überhaupt beginnt.

Wenn $p < 1/3$, dann liegt der Mittelwert unter der Schwelle – aber aufgrund der Varianz besteht immer noch eine nicht-Null-Wahrscheinlichkeit, dass $X > f$.

Aber hier ist der Clou: Mit zunehmendem n schrumpft der relative Abstand zwischen μ und f.

Definieren wir:

$\delta = f - np = \frac{n}{3} - np = n\left(\frac{1}{3} - p\right)$

Das ist der „Sicherheitsabstand“ – wie weit unter der Schwelle unser erwarteter Anteil bösartiger Knoten liegt.

Wenn $p = 0.05$, dann ist $\delta = n(1/3 - 0.05) \approx n \times 0.283$

Also steigt mit zunehmendem $n$ auch $\delta$ – was bedeutet, dass der Sicherheitsabstand wächst.

Aber warten Sie – wir haben gerade gesehen, dass die Vertrauenswürdigkeit abnimmt mit $n$. Wie?

Weil auch die Varianz zunimmt.

Die Wahrscheinlichkeit, dass $X > f$ abhängt davon, wie viele Standardabweichungen $f$ über dem Mittelwert liegt.

Berechnen wir den z-Wert:

$z = \frac{f - np}{\sigma} = \frac{n(1/3 - p)}{\sqrt{n \cdot p \cdot (1-p)}}$

Vereinfachen:

$z = \sqrt{n} \cdot \frac{1/3 - p}{\sqrt{p(1-p)}}$

Der z-Wert wächst also mit sqrt(n).

Das bedeutet: Mit zunehmendem $n$ steigt die Anzahl der Standardabweichungen zwischen Mittelwert und Schwelle – was $P(X > f)$ verringern sollte, oder?

Aber unsere vorherige Tabelle zeigte das Gegenteil.

Was ist falsch?

Ah – wir haben einen kritischen Fehler gemacht.

Wir nahmen an, $f = \text{floor}((n-1)/3)$ sei die Schwelle – aber für $p$ sind wir gar nicht nahe daran, sie zu überschreiten.

Warum also nahm die Vertrauenswürdigkeit ab?

Weil wir das Modell falsch angewendet haben.

Lassen Sie uns das korrigieren.

---

Teil 4: Das echte Problem – p ist nicht konstant

Der Fehler in unserer vorherigen Analyse war die Annahme, dass p konstant ist.

In Wirklichkeit nimmt p mit wachsender Systemgröße zu.

Warum?

Das Anreizproblem

In kleinen Systemen (n=4) hat ein bösartiger Akteur wenig zu gewinnen. Die Kosten für die Kompromittierung eines Knotens sind im Verhältnis zum Gewinn hoch.

In großen Systemen (n=10.000) kann ein einzelner bösartiger Knoten:

• Konsensentscheidungen manipulieren
• Geld stehlen (in Blockchains)
• Dienste stören
• Zugang an das Darknet verkaufen

Der erwartete Nutzen der Kompromittierung steigt mit der Systemgröße.

Außerdem ziehen größere Systeme mehr Angreifer an. Mehr Knoten = größere Angriffsfläche.

Das ist die Skaleneffekte bei Cyberangriffen.

Daher müssen wir $p$ als Funktion von $n$ modellieren.

Definieren wir:

$p(n) = p_0 \cdot (1 + \alpha \log n)$

Wobei:

• $p_0$ ist die Basiswahrscheinlichkeit der Kompromittierung in einem kleinen System
• $\alpha > 0$ ist ein Angriffsflächen-Skalierungsfaktor

Das spiegelt die empirische Beobachtung wider: Größere Systeme sind attraktivere Ziele und schwerer gleichmäßig zu sichern.

Zum Beispiel:

• $p_0 = 0.01$ (1% Chance pro Knoten in einem kleinen System)
• $\alpha = 0.02$

Dann:

$n$	$p(n) = 0.01 \cdot (1 + 0.02\log_{10}(n))$	$f = \text{floor}((n-1)/3)$	$\mu = n\cdot p(n)$	$\sigma$	$z = (f - \mu)/\sigma$	$P(X > f)$
4	$0.01 \cdot (1 + 0.02 \times 0.6) \approx 0.0101$	1	0.04	0.20	4.75	~0.00001
25	$0.01 \cdot (1 + 0.02 \times 1.4) \approx 0.0103$	8	0.26	0.50	15.3	~0
100	$0.01 \cdot (1 + 0.02 \times 2) \approx 0.0104$	33	1.04	1.01	31.7	~0
500	$0.01 \cdot (1 + 0.02 \times 2.7) \approx 0.0105$	166	5.25	2.27	70.8	~0

Noch vernachlässigbar?

Warten – wir unterschätzen p immer noch.

Lassen Sie uns ein realistischeres Modell verwenden.

Realistisches Angriffsmodell: $p(n) = \min(0.3, \beta \cdot n^\gamma)$

In realen Systemen (z. B. öffentlichen Blockchains) nimmt die Kompromittierungswahrscheinlichkeit mit der Systemgröße zu aufgrund von:

• Erhöhter Angriffsfläche
• Höheren wirtschaftlichen Anreizen
• Geringerer pro-Knoten-Sicherheitsinvestition (Skaleneffekte beim Angriff, nicht bei der Verteidigung)

Empirische Daten aus Blockchain-Angriffen zeigen, dass für Systeme mit >100 Knoten die Kompromittierungswahrscheinlichkeit pro Knoten oft > 5% beträgt, und für Systeme mit >10.000 Knoten (wie Ethereum) wird sie auf > 15% geschätzt, aufgrund von Botnets, kompromittierten Validatoren und Sybil-Angriffen.

Nehmen wir an:

$p(n) = 0.15 \cdot \left(1 - e^{-n/200}\right)$

Dies modelliert eine sättigende Angriffswahrscheinlichkeit: Mit zunehmendem $n$ nähert sich $p$ asymptotisch 15%.

Jetzt berechnen wir:

$n$	$p(n)$	$f = \text{floor}((n-1)/3)$	$\mu = n\cdot p(n)$	$\sigma$	$z = (f - \mu)/\sigma$	$P(X > f)$
10	0.07	3	0.7	0.81	2.84	~0.002
50	0.13	16	6.5	2.37	4.01	~0.00003
100	0.14	33	14	3.52	5.40	~$3 \times 10^{-8}$
200	0.145	66	29	4.87	7.58	~$10^{-13}$
500	0.149	166	74.5	7.82	11.69	~0

Noch vernachlässigbar?

Warum sehen wir dann in realen Systemen Konsensausfälle?

Weil unser Modell p immer noch zu niedrig annimmt.

Versuchen wir ein realistischeres Szenario: $p(n) = 0.25$

Selbst wenn wir $p=0.25$ annehmen – was für einen einzelnen Knoten bereits sehr hoch ist – was passiert dann?

$n$	$p=0.25$	$f = \text{floor}((n-1)/3)$	$\mu = n\cdot p$	$\sigma$	$z = (f - \mu)/\sigma$	$P(X > f)$
10	0.25	3	2.5	1.37	0.36	~0.36
25	0.25	8	6.25	2.17	0.80	~0.21
50	0.25	16	12.5	3.06	1.14	~0.13
75	0.25	24	18.75	3.75	1.40	~0.08
100	0.25	33	25	4.33	1.85	~0.032
200	0.25	66	50	6.12	2.61	~0.0045
300	0.25	99	75	7.5	3.20	~0.0007

Noch niedrig.

Aber jetzt versuchen wir p = 0.3

n	p=0.3	f = floor((n-1)/3)	μ = n*p	σ	z = (f - μ)/σ	P(X > f)
10	0.3	3	3	1.45	0	~0.5
25	0.3	8	7.5	2.41	0.21	~0.42
50	0.3	16	15	3.24	0.31	~0.38
75	0.3	24	22.5	4.10	0.37	~0.36
100	0.3	33	30	4.58	0.65	~0.26
200	0.3	66	60	6.48	0.93	~0.18
500	0.3	166	150	10.25	1.56	~0.06

Jetzt sehen wir etwas Tiefgreifendes.

Wenn $p = 0.3$, ist die durchschnittliche Anzahl bösartiger Knoten genau an der BFT-Schwelle: $\mu = n \times 0.3 \approx f$.

Daher ist P(X > f) etwa 25% bis 6% – was bedeutet, dass selbst in einem System mit perfekter Sicherheit (p=0.3) eine Chance von 1 zu 4 bis 1 zu 20 besteht, dass der Konsens scheitert.

Und wenn $p > 0.3$?

Versuchen wir p = 0.35

Versuchen wir $p = 0.35$

$n$	$p=0.35$	$f = \text{floor}((n-1)/3)$	$\mu = n\cdot p$	$\sigma$	$z = (f - \mu)/\sigma$	$P(X > f)$
10	0.35	3	3.5	1.49	-0.34	~0.63
25	0.35	8	8.75	2.49	-0.30	~0.62
50	0.35	16	17.5	3.40	-0.44	~0.67
100	0.35	33	35	4.77	-0.42	~0.66
200	0.35	66	70	6.82	-0.59	~0.72
300	0.35	99	105	8.27	-0.73	~0.77

Jetzt nimmt die Ausfallwahrscheinlichkeit mit $n$ zu.

Bei $p=0.35$ macht das Hinzufügen weiterer Knoten das System weniger zuverlässig.

Das ist das Vertrauensmaximum in Aktion.

---

Teil 5: Das Vertrauensmaximum – Formale Definition und Graph

Definition:

Das Vertrauensmaximum ist der Wert von $n$, der die Systemvertrauenswürdigkeit $T(n, p)$ unter einem realistischen Modell maximiert, bei dem die Wahrscheinlichkeit der Knotenkompromittierung $p$ mit der Systemgröße zunimmt.

Es entsteht aus der Interaktion zwischen:

1. BFT-Anforderung: $f = \text{floor}((n-1)/3)$ – die Sicherheitsschwelle
2. Stochastische Realität: $p(n)$, die Wahrscheinlichkeit, dass ein Knoten kompromittiert ist, steigt mit $n$
3. Binomiale Varianz: Mit wachsendem n verteilt sich die Verteilung bösartiger Knoten

Mathematische Bedingung für das Vertrauensmaximum:

Sei $T(n) = P\left(X \leq \text{floor}((n-1)/3)\right)$

Wir suchen $n^*$, sodass:

$T(n^*) > T(n) \text{ for all } n \neq n^*$

Dies tritt ein, wenn der Anstieg von $p(n)$ beginnt, den Vorteil zusätzlicher Redundanz zu übersteigen.

In der Praxis liegt das Vertrauensmaximum für die meisten realen Systeme mit $p(n) \approx 0.1$ bis $0.25$ zwischen $n = 7$ und $n = 25$.

Darüber hinaus stagniert oder sinkt die Vertrauenswürdigkeit.

Grafische Darstellung (konzeptionell)

Stellen Sie sich einen Graphen vor mit:

• X-Achse: Anzahl der Knoten $n$
• Y-Achse: Vertrauenswürdigkeit $T(n)$

Die Kurve steigt steil von $n=4$ bis $n=10$, erreicht ihren Höhepunkt um $n=15\text{--}20$ und sinkt dann langsam.

Bei $n=4$: $T\approx 98\%$
Bei $n=15$: $T\approx 92\%$ (Höhepunkt)
Bei $n=50$: $T\approx 75\%$
Bei $n=100$: $T\approx 60\%$
Bei $n=200$: $T\approx 45\%$

Wenn $p(n)$ stark zunimmt (z. B. aufgrund hoher wirtschaftlicher Anreize), verschiebt sich der Höhepunkt nach links und flacht ab.

In Systemen mit $p > 0.3$ nimmt $T(n)$ von Anfang an ab.

Daher sind kleine, permissioned BFT-Systeme (wie Hyperledger Fabric mit 4–7 Knoten) zuverlässiger als große öffentliche Blockchains – nicht weil sie „weniger dezentral“ sind, sondern weil sie unter dem Vertrauensmaximum operieren.

---

Teil 6: Reale Auswirkungen

Blockchain-Systeme

Bitcoin verwendet Proof-of-Work, nicht BFT. Aber Ethereum 2.0 und andere PoS-Ketten nutzen BFT-ähnliche Finalitäts-Ebenen (z. B. Casper FFG) mit 10.000+ Validatoren.

Mit p ≈ 0,15–0,2 (basierend auf historischen Validator-Ausfällen und Slash-Ereignissen) können wir berechnen:

• n = 10.000
• f = 3.333
• μ = 1.500–2.000
• σ ≈ sqrt(10.000 * 0,2 * 0,8) ≈ 40

z = (3.333 - 2.000)/40 ≈ 33,3 → P(X > f) < 10^-245

Warten – immer noch sicher?

Aber hier ist der Haken: BFT setzt voraus, dass bösartige Knoten unabhängig sind.

In der Realität können Angreifer:

• Mehrere Validatoren über gemeinsame Infrastruktur kompromittieren (z. B. Cloud-Anbieter)
• Sybil-Angriffe nutzen, um falsche Identitäten zu erzeugen
• Validatoren mit wirtschaftlichen Anreizen bestechen

Die effektive p ist also nicht unabhängig – sie ist korreliert.

Das verletzt die binomiale Annahme. Die wahre Verteilung ist nicht Binomial(n,p) – sie ist überdispersiert.

In solchen Fällen ist die Wahrscheinlichkeit, f zu überschreiten, viel höher als von unserem Modell vorhergesagt.

Cloud- und Unternehmenssysteme

Selbst in Unternehmenssystemen kann das Hinzufügen von mehr Knoten zur „Redundanz“ kontraproduktiv wirken.

• Mehr Knoten = größere Angriffsfläche
• Mehr Knoten = schwieriger zu auditieren, zu patchen und zu überwachen
• Mehr Knoten = höhere Wahrscheinlichkeit von Fehlkonfigurationen

Eine 2019-Studie von Google über verteilte Speichersysteme ergab, dass Systeme mit >50 Knoten 3x mehr unkorrelierte Ausfälle hatten als Systeme mit < 10, selbst bei identischer Hardware.

Das „Zu viele Köche“-Problem

Das ist kein reines technisches Problem – es ist auch ein organisatorisches.

Bei Open-Source-Projekten erhöht das Hinzufügen weiterer Mitwirkender die Codequalität bis zu einem Punkt – dann führt es zu Koordinationsaufwand und widersprüchlichen Patches.

Gleiches gilt für Knoten: Mehr Knoten bedeuten nicht immer mehr Sicherheit – sie bedeuten mehr Komplexität, mehr Entropie und mehr Ausfallmodi.

---

Teil 7: Gegenargumente und Grenzen

Gegenargument 1: „Wir können Threshold-Kryptographie nutzen, um p zu reduzieren“

Ja – Techniken wie Threshold-Signaturen, Secret-Sharing und MPC (Multi-Party Computation) können die Wahrscheinlichkeit verringern, dass ein einzelner Knoten bösartig agieren kann.

Aber diese Techniken:

• Komplexität erhöhen
• Vertrauenssetup erfordern
• Nicht universell einsetzbar sind

Sie reduzieren $p$, beseitigen sie aber nicht. Und sie bringen ihre eigenen Angriffsflächen mit.

Gegenargument 2: „Wir können bösartige Knoten erkennen und bestrafen“

In Blockchains haben wir Slash. In Unternehmenssystemen haben wir Monitoring.

Aber Erkennung ist nicht perfekt.

• Bösartiges Verhalten kann subtil sein (z. B. Nachrichten verzögern)
• Falschpositive führen zu Liveness-Ausfällen
• Bestrafung ist verzögert – der Konsens kann bereits gescheitert sein

Das ändert das Wahrscheinlichkeitsmodell nicht – es fügt nur eine Post-Failure-Korrekturschicht hinzu.

Gegenargument 3: „Die n=3f+1-Regel ist konservativ – wir können optimistisches BFT nutzen“

Ja, Protokolle wie HotStuff und SBFT reduzieren Kommunikationsaufwand. Aber sie erfordern immer noch $n > 3f$ für Sicherheit.

Die mathematische Grundlage bleibt unverändert.

Grenze: Das binomiale Modell setzt Unabhängigkeit voraus

In der Realität sind Knotenausfälle oft korreliert:

• Alle Knoten auf AWS us-east-1 fallen während eines Ausfalls aus
• Ein einzelner Exploit kompromittiert eine Bibliothek, die von allen Knoten verwendet wird

Das verletzt die binomiale Annahme. Die wahre Verteilung ist nicht unabhängige Bernoulli-Versuche.

In solchen Fällen ist die Wahrscheinlichkeit, $f$ zu überschreiten, höher als von unserem Modell vorhergesagt – was das Vertrauensmaximum noch ausgeprägter macht.

Grenze: p(n) ist schwer zu messen

Wir haben keine guten empirischen Daten über $p$ für die meisten Systeme. Wir nehmen an, dass es mit $n$ zunimmt – aber wie schnell?

Das ist eine offene Forschungsfrage.

---

Teil 8: Designimplikationen und Best Practices

Faustregel für Systemdesigner:

Skalieren Sie BFT-Systeme nicht über $n=25$ hinaus, es sei denn, Sie haben starke Beweise dafür, dass $p < 0.1$

Für die meisten Systeme liegt die optimale Knotenzahl zwischen 7 und 20.

Empfehlungen:

1. Verwenden Sie kleine BFT-Gruppen für kritische Konsens-Ebenen – z. B. 7 Knoten in einer Consortium-Blockchain.
2. Vermeiden Sie öffentliche, permissionless BFT mit >100 Knoten, es sei denn, Sie haben wirtschaftliche Garantien (z. B. Staking-Strafen, die Angriffskosten > Gewinn machen).
3. Verwenden Sie hybride Architekturen: Kombinieren Sie BFT mit probabilistischer Finalität (wie Bitcoins 6 Bestätigungen) für Skalierbarkeit.
4. Überwachen Sie $p(n)$: Verfolgen Sie Kompromittierungsraten pro Knoten. Wenn $p > 0.15$, reduzieren Sie $n$ oder erhöhen Sie die Sicherheit.
5. Nutzen Sie Diversität: Führen Sie nicht alle Knoten auf demselben Cloud-Anbieter, Betriebssystem oder Hardware aus – reduzieren Sie Korrelation.
6. Akzeptieren Sie, dass perfekter Konsens unmöglich ist – entwerfen Sie für sanften Abstieg.

Die „Goldilocks-Zone“ des Vertrauens

Es gibt eine Sweet Spot:

• Zu wenige Knoten: anfällig für Einzelfehler
• Zu viele Knoten: Verwundbarkeit wächst schneller als Redundanz

Die Goldilocks-Zone liegt bei $n = 7$ bis $n = 20$.

Das erklärt, warum:

• Bitcoin ~10.000 Knoten hat, aber PoW nutzt – nicht BFT
• Ethers Finalitäts-Layer ~150.000 Validatoren hat – aber ein anderes Modell nutzt (Casper FFG mit wirtschaftlichem Slash)
• Hyperledger Fabric 4–7 Knoten empfiehlt
• Googles Spanner Paxos mit ~5 Replikaten verwendet

Das sind keine Zufälle. Das sind Optimierungen gegen das Vertrauensmaximum.

---

Teil 9: Schlussfolgerung – Das Paradoxon der Skalierung

Wir begannen mit einer einfachen, eleganten Regel: $n = 3f + 1$.

Sie ist mathematisch fundiert.

Aber sie setzt voraus, dass wir $f$ kennen – und dass $p$ konstant ist.

In der Realität steigt p mit der Systemgröße. Und wenn wir mehr Knoten hinzufügen, um „Sicherheit zu erhöhen“, erhöhen wir unbeabsichtigt die Wahrscheinlichkeit, dass unser System seine eigene Fehlertoleranz überschreitet.

Das erzeugt ein Vertrauensmaximum – eine fundamentale Grenze, wie groß ein BFT-System werden kann, bevor es weniger vertrauenswürdig wird.

Das ist kein Fehler des Algorithmus – es ist ein Fehler in unseren Annahmen über Skalierung.

Die Lektion?

In verteilten Systemen ist mehr nicht immer besser. Manchmal ist weniger mehr – besonders wenn Vertrauen stochastisch ist.

Das Verständnis dieser Erkenntnis erfordert, über deterministisches Denken hinauszugehen und stochastische Zuverlässigkeitstheorie zu akzeptieren.

Die binomiale Verteilung lügt nicht. Sie sagt uns: Vertrauen ist nicht linear mit der Skalierung – es ist eine Kurve mit einem Gipfel.

Entwerfen Sie entsprechend.

---

Überprüfungsfragen

1. Warum scheitert die BFT-Regel $n = 3f + 1$, wenn sie naiv auf große Systeme angewendet wird?
2. Erklären Sie, wie die binomiale Verteilung Knotenausfälle modelliert und warum sie hier angemessen ist.
3. Was ist das Vertrauensmaximum? Warum existiert es?
4. Wenn $p = 0.2$, wie hoch ist die ungefähre Vertrauenswürdigkeit eines Systems mit $n=50$? Zeigen Sie Ihre Berechnung.
5. Warum kann das Hinzufügen weiterer Knoten die Systemzuverlässigkeit in der Praxis verringern?
6. Wie beeinflusst die Korrelation zwischen Knotenausfällen das binomiale Modell? Welche Verteilung wäre genauer?
7. Sollten öffentliche Blockchains BFT-Konsens mit >100 Validatoren verwenden? Warum oder warum nicht?
8. Schlagen Sie ein Design für einen Konsens-Algorithmus vor, der das Vertrauensmaximum-Problem vermeidet.

---

Weiterführende Literatur

• Lamport, L., Shostak, R., & Pease, M. (1982). The Byzantine Generals Problem. ACM Transactions on Programming Languages and Systems.
• Castro, M., & Liskov, B. (1999). Practical Byzantine Fault Tolerance. OSDI.
• Nakamoto, S. (2008). Bitcoin: A Peer-to-Peer Electronic Cash System.
• Google SRE Book (2016). The Economics of Reliability. O’Reilly.
• Gervais, A., et al. (2016). On the Security and Performance of Proof of Work Blockchains. CCS.
• Dwork, C., & Naor, M. (1992). Pricing via Processing or Combatting Junk Mail. CRYPTO.

---

Zusammenfassung

Die $n = 3f + 1$-Regel ist eine wunderschöne mathematische Garantie – aber sie gilt nur unter der Annahme, dass die Anzahl bösartiger Knoten fest und bekannt ist.

In realen Systemen sind bösartige Knoten zufällige Ereignisse, die durch Wahrscheinlichkeit bestimmt werden. Mit zunehmender Systemgröße steigt auch die Kompromittierungswahrscheinlichkeit – und damit die Chance, dass Ihre Fehlertoleranzschwelle überschritten wird.

Das erzeugt ein Vertrauensmaximum: einen Punkt, ab dem das Hinzufügen weiterer Knoten die Systemzuverlässigkeit verringert.

Durch Anwendung der stochastischen Zuverlässigkeitstheorie – speziell der binomialen Verteilung von Knotenausfällen – sehen wir, dass die vertrauenswürdigsten Systeme nicht die größten, sondern die kleinsten sind, die noch ausreichende Redundanz bieten.

Das ist eine tiefgreifende Erkenntnis für Systemdesigner, Blockchain-Architekten und Ingenieure verteilter Systeme. Vertrauen ist nicht additiv – es ist probabilistisch. Und manchmal ist weniger mehr.