Route summarisation (supernetting): combining networks into one route, step by step

Summarisation (also called supernetting or route aggregation) is the opposite of subnetting: combining several networks into one bigger route. Instead of telling the whole network about every small subnet at a branch, the branch router advertises a single summary. Routers then need fewer entries, use less memory and CPU, converge faster after changes, and a problem in one small subnet (a link flapping up and down) doesn't disturb routers far away.

The internet depends on it: ISPs receive large blocks and advertise one route for thousands of customers. Without summarisation, the global routing table would be unmanageable.

A first example

A branch office uses:

192.168.8.0/24
192.168.9.0/24
192.168.10.0/24
192.168.11.0/24

Instead of four routes, the head office can use one: 192.168.8.0/22.

Method 1: binary

1. Write the changing octet of each network in binary (the octets before it are identical):

 8 = 000010 00
 9 = 000010 01
10 = 000010 10
11 = 000010 11

1. Count the bits that are the same from the left: the first 6 bits (000010) match.
2. Summary prefix = bits in the earlier octets + matching bits = 16 + 6 = /22.
3. Summary address = the matching bits followed by zeros: 00001000 = 8 → 192.168.8.0/22.

Method 2: block sizes (faster)

1. Count the networks: 4 consecutive /24s.
2. Is the count a power of 2? 4 = 2² → the summary is 2 bits shorter: /24 − 2 = /22.
3. Does the first network sit on a boundary of that size? A /22 has a block size of 4 in the third octet: valid starts are 0, 4, 8, 12... 8 is a multiple of 4 ✓.
4. Summary: 192.168.8.0/22.

If the first network isn't on the boundary, the summary must be bigger (and will include extra networks).

More examples

import ipaddress
groups = [
    ["192.168.8.0/24", "192.168.9.0/24", "192.168.10.0/24", "192.168.11.0/24"],
    ["172.16.32.0/24", "172.16.47.0/24"],     # endpoints only: the smallest supernet that holds both
    ["10.1.4.0/24", "10.1.7.0/24"],
]
for nets in groups:
    nets = [ipaddress.ip_network(n) for n in nets]
    summary = nets[0]
    while not all(n.subnet_of(summary) for n in nets):
        summary = summary.supernet()
    print(", ".join(map(str, nets)), "->", summary)

Check the summary

A summary /p covers 2^(32 − p) addresses. For 192.168.8.0/22: 2¹⁰ = 1,024 = 4 × 256 → exactly 192.168.8.0 to 192.168.11.255 ✓.

Careful: over-summarisation

Networks 172.16.4.0/24 and 172.16.7.0/24 share the first 6 bits of the third octet (000001), giving 172.16.4.0/22. But that summary also includes 172.16.5.0 and 172.16.6.0. If those networks are at another site, routers will send their traffic to the wrong place.

Even worse, if the summarising router receives traffic for a network inside the summary that doesn't exist, it may drop it or bounce it around. Routers usually add a route to Null0 (a "discard" route) for the summary to prevent loops; traffic for non-existent subnets is quietly dropped. That's the safe behaviour, but it means a misplaced summary can create a black hole for real networks elsewhere.

Only summarise address space that really lives behind that router.

Non-contiguous networks

Networks 192.168.1.0/24 and 192.168.3.0/24 can't be summarised exactly: the smallest summary is 192.168.0.0/22, which also covers .0 and .2. Options: advertise them separately, or redesign addressing.

Designing for summarisation

Good IP plans make summaries natural:

• Give each site or region a contiguous, power-of-two block: Nairobi 10.1.0.0/16, Mombasa 10.2.0.0/16, Kisumu 10.3.0.0/16.
• Inside each site, subnet from its block (10.1.10.0/24, 10.1.20.0/24...).
• The core then needs only one route per site: 10.1.0.0/16 via the Nairobi router.

Where summaries are configured

Why providers love CIDR

Internet providers receive big blocks and advertise one route to the rest of the internet, while splitting it into thousands of customer subnets inside. The global IPv4 routing table has around a million routes instead of billions, because of aggregation.

Summary

• Summarisation combines contiguous networks into one shorter-prefix route, shrinking routing tables and hiding instability.
• Binary method: count matching bits; block method: power-of-two count starting on a boundary.
• Verify the summary covers exactly the intended networks; over-summarising sends traffic to the wrong place.
• Design addressing per site in contiguous power-of-two blocks so summaries are clean.
• Configure summaries in static routes, OSPF, EIGRP and BGP.