⚙️ Stage 4: Deep Dive into HTTP/2¶

🎯 Learning Objectives¶

By the end of this stage, you will be able to:

Explain why HTTP/2 was created and how it improves HTTP/1.1.
Describe binary framing, streams, frames, and multiplexing.
Understand HPACK header compression.
Identify ALPN negotiation in TLS.
Capture and interpret HTTP/2 sessions in Wireshark and using command-line tools.
Troubleshoot performance or compatibility issues between HTTP/1.1 and HTTP/2.

📆 Suggested Duration¶

1.5 weeks (8–10 hours total) - 4h theory - 4–6h labs and captures

📘 Section 1: Why HTTP/2 Exists¶

🧠 Background¶

HTTP/1.1 had major limitations: - Each TCP connection handled one request at a time. - Multiple requests required multiple TCP connections (usually 6 per domain). - Head-of-line blocking (one slow request blocked the rest). - Repeated headers increased bandwidth use.

🧩 HTTP/2 Goals¶

Reduce latency
Increase parallelism (multiplexing)
Compress headers (HPACK)
Maintain full backward compatibility with HTTP semantics

📘 Section 2: HTTP/2 Architecture Overview¶

🧠 Key Concepts¶

Binary Framing Layer — all data exchanged as frames, not text.
Streams — bidirectional logical channels within a single TCP connection.
Messages — groups of frames representing one request/response.
Frames — smallest unit of communication (e.g., HEADERS, DATA, SETTINGS).

🧩 Visualization¶

TCP connection
 ├── Stream 1: Request A
 │     ├── HEADERS
 │     ├── DATA
 │     └── END_STREAM
 ├── Stream 3: Request B
 │     ├── HEADERS
 │     ├── DATA
 │     └── END_STREAM
 └── Stream 5: Request C

→ Multiple streams share the same TCP connection = multiplexing.

🔍 Analogy¶

Think of HTTP/2 like a multi-lane highway inside one TCP tunnel. Each stream is a car using its lane — no longer waiting for others to finish.

📘 Section 3: ALPN Negotiation (TLS Layer)¶

🧠 Concept¶

HTTP/2 is negotiated over TLS using ALPN (Application-Layer Protocol Negotiation). During the TLS handshake, the client advertises supported protocols, e.g.:

1	`ALPN extension: h2, http/1.1`

If the server supports HTTP/2, it responds:

1	`ALPN protocol: h2`

🧪 Lab 1 – Observe ALPN Negotiation¶

1	`openssl s_client -connect www.google.com:443 -alpn h2`

→ Look for:

1	`ALPN protocol: h2`

Try forcing HTTP/1.1:

1 2	`curl -v --http1.1 https://www.google.com curl -v --http2 https://www.google.com`

Compare connection setup output.

📘 Section 4: HTTP/2 Frames and Streams¶

🧠 Common Frame Types¶

Frame Type	Description
HEADERS	Contains compressed headers for a request or response
DATA	Carries payload (body)
SETTINGS	Negotiates connection parameters
PRIORITY	Sets stream dependencies
RST_STREAM	Cancels a stream
WINDOW_UPDATE	Controls flow (for congestion management)
PING	Measures latency or checks connection health

🧩 Example Flow¶

Client sends HEADERS (GET /).
Server responds with HEADERS (200 OK).
Server sends DATA frames (HTML).
END_STREAM flag marks completion.

📘 Section 5: HPACK – Header Compression¶

🧠 Concept¶

HTTP/1.1 sent the same headers repeatedly (e.g., User-Agent, Host).
HTTP/2 uses HPACK to compress headers efficiently using:
Static table of common headers.
Dynamic table that grows as session progresses.
This saves bandwidth and reduces latency.

🧩 Example¶

HTTP/1.1:

GET /index.html HTTP/1.1
Host: example.com
User-Agent: curl/8.0
Accept: */*

HTTP/2:

HEADERS frame:
  :method = GET
  :path = /index.html
  :scheme = https
  :authority = example.com
  (compressed binary form)

🧪 Lab 2 – View Headers with HTTP/2¶

1	`curl -v --http2 -o /dev/null -s -w '%{http_version}\n' https://nghttp2.org`

→ Output: 2

Then use:

1	`nghttp -nv https://nghttp2.org`

→ You’ll see HEADERS and DATA frames decoded (requires nghttp package).

📘 Section 6: Multiplexing and Flow Control¶

🧠 Concepts¶

Multiple requests share the same TCP connection.
Flow control prevents a single stream from monopolizing bandwidth.
Window size adjusted via WINDOW_UPDATE frames.

🧪 Lab 3 – Demonstrate Multiplexing¶

Run:

1	`curl -v --http2 --parallel https://http2.golang.org/reqinfo`

Observe how multiple requests are served simultaneously on one connection (check Wireshark).
Compare to HTTP/1.1:

1	`curl -v --http1.1 --parallel https://http2.golang.org/reqinfo`

→ HTTP/1.1 opens multiple TCP connections.

📘 Section 7: Server Push (Optional Feature)¶

🧠 Concept¶

HTTP/2 allows servers to push resources (e.g., CSS, JS) before the client asks. Useful for performance, but often disabled now (replaced by preload in HTTP/3).

🧪 Lab 4 – Observe Server Push¶

1	`nghttp -ansv https://http2.golang.org/serverpush`

→ You’ll see pushed resources listed with PUSH_PROMISE frames.

📘 Section 8: Wireshark Analysis¶

🧪 Lab 5 – Capture and Decode HTTP/2¶

Start Wireshark, filter: tcp.port == 443.
Visit https://nghttp2.org or https://www.google.com.

In Protocol Preferences, enable:

1	`Analyze → Enabled Protocols → http2`

Inspect:
ALPN negotiation in TLS handshake.
HTTP/2 frames (SETTINGS, HEADERS, DATA).
Multiplexed stream IDs.

🧩 Tip¶

- Stream IDs: odd numbers = client-initiated, even = server-initiated. The “Follow TCP Stream” view won’t show plaintext (it’s binary).

📘 Section 9: HTTP/1.1 vs HTTP/2 Comparison¶

Feature	HTTP/1.1	HTTP/2
Format	Text-based	Binary
Multiplexing	❌ One per connection	✅ Many per connection
Header Compression	❌ None	✅ HPACK
Server Push	❌	✅
Negotiation	Implicit	Via ALPN
Security	Optional	TLS required (in browsers)

🧪 Lab 6 – Compare Latency¶

Use curl’s built-in timing:

curl -w "@- " -o /dev/null -s --http1.1 https://www.google.com <<'EOF'
time_connect:  %{time_connect}s
time_starttransfer:  %{time_starttransfer}s
time_total:  %{time_total}s
EOF

Repeat with --http2.

Compare results — HTTP/2 often has slightly faster total times on modern servers.

📘 Section 10: Troubleshooting HTTP/2¶

Symptom	Cause	Diagnostic
Falls back to HTTP/1.1	ALPN mismatch	Check TLS handshake for h2
Stream resets	Flow control or protocol error	Wireshark: RST_STREAM
Mixed content issues	HTTP/2 always requires HTTPS	Ensure all subresources use HTTPS
Poor performance	Single connection overload	Check server SETTINGS and window sizes

🧪 Lab 7 – ALPN Failure Simulation¶

Force HTTP/1.1:

1	`curl -v --http1.1 https://example.com`

Then check why HTTP/2 was not negotiated (e.g., missing h2 in server’s ALPN).

🧠 Knowledge Check¶

What is multiplexing, and why does it improve performance?
What is the purpose of HPACK?
How does ALPN determine protocol version?
What are frames and streams in HTTP/2?
What changed between HTTP/1.1’s pipelining and HTTP/2’s multiplexing?

🏁 Stage 4 Completion Outcome¶

You should now be able to: ✅ Explain the binary framing model of HTTP/2. ✅ Capture and interpret HTTP/2 handshakes and frames. ✅ Use nghttp and curl to test HTTP/2 behavior. ✅ Identify performance benefits and troubleshooting steps. ✅ Understand how HTTP/2 builds on TLS with ALPN negotiation.