Course 4 - Computer Networks
CS 6250 · Difficulty: 3/5
Brief Overview
This course covers how the Internet actually works, from the link layer up through routing policy and content delivery. It moves through switching and intra-domain routing, inter-domain routing with BGP, software defined networking, and modern topics like CDNs, IXPs, and network security.
The course centers on five hands-on projects:
- Implement the Spanning Tree Protocol to prevent forwarding loops in switched networks.
- Build the Distance Vector routing algorithm (Bellman-Ford) with support for handling negative cycles.
- Develop a configurable SDN firewall using POX and OpenFlow that filters traffic based on packet header fields.
- Measure real-world BGP behavior using PyBGPStream and historical routing data.
- Demonstrate a BGP hijacking attack in an emulated multi-AS network built with Mininet and FRR.
Detailed Overview
Course Structure
Class is broken into lectures, quizzes/exams, and five projects. Lectures cover the classic networking stack topics but spend more time than most courses on the operational Internet: BGP policy and business relationships, router architecture, packet classification, traffic scheduling, CDNs and DNS, and DDoS mitigation.
Project 1: Spanning Tree Protocol
Implement a simplified Spanning Tree Protocol in Python over a simulated network topology.
- Each switch runs the same distributed logic, exchanging messages with neighbors to elect a root and determine which links to keep active.
- The end result is a loop-free logical topology over an arbitrary physical one.
Difficulty: 2/5
Summary: Gentle introduction. The concept is simple but it forces you to think in terms of distributed algorithms where each node only has local information.
Project 2: Distance Vector Routing
Implement the Bellman-Ford based Distance Vector algorithm across a simulated topology.
- Each node maintains a distance vector and advertises it to neighbors, iterating until convergence.
- Must correctly handle link changes and negative cycles in the topology.
Difficulty: 2/5
Summary: Straightforward if you understand Bellman-Ford. The edge cases around cycles are where the points hide.
Project 3: SDN Firewall
Build a configurable firewall on top of the POX OpenFlow controller.
- Firewall rules are defined in a configuration file and parsed into OpenFlow flow-table entries pushed to switches.
- Rules match on header fields like source/destination IP, protocol, and port ranges, with support for both blocking and explicitly allowing traffic.
- Tested against a provided suite covering rule precedence and edge cases.
Difficulty: 3/5
Summary: The most software-engineering-flavored project of the course. Getting every test to pass is mostly about carefully handling rule matching and precedence rather than deep networking theory.
Project 4: BGP Measurements
Analyze real historical BGP routing data using PyBGPStream.
- Process BGP update and RIB dumps to measure things like routing table growth, AS path lengths, and announcement/withdrawal dynamics over time.
- Work with large real-world datasets rather than simulated networks.
Difficulty: 3/5
Summary: Less about networking code, more about data processing. The datasets are large enough that inefficient code becomes painful, so it doubles as an exercise in writing performant Python.
Project 5: BGP Hijacking
Demonstrate a prefix hijacking attack in an emulated network of six autonomous systems built with Mininet and FRR routing software.
- Configure BGP peering between multiple ASes and observe legitimate route propagation.
- Launch a rogue AS that announces a more-specific prefix, redirecting traffic away from the legitimate origin.
- Observe the attack and recovery through router tables and end-to-end connectivity tests.
Difficulty: 3/5
Summary: The most interesting project conceptually — you get to see why the Internet's trust-based routing is fragile, using the same routing software real networks run. Configuration debugging in FRR is its own skill.
Overall
Difficulty: 3/5
Summary: Lighter workload than GIOS, with projects that are more guided and self-contained. The value is breadth: after this course the Internet stops being a black box. Exams require real studying since the lecture material is wide-ranging, but the projects are very manageable if you're comfortable with Python.