Binary, IPv4, and Subnets

The IPv4 protocol which we broadly (but not totally) use today rests on an addressing system that was designed in the 1970s and formally published in 1980. It uses quad dotted 32 bit addresses, which can be written in various notations, and a straightforward subnetting scheme.

Binary

For example, the address 1.0.0.1, which belongs to CloudFlare, is constituted by four separate octets, 1, 0, 0, and 1. We can convert these numbers into alternative representations like binary, which is a number N base-2, N₂. And octets here are simply integers ranging from 0 to 255. Each digit in the binary number represents a power of 2, starting from the rightmost digit, the least significant bit, and then you multiply it by either 0 or 1. For example!

0 = 0 = (2^0 * 0)
1 = 1 = (2^0 * 1)
2 = 10 = (2^1 * 1) + (2^0 * 0)
3 = 11 = (2^1 * 1) + (2^0 * 1)
4 = 100 = (2^2 * 1) + (2^1 * 0) + (2^0 * 0)
5 = 101 = (2^2 * 1) + (2^1 * 0) + (2^0 * 1)
6 = 110 = (2^2 * 1) + (2^1 * 1) + (2^0 * 0)
7 = 111 = (2^2 * 1) + (2^1 * 1) + (2^0 * 1)
8 = 1000 = (2^3 * 1) + (2^2 * 0) + (2^1 * 0) + (2^0 * 0)
9 = 1001 = (2^3 * 1) + (2^2 * 0) + (2^1 * 0) + (2^0 * 1)

Decimal to Binary

To find the binary of a number like 3, we repeatedly divide by 2 and note the remainder each time. First, 3 ÷ 2 gives a remainder of 1, then 1 ÷ 2 gives another remainder of 1. Reading the remainders from bottom to top, we get "11" as the binary representation of 3.

Binary to Decimal

But how do we convert a binary representation of three back to decimal form? The number three is "11" in binary representation.

So we calculate by powers of 2 from our left most significant bit N, to the right least significant bit, which is 0, e.g. from 2^N to 2^0. And each time, we multiply this value by the binary value, 0 or 1, of each individual digit, like this. Then we take the sum of this sequence. For example, for the binary representation of three, which is "11":

(2^1 * 1) + (2^0 * 1) = 2 + 1 = 3

And for the binary representation of two, which is "10", we do this:

(2^1 * 1) + (2^0 * 0) = 2 + 0 = 2

Altogether, we expand this notion and use the 8 bit standard to construct a byte representation our possible octet values from 0 to 255. And we write them like this:

0 = 00000000 
1 = 00000001
2 = 00000010
..
254 = 11111110
255 = 11111111

32-bit addressing

Why does this matter? Well, it's applicable to almost anything involving networks. For example, the first digit in CloudFlare's DNS IPv4 address, 1.0.0.1, is represented by 1₂. And the second digit, 0, by 0₂. And so on. This format follows for any other numbers in an IP address. And altogether, we can rewrite the address 1.0.0.1 in binary like so:

00000001.00000000.00000000.00000001

We say this binary represents an address within the 32-bit IPv4 addressing system. That is, each IP address is composed of four 8-bit octets. And every address has 32 bits. And each bit can be 1 or 0.

Therefore, we say there are 2³² possible IPv4 addresses, or approximately 4.3 billion possible unique addresses.

IPv4 Subnetting

Subnets are a strategy for dividing IP addresses into subnetwork blocks. This involves what we call "subnet masks" which are used to delineate different classes of subnets.

Each subnet mask corresponds to a number of bits assigned for network addressing, with the rest of the bits left for hosts. Subnet classes are as follows:

Class A (0-127): For large organizations. The first byte is used for the network, and the last three bytes are for hosts. E.g. 10.0.0.0 to 10.255.255.255.

Class B (128-191): For medium-sized networks. The first two bytes are for the network, and the last two are for hosts. E.g. 152.93.0.0 to 152.93.255.255.

Class C (192-223): For small networks. The first three bytes define the network, and the last byte is for hosts. E.g. 200.10.10.0 to 200.10.10.255.

Class D (224-239): Used for multicast, not for general public use.

Class E (240-255): Reserved for research, not used in the public sector.

But to get a better understanding and visualize it, each IP range delineates an address or range of addresses.

For example, 10.0.0.1/32 refers to a single machine. While 0.0.0.0/0 refers to the entire address space of possible IP4 addresses. A subnet mask is a bitmask that denotes how many bits are used for networking and which are for hosting.

/0 - 0.0.0.0 
/1 - 128.0.0.0
/2 - 192.0.0.0
/3 - 224.0.0.0
/4 - 240.0.0.0
/5 - 248.0.0.0
/6 - 252.0.0.0
/7 - 254.0.0.0
/8 - 255.0.0.0 (Class A)
/9 - 255.128.0.0
/10 - 255.192.0.0
/11 - 255.224.0.0
/12 - 255.240.0.0
/13 - 255.248.0.0
/14 - 255.252.0.0
/15 - 255.254.0.0
/16 - 255.255.0.0 (Class B)
/17 - 255.255.128.0
/18 - 255.255.192.0
/19 - 255.255.224.0
/20 - 255.255.240.0
/21 - 255.255.248.0
/22 - 255.255.252.0
/23 - 255.255.254.0
/24 - 255.255.255.0 (Class C)
/25 - 255.255.255.128
/26 - 255.255.255.192
/27 - 255.255.255.224
/28 - 255.255.255.240
/29 - 255.255.255.248
/30 - 255.255.255.252
/31 - 255.255.255.254 (Used for point-to-point links)
/32 - 255.255.255.255 (Single IP address)

In practical terms, a /24 network has 254 usable IP addresses for devices, while a /30 network has only 2 usable IP addresses, with the remaining two being reserved for the network and broadcast addresses.

For example, the subnet mask for the /30 block is 255.255.255.252. In binary, this address converts to the values:

11111111.11111111.11111111.11111100

This particular subnet mask assigns 30 bits to network addressing, leaving us only 2 bits for our own possible host addressing. Because IPv4 is a 32 bit system.

And we're using base-2, so we take the 2 leftover bits for hosting and raise it to the number of leftover bits we have, which in this case is 2.

So we say 2² leaves us with a resulting 4 possible host addresses.

For example, we can take our IP address 1.0.0.1, and subnet mask 255.255.255.252, and perform a bitwise AND operation:

00000001.00000000.00000000.00000001
AND
11111111.11111111.11111111.11111100

-------

00000001.00000000.00000000.00000000

We have taken the IP address and subnet mask, and compared the binary of each corresponding bit. In an AND operation, if we have 0 and 0, the result is 0. If we have 1 and 0, the result is 0. But if we have 1 and 1, the result is 1. Here, this gives us the network address of the range. It produces the binary output equivalent to 1.0.0.0, which is our base network address.

And following our rule for calculating the host addresses using the leftover bits we have, we say we have 2², or 4 IPv4 addresses, including our network address: 1.0.0.0, 1.0.0.1, 1.0.0.2, and 1.0.0.3.

The lower address, 1.0.0.0, is the network address, while the upper address, 1.0.0.3, denotes the broadcast address. The two addresses between, 1.0.0.1 and 1.0.0.2, denote the actual usable host range.

If we were calculating 1.0.0.1 with the /29 block, subnet 255.255.255.248, we would have 29 bits set to network addressing and 3 bits for our own host addressing. So we would again take 2 and raise it to the number of free bits we have: 2³, which gives us 8. Hence, the 8 addresses, with our actual usable range in between the network and broadcast addresses:

1.0.0.0 (Network address)
1.0.0.1
1.0.0.2
1.0.0.3
1.0.0.4
1.0.0.5
1.0.0.6
1.0.0.7 (Broadcast address)

Some useful references:

Understand TCP/IP addressing and subnetting basics

RFC 971, the original IPv4 Specification