-
Notifications
You must be signed in to change notification settings - Fork 2
/
cidr-calculator
299 lines (217 loc) · 9.12 KB
/
cidr-calculator
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
https://www.site24x7.com/tools/ipv4-subnetcalculator.html
Example 1
---------
20.20.0.0/20 --->2^12 = 4096/256=16 (32-20) 4+8=12
8.8.4.4.8
20.20.16.0/20
20.20.32.0/20
# Formula for calculating the number of IP addresses in a CIDR block
Number of IPs = 2^(32 - subnet mask)
# In this case, the subnet mask is 20
subnet_mask = 20
number_of_ips = 2 ** (32 - subnet_mask)
# The calculation would be:
Number of IPs = 2^(32 - 20) = 2^12
# Calculating the exact number
number_of_ips = 2 ** (32 - subnet_mask)
# Output the number of IPs in the CIDR block 20.20.32.0/20
("The CIDR block 20.20.32.0/20 contains", number_of_ips, "IP addresses.")
Example 2
----------
10.10.0.0/19 ---> 2^13 = 8192/256=32 (32-19) 5+8=13
8.8.3.5.8
10.10.0.0/19
10.10.32.0/19
10.10.64.0.0/19
Example 3
----------
10.205.0.0/22 ---> 2^10 = 1024/256=4 (32-22) 8+2=10
8.8.6.2.8
6 ---> means /22
11x4=44
12x4=48
Example 4
---------
10.10.0.0/16 ---> vpc
10.10.64.0/18 ---> 2^14 = 16,384/256=64 (32-18=14)
see /18 & count 8.8.2.6.8
/18 8+8+2 ---> remaining 6+8=14 see above (32-18=14)
10.10.128.0/18
(64+64)
10.10.192.0/18
(128+64)
To convert an IP address from decimal (like 192.168.13.10) to binary, follow these steps for each octet (each part of the IP address separated by a period).
Steps:
1. Convert Decimal to Binary:
Each octet (number) is converted to binary. Here's how to do it:
Start with the decimal number.
Repeatedly divide the number by 2, recording the remainder each time.
Continue until the quotient is 0.
The binary number is the sequence of remainders read from bottom to top (reverse order).
Example: Converting 192 to Binary
Divide 192 by 2:
192
÷
2
=
96
192÷2=96 remainder 0
Divide 96 by 2:
96
÷
2
=
48
96÷2=48 remainder 0
Divide 48 by 2:
48
÷
2
=
24
48÷2=24 remainder 0
Divide 24 by 2:
24
÷
2
=
12
24÷2=12 remainder 0
Divide 12 by 2:
12
÷
2
=
6
12÷2=6 remainder 0
Divide 6 by 2:
6
÷
2
=
3
6÷2=3 remainder 0
Divide 3 by 2:
3
÷
2
=
1
3÷2=1 remainder 1
Divide 1 by 2: (Note: which is not divisble by 2 put 1)
1
÷
2
=
0
1÷2=0 remainder 1
2. Repeat the process for each octet.
168:
Following the same process, the binary form of 168 is 10101000.
13:
For 13, divide and get 00001101.
10:
For 10, divide and get 00001010.
3. Combine the Binary Octets:
Now you combine each of the binary octets into a single 32-bit representation:
192 → 11000000
168 → 10101000
13 → 00001101
10 → 00001010
So, the full IP address 192.168.13.10 in binary is:
11000000.10101000.00001101.00001010
Each of these binary octets represents 8 bits, which is why IPv4 addresses are 32 bits (4 octets of 8 bits each).
Summary Table:
Decimal Binary
192 11000000
168 10101000
13 00001101
10 00001010
You can use this process to convert any decimal number to binary.
IP Address: The address "192.168.13.10" is shown in both decimal (the common format we use) and binary form (how computers process it).
The binary form of the IP is: 11000000 10101000 11001101 00001010.
Subnet Mask: The subnet mask "255.255.255.0" is used to divide the network and host portions of the IP address. The binary form of the subnet mask is: 11111111 11111111 11111111 00000000.
The subnet mask 255.255.255.0 in binary is: 11111111 11111111 11111111 00000000.
The "/24" means that the first 24 bits of the IP address are used for the network portion (the 1s in the subnet mask), and the remaining 8 bits (the 0s) are used for the host portion.
So, 255.255.255.0 and /24 represent the same network configuration.
The "1"s in the subnet mask indicate the network portion of the IP address, while the "0"s indicate the host portion.
Network Portion: In the image, the first three octets (192.168.13) represent the network part of the IP address, as indicated by the purple underlining. This is determined by the subnet mask (255.255.255.0), which has all 1's in the first three octets and 0's in the last octet.
Host Portion: The last octet (10) is the host portion, highlighted with a red underline. This part can vary within the network, representing different devices or systems within the same subnet.
Summary:
The network is represented by "192.168.13" (or 11000000 10101000 11001101 in binary).
The host within that network is represented by ".10" (or 00001010 in binary).
What is an IP Address?
An IP (Internet Protocol) address is like a home address for computers on a network. It helps devices find each other and communicate on the internet or local network. An IP address looks like this: 192.168.1.1 and is made up of four numbers (called octets), each ranging from 0 to 255.
IP Classes and Subnet Masks (CIDR Notation)
There are different "classes" of IP addresses, which help define how many devices (hosts) can exist in a network. Each class has a "subnet mask," which tells us how many parts of the IP address are used for the network (the home address) and how many parts are used for hosts (the specific rooms/devices in the home).
Let’s go class by class.
Class A (Large Networks)
Range: IP addresses from 1.0.0.0 to 126.255.255.255.
Example: 10.0.0.0/8
CIDR: /8 means that the first 8 bits are used for the network, and the rest of the bits (remaining 24 bits) are used for hosts.
Subnet Mask Calculation:
11111111.00000000.00000000.00000000 (in binary)
This is 255.0.0.0 in decimal.
Explanation:
Class A is used for very large networks, like ISPs or huge corporations. With /8, the first octet (10 in 10.0.0.0) is the network, and the rest are used for hosts, meaning it can support millions of devices.
Class B (Medium Networks)
Range: IP addresses from 128.0.0.0 to 191.255.255.255.
Example: 172.16.0.0/12 (this is part of Class B's private range)
CIDR: /12 means that the first 12 bits are used for the network, and the rest of the bits (remaining 20 bits) are for hosts.
Subnet Mask Calculation:
11111111.11110000.00000000.00000000 (in binary)
This is 255.240.0.0 in decimal.
Explanation:
Class B is used for medium-sized networks. With /12, the first 12 bits are for the network part (like 172.16), and the rest are for hosts. This allows up to thousands of devices on the network.
Class C (Small Networks)
Range: IP addresses from 192.0.0.0 to 223.255.255.255.
Example: 192.168.0.0/24
CIDR: /24 means that the first 24 bits are used for the network, and the remaining 8 bits are for hosts.
Subnet Mask Calculation:
11111111.11111111.11111111.00000000 (in binary)
This is 255.255.255.0 in decimal.
Explanation:
Class C is for small networks, like home or small business networks. With /24, the first 24 bits represent the network, and only 8 bits are for hosts, meaning it can support 254 devices.
Class D (Multicasting)
Range: IP addresses from 224.0.0.0 to 239.255.255.255.
Use: Class D is not used for regular devices. It’s used for multicasting, where one source sends data to a group of devices. Think of this like a live broadcast to multiple people.
Class E (Experimental)
Range: IP addresses from 240.0.0.0 to 255.255.255.255.
Use: Class E is reserved for experimental or research purposes and not used in normal networks.
How to Read CIDR Notation (/8, /12, /16, etc.)
CIDR Notation tells us how many bits in the IP address are used for the network part.
For example, /8 means 8 bits are for the network, and the remaining bits are for hosts.
/8 → 255.0.0.0 (Class A)
/12 → 255.240.0.0 (Class B)
/16 → 255.255.0.0 (Class B)
/24 → 255.255.255.0 (Class C)
Each of these helps determine how many devices (hosts) can fit in that network.
When you use the CIDR notation 192.168.0.0/16, you are reserving 16 bits for the host part of the IP addresses. Since there are 16 bits left for hosts, the total number of IP addresses you can get is calculated as:
2
16
=
65
,
536
2
16
=65,536
So, you will get 65,536 IP addresses in total.
Breakdown:
Network bits: /16 means 16 bits are used for the network portion.
Host bits: The remaining 16 bits are used for hosts.
The total number of IP addresses = 2^16 = 65,536.
Important Note:
AWS reserves 5 IP addresses from each subnet you create for internal use. So, effectively, you get 65,531 usable IP addresses in your VPC.
Simple Summary of Classes:
Class Example IP CIDR Default Subnet Mask Number of Hosts
A 10.0.0.0/8 /8 255.0.0.0 Millions (very large network)
B 172.16.0.0/12 /12 255.240.0.0 Thousands (medium network)
C 192.168.0.0/24 /24 255.255.255.0 254 (small network)
D 224.0.0.0 N/A N/A Used for multicasting
E 240.0.0.0 N/A N/A Reserved for research
you can create a 192.168.0.0/16 network in AWS, and here's why and how:
Why can you use 192.168.0.0/16 in AWS?
Even though 192.168.0.0 is traditionally a Class C network (with a /24 subnet mask by default), the concept of IP classes (Class A, B, C) is not strictly followed anymore in modern networking, especially with CIDR (Classless Inter-Domain Routing). CIDR allows us to create subnets of any size, regardless of the original class.
In AWS, you're not restricted by the old Class A, B, or C boundaries. You can choose any size for your VPC (Virtual Private Cloud) and subnets within the private IP ranges.
192.168.0.0/16 means you are reserving the entire network space from 192.168.0.0 to 192.168.255.255 for your AWS VPC. This provides a much larger range of IP addresses than a standard Class C /24 network.