IPv4 Addressing and Subnetting Basics

Mastering IPv4 addressing is not just a certification requirement; it is the fundamental skill that underpins all modern network design, troubleshooting, and administration. For your CCNA exam and real-world networking career, the ability to confidently manipulate IP addresses, determine network boundaries, and allocate subnets efficiently separates competent technicians from expert network engineers.

The Binary Foundation of IPv4

Every IPv4 address is a 32-bit binary number, but for human readability, it is expressed in dotted-decimal notation—four decimal numbers separated by periods, like 192.168.1.1. Each of these four numbers, called an octet, represents 8 bits, with a decimal range from 0 to 255.

The core skill is seamless conversion between decimal and binary. The 8 bits in an octet have positional values, from left to right: 128, 64, 32, 16, 8, 4, 2, 1. To convert decimal 192 to binary, you ask: Does 192 fit into 128? Yes. Subtract: 192 - 128 = 64. Does 64 fit into 64? Yes. Subtract to zero. You place a '1' in the 128 and 64 positions and '0' in the rest: 11000000. The full address 192.168.1.1 in binary is 11000000.10101000.00000001.00000001. On the CCNA exam, you must be able to perform this conversion quickly and accurately for any octet.

IPv4 Address Structure and Classes

The 32-bit address is divided into two logical parts: the network portion and the host portion. The network portion identifies the specific network segment, while the host portion identifies an individual device on that segment. Historically, fixed boundaries were defined by address classes.

• Class A: The first octet is the network portion. The first bit is always 0. Range: 1.0.0.0 to 126.0.0.0. The default subnet mask is 255.0.0.0.
• Class B: The first two octets are the network portion. The first two bits are 10. Range: 128.0.0.0 to 191.255.0.0. The default subnet mask is 255.255.0.0.
• Class C: The first three octets are the network portion. The first three bits are 110. Range: 192.0.0.0 to 223.255.255.0. The default subnet mask is 255.255.255.0.
• Class D: Reserved for multicast (224.0.0.0 to 239.255.255.255).
• Class E: Reserved for experimental use (240.0.0.0 and above).

The subnet mask is a 32-bit value that uses consecutive 1s to identify the network portion and consecutive 0s to identify the host portion. For a Class C address like 192.168.1.0 with a default mask of 255.255.255.0, the first 24 bits (the three 255s) are network, and the last 8 bits (the 0) are host.

CIDR Notation and the Modern Subnet Mask

Classful addressing is inefficient. Classless Inter-Domain Routing (CIDR) introduced a flexible way to define the network/host boundary. CIDR notation appends a slash (/) followed by the number of bits in the network portion to the IP address. This number is called the prefix length.

The default masks translate directly to CIDR: 255.0.0.0 is /8, 255.255.0.0 is /16, and 255.255.255.0 is /24. The power of CIDR is that you can use masks that don't align with class boundaries, like 255.255.255.192, which is a /26 prefix (24 bits from the Class C plus 2 extra bits from the host portion "borrowed" for subnetting).

Calculating Network, Broadcast, and Usable Hosts

This is the critical math for subnetting. Given an IP address and its subnet mask (in CIDR or dotted-decimal form), you must find three key pieces of information for its subnet.

1. The Network Address: This is the first address in the subnet. It identifies the subnet itself. All host bits are set to 0.
2. The Broadcast Address: This is the last address in the subnet. It is used to send traffic to all hosts in that subnet. All host bits are set to 1.
3. Usable Host Addresses: These are all addresses between the network and broadcast addresses.

Let's calculate for 192.168.1.133/26.

• Step 1: Determine the subnet mask. /26 means the first 26 bits are network. In dotted-decimal, that's 255.255.255.192.
• Step 2: Find the interesting octet and block size. The mask changes in the fourth octet (192). The block size is 256 - 192 = 64. This is the number of addresses in each subnet.
• Step 3: Find the network address. List multiples of the block size (64) up to the value in the interesting octet (133): 0, 64, 128, 192. 133 falls between 128 and 192. Therefore, the network address is 192.168.1.128.
• Step 4: Find the broadcast address. The broadcast is the last address before the next network. The next network is 192.168.1.192, so subtract 1: 192.168.1.191.
• Step 5: Find usable hosts. All addresses between .129 and .190. The formula for the number of usable hosts is $2^{(32-prefixlength)}-2$. For /26, that's $2^{(6)}-2=64-2=62$ usable hosts.

Practical Subnetting for Efficient Design

Subnetting is the process of taking a large network and dividing it into smaller, more manageable sub-networks. You borrow bits from the host portion to create more network portions. This improves security, reduces broadcast traffic, and allows for efficient address allocation across different departments or geographic locations.

For example, you have the network 172.16.0.0/16. The Marketing department needs subnets for at least 400 hosts, and the IT department needs subnets for exactly 30 hosts. You must create these without wasting addresses.

• For Marketing: You need at least 400 hosts. Using the formula $2^n-2>=400$, $n$ (host bits) must be 9 (which gives 510 hosts). A /16 has 16 host bits. Borrowing 7 bits for subnetting (23 network bits total) gives you a /23 prefix. The subnet mask is 255.255.254.0. The first subnet for Marketing could be 172.16.0.0/23.
• For IT: You need exactly 30 hosts. $2^n-2>=30$ means $n=5$ (30 hosts). Borrowing 11 bits from the original /16 gives a /27 prefix (mask 255.255.255.224). The first subnet for IT could be 172.16.2.0/27.

Common Pitfalls

1. Confusing Network/Host Addresses with Usable Addresses: A common CCNA trap is asking for the "first usable host" or "last usable host." Remember, the network address (.128 in our example) and broadcast address (.191) are not usable for devices. The first usable is .129, and the last usable is .190. Always double-check what the question is asking for.

1. Misidentifying the Subnet Based on a Host IP: When given a host IP like 10.50.100.75/21, students often try to start calculations with the host number. You must always first find the network address (10.50.96.0) by zeroing out the host bits. All other calculations stem from the network address, not the given host IP.

1. Forgetting the "-2" in the Host Formula: The formulas for total addresses in a subnet is $2^{(hostbits)}$. The formula for usable device addresses is always $2^{(hostbits)}-2$, to account for the network and broadcast addresses. In modern networking, some contexts use the first and last addresses (like /31 point-to-point links), but for the CCNA and general use, the "-2" rule is essential.

1. Incorrect Block Size Calculation: The block size is the simplest way to find network boundaries. It is calculated as 256 minus the value in the interesting octet of the subnet mask. For a mask of 255.255.255.240, the block size is 256 - 240 = 16. Networks would be .0, .16, .32, etc. Mistaking this calculation will throw off every subsequent answer.

Summary

• An IPv4 address is a 32-bit binary number expressed in dotted-decimal notation, divided into network and host portions defined by a subnet mask.
• CIDR notation (/24) provides a flexible, classless way to represent the subnet mask by specifying the number of network bits.
• The network address (all host bits 0) and broadcast address (all host bits 1) define the boundaries of a subnet and cannot be assigned to devices.
• The number of usable hosts in a subnet is calculated with $2^{(32-prefixlength)}-2$.
• Subnetting involves borrowing host bits to create multiple smaller networks from a larger one, which is critical for efficient, scalable, and secure network design—a core competency tested on the CCNA exam.