Networking Fundamentals: Learn How the Internet Really Work

In this session, we introduce the foundational concepts of networking, establishing its core purpose: to enable communication and data exchange between two or more individual entities, or "nodes." The session explains the minimum requirements for two computers to form a network, emphasizing the need for a physical connection, network interface cards, and unique IP addresses. It also provides a high-level introduction to the OSI model as a framework for understanding network communication layers.

Key topics covered include:

• The primary goal of networking: to exchange data and information.

• The essential physical components: a medium (wired or wireless) and network cards.

• The role of an IP address as a unique identifier for devices on a network.

• An introduction to the OSI model, positioning the physical medium at Layer 1 and IP addressing at Layer 3.

By the end of this session, you will understand what a network is at its most basic level and the fundamental components required for any two computers to communicate with each other.

This session explores the practical methods for connecting multiple computers, contrasting different network layouts and introducing the essential hardware that makes a local network function. It focuses on the "star topology" as a common and efficient design, and clearly differentiates between the roles of a switch (for same-network communication) and a router (for connecting different networks). The session concludes with a practical demonstration of the ping command as a primary tool for verifying network connectivity.

Key topics covered include:

• An overview of network topologies, focusing on the practical advantages of the star topology.

• The distinct functions of core network devices: switches and routers.

• How to find a computer's IP address and network name on both Windows and Linux.

• Using the ping command to test and confirm network connectivity.

• How to interpret ping results, such as round-trip time, to gauge connection quality.

By the end of this session, you will understand how multiple computers are connected in a typical network and know how to use the ping command to perform basic connectivity tests and troubleshooting.

In this session, we explain that a network protocol is a set of rules, much like a language, that dictates how data is interpreted and processed by a receiving computer. Using practical examples, it shows how a protocol like SSH can instruct a remote system to execute a command rather than just display text. The session focuses heavily on ICMP, the protocol that powers the ping utility, highlighting its critical role in network diagnostics and troubleshooting through its system of feedback messages.

Key topics covered include:

• The definition of a protocol as a "language" for network communication.

• A demonstration of how the SSH protocol interprets data as commands.

• The function of ICMP (Internet Control Message Protocol) as the foundation of ping.

• Understanding ICMP messages (e.g., "host unreachable") for network troubleshooting.

• Classifying common protocols (HTTP, SMTP, SSH) as part of the Application Layer (Layer 7) in the OSI model.

By the end of this session, you will understand the critical function of protocols in network communication and be able to recognize how different protocols like ICMP and SSH serve distinct purposes.

This session demystifies the roles of the upper layers of the OSI model—specifically the Presentation and Session Layers—using a simple web browsing example. It explains that the Presentation Layer is responsible for ensuring data is in a usable format, while the Session Layer manages the dialogue between the two communicating devices. The session emphasizes how HTTP headers, such as "Content-Type," instruct a browser how to properly render a webpage instead of displaying raw code.

Key topics covered include:

• The flow of an HTTP/HTTPS "GET" request from a browser to a server.

• The function of the Presentation Layer (Layer 6) in data formatting and translation.

• The importance of the "Content-Type" header for correctly displaying web content.

• The basic structure of a network packet, consisting of a header and a payload.

• Why the TCP/IP model combines the Application, Presentation, and Session layers into a single layer.

By the end of this session, you will understand the distinct responsibilities of the Presentation and Session layers and how they work together with the Application Layer to deliver a seamless user experience

In this session, we move from theory to practice by dissecting the structure of a network packet using the Linux ping command as a live example. It breaks down the packet into its constituent parts—the IP header, ICMP header, and data payload—and explains the meaning of the byte counts seen in the ping output. The session introduces tcpdump, a powerful command-line tool for capturing and inspecting network packets in real-time, and even demonstrates how to manipulate a packet's payload to send custom data.

Key topics covered include:

• The anatomical breakdown of a network packet (IP header, protocol header, payload).

• Understanding the byte sizes of each component within an ICMP packet.

• An introduction to tcpdump for capturing and analyzing live network traffic.

• A practical demonstration of crafting a ping request with a custom data payload.

• The concept of using ping as a covert channel for data transmission.

By the end of this session, you will have a concrete understanding of a network packet's structure and be able to use tcpdump to capture and analyze traffic on your own network.

This session elevates your networking skills by teaching you how to build custom network packets from scratch using the Scapy library in Python. Moving beyond standard tools, this hands-on tutorial provides a step-by-step guide to programmatically constructing, sending, and analyzing your own raw packets. This approach offers unparalleled control, making it an essential skill for advanced network testing, debugging, and security analysis.

Key topics covered include:

• An introduction to the Scapy library for raw packet manipulation.

• Writing a Python script to construct a custom ICMP packet.

• Defining packet layers, including the destination IP and a custom data payload.

• Sending the crafted packet and using tcpdump to verify its transmission.

• Capturing the reply and analyzing its headers and payload.

• Demonstrating IP spoofing by setting a fake source IP address in the packet header.

By the end of this session, you will be able to write a simple Python script to create, send, and analyze custom network packets, opening the door to advanced network experimentation.

In this session, we explore the two primary protocols of the Transport Layer: TCP and UDP. It clearly distinguishes between TCP's reliable, connection-oriented approach and UDP's fast, connectionless method. Using the analogies of a "phone call" for TCP and an "SMS text message" for UDP, the session explains why one is built for guaranteed delivery while the other is built for speed, making them suitable for different types of applications.

Key topics covered include:

• The concept of reliable communication and TCP’s three-way handshake (SYN, SYN-ACK, ACK).

• The concept of unreliable communication and UDP's "fire-and-forget" approach.

• Why TCP is ideal for applications where data integrity is critical (e.g., file transfers, email).

• Why UDP is the preferred choice for real-time applications where speed is essential (e.g., live video streaming, online gaming).

• The trade-off between reliability (TCP) and speed (UDP).

By the end of this session, you will understand the fundamental differences between TCP and UDP and be able to identify which protocol is appropriate for various network applications.

This session explains two critical networking concepts: the Domain Name System (DNS) and port numbers. It describes DNS as the "phonebook of the internet," responsible for translating human-friendly domain names into computer-friendly IP addresses. The session demonstrates how DNS queries use the fast UDP protocol. It then introduces port numbers as a mechanism for directing incoming data to the correct application (e.g., a web server vs. an email server) running on a single machine.

Key topics covered include:

• The function of DNS in resolving domain names to IP addresses.

• A practical demonstration of a DNS lookup using ping and tcpdump.

• The role of port numbers in identifying specific network services or applications.

• How the Transport Layer (Layer 4) uses source and destination ports to manage conversations.

• The distinction between well-known ports (for servers) and ephemeral ports (for clients).

By the end of this session, you will understand how your computer finds a server using DNS and how it uses port numbers to ensure data gets to the right application.

In this session, we cover the management of a network connection from beginning to end, focusing on the role of the Session Layer (Layer 5). It explains how TCP flags like FIN (finish) and RST (reset) are used to gracefully establish, maintain, and terminate a communication session. Building on this knowledge, the session provides an introduction to Scapy, a versatile Python library that allows you to programmatically create and manipulate your own raw network packets for advanced testing and analysis.

Key topics covered include:

• An overview of the client-server communication model.

• The role of the Session Layer in managing the dialogue between devices.

• Understanding TCP flags and their use in controlling a session's lifecycle.

• An introduction to the Scapy library and its interactive shell.

• A first look at creating a basic IP packet and inspecting its default headers using Scapy.

By the end of this session, you will understand how a network session is managed and have taken the first steps in using a professional tool to craft your own network packets.

This session provides a complete, hands-on demonstration of building and sending custom TCP packets to a live server in the cloud. Using Scapy, you will learn to construct a TCP SYN packet and analyze the server's response in different scenarios—first when a port is closed, and then after a service is started to open the port. This practical exercise makes the theory of the three-way handshake tangible and easy to understand.

Key topics covered include:

• Launching a cloud server on AWS to serve as a live target.

• Using Scapy to craft a TCP packet targeting a specific IP and port (port 80).

• Analyzing the server's RST (Reset) response, which indicates a closed port.

• Installing a web server to open port 80 and put it in a "listening" state.

• Observing the correct SYN-ACK response from the server, confirming the port is open.

• Using the netstat command to view listening ports and active connections on a server.

By the end of this session, you will have successfully crafted a TCP packet, sent it to a live server, and analyzed the response, giving you practical experience with the TCP connection process.

This session focuses on the practical application of crafting custom UDP packets using Scapy. It guides you through building a complete UDP packet, including IP and UDP layers as well as a custom data payload. You will send this packet to a live cloud server and learn how to configure the server to receive it and even send a reply, establishing a basic two-way communication channel using a connectionless protocol.

Key topics covered include:

• Constructing a multi-layer UDP packet with a custom payload in Scapy.

• Configuring a cloud server's firewall to accept incoming UDP traffic.

• Sending the custom packet and capturing it on the server with tcpdump.

• Using the netcat (nc) utility to create a simple UDP listener on the server.

• Establishing two-way communication by sending a reply from the netcat listener back to the Scapy script.

• Demonstrating that UDP communication is possible even without a formal "listening" service.

By the end of this session, you will be able to create and send UDP packets with custom data and set up a simple listener to capture data and send replies, completing your practical knowledge of both TCP and UDP.