Chapter 8 Review · Security in Computer Networks

Cross-layer ★ Chapter review Kurose & Ross p. 679 · ~14 min read

  • confidentiality
  • message integrity
  • firewall

Where you are

  • Application layer you are here
  • Transport layer you are here
  • Network layer you are here
  • Link layer you are here
  • Physical layer you are here

Four primitives — a block cipher, a hash function, a key pair and a nonce — arranged four different ways for four layers. And then one section that uses none of them.

What this page is

  • The chapter in one picture — every idea, linked to the section that taught it.

  • The argument, in three parts, which is how the chapter is built.

  • Four primitives against four protocols, which is its real thesis.

  • Every number worth remembering, sortable.

  • The book’s six slips in this chapter, all verified on the page images.

  • A closing quiz on the chapter as a whole.

Where you are

This is the last chapter, and it is the one that finally answers section 1.6. That section listed the attacks — malware, denial of service, sniffing, masquerading, message modification — and said the answers would come later.

Section 8.1 turned “later” into a plan by naming four properties, each with a section attached. Everything since has delivered one of them.

The thing worth carrying away is not any single protocol. It is that a very small number of primitives, composed differently, produce all of them. You can now read a new secure protocol and predict roughly what will be inside it.

The chapter in one picture

Chapter 8 in one picture

Hover an idea to see what it connects to. Click one to go back to the section that taught it.

The left column is the toolbox. The middle column is the same toolbox applied once at each layer. The right is a different subject that happens to live in the same chapter. Click any box.

Read this map as a list
  • Four properties (§8.1 · and the sections that deliver them) — connects to Symmetric key
  • Symmetric key (§8.2.1 · block ciphers, and CBC) — connects to Four properties, Public key, RSA, Hashes and MACs
  • Public key, RSA (§8.2.2 · and the session key) — connects to Symmetric key, Signatures and certificates, PGP — application layer
  • Hashes and MACs (§8.3.1–8.3.2 · integrity from a shared secret) — connects to Signatures and certificates, Symmetric key, TLS — transport layer, IPsec — network layer
  • Signatures and certificates (§8.3.3 · and a public key infrastructure) — connects to Public key, RSA, Hashes and MACs, End-point authentication, PGP — application layer
  • End-point authentication (§8.4 · ap1.0 → ap4.0, and the nonce) — connects to Signatures and certificates, TLS — transport layer, WPA and AKA — link layer
  • PGP — application layer (§8.5 · e-mail, and a web of trust) — connects to Public key, RSA, Signatures and certificates
  • TLS — transport layer (§8.6 · four attacks on a byte stream) — connects to Hashes and MACs, End-point authentication
  • IPsec — network layer (§8.7 · tunnel mode, and blanket coverage) — connects to Hashes and MACs
  • WPA and AKA — link layer (§8.8 · mutual authentication) — connects to End-point authentication
  • Firewalls (§8.9.1 · packet filter → stateful → gateway) — connects to Intrusion detection
  • Intrusion detection (§8.9.2 · signatures, or anomalies) — connects to Firewalls, No cryptography at all
  • No cryptography at all (which is why it waits until the end) — connects to Intrusion detection

The argument, in three parts

1 — Build the toolbox (§8.1–8.4)

Four properties, then the machinery for three of them.

Confidentiality comes from encryption, in two forms: symmetric, where the key must somehow be agreed in advance, and public key, which removes that requirement and costs far more to compute.

Integrity is reached twice. A message authentication code needs only a shared secret and a hash function, and no encryption at all. A digital signature needs a whole public key infrastructure — and buys nonrepudiation, which a shared secret can never give.

Authentication turns out to be a different kind of problem, and section 8.4 is where that becomes clear.

2 — Apply it at every layer (§8.5–8.8)

The same descent the whole book makes: application, transport, network, link.

And the same three lines every time. A session key, because public key cryptography is too slow for real data. A hash, because signing or authenticating a whole message is wasteful. A nonce, because a message is bytes and bytes can be recorded.

The reason security exists at four layers rather than one is stated in section 8.5. Network-layer security gives blanket coverage but cannot authenticate a user, and higher layers are far easier to deploy.

3 — Then change subject entirely (§8.9)

Firewalls and intrusion detection are not about two parties communicating. They are about an organisation defending a boundary with a firewall , and they use none of the cryptography built in the first two parts.

That is why operational security sat apart in section 8.1’s grid, and why it waits until the end. Its own ladder runs packet filter, stateful filter, application gateway, then deep packet inspection. It is about how much a device is allowed to see, not about what it can compute.

Four primitives, four protocols

Four primitives, four protocols
PGPapplicationTLStransportIPsecnetworkWPA / AKAlink
Symmetric key cipher
Public key cryptography
How integrity is provided
How freshness is provided
What it protects

Cells marked ⓘ have a reason behind them — click to read it.

The chapter's real thesis: every protocol in §8.5–8.8 is an arrangement of the same small set of parts. Click any cell.

Two rows repay a careful look.

Integrity splits the protocols cleanly. PGP (Pretty Good Privacy) signs, while TLS (Transport Layer Security) and IPsec (IP Security) use message authentication codes. The book draws that contrast itself, and the reason is in section 8.3.3. A signature needs an infrastructure, and a protocol that already has a shared key need not pay for one.

Freshness is the row where PGP is empty. An e-mail has no session, so there is no handshake in which a nonce could live — which means nothing in PGP prevents an old message being replayed at you.

Every number worth remembering

Every number worth remembering

Cells marked ⓘ have an explanation — click to read it. Sortable columns have a ↕ in the heading.

Sortable. Each is either a design constant or the outcome of an argument the chapter makes.

The book’s slips in this chapter

The book's slips in this chapter
What the book printsWhat it should say

Cells marked ⓘ have an explanation — click to read it. Sortable columns have a ↕ in the heading.

Six, all verified against the printed page images rather than the text extraction.

In plain words

Three of the six are in one table, and they are all the same kind of damage: enormous printed integers with digits duplicated or added. The recovered column is right in every row, so the worked example still teaches. But the book asks the reader to check the arithmetic, and three of those numbers will not reproduce.

The other three are worse for a reader. Figure 8.18 promises a failure scenario that is not in the figure. §8.8.2 points at a section that does not exist. And R27 asks a question that cannot be answered as printed, about material this edition removed.

Both dangling cross-references in this book are of the same form, and both were found the only way such things are found: by following the pointer.

What the chapter does not settle

Anomaly-based detection. Recognising an attack nobody has recorded requires separating unusual traffic from wrong traffic, and section 8.9.2 calls that an extremely challenging problem. Most deployments remain signature-based, which means blind to new attacks by construction.

Trust. Every certificate is checked with another public key, and the chain has to end somewhere. It ends in keys that arrive with your browser, trusted for where they came from rather than because of a signature. Section 8.3.3’s phrase for this is worth keeping: what a tangled web of trust we spin.

Check yourself

Chapter 8 — check yourself

0 of 8 answered
  1. 1.Why does section 8.9 — firewalls and intrusion detection — come last?

  2. 2.PGP uses digital signatures for message integrity, while TLS and IPsec use message authentication codes. Why the difference?

  3. 3.predictIn the four-protocols grid, the freshness row is empty for PGP. What does that mean in practice?

  4. 4.Which primitive appears in all four of PGP, TLS, IPsec and WPA?

  5. 5.Why is security provided at four layers rather than only at the network layer?

  6. 6.Three of the chapter's five book slips are in Table 8.3. What is wrong with them, and why does the example still work?

  7. 7.The three kinds of firewall form a ladder. What increases as you climb it?

  8. 8.Both of the book's dangling cross-references share a form. What is it?

The chapter in three lines

  • Every protocol here is the same few parts, rearranged. A block cipher, a hash function, a public/private key pair and a nonce — and the differences between PGP, TLS, IPsec and WPA (WiFi Protected Access) are mostly about which of them the setting already has.

  • Signing and authenticating are not the same, and neither is encrypting. A message authentication code proves the sender held a shared secret. A signature proves one person specifically, and costs an infrastructure to say so. Both leave the message readable unless something else encrypts it.

  • The last section uses none of it. A boundary is defended by deciding what to let past, and the three kinds of firewall differ only in how much of each packet they are allowed to look at.