12 Formeln mit Beispielen

$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. Beispiel: N=5 ergibt K=5·4/2=10 Leitungen.

$T_P=\frac{L}{r}$ — T_P = Packetization Delay in s, L = Paketgröße/Nutzdaten in bit, r = Bitrate/Senderate in bit/s. Beispiel: L=8000 bit und r=64 kbit/s=64000 bit/s ergeben T_P=8000/64000=0,125 s=125 ms.

$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). Beispiel: 125 ms+30 ms+20 ms=175 ms.

$PDU=PCI+SDU$ — PDU = Protocol Data Unit (vollständige Nachricht einer Schicht), PCI = Protocol Control Information (Header/Trailer), SDU = Service Data Unit (Nutzdaten der oberen Schicht). Beispiel: TCP-Header 20 Byte + Nutzdaten 1460 Byte = TCP-Segment 1480 Byte.

$\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. Beispiel: R=100 Mbit/s bei B=20 MHz ergeben 100/20=5 bit/(s·Hz).

$S=G\cdot e^{-2G}$ — S = Durchsatz (Erfolgswahrscheinlichkeit pro Slot, 0…1), G = Verkehrsangebot (mittlere Sendeversuche pro Paketdauer T), e = Eulersche Zahl 2,718. Kollisionsintervall ist 2T, daher $e^{-2G}$. Maximum bei G=0,5 mit $S_{\max}=\frac{1}{2e}\approx0{,}184$ (18,4 %). Beispiel: G=0,5 ergibt S=0,5·e^(−1)≈0,184.

$S=G\cdot e^{-G}$ — S = Durchsatz, G = Verkehrsangebot pro Slot T, e = Eulersche Zahl. Slots halbieren das Kollisionsintervall auf T, daher $e^{-G}$. Maximum bei G=1 mit $S_{\max}=\frac{1}{e}\approx0{,}368$ (36,8 %). Beispiel: G=1 ergibt S=0,368.

$36{,}8\,\%$ erfolgreiche Übertragungen ($S=\frac{1}{e}$), $36{,}8\,\%$ leere Slots ($P(0)=e^{-1}$), $26{,}4\,\%$ Kollisionen. Beispiel: Summe 36,8+36,8+26,4=100 %.

$\frac{G}{S}=e^{2G}$ und mittlere Wiederholungen $\frac{G}{S}-1=e^{2G}-1$ — G = Verkehrsangebot, S = Durchsatz. Beispiel: G=0,5 ergibt e^1−1≈1,718 Wiederholungen.

$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 der Sender eine Kollision noch während des Sendens erkennt. Beispiel: 2·25,6 µs=51,2 µs Slot-Time bei 10BaseT.

$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. Beispiel: 50 µs·10 Mbit/s=500 bit, spezifiziert 512 bit=64 Byte.

$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. Beispiel: k=3 ergibt n∈{0,…,7}.

$\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. Beispiel: r=10 Mbit/s, τ_max=25,6 µs, L=12000 bit ergeben η≈0,896.

$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; Gegenwahrscheinlichkeit = Rahmenfehler. Beispiel: P_E=10^−5 und L=10000 bit ergeben P_r≈0,095=9,5 %.

$\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 (Zyklus = Sendezeit + RTT). Beispiel: T=8 ms und 2τ=4 ms ergeben η=8/12=0,667.

$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), sonst entstehen Leerlaufzeiten. Beispiel: T=8 ms und 2τ=4 ms ergeben w=1,5, praktisch mindestens 2.

$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. Beispiel: K=8 erlaubt w_S≤7.

$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. Beispiel: K=8 erlaubt w_S≤4.

$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. Beispiel: R=1 Mbit/s und P_r=0,1 ergeben D=0,9 Mbit/s und θ=1,111.

$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). Beispiel: R=1 Mbit/s, P_r=0,1, N=4 ergeben D≈0,692 Mbit/s und θ≈1,333.

$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 = L, τ_ges ≈ 2τ = Umlaufverzögerung inkl. Verarbeitungs- und ACK-Zeiten. Beispiel: R=1 Mbit/s, P_r=0,1, T=8 ms, τ_ges=4 ms ergeben D=0,6 Mbit/s.

$\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. Beispiel: τ=2 ms und r=1 Mbit/s ergeben 4000 bit, also 0,5 Rahmen bei T=8 ms.

$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. Beispiel: /24 ergibt 2^8−2=254 nutzbare Hosts.

$\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. Beispiel: IHL=5 ergibt 20 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. Beispiel: Offset 185 ergibt 1480 Byte.

$\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.

Beispiel: B=1000 Byte, R=1 Mbit/s, R_in=2 Mbit/s ergeben MBS=1000/(1−0,5)=2000 Byte.

$\text{Ausfall}=(1-A)\cdot365\cdot24\cdot3600\ \text{s}$ — A = Verfügbarkeit (z. B. 0,999999), 365·24·3600 = Sekunden pro Jahr. Beispiel: 99,9999 % ergeben (1−0,999999)·31536000≈31,2 s 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, Ethernet 1500 Byte), IP-Header = 20 Byte (IPv4 ohne Optionen), TCP-Header = 20 Byte (ohne Optionen). Beispiel Ethernet: 1500−20−20=1460 Byte.

$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). Der kleinere Wert begrenzt. Beispiel: w_C=8 MSS und w_R=6 MSS ergeben w_S=6 MSS.

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 erreicht ist. Beispiel: nach 3 RTT etwa 1, 2, 4, 8 MSS.

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

$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. Beispiel: w_S=16 MSS ergibt t_C=8 MSS und w_C=8 MSS.

$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 (Glasfaser ca. 2/3·c=200000 km/s), r_link = Link-Bitrate. Beispiel: 8000 bit bei 64 kbit/s=125 ms, 9200 km bei 200000 km/s=46 ms, 8000 bit bei 100 Mbit/s=0,08 ms, Summe ca. 171,08 ms.

$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. Beispiel G.711 mit 20 ms: 160 Byte Nutzdaten + 66 Byte = 226 Byte, Overhead ca. 66/226≈29 %.

$\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. Beispiel: (20+66)·8/0,030=86·8/0,03≈22933 bit/s=22,93 kbit/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. Beispiel: binäre Quelle mit p=0,5 ergibt H=1 bit/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. Beispiel: 27 Zeichen ergeben H_max=ld(27)≈4,75 bit/Zeichen.

$R=H_{\max}-H$ — R = Redundanz, H_max = maximale Entropie des Alphabets, H = tatsächliche Entropie der Quelle. Beispiel: deutscher Text mit H≈1,5 und H_max≈4,75 ergibt R≈3,25 bit/Zeichen.

$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. Beispiel: p=0,1 ergibt ca. 0,469 bit/Zeichen.

$26^3\cdot3!\cdot\frac{26!}{2^{10}\cdot10!\cdot6!}\approx1{,}6\cdot10^{19}$ — 26^3 = Anfangsstellung der 3 Rotoren (17.576), 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. Beispiel: 3 Rotoren und 10 Steckerkabel.

$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. Beispiel: GEHEIM + TXFZDP ergibt ZBMDLB.

$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. Beispiel: 16 Runden, danach Vertauschung und finale Permutation.

$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. Beispiel: 8 S-Boxen ergeben zusammen wieder 32 bit.

$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. Beispiel: 3 Schlüssel mit je 56 bit ergeben 168 bit nominal, aber 112 bit effektiv.

$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). Beispiel: gleicher Klartextblock ergibt mit unterschiedlichem C_(i−1) unterschiedliche Geheimtextblöcke.

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. Beispiel: Bitfehler an Position 5 in C_i ergibt Bitfehler an Position 5 in P_(i+1).

$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. Beispiel: 1 Bitfehler im Chiffrat = 1 Bitfehler im Klartext.

$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 %. Beispiel: wird selten benutzt.

$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. Vorteile: Stromchiffre, Ver-/Entschlüsselung identisch, keine Fehlerfortpflanzung, voll parallelisierbar. Beispiel: jeder Block kann unabhängig berechnet werden.

$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. Beispiel: gleicher Schlüsselstrom für zwei Nachrichten ist unsicher.

$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. Beispiel: p=11, s=6, a=7, b=4 ergeben A=8, B=9, k=4.

$\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. Beispiel: p=5, q=13 ergeben φ(65)=4·12=48.

$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. Beispiel: RSA nutzt e·d=r·φ(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. Beispiel: p=5, q=13, e=11 ergeben n=65, φ=48, d=35.

$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$. Beispiel: m=9, n=65, e=11 ergeben c=29, und 29^35 mod 65=9.

$p=3$, $q=17$ ergeben $n=51$ und $\phi(51)=2\cdot16=32$. Mit $e=3$ (ggT(3,32)=1) folgt $d=11$, denn $3\cdot11=33\equiv1\bmod32$. Alternativ $e=5$ ergibt $d=13$, denn $5\cdot13=65\equiv1\bmod32$.

Mit $p=719$, $s=3$, $A=191$, $B=543$, $a=16$ gilt $k=543^{16}\bmod719=59$. p = Primzahl, s = Generator, A/B = öffentliche Werte, a = geheimer Wert von Alice.

Berechne $a^x\bmod n$ durch fortgesetztes Quadrieren und Multiplizieren — a = Basis, x = Exponent, n = Modul; Zwischenergebnisse bleiben klein. Beispiel: $543^{16}\bmod719$ über $543^2\equiv386$, $386^2\equiv173$, $173^2\equiv450$, $450^2\equiv59$.

$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. Beispiel: s=3 erzeugt in Z_5* die Werte 3, 4, 2, 1.

$\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. Beispiel: Sender signiert nur H(m), nicht die ganze Nachricht.

$\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). Beispiel: Ein Angreifer ohne K_A kann keinen gültigen MAC neu berechnen.

$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. Beispiel: kein Replay möglich, da z jedes Mal neu ist; k wird nie übertragen.

$\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). Beispiel: SIM sendet SRES, Netz vergleicht.

$\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 (authentisiert das Netz!) und sendet nur bei Erfolg RES zurück. Beispiel: gegenseitige Authentisierung statt einseitig wie bei GSM.

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

DF (Don't Fragment) = Paket darf nicht fragmentiert werden; MF (More Fragments) = 1 wenn weitere Fragmente folgen, 0 beim letzten/einzigen Fragment. Beispiel: MF=0 kennzeichnet das letzte 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. Beispiel: Fragmentierung nur durch Sender, nie durch Router.

$\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. Beispiel: TCP hat die Protokollnummer 6.

$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. Beispiel: EF ist für VoIP bevorzugt.

AES/MAC 128 bit, RSA/DH 3000 bit, ECC (ECDH/ECDSA) 250 bit. Beispiel: ECC erreicht mit 250 bit ca. das Sicherheitsniveau von 3000-bit-RSA.