IP Addressing, Subnetting, and CIDR

Overview

• What you’ll learn: IPv4 address structure, address classes, private ranges, subnet masks, CIDR notation, how to calculate subnets, and an introduction to IPv6.
• Prerequisites: Lesson 11 – OSI Model and TCP/IP Protocol Suite
• Estimated reading time: 22 minutes

Introduction

IP addresses are the fundamental identifiers that allow devices to communicate on a network. Every server, workstation, router, and IoT device needs at least one IP address to participate in network communication. Understanding how IP addresses work, how to divide networks into subnets, and how CIDR notation simplifies addressing is essential for any Linux system administrator.

In this lesson, you will learn the structure of IPv4 addresses, the concept of address classes and private ranges, how subnet masks define network boundaries, and how CIDR provides a flexible way to allocate addresses. We will also introduce IPv6, the next generation of IP addressing.

IPv4 Address Structure

An IPv4 address is a 32-bit number, typically written in dotted decimal notation as four octets separated by dots. Each octet represents 8 bits, with values ranging from 0 to 255.

# IPv4 address structure
192.168.1.10

# Binary representation
11000000.10101000.00000001.00001010

# Each octet is 8 bits (32 bits total)
# Octet 1: 192 = 11000000
# Octet 2: 168 = 10101000
# Octet 3: 1   = 00000001
# Octet 4: 10  = 00001010

# View your IP address on Linux
$ ip addr show ens33
2: ens33: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500
    inet 192.168.1.10/24 brd 192.168.1.255 scope global ens33
       valid_lft forever preferred_lft forever
    inet6 fe80::20c:29ff:feab:cdef/64 scope link
       valid_lft forever preferred_lft forever

Network and Host Portions

Every IP address is divided into two parts: the network portion (identifies which network the device belongs to) and the host portion (identifies the specific device on that network). The subnet mask determines where the division occurs.

# IP address:    192.168.1.10
# Subnet mask:   255.255.255.0
#
# Network part:  192.168.1.0     (first 24 bits)
# Host part:     .10             (last 8 bits)
#
# Binary breakdown:
# IP:    11000000.10101000.00000001.00001010
# Mask:  11111111.11111111.11111111.00000000
# Net:   11000000.10101000.00000001.00000000  (AND operation)

Address Classes (Historical)

Originally, IPv4 addresses were divided into five classes. While classful addressing has been replaced by CIDR, understanding classes helps when reading older documentation:

• Class A (1.0.0.0 – 126.255.255.255): /8 mask. 126 networks, ~16.7 million hosts each.
• Class B (128.0.0.0 – 191.255.255.255): /16 mask. 16,384 networks, ~65,534 hosts each.
• Class C (192.0.0.0 – 223.255.255.255): /24 mask. ~2.1 million networks, 254 hosts each.
• Class D (224.0.0.0 – 239.255.255.255): Multicast addresses.
• Class E (240.0.0.0 – 255.255.255.255): Reserved for experimental use.

Private IP Address Ranges

RFC 1918 defines three private address ranges that are not routable on the public Internet. These are used within internal networks and are translated to public addresses via NAT (Network Address Translation):

# Private IP ranges (RFC 1918)
10.0.0.0/8        10.0.0.0    – 10.255.255.255      (16,777,216 addresses)
172.16.0.0/12     172.16.0.0  – 172.31.255.255      (1,048,576 addresses)
192.168.0.0/16    192.168.0.0 – 192.168.255.255     (65,536 addresses)

# Special addresses
127.0.0.0/8       Loopback (localhost)
169.254.0.0/16    Link-local (APIPA, when DHCP fails)
0.0.0.0           "Any" address (used for default routes and binding)
255.255.255.255   Broadcast address

Subnet Masks

A subnet mask is a 32-bit number that masks the network portion of an IP address. It consists of consecutive 1s (network bits) followed by consecutive 0s (host bits).

# Common subnet masks
/8   = 255.0.0.0         (Class A default)
/16  = 255.255.0.0       (Class B default)
/24  = 255.255.255.0     (Class C default)
/25  = 255.255.255.128   (2 subnets from a /24)
/26  = 255.255.255.192   (4 subnets from a /24)
/27  = 255.255.255.224   (8 subnets from a /24)
/28  = 255.255.255.240   (16 subnets from a /24)
/30  = 255.255.255.252   (Point-to-point links, 2 usable hosts)
/32  = 255.255.255.255   (Single host route)

CIDR Notation

CIDR (Classless Inter-Domain Routing) was introduced in 1993 to replace classful addressing and slow the exhaustion of IPv4 addresses. CIDR uses a suffix notation indicating how many bits form the network prefix.

# CIDR notation examples
192.168.1.0/24     # 256 addresses (254 usable hosts)
10.0.0.0/8         # 16,777,216 addresses
172.16.0.0/12      # 1,048,576 addresses
192.168.1.0/26     # 64 addresses (62 usable hosts)

# Calculate usable hosts: 2^(32-prefix) - 2
# /24: 2^8 - 2  = 254 usable hosts
# /26: 2^6 - 2  = 62 usable hosts
# /30: 2^2 - 2  = 2 usable hosts
# /27: 2^5 - 2  = 30 usable hosts

Subnetting in Practice

Subnetting is the process of dividing a larger network into smaller sub-networks. This improves security, reduces broadcast domains, and makes efficient use of address space.

Subnetting Example

# Given: 192.168.1.0/24 — divide into 4 equal subnets
#
# We need 2 extra bits (2^2 = 4 subnets), so /24 becomes /26
# Each subnet has 2^6 = 64 addresses (62 usable)
#
# Subnet 1: 192.168.1.0/26    (hosts: .1 – .62,   broadcast: .63)
# Subnet 2: 192.168.1.64/26   (hosts: .65 – .126,  broadcast: .127)
# Subnet 3: 192.168.1.128/26  (hosts: .129 – .190, broadcast: .191)
# Subnet 4: 192.168.1.192/26  (hosts: .193 – .254, broadcast: .255)

# Verify with ipcalc (install: sudo apt install ipcalc)
$ ipcalc 192.168.1.0/26
Address:   192.168.1.0          11000000.10101000.00000001.00 000000
Netmask:   255.255.255.192 = 26 11111111.11111111.11111111.11 000000
Wildcard:  0.0.0.63             00000000.00000000.00000000.00 111111
=>
Network:   192.168.1.0/26       11000000.10101000.00000001.00 000000
HostMin:   192.168.1.1          11000000.10101000.00000001.00 000001
HostMax:   192.168.1.62         11000000.10101000.00000001.00 111110
Broadcast: 192.168.1.63         11000000.10101000.00000001.00 111111
Hosts/Net: 62                    Class C, Private Internet

Configuring a Subnet on Linux

# Add an IP address with a /26 subnet
$ sudo ip addr add 192.168.1.65/26 dev ens33

# Verify the configuration
$ ip addr show ens33
2: ens33: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500
    inet 192.168.1.65/26 brd 192.168.1.127 scope global ens33

# Check which subnet an address belongs to
$ ipcalc 192.168.1.100/26
Network:   192.168.1.64/26
HostMin:   192.168.1.65
HostMax:   192.168.1.126
Broadcast: 192.168.1.127

IPv6 Introduction

IPv6 uses 128-bit addresses, providing a vastly larger address space than IPv4. Addresses are written as eight groups of four hexadecimal digits separated by colons.

# IPv6 address format
2001:0db8:85a3:0000:0000:8a2e:0370:7334

# Simplified (leading zeros dropped, consecutive zero groups replaced with ::)
2001:db8:85a3::8a2e:370:7334

# Common IPv6 addresses
::1                     # Loopback (equivalent to 127.0.0.1)
fe80::/10               # Link-local addresses
2000::/3                # Global unicast addresses
ff00::/8                # Multicast addresses

# View IPv6 addresses on Linux
$ ip -6 addr show
1: lo: <LOOPBACK,UP,LOWER_UP>
    inet6 ::1/128 scope host
2: ens33: <BROADCAST,MULTICAST,UP,LOWER_UP>
    inet6 fe80::20c:29ff:feab:cdef/64 scope link
    inet6 2001:db8::10/64 scope global

Key Takeaways

• IPv4 addresses are 32-bit numbers written in dotted decimal notation; each address has a network and host portion defined by the subnet mask.
• Private ranges (10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16) are reserved for internal networks and are not routed on the Internet.
• CIDR notation (/prefix) replaces classful addressing, allowing flexible allocation of IP address blocks.
• Subnetting divides larger networks into smaller segments, improving organization, security, and efficiency.
• Use ipcalc to quickly compute network, broadcast, and host ranges for any CIDR block.
• IPv6 provides 128-bit addresses, solving the IPv4 exhaustion problem and simplifying network configuration with features like auto-configuration.

What’s Next

In Lesson 13, you will learn Socket Programming Fundamentals — how applications communicate over the network using the socket API, with hands-on examples using Python and netcat.