Computer networks

1 · Layering — OSI vs TCP/IP

Networks are built as a stack of layers. Each layer uses the layer below and serves the layer above, so you can reason about (say) HTTP without thinking about voltage on a wire. The OSI model has seven layers (a teaching reference); the TCP/IP model that the internet actually runs has four. Data moving down the stack is encapsulated — each layer wraps the layer above in its own header.

2 · TCP vs UDP & the 3-way handshake

TCP gives a reliable, ordered byte stream: it retransmits lost data, reorders what arrives out of order, and controls its sending rate. UDP gives none of that — it just fires datagrams and hopes. You pay for TCP's guarantees with latency (handshakes, acknowledgements); UDP trades reliability for speed, which is why live video, games, and DNS often use it. A TCP connection opens with a 3-way handshake: SYN → SYN-ACK → ACK, which synchronises sequence numbers on both sides before any data flows.

handshake.py# MODEL: the client/server sequence-number exchange of a TCP open.
def three_way_handshake(client_isn, server_isn):
    log = []
    # 1. client -> server: SYN, seq = client_isn
    log.append(("C->S", "SYN", client_isn))
    # 2. server -> client: SYN-ACK, seq = server_isn, ack = client_isn + 1
    log.append(("S->C", "SYN-ACK", server_isn, client_isn + 1))
    # 3. client -> server: ACK, ack = server_isn + 1
    log.append(("C->S", "ACK", server_isn + 1))
    established = True
    return established, log

ok, log = three_way_handshake(client_isn=1000, server_isn=5000)
for step in log:
    print(step)
print("connection established:", ok)

('C->S', 'SYN', 1000)
('S->C', 'SYN-ACK', 5000, 1001)
('C->S', 'ACK', 5001)
connection established: True

3 · IP addressing, routing & DNS

An IP address identifies an interface on the network; a packet carries a source and destination IP. Routing is how packets hop from router to router toward the destination network — each router consults a table and forwards to the best next hop. But humans use names, not numbers, so DNS (the Domain Name System) resolves a name like example.com to an IP, walking from the root servers down to the authoritative server, with caching at every level to keep it fast.

dns.py# MODEL: a resolver that walks root -> TLD -> authoritative, caching answers.
ROOT = {"com": "tld-com-server"}
TLD  = {"example.com": "ns.example.com"}
AUTH = {"example.com": "93.184.216.34"}

class Resolver:
    def __init__(self):
        self.cache = {}
    def resolve(self, name):
        if name in self.cache:
            return ("cache", self.cache[name])
        tld = name.split(".")[-1]
        ROOT[tld]                       # ask root for the TLD server
        TLD[name]                       # ask TLD for the authoritative server
        ip = AUTH[name]                 # ask authoritative for the A record
        self.cache[name] = ip
        return ("resolved", ip)

r = Resolver()
print(r.resolve("example.com"))         # walks the chain
print(r.resolve("example.com"))         # served from cache

('resolved', '93.184.216.34')
('cache', '93.184.216.34')

4 · HTTP, HTTPS & the TLS handshake

HTTP is the application-layer request/response protocol of the web: a method (GET, POST), a path, headers, and an optional body; the server replies with a status code and body. HTTPS is HTTP running inside a TLS tunnel. The TLS handshake (after the TCP handshake) authenticates the server via its certificate and negotiates a shared symmetric key, so everything afterward is encrypted and tamper-evident. TLS gives three guarantees: confidentiality (eavesdroppers see ciphertext), integrity (tampering is detected), and authentication (you're really talking to that server).

tls_model.py# MODEL: a key exchange producing a shared secret, then an integrity check.
# This illustrates WHAT TLS guarantees, not the real cryptographic protocol.
import hashlib, hmac

def derive_shared_key(client_random, server_random, premaster):
    seed = f"{client_random}:{server_random}:{premaster}".encode()
    return hashlib.sha256(seed).hexdigest()   # stand-in for the TLS PRF

def mac(key, message):                        # integrity tag
    return hmac.new(key.encode(), message.encode(), hashlib.sha256).hexdigest()

key = derive_shared_key("cr-123", "sr-456", "premaster-secret")
msg = "GET /account HTTP/1.1"
tag = mac(key, msg)
print("shared key (first 16):", key[:16])
# receiver recomputes the tag; a tampered message would not match
print("integrity ok:", hmac.compare_digest(tag, mac(key, msg)))
print("tamper detected:", not hmac.compare_digest(tag, mac(key, "GET /admin HTTP/1.1")))

shared key (first 16): fb61405c41b1c1df
integrity ok: True
tamper detected: True

5 · Reliability — checksums, windows, congestion & flow control

TCP turns an unreliable IP layer into a reliable stream with a few mechanisms. A checksum detects corrupted packets. Sequence numbers + acknowledgements detect loss and reordering. A sliding window lets the sender have several packets in flight at once (not stop-and-wait) while bounding how far ahead it may run. Two feedback loops shape the rate: flow control stops a fast sender from overwhelming a slow receiver (the receiver advertises its window), and congestion control stops senders from overwhelming the network (slow start, then back off on loss).

reliability.py# MODEL: 16-bit ones-complement-style checksum + a sliding window sender.
def checksum(data: bytes) -> int:
    total = 0
    for b in data:
        total = (total + b) & 0xFFFF        # keep it 16-bit
    return (~total) & 0xFFFF                # ones-complement

def corrupted(data, sent_ck):
    return checksum(data) != sent_ck        # receiver recomputes and compares

msg = b"hello-network"
ck = checksum(msg)
print("checksum ok:", not corrupted(msg, ck))
print("corruption caught:", corrupted(b"hallo-network", ck))

# Sliding window: at most `window` unacked packets in flight at once.
def send_with_window(packets, window):
    base, next_seq, acked = 0, 0, []
    timeline = []
    while base < len(packets):
        # send everything the window allows
        while next_seq < len(packets) and next_seq < base + window:
            timeline.append(("send", next_seq)); next_seq += 1
        # receiver acks the oldest in order; window slides forward
        timeline.append(("ack", base)); acked.append(base); base += 1
    return timeline, acked

tl, acked = send_with_window(list(range(6)), window=3)
print("in-flight cap = 3; acked in order:", acked)
print("first 5 events:", tl[:5])

checksum ok: True
corruption caught: True
in-flight cap = 3; acked in order: [0, 1, 2, 3, 4, 5]
first 5 events: [('send', 0), ('send', 1), ('send', 2), ('ack', 0), ('send', 3)]

6 · What happens when you type a URL

This is the classic interview question — and it ties every section together. Follow one request from keystroke to rendered page:

From https://studybydoing.in to a rendered page:

1. DNS resolution — the browser resolves example.com to an IP (§3), hitting caches first.
2. TCP handshake — a 3-way SYN/SYN-ACK/ACK opens a connection to that IP on port 443 (§2).
3. TLS handshake — client and server authenticate and agree a symmetric key; the channel is now encrypted (§4).
4. HTTP request — the browser sends GET / with headers, inside the TLS tunnel, carried by TCP over IP (§1 encapsulation).
5. Server processing — a load balancer picks an app server (SD5), which may hit a cache or database and returns an HTTP response.
6. Render — the browser parses HTML, and fetches CSS/JS/images (often reusing the same connection), then paints the page.

Knowledge check

layer_of = {
    "HTTP": "Application", "DNS": "Application", "TLS": "Application",
    "TCP": "Transport", "UDP": "Transport",
    "IP": "Internet",
    "Ethernet": "Link",
}
from collections import defaultdict
grouped = defaultdict(list)
for proto, layer in layer_of.items():
    grouped[layer].append(proto)
for layer in ["Application", "Transport", "Internet", "Link"]:
    print(f"{layer:12s}: {grouped[layer]}")

def handshake(client_isn, server_isn):
    log = []
    log.append(("C->S", "SYN", {"seq": client_isn}))
    log.append(("S->C", "SYN-ACK", {"seq": server_isn, "ack": client_isn + 1}))
    log.append(("C->S", "ACK", {"ack": server_isn + 1}))
    return True, log

established, log = handshake(1000, 5000)
for m in log: print(m)
print("ESTABLISHED" if established else "FAILED")

def checksum(data: bytes) -> int:
    total = 0
    for b in data:
        total = (total + b) & 0xFFFF
    return (~total) & 0xFFFF

def verify(data, sent_ck):
    return checksum(data) == sent_ck

msg = b"reliable-transport"
ck = checksum(msg)
print("intact verifies:", verify(msg, ck))               # True
print("one byte changed:", verify(b"reliqble-transport", ck))  # False

import math

def send_time_ms(n_packets, window, rtt_ms=50):
    round_trips = math.ceil(n_packets / window)
    return round_trips * rtt_ms

N = 100
saw = send_time_ms(N, window=1)     # stop-and-wait
win = send_time_ms(N, window=10)
print(f"stop-and-wait: {saw} ms")   # 5000
print(f"window=10:     {win} ms")   # 500
print(f"speedup:       {saw / win:.0f}x")   # 10x

# ideal window ~ bandwidth-delay product
bandwidth_bps, rtt_s, pkt_bits = 10_000_000, 0.05, 12_000
bdp_packets = (bandwidth_bps * rtt_s) / pkt_bits
print(f"ideal window ~ {bdp_packets:.0f} packets")

import time

ROOT = {"com": "tld-com"}
TLD  = {"example.com": "ns.example.com"}
AUTH = {"example.com": "93.184.216.34"}

class Resolver:
    def __init__(self): self.cache = {}    # name -> (ip, expires_at)
    def resolve(self, name, ttl=1.0):
        now = time.monotonic()
        hit = self.cache.get(name)
        if hit and hit[1] > now:
            return ("cache", hit[0])
        _ = ROOT[name.split(".")[-1]]      # walk root
        _ = TLD[name]                      # walk TLD
        ip = AUTH[name]                    # authoritative answer
        self.cache[name] = (ip, now + ttl)
        return ("resolved", ip)

r = Resolver()
print(r.resolve("example.com", ttl=0.05))  # resolved
print(r.resolve("example.com", ttl=0.05))  # cache
time.sleep(0.06)
print(r.resolve("example.com", ttl=0.05))  # resolved again (expired)

def load_url_model(phases_ms):
    """MODEL: phases_ms maps phase -> modelled milliseconds."""
    total = sum(phases_ms.values())
    worst = max(phases_ms, key=phases_ms.get)
    fixes = {
        "dns": "cache DNS / raise TTL",
        "tcp": "connection keep-alive / reuse",
        "tls": "session resumption / keep-alive",
        "server": "cache or speed up the app tier (SD5)",
        "transfer": "compression / CDN edge",
    }
    return total, worst, fixes[worst]

first_load = {"dns": 40, "tcp": 30, "tls": 50, "server": 120, "transfer": 60}
total, worst, fix = load_url_model(first_load)
print(f"total {total} ms; dominant phase: {worst} -> {fix}")

# second load reuses the connection: DNS/TCP/TLS drop out
second_load = {"dns": 0, "tcp": 0, "tls": 0, "server": 120, "transfer": 60}
print("second load total:", sum(second_load.values()), "ms")