13 Formeln ohne Beispiele

$K=\frac{N\cdot(N-1)}{2}$ — K = Anzahl Leitungen, N = Anzahl Knoten. Herleitung: jeder Knoten braucht N−1 Leitungen, jede Leitung wird von 2 Knoten geteilt, daher /2.

$T_P=\frac{L}{r}$ — T_P = Packetization Delay in s, L = Paketgröße/Nutzdaten in bit, r = Bitrate/Senderate in bit/s.

$T_T=T_P+T_N+T_B$
$T_T$ = Gesamtlaufzeit Ende-zu-Ende
$T_P$ = Packetization Delay
$T_N$ = mittlere Netzübertragungszeit inkl. Store-and-Forward
$T_B$ = Pufferverzögerung (Jitter-Puffer).

$PDU=PCI+SDU$
PDU = Protocol Data Unit
PCI = Protocol Control Information (Header/Trailer)
SDU = Service Data Unit (Nutzdaten der oberen Schicht).

$\eta_{\mathrm{spec}}=\frac{R}{B}$ in $\frac{\text{bit/s}}{\text{Hz}}$ — R = erzielte Datenrate in bit/s, B = benötigte Bandbreite in Hz.

$S=G\cdot e^{-2G}$ — S = Durchsatz (0…1)
G = Verkehrsangebot (mittlere Sendeversuche pro Paketdauer T)
e = Eulersche Zahl. Kollisionsintervall 2T. Maximum bei $G=0{,}5$: $S_{\max}=\frac{1}{2e}\approx0{,}184$.

$S=G\cdot e^{-G}$ — S = Durchsatz, G = Verkehrsangebot pro Slot T, e = Eulersche Zahl. Kollisionsintervall T. Maximum bei $G=1$: $S_{\max}=\frac{1}{e}\approx0{,}368$.

$\frac{G}{S}=e^{2G}$ und mittlere Wiederholungen $\frac{G}{S}-1=e^{2G}-1$ — G = Verkehrsangebot, S = Durchsatz.

$T_{\min}=2\cdot\tau_{\max}$ — T_min = minimale Sendedauer/Slot-Time, τ_max = maximale einfache Signallaufzeit zwischen entferntesten Stationen. Faktor 2 = Round-Trip-Time, damit Kollision noch während des Sendens erkannt wird.

$L_{\min}=2\cdot\tau_{\max}\cdot r=T_{\min}\cdot r$ — L_min = minimale Rahmenlänge in bit, τ_max = max. einfache Signallaufzeit, r = Bitrate.

$n\in\{0,\dots,\min(2^k-1,1023)\}$ — n = Anzahl der Slot-Times Wartezeit, k = Anzahl bisheriger Kollisionen. Limit bei k=10 (2^10−1=1023), Abbruch nach 16 Versuchen.

$\eta=\frac{1}{1+2\cdot r\cdot\tau_{\max}\cdot\frac{e}{L}}$ — η = Kanalausnutzung (0…1), r = Bitrate, τ_max = max. einfache Signallaufzeit, L = Rahmenlänge in bit, e = Eulersche Zahl.

$P_r=1-(1-P_E)^L$ — P_r = Wahrscheinlichkeit, dass ein Rahmen mit L bit mindestens einen Fehler hat, P_E = Bitfehlerrate pro Bit, L = Rahmenlänge in bit. $(1-P_E)^L$ = Wahrscheinlichkeit, dass alle L Bits fehlerfrei ankommen.

$\eta_{SW}\approx\frac{T}{T+2\tau}$ mit $T=\frac{L}{r}$ — η_SW = Kanalausnutzung, T = Sendedauer eines Rahmens, L = Rahmenlänge in bit, r = Bitrate, τ = einfache Signallaufzeit, 2τ = Round-Trip-Time.

$w=\frac{2\tau}{T}+1\approx\frac{2\tau}{T}$ — w = Fenstergröße in Rahmen, τ = einfache Signallaufzeit, T = Sendedauer eines Rahmens. Fensterdauer w·T muss die Umlaufzeit 2τ abdecken (Bandbreite-Laufzeit-Produkt).

$w_S\le K-1$ — w_S = Sendefenstergröße in Rahmen, K = Anzahl Sequenznummern (z. B. 2^m bei m Bit). Bei w_S=K ließe sich bei verlorenen ACKs Wiederholung nicht von neuem Rahmen unterscheiden.

$w_S\le\left\lfloor\frac{K}{2}\right\rfloor$ — w_S = Sendefenstergröße, w_R = Empfangsfenster = w_S, K = Anzahl Sequenznummern, floor = Abrunden. Verhindert Überlappung von altem und neuem Fenster.

$D_{SR}=R\cdot(1-P_r)$ und $\theta_{SR}=\frac{1}{1-P_r}$ — D_SR = Durchsatz in bit/s, R = Coderate/Bitrate, P_r = Rahmenfehlerrate, θ_SR = mittlere Anzahl Übertragungsversuche pro Rahmen.

$D_{GBN}=R\cdot\frac{1-P_r}{1+(N-1)\cdot P_r}$ und $\theta_{GBN}=1+\frac{(N-1)\cdot P_r}{1-P_r}$ — D_GBN = Durchsatz, R = Bitrate, P_r = Rahmenfehlerrate, N = w_S = Sendefenstergröße, θ_GBN = mittlere Versuche pro Rahmen (pro Fehler werden im Mittel N Rahmen neu gesendet).

$D_{SW}=R\cdot(1-P_r)\cdot\frac{T}{T+\tau_{\mathrm{ges}}}$ — D_SW = Durchsatz in bit/s, R = Bitrate, P_r = Rahmenfehlerrate, T = Rahmenübertragungsdauer = $\frac{L}{r}$, τ_ges ≈ 2τ = Umlaufverzögerung inkl. Verarbeitungs- und ACK-Zeiten.

$\mathrm{BDP}=2\tau\cdot r$ bzw. in Rahmen $\frac{2\tau}{T}$ — BDP = Speicherkapazität der Strecke für Hin- und Rückweg in bit, τ = einfache Signallaufzeit, r = Bitrate, T = Sendedauer eines Rahmens. Gibt an, wie viele Bits/Rahmen gleichzeitig „im Flug“ sind.

$N_{\mathrm{Host}}=2^{32-L}-2$ — N_Host = Anzahl nutzbarer Hostadressen, L = Präfixlänge (Anzahl Netzbits), 32−L = Anzahl Hostbits, −2 weil Netzadresse (alle Hostbits 0) und Broadcast-Adresse (alle Hostbits 1) abgezogen werden.

$\text{Headerlänge}=IHL\cdot4\ \text{Byte}$ — IHL = Internet Header Length (4-Bit-Feld im IPv4-Header), zählt in 32-Bit-Wörtern (4 Byte). Werte 5…15, also 20…60 Byte.

$\text{Byte-Offset}=\text{Fragment Offset}\cdot8$ — Fragment Offset = 13-Bit-Feld im IPv4-Header, zählt in 8-Byte-Blöcken; Byte-Offset = Position der Fragment-Nutzdaten im ursprünglichen Datagramm.

$\mathrm{MBS}=\frac{B}{1-\frac{R}{R_{\mathrm{in}}}}$ — MBS = Maximum Burst Size (max. kurzzeitig abgebbare Datenmenge), B = Puffergröße/Eimergröße, R = konstante Abfluss-/Tokenrate, R_in = Eingangs-/Ankunftsrate. Herleitung: $\mathrm{MBS}=B+R\cdot\frac{\mathrm{MBS}}{R_{\mathrm{in}}}$ nach MBS auflösen.

$\text{Ausfall}=(1-A)\cdot365\cdot24\cdot3600\ \text{s}$ — A = Verfügbarkeit (z. B. 0,999999), 365·24·3600 = Sekunden pro Jahr.

$\mathrm{MSS}=\mathrm{MTU}-\text{IP-Header}-\text{TCP-Header}$ — MSS = Maximum Segment Size (max. TCP-Nutzdaten pro Segment), MTU = Maximum Transmission Unit (max. Paketgröße inkl. Header), IP-Header = 20 Byte (IPv4 ohne Optionen), TCP-Header = 20 Byte (ohne Optionen).

$w_S=\min(w_C,w_R)$ — w_S = tatsächliches Sendefenster (max. unbestätigte Bytes), w_C = Congestion Window (Staufenster, vom Sender aus Netzrückmeldung), w_R = Receiver Window (freie Pufferkapazität des Empfängers, vom Empfänger gemeldet).

Start $w_C=1\ \mathrm{MSS}$, pro ACK $+1\ \mathrm{MSS}$, Verdopplung pro RTT bis $t_C$ — w_C = Congestion Window, MSS = Maximum Segment Size, t_C = Slow-Start-Threshold. Exponentielles Wachstum bis t_C.

pro ACK $+\frac{1}{w_C}\ \mathrm{MSS}$, also ca. $+1\ \mathrm{MSS}$ pro RTT — w_C = Congestion Window. Lineares Wachstum (AIMD: additive increase).

$t_C=\frac{w_S}{2}$ und $w_C=t_C$ — t_C = neuer Slow-Start-Threshold, w_S = aktuelles Sendefenster, w_C = neues Congestion Window. Fast Retransmit/Recovery, danach Congestion Avoidance.

$T\approx t_{\mathrm{pack}}+t_{\mathrm{prop}}+t_{\mathrm{trans}}$ mit $t_{\mathrm{pack}}=\frac{L_{\mathrm{bit}}}{r_{\mathrm{codec}}}$, $t_{\mathrm{prop}}=\frac{d}{v}$, $t_{\mathrm{trans}}=\frac{L_{\mathrm{bit}}}{r_{\mathrm{link}}}$ — L_bit = Nutzdaten in bit, r_codec = Codec-Bitrate, d = Distanz, v = Ausbreitungsgeschwindigkeit im Medium, r_link = Link-Bitrate.

$12+8+20+22+4=66\ \text{Byte}$ — 12 Byte RTP-Header, 8 Byte UDP-Header, 20 Byte IP-Header, 22 Byte Ethernet-Header (inkl. Preamble/SFD), 4 Byte Ethernet-Trailer/FCS.

$\text{Rate}=\frac{(N_{\mathrm{utz}}+66)\cdot8}{t_{\mathrm{sample}}}\ \text{bit/s}$ — N_utz = Codec-Nutzdaten pro Paket in Byte, 66 Byte = Header-Overhead, t_sample = Paketierungsintervall in s.

$H=-\sum_i P_i\cdot\mathrm{ld}(P_i)\ \text{bit/Zeichen}$ — H = mittlerer Informationsgehalt/Entropie pro Zeichen, P_i = Auftrittswahrscheinlichkeit des i-ten Zeichens, ld = Logarithmus dualis (log zur Basis 2), Σ über alle n Zeichen.

$H_{\max}=\mathrm{ld}(n)$ — H_max = maximal mögliche Entropie, n = Anzahl Zeichen im Alphabet. Wird erreicht, wenn alle Zeichen gleich wahrscheinlich P_i=1/n und statistisch unabhängig sind.

$R=H_{\max}-H$ — R = Redundanz, H_max = maximale Entropie des Alphabets, H = tatsächliche Entropie der Quelle.

$H_{\mathrm{bin}}(p)=-p\cdot\mathrm{ld}(p)-(1-p)\cdot\mathrm{ld}(1-p)$ — p = Wahrscheinlichkeit für Zeichen 0, 1−p = Wahrscheinlichkeit für Zeichen 1. Maximum 1 bit/Zeichen bei p=0,5; Null bei p=0 oder p=1.

$26^3\cdot3!\cdot\frac{26!}{2^{10}\cdot10!\cdot6!}\approx1{,}6\cdot10^{19}$ — 26^3 = Anfangsstellung der 3 Rotoren, 3! = Anordnung/Lage der 3 Rotoren, 26!/(2^10·10!·6!) = Steckerbrett mit n=10 Kabeln (26! Permutationen, 2^10 Kabelrichtung, 10! Kabelreihenfolge, 6! nicht gesteckte Buchstaben). $\mathrm{ld}(1{,}6\cdot10^{19})\approx64$ Bit.

$C=(P+K)\bmod26$ bzw. binär $C=P\oplus K$ — C = Geheimtext, P = Klartext, K = einmaliger Zufallsschlüssel gleicher Länge. Sicher nur, wenn K echt zufällig, nie wiederholt und so lang wie P.

$L_i=R_{i-1}$ und $R_i=L_{i-1}\oplus f(R_{i-1},K_i)$ — L_i = linke 32-Bit-Hälfte nach Runde i, R_i = rechte 32-Bit-Hälfte nach Runde i, f = Rundenfunktion, K_i = i-ter 48-Bit-Rundenschlüssel. Entschlüsselung nutzt dieselbe Runde mit K_16…K_1.

$f$: Expansion $E$ von 32 auf 48 bit, XOR mit $K_i$ (48 bit), 8 S-Boxen $S_1\dots S_8$ mit je $6\to4$ bit (zusammen 32 bit), Permutation $P$ — R_(i−1) = 32-Bit-Eingang, K_i = 48-Bit-Rundenschlüssel.

$C=\mathrm{DES}_{k_1}(\mathrm{DES}^{-1}_{k_2}(\mathrm{DES}_{k_1}(P)))$ — k1, k2, k3 = 56-Bit-Schlüssel (k1=k3 bei 2-Schlüssel-Variante), E = Encryption, D = Decryption, P = Klartext, C = Geheimtext. Effektive Sicherheit nur 112 bit wegen Meet-in-the-Middle.

$C_i=E_K(P_i\oplus C_{i-1})$ mit $C_0=IV$ und $P_i=D_K(C_i)\oplus C_{i-1}$ — C_i = i-ter Geheimtextblock, P_i = i-ter Klartextblock, E_K/D_K = Blockchiffre mit Schlüssel K, IV = Initialisierungsvektor (nicht geheim, aber pro Nachricht unterschiedlich).

1 Bitfehler in $C_i$ zerstört $P_i$ komplett (Lawineneffekt) und erzeugt in $P_{i+1}$ exakt an derselben Bitposition 1 Bitfehler, danach fehlerfrei.

$O_i=E_K(O_{i-1})$, $C_i=P_i\oplus O_i$, $O_0=IV$ — O_i = i-ter Ausgangsblock/Schlüsselstromblock, E_K = Blockchiffre-Encryption, IV = Initialisierungsvektor. Arbeitet wie synchrone Stromchiffre; Ver- und Entschlüsselung nutzen identisch E_K; keine Fehlerfortpflanzung; Sender/Empfänger müssen synchron sein.

$C_i=P_i\oplus E_K(C_{i-1})$ mit $C_0=IV$ — C_i = Geheimtextblock, P_i = Klartextblock, E_K = Blockchiffre-Encryption, C_(i−1) = vorheriger Geheimtextblock. Selbstsynchronisierend; 1 Bitfehler stört aktuellen Block mit 1 bit und nächsten Block mit ca. 50 %.

$C_i=P_i\oplus E_K(\mathrm{Nonce}\parallel\mathrm{Counter}_i)$ — Nonce = Zufallszahl/Nummer einmalig pro Schlüssel, Counter_i = fortlaufender Zähler 0,1,2,…, E_K = Blockchiffre-Encryption, P_i = Klartextblock. Stromchiffre, Ver-/Entschlüsselung identisch, keine Fehlerfortpflanzung, voll parallelisierbar.

$C=P\oplus K_S$ — C = Geheimtext, P = Klartext, K_S = Schlüsselstrom (pseudozufällig aus Schlüssel und IV). Bei Wiederverwendung von K_S gilt $C_1\oplus C_2=P_1\oplus P_2$, d. h. der Angreifer erhält das XOR der Klartexte.

$A=s^a\bmod p$, $B=s^b\bmod p$, $k=B^a\bmod p=A^b\bmod p=s^{a\cdot b}\bmod p$ — p = große öffentliche Primzahl, s = öffentlicher Generator von Z_p* (s<p), a = geheimer Schlüssel von Alice (a<p), b = geheimer Schlüssel von Bob (b<p), A = öffentlich gesendeter Wert von Alice, B = öffentlich gesendeter Wert von Bob, k = gemeinsamer geheimer Sitzungsschlüssel.

$\phi(p)=p-1$ und $\phi(p\cdot q)=(p-1)(q-1)$ — φ(n) = Anzahl x<n mit ggT(x,n)=1; p, q = verschiedene Primzahlen, n = Modul, ggT = größter gemeinsamer Teiler.

$m^{\phi(n)}\bmod n=1$ für $\gcd(m,n)=1$; daraus $m^{r\cdot\phi(n)+1}\bmod n=m$ — m = Nachricht, n = Modul, φ(n) = Eulersche Phi-Funktion, r = beliebige ganze Zahl. Bei n=p·q gilt die Gleichung sogar, wenn ggT(m,n)≠1.

$n=p\cdot q$, $\phi(n)=(p-1)(q-1)$, $e\cdot d\bmod\phi(n)=1$ — p,q = zwei große verschiedene Primzahlen, n = öffentlicher Modul, φ(n) = Eulersche Phi-Funktion, e = öffentlicher Exponent (ggT(e,φ(n))=1), d = privater Exponent (multiplikatives Inverses zu e mod φ(n), per erweitertem Euklid). Öffentlicher Schlüssel (n,e), privater Schlüssel d.

$c=m^e\bmod n$ und $m=c^d\bmod n$ — m = Klartextblock (m<n), c = Geheimtextblock, e = öffentlicher Exponent, d = privater Exponent, n = Modul. Beweis: $m^{e\cdot d}=m^{r\cdot\phi(n)+1}\equiv m\bmod n$.

Berechne $a^x\bmod n$ durch fortgesetztes Quadrieren und Multiplizieren — a = Basis, x = Exponent, n = Modul; Zwischenergebnisse bleiben klein.

$s$ ist Generator von $\mathbb{Z}_p^*$, wenn $s^1,\dots,s^{p-1}\bmod p$ alle p−1 Elemente erzeugen — p = Primzahl, s = Kandidat. Nur dann ist $y=s^x\bmod p$ bijektiv und der diskrete Logarithmus $x=\mathrm{Dlog}_s(y)$ eindeutig.

$\text{Signatur}=E_{\mathrm{priv}}(H(m))$ und Prüfung $D_{\mathrm{pub}}(\text{Signatur})=H(m)$ — H = Hash-Funktion, m = Nachricht, E_priv = Verschlüsselung mit privatem Schlüssel des Senders, D_pub = Entschlüsselung mit öffentlichem Schlüssel des Senders. Beweist Authentizität und Nichtabstreitbarkeit.

$\mathrm{MAC}=h(K_A,m)$ — h = Hash-Funktion, K_A = geheimer gemeinsamer Schlüssel von Sender und Empfänger, m = Nachricht. Prüft Integrität UND Authentizität (Herkunft).

$r=f_k(z)$ — f_k = Einwegfunktion mit geheimem Schlüssel k, z = Zufallszahl (Challenge) vom Netz, r = Antwort (Response) des Terminals. Netz prüft r'=f_k(z) mit r.

$\mathrm{SRES}=\mathrm{A3}(\mathrm{RAND},K_i)$ und $K_c=\mathrm{A8}(\mathrm{RAND},K_i)$ — RAND = 128-Bit-Zufallszahl vom AuC, K_i = 128-Bit-Teilnehmerschlüssel auf SIM und im AuC, SRES = 32-Bit-Antwort, K_c = 64-Bit-Sitzungsschlüssel für A5 (real oft nur 54 bit, 10 Bit genullt).

$\mathrm{AV}=(\mathrm{RAND},\mathrm{XRES},\mathrm{CK},\mathrm{IK},\mathrm{AUTN})$ — RAND = Zufallszahl, XRES = erwartete Response, CK = 128-Bit-Cipher-Key, IK = 128-Bit-Integrity-Key, AUTN = Authentisierungstoken (enthält MAC). USIM prüft zuerst AUTN und sendet nur bei Erfolg RES zurück.

20 bis 60 Byte, $\text{Headerlänge}=IHL\cdot4\ \text{Byte}$ — IHL = Internet Header Length (4 bit), Werte 5…15.

DF (Don't Fragment) = Paket darf nicht fragmentiert werden; MF (More Fragments) = 1 wenn weitere Fragmente folgen, 0 beim letzten/einzigen Fragment.

feste 40 Byte, keine Prüfsumme, keine Fragmentierungsfelder im Basis-Header, Flow-Label für QoS, Next Header verweist auf Erweiterungs-Header oder L4-Protokoll.

$\mathrm{ICMP}=0\mathrm{x}01$, $\mathrm{TCP}=0\mathrm{x}06$, $\mathrm{UDP}=0\mathrm{x}11$ — steht im Protocol-Feld des IPv4-Headers und zeigt das L4-Protokoll an.

$1\ \mathrm{EF}+12\ \mathrm{AF}+1\ \mathrm{BE}=14$ Klassen — EF = Expedited Forwarding (minimale Verzögerung/Jitter/Verlust für Echtzeit), AF = Assured Forwarding (4 Prioritätsklassen × 3 Drop-Precedence), BE = Best Effort.

AES/MAC 128 bit, RSA/DH 3000 bit, ECC (ECDH/ECDSA) 250 bit — empfohlene Mindestschlüssellängen.