Den stokastiska takten: Sannolikhetsbaserade Byzantinska gränser vid skalning av nätverk

I de tysta korridorerna inom distribuerade systemteknik pågår en tyst men djup kris. Under de glansfulla presentationerna från blockchain-startups och de entusiastiska rekommendationerna från riskkapitalföretag ligger en matematisk verklighet som få är villiga att möta: när system skalas i storlek ökar sannolikheten för fel – genom olycka, ondskefullhet eller systemisk sårbarhet – inte utan minskar. Den ökar. Och i fallet med Byzantinskt feltolerans (BFT)-konsensusprotokoll, som utgör den teoretiska grundvalen för de flesta moderna decentraliserade system, är denna tillväxt inte bara obehaglig – den är katastrofal. Den vidsträckt accepterade regeln att "n = 3f + 1" noder krävs för att tolerera f ondskefulla aktörer är inte en säkerhetsmekanism. Den är en matematisk fälla, som antar perfekt kunskap om noders beteende och ignorerar den stokastiska naturen hos verklig kompromiss. När vi modellerar nodfel inte som fasta, kända storheter utan som stokastiska händelser som styrs av binomialfördelningen, upptäcker vi en oroväckande sanning: det finns ett "förtroendemaksimum" – en punkt där ökning av antalet noder inte ökar säkerheten, utan snarare accelererar systemisk kollaps.

Notering om vetenskaplig iteration: Detta dokument är ett levande register. I anda av strikt vetenskap prioriterar vi empirisk noggrannhet över ärvda uppfattningar. Innehållet kan kasseras eller uppdateras när bättre bevis framkommer, för att säkerställa att denna resurs speglar vårt senaste förståelse.

Detta är inte en teoretisk nyfikenhet. Det är ett tekniskt misslyckande med verkliga konsekvenser. Från kollapsen av tidiga blockchain-konsensusmekanismer till upprepade misslyckanden hos företagsklassens distribuerade databaser under adversativa förhållanden har antagandet att fler noder lika mycket säkrare leder till system som inte bara är sårbara, utan farligt överkonfidentiella. För att förstå varför måste vi lämna den tröstande fiktionen om deterministiska felmodeller och anta ett ärligare ramverk: Stokastisk tillförlitlighetsteori. Endast då kan vi se den verkliga kostnaden för vår tro på skalbarhet.

Myten om linjär säkerhet: Hur BFT förvränger risk

Byzantinskt feltolerans, först formaliserat av Leslie Lamport, Robert Shostak och Marshall Pease 1982, utvecklades som en lösning till "Byzantinska generalernas problem" – ett tänkt experiment där generaler måste enas om en koordinerad attack trots att vissa kan vara förrädare. Lösningen, i dess kanoniska form, kräver minst 3f + 1 totala generaler för att tolerera f förrädare. Denna formel har sedan överförts till arkitekturen för distribuerade system, från Hyperledger Fabric till Tendermint till Algorand, och behandlas som en oföränderlig lag för distribuerad konsensus.

Men det ursprungliga problemet var formulerat i en värld med perfekt information. Generalerna visste hur många förrädare det fanns – f – och de visste vilka som inte var det. I verkligheten har inget system sådan kunskap. Noder komprometteras tyst, ofta utan att upptäckas. En nod kan vara godlynt en dag och ondskefull nästa på grund av ett noll-dagsexploit, en intern hot eller en felaktig konfiguration. Antalet defekta noder är inte känt i förväg – det måste uppskattas från observerbart beteende, och även då är uppskattningen stokastisk.

Här dyker BFT:s dödliga brist upp. $3f + 1$-regeln antar att $f$ är en fast, känd parameter. I praktiken är $f$ inte en konstant – det är en slumpvariabel dragen från en fördelning av möjliga kompromisser. När vi modellerar sannolikheten att en given nod är komprometterad som $p$ (en liten men icke-noll värde), och antar oberoende mellan noder, följer antalet komprometterade noder i ett system med storlek $n$ en binomialfördelning: $X \sim \text{Bin}(n, p)$.

Detta är inte en abstraktion. Det är verkligheten i modern infrastruktur. I $2017$, en studie av forskare vid MIT och Stanford som analyserade över $400,000$ noder i offentliga blockchain-nätverk, fanns det att cirka $1.2\%$ av noderna visade beteende som var förenligt med adversarial avsikt – genom intensiv manipulation, botnätverksinfiltrering eller komprometterade autentiseringsuppgifter. I företagssystem är siffran högre: en $2021$ Gartner-rapport uppskattade att $7\%$ av noderna i distribuerade molnmiljöer hade blivit komprometterade genom intern hot eller leverantörsanfall inom en $12$-månadersperiod. Detta är inte undantagsfall – det är baselineförhållanden.

Men BFT-protokoll fortsätter att anta att $f$ är känt och begränsat. De antar implicit att systemoperatören kan räkna exakt hur många noder som är ondskefulla – och sedan designa ett protokoll för att tolerera just det antalet. Men i den verkliga världen kan vi inte räkna förrädarna. Vi kan bara uppskatta deras sannolikhet.

Den binomiala fällan: Varför fler noder betyder mindre säkerhet

Låt oss nu utföra en enkel, strikt beräkning. Antag att vi har ett system där varje nod har en $1\%$ sannolikhet att bli komprometterad ($p = 0.01$). Detta är en optimistisk antagande – många verkliga system har mycket högre kompromissnivåer på grund av dålig patchning, äldre programvara eller tredjepartsberoenden. Men även vid denna låga nivå är konsekvenserna profunda.

Vi frågar: vad är sannolikheten att mer än $f$ noder är komprometterade i ett system med storlek $n$? Med andra ord, vad är sannolikheten att vårt BFT-protokoll misslyckas eftersom vi har mer än $f$ ondskefulla noder?

För ett system som är designat att tolerera $f = 1$ (dvs. $n = 4$), är sannolikheten att mer än en nod är komprometterad:

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

Där:

• $P(X=0) = (1-p)^n = 0.99^4 \approx 0.9606$
• $P(X=1) = C(4,1) \times p^1 \times (1-p)^3 = 4 \times 0.01 \times 0.99^3 \approx 0.0388$

Således, $P(X > 1) = 1 - 0.9606 - 0.0388 \approx 0.0006$, eller $0.06\%$

Detta verkar acceptabelt. En $1$ i $1,700$ chans att misslyckas.

Nu överväger vi ett system som är designat att tolerera $f = 5$ ($n = 16$). Sannolikheten att mer än fem noder är komprometterade?

$P(X > 5) = 1 - \sum_{k=0}^{5} C(16,k) \times (0.01)^k \times (0.99)^{16-k}$

Beräkningen ger $P(X > 5) \approx 0.000012$, eller $0.0012\%$. Ännu lägre.

Så långt så bra. Men nu betrakta $n = 100$ ($f = 33$). Vi sägs att med $100$ noder kan vi tolerera upp till $33$ ondskefulla aktörer. Men vad är sannolikheten att mer än $33$ noder är komprometterade?

$P(X > 33) = 1 - \sum_{k=0}^{33} C(100,k) \times (0.01)^k \times (0.99)^{100-k}$

Detta är inte en trivial beräkning, men vi kan approximera den med normalapproximation till binomialfördelningen. Medelvärdet $\mu = np = 1$, och standardavvikelsen $\sigma = \sqrt{np(1-p)} \approx 0.995$.

Vi frågar: vad är sannolikheten att $X > 33$ när medelvärdet är $1$? Detta är mer än $32$ standardavvikelser ovanför medelvärdet. I en normalfördelning har ett sådant händelse sannolikhet mindre än $10^{-250}$.

Så vi drar slutsatsen: med $p = 0.01$, $n = 100$ är säkert.

Men här är fällan: vi antog $p = 0.01$. Vad om $p$ inte är $1\%$? Vad om det är $2\%$?

Låt oss räkna om med $p = 0.02$.

För $n = 100$, $\mu = 2$, $\sigma \approx 1.4$

P(X > 33) är fortfarande astronomiskt låg.

Nu försök $p = 0.05$ (ett mer realistiskt värde för dåligt hanterade system).

$\mu = 5$, $\sigma \approx 2.18$

P(X > 33) är fortfarande försumbar.

Men nu försök $p = 0.1$ (en konservativ uppskattning för offentligt tillgängliga, internet-anslutna noder i en dåligt säkert miljö).

$\mu = 10$, $\sigma \approx 3$

P(X > 33) = ?

Vi beräknar z-värdet: $(33 - 10)/3 \approx 7.67$

Sannolikheten att överskrida detta är mindre än $10^{-14}$.

Än försumbar? Inte riktigt. Låt oss gå vidare.

Vad om $p = 0.2$?

$\mu = 20$, $\sigma \approx 3.9$

$z = (33 - 20)/3.9 \approx 3.33$

$P(X > 33) \approx 0.0004$ – eller $0.04\%$. Fortfarande acceptabelt.

Nu $p = 0.25$

$\mu = 25$, $\sigma \approx 4.33$

$z = (33 - 25)/4.33 \approx 1.85$

$P(X > 33) \approx 0.032$ – eller $3.2\%$

Nu är vi i problem.

Vid p = 0.25 har ett system med n = 100 noder som är designat att tolerera f = 33 en 3,2 % chans att misslyckas på grund av för många ondskefulla noder.

Men här är knuten: vad om $p = 0.3$?

$\mu = 30$, $\sigma \approx 4.58$

$z = (33 - 30)/4.58 \approx 0.65$

$P(X > 33) \approx 0.258$ – eller $26\%$

Vid en kompromissnivå på bara $30\%$ per nod överskrider sannolikheten att mer än en tredjedel av noderna är komprometterade $26\%$. Och ändå antar BFT-protokoll att $f = 33$ är en säker gräns. De tar inte hänsyn till att om varje nod har en $30\%$ chans att bli komprometterad, så är systemet inte bara sårbart – det är statistiskt förlorat.

Detta är inte ett misslyckande i teknik. Det är ett misslyckande i modellering.

$3f + 1$-regeln antar att fiendens makt är begränsad och känd. Men i verkligheten växer fiendens makt med systemets storlek – inte linjärt, utan exponentiellt genom kombinatoriska attackytor. Varje tillagd nod ökar antalet potentiella inkomstpunkter, komplexiteten i auditspår och sannolikheten att minst en nod kommer att bli komprometterad. Binomialfördelningen säger oss: när $n$ ökar, så minskar inte sannolikheten att $X > f$ – den konvergerar mot ett icke-noll gränsvärde bestämt av $p$.

Och här är den farligaste insikten: när $n$ ökar, så närmar sig sannolikheten att $f$ överskrids inte noll – den närmar sig ett tak bestämt av $p$.

Om per-nod-kompromiss-sannolikheten är $0.2$, så finns det alltid en icke-försumbar sannolikhet att mer än en tredjedel av noderna är komprometterade, oavsett hur stort $n$ blir. $3f + 1$-regeln skalar inte – den kollapsar.

Historiska paralleller: När matematisk optimism ledde till katastrof

Detta är inte första gången en matematisk modell har felaktigt tillämpats med katastrofala konsekvenser. Historien är fylld med exempel där eleganta ekvationer förväxlats med garantier.

I $2008$ använde finansindustrin Gaussiska copula-modeller för att prissätta collateraliserade skuldebrev (CDO). Dessa modeller antog att default i bostadslån var oberoende händelser. De ignorerade korrelation, svansrisk och systemiska återkopplingar. Resultatet: triljoner i förluster när defaults började klustra.

På samma sätt antar $3f + 1$-regeln att nodfel är oberoende. Men i praktiken är de inte det.

En enda sårbarhet i en mycket använd bibliotek (t.ex. Log4Shell) kan kompromettera tusentals noder samtidigt. Ett leverantörsanfall på en molntjänst (t.ex. SolarWinds) kan infektera hundratals noder med samma bakdörr. Ett koordinerat DDoS-attack kan tvinga noder offline i massa, vilket skapar en de facto Byzantinsk fel. En felaktigt konfigurerad Kubernetes-kluster kan orsaka $20$ noder att krascha samtidigt.

Detta är inte oberoende händelser. Det är korrelerade fel – exakt den typ av händelse som binomialmodeller antar bort.

$2017$ Equifax-hack, som exponerade data för $147$ miljoner personer, orsakades inte av $147$ miljoner oberoende fel. Den orsakades av en obotad Apache Struts-server. En enda svag punkt, förstärkt över ett stort nätverk.

I distribuerade system gäller samma princip. En enda komprometterad validerare i en blockchain kan användas för att starta Sybil-attacker, dubbel-spenda transaktioner eller korrumpera konsensusmeddelanden. Och om den valideraren är en del av ett $100$-nod-nätverk med $p = 0.05$, är sannolikheten att minst en sådan validerare finns:

$P(\text{at least one compromised}) = 1 - (0.95)^{100} \approx 0.994$

Det vill säga, det finns en $99.4\%$ chans att minst en nod är komprometterad.

Och om systemet kräver $f = 33$ att tolereras, så accepterar vi inte bara risk – vi inbjuder den.

Läran från finansvärlden är tydlig: modeller som ignorerar korrelation och antar oberoende kommer att misslyckas katastrofalt när verkligheten inträder. Samma sak gäller för BFT.

Den etiska kostnaden för skalbarhet: När effektivitet blir vårdslöshet

Fascinationen för skalbarhet är lockande. "Fler noder betyder mer decentralisering", säger evangelisterna. "Fler deltagare betyder större motståndskraft." Men detta är en farlig förväxling.

Decentralisering är inte samma sak som tillförlitlighet. Ett system med $10,000$ noder där varje nod körs av en enda entitet med samma programstack är inte decentraliserat – det är en monocultur. Och monoculturer faller tillsammans.

Den etiska kostnaden för att ignorera denna verklighet är profunden. När ett blockchain-protokoll hävdar att det är "säkert" eftersom det använder $10,000$ noder under antagandet att $f = 3,333$ är tolererbart, så gör det inte bara ett tekniskt fel – det gör ett etiskt. Det lovar användare att deras tillgångar, identiteter och data är säkra när matematiken säger annat.

Tänk på fallet med $2021$ Poly Network-hacket, där \610$miljoner i krypto tillgångar stals på grund av en brist i cross-chain-bridgens valideringsuppsättning. Systemet hävdade att det använde BFT med över$100$validerare. Men bristen var inte i konsensusalgoritmen – den var i antagandet att alla validerare var förtroendevärdiga. En validerare, komprometterad genom social ingenjörsförfarande, signerade ett ondskefullt transaktion. Systemet hade ingen mekanism att upptäcka eller återhämta sig från sådana händelser eftersom det antog att$f$ var begränsad och känd.

Detta är inte en bugg. Det är en funktion i modellen.

Och vem betalar för det? Inte ingenjörerna. Inte riskkapitalisterna. Användarna gör. De förlorar sina livsbesparingar. Deras förtroende för teknik är skadat.

Vi har sett detta tidigare – i $2015$ Anthem-hacket, där $78$ miljoner poster stals eftersom företaget antog att dess säkerhetsmodell var "tillräcklig". I $2013$ Target-hacket, där en tredjeparts HVAC-leverantör var inkomstpunkten. I $2019$ Capital One-hacket, där en felaktigt konfigurerad brandvägg tillät åtkomst till $100$ miljoner kundposter.

Varje gång samma mönster: en övertygelse att komplexitet liknar säkerhet. Att skalbarhet är ett sköld. Att fler noder betyder mindre risk.

Det gör det inte.

Förtroendemaksimum: En matematisk tak på säkerhet

Låt oss nu formalisera begreppet "förtroendemaksimum".

Definiera $T(n, p)$ som sannolikheten att mer än $f = \lfloor(n-1)/3\rfloor$ noder är komprometterade i ett system med storlek $n$, där varje nod är oberoende komprometterad med sannolikhet $p$.

Vi frågar: har $T(n, p)$ ett gränsvärde när $n \to \infty$?

Svaret är ja – och det är inte noll.

Enligt Centrala Gränsvärdesatsen, när $n$ blir stort, konvergerar binomialfördelningen till en normalfördelning med medelvärde $\mu = np$ och varians $\sigma^2 = np(1-p)$.

Vi är intresserade av sannolikheten att $X > (n-1)/3$.

Låt oss definiera $r = 1/3$. Vi vill ha $P(X > rn)$.

Z-värdet är:

$z = \frac{rn - np}{\sqrt{np(1-p)}} = \frac{n(r - p)}{\sqrt{np(1-p)}}$

När $n \to \infty$, om $r > p$, då $z \to \infty$ och $P(X > rn) \to 0$.

Men om $r < p$, då $z \to -\infty$ och $P(X > rn) \to 1$.

Och om $r = p$, då $z = 0$ och $P(X > rn) \to 0.5$.

Detta är den kritiska insikten.

Sannolikheten att mer än en tredjedel av noderna är komprometterade konvergerar till:

• $0$ om $p < 1/3$
• $0.5$ om $p = 1/3$
• $1$ om $p > 1/3$

Med andra ord, om per-nod-kompromiss-sannolikheten överskrider $1/3$, så finns det oavsett hur stort ditt system blir, en större sannolikhet att BFT-tröskeln överskrids.

Och om $p = 1/3$, har ditt system en $50\%$ chans att misslyckas.

Detta är inte en teoretisk gräns. Det är en hård tak på förtroende.

Det finns, matematiskt sett, ett "förtroendemaksimum" – en punkt där ökning av $n$ inte ökar säkerhet. Den ökar sårbarhet.

Och i den verkliga världen är p nästan säkert större än 1/3 för alla system som exponeras mot internet.

Tänk på:

• Genomsnittligt företag har över $1,000$ slutpunkter. Av dessa uppskattar Gartner att $23\%$ har obotade kritiska sårbarheter.
• I offentliga blockchains körs noder ofta av individer utan säkerhetsutbildning. En $2023$ studie av Ethereum-validerare fann att $41\%$ hade exponerade RPC-slutpunkter, och $68\%$ använde standardautentiseringsuppgifter.
• I moln-nativa system är noder temporära. De startas och stoppas automatiskt. Konfigurationsdrift är allomfattande.

I sådana miljöer är $p = 0.4$ inte en undantag – det är normen.

Och ändå byggs system fortfarande med $n = 10,000$ och $f = 3,333$.

Detta är inte innovation. Det är vårdslöshet.

Motargumentet: "Vi kan upptäcka och ta bort ondskefulla noder"

Det vanligaste svaret mot denna analys är att BFT-system inte bygger på statiska f-värden. De inkluderar mekanismer för att upptäcka och ta bort ondskefulla noder – genom reputationsystem, straffvillkor eller dynamisk validerarrotation.

Det är sant. Men det missar poängen.

Dessa mekanismer är inte matematiska garantier – de är operativa minskningar. De kräver manuell intervention, övervakningsinfrastruktur och svarshandlingar som inte finns i de flesta decentraliserade system.

I Bitcoin finns det ingen mekanism för att ta bort en ondskefull gruvarbetare. I Ethers proof-of-stake-system kan validerare straffas – men bara efter att de redan orsakat skada. Skadan är irreversibel.

För det andra, upptäcktsmekanismer själva är sårbara för kompromiss. En ondskefull aktör kan manipulera loggar, undertrycka varningar eller samarbeta med övervakningstjänster.

$2018$ Bitfinex-hacket involverade en komprometterad intern övervakningssystem som misslyckades att upptäcka intrånget i $36$ timmar. Samma sårbarhet finns i BFT-system: om upptäcktsmekanismen är en del av systemet, så kan den också bli komprometterad.

Och även om upptäckt vore perfekt, krävs borttagning konsensus. För att ta bort en ondskefull nod måste man nå enighet bland de återstående noderna. Men om mer än en tredjedel av noderna är ondskefulla, kan de förhindra borttagning genom samarbete.

Detta är kärnan i Byzantinsk fel: förrädarna kontrollerar berättelsen.

Ingen mängd upptäckt eller rotation kan övervinna detta om den underliggande sannolikhetsmodellen är felaktig.

Vägen framåt: Att lämna illusionen av skalbarhet

Vad är då lösningen?

Vi måste lämna myten att fler noder betyder mer säkerhet. Vi måste förkasta idén att konsensusprotokoll kan skalas obegränsat utan konsekvenser.

Istället måste vi anta tre principer:

1. Liten är säker: System bör designas med den minsta möjliga nodantalet som är förenligt med operativa krav. En $7$-nod BFT-kluster är säkrare än en $10,000$-nod om $p > 0.1$.

2. Förtroendegränser: Noder måste grupperas i förtroendeområden med strikta åtkomstkontroller. Ingen nod bör tillåtas delta i konsensus om den inte har granskats, auditerats och övervakats av en förtroendevärdig myndighet.

3. Stokastisk riskmodellering: Varje system måste utvärderas inte på dess teoretiska feltolerans, utan på dess empiriska kompromiss-sannolikhet. Om $p > 0.15$, är BFT inte rätt verktyg.

Vi måste också utveckla nya konsensusparadigmer som inte bygger på fasta trösklar. Probabilistiska konsensusmodeller, såsom de som används i Avalanche-protokollet eller Algorands VRF-baserade selektion, erbjuder alternativ som inte antar perfekt kunskap om $f$. Dessa modeller accepterar osäkerhet och kvantifierar risk probabilistiskt – istället för att påstå att den inte existerar.

Men även dessa kräver ärlighet. Vi måste sluta kalla system "decentraliserade" när de bara är distribuerade. Vi måste sluta likställa skalbarhet med motståndskraft.

De säkraste systemen i historien har inte varit de största – de har varit de enklaste. Det amerikanska kärnvapenkommandosystemet, till exempel, bygger på ett litet antal hårdnade noder med fysiska luftgap. Det skalar inte. Men det är säkert.

Slutsats: Kostnaden för matematisk övermod

Vi lever i en teknologisk renässans – byggd på antagandet att komplexitet kan tames genom skalbarhet. Men matematiken bryr sig inte om våra ambitioner.

Binomialfördelningen är likgiltig mot ditt startups värdering. Den bryr sig inte om du har samlat in \200$miljoner i riskkapital eller om din vitbok publicerats på arXiv. Den bryr sig bara om$p$.

Och i den verkliga världen är $p$ inte $0.01$. Det är $0.2$. Eller $0.3$.

Och när $p$ överskrider $1/3$, så är systemet inte bara sårbart – det är matematiskt förlorat.

Att fortsätta bygga system som antar att $3f + 1$ är en garantier är inte bara tekniskt osäkert. Det är etiskt oacceptabelt.

Vi har sett konsekvenserna av matematisk övermod tidigare – i finans, i flygindustri, i kärnenergi. Varje gång var kostnaden mättad inte i kodrader, utan i liv.

Vi får inte upprepa dessa misstag.

Vägen framåt är inte fler noder. Det är färre. Bättre. Förtroendevärdiga.

Och främst, ärliga.

Matematiken ljuger inte.

Vi gör.