Windows Server 2019 – Introduction to IPv6

How to Configure Network Static IP Address on Ubuntu 19.10

Welcome to the dark side! Unfortunately, that is how many people think of IPv6 at the moment. While IPv6 is by no means a new thing, in my experience it is still something that almost no one has deployed in their own networks. While working with hundreds of different companies all over the world over the past few years, I have come across only one organization that was running IPv6 over their entire production network, and it wasn’t even true native IPv6. Instead, they were using a tunneling technology, called ISATAP, over their whole network in order to make all of the servers and clients talk to each other using IPv6 packets, but these packets were still traversing an IPv4 physical network. Don’t get me wrong; I have found plenty of cases where companies are toying around with IPv6 and have some semblance of it configured on a sectioned-off piece of their networks, but using it for the entire production network? Most of us just aren’t ready for that big a change yet. Why is it so difficult to put IPv6 into place? Because we have been using IPv4 since basically the beginning of time, it’s what we all know and understand, and there really isn’t a great need to move to IPv6 inside our networks. Wait a minute; I thought there was some big scare about running out of IPv4 addresses? Yes, that is true for IP addresses on the public internet, but it has nothing to do with our internal networks. You see, even if we run out of public IPv4 addresses tomorrow, our internal networks at our companies are not going to be impacted. We can continue to run IPv4 inside the network for a long time to come, possibly forever and always, as long as we are comfortable using NAT technologies to translate the traffic down into IPv4 as it comes into us from the internet. We have all been using NAT in one form or another for almost as long as IPv4 has existed, so it is obviously something people are very comfortable with.

Let me be clear: I am not trying to convince you that sticking with IPv4 is the way of the future. I am just laying out the fact that, for most organizations over the next few years, this will simply be the truth. The reason I want to discuss IPv6 here is that, eventually, you will have to deal with it. And once you do, you’ll actually get excited about it! There are some huge advantages that IPv6 has over IPv4, namely, the enormous number of IP addresses that you can contain within a single network. Network teams in companies around the World struggle every day with the need to build more and more IPv4 networks and tie them together. Think about it: there are many companies now with employee counts in excess of 10,000. Some have many, many times that number. In today’s world, everyone needs almost constant access to their data. Data is the new currency. Most users now have at least two physical devices they utilize for work, sometimes more than that: a laptop and a tablet, or a laptop and a smart phone, or a desktop and a laptop and a tablet and a smart phone; you get the idea. In the IPv4 world, where you are dealing with comparatively small IP address ranges, you have to get very creative with creating subnets in order to accommodate all of these physical devices, which each need a unique IP address in order to communicate on the network. The biggest advantage to IPv6 is that it resolves all of these problems immediately, and by default, by providing the capability to have a huge number of IP addresses within a single network. How many more addresses are we talking about? The following is some comparison data to give you a little perspective:

  • An IPv4 address is a 32-bit length address that looks like this:
192.168.1.5 
  • An IPv6 address is a 128-bit length address that looks like this.
2001:AABB:CCDD:AB00:0123:4567:8901:ABCD 

As you can see, the IPv4 address is much shorter, which obviously means there are fewer possibilities for unique IP addresses. What you don’t see is how much longer IPv6 addresses really are. These examples portray IPv4 and IPv6 addresses as we are used to seeing them, in their finished forms. Really though, the IPv4 address is shown in decimal form, and the IPv6 in hexadecimal. IPv6 addresses are shown and used via hex so that the addresses are compressed as much as possible. In reality, if you dig around under the hood, an IPv6 address in its native 128-bit form might look something like this (and indeed, this is how it looks inside the actual packet):

0001000001000001000011011001100000000000000000010000000000000000
0001000000000000000000000000100000000000000000000000000000000001

That’s an impressive set of digits, but not something that is very usable or friendly to the human eye. So rather than show the bits, what about an IPv6 address shown in decimal format, in the same way that IPv4 addresses have always been shown? In that case, an IPv6 address might look something like this:

192.16.1.2.34.0.0.1.0.0.0.0.0.0.0.1

Now we fully understand why IPv6 is always used and shown in hexadecimal; the addresses are long even in that compressed format!

Understanding IPv6 IP addresses

When we set up IPv4 networks, subnetting is extremely important because it is what enables us to have more than one collection of IP addresses within the same network. In the most basic form of networking, where you set up some IP addresses and run a /24 subnet (a subnet mask of 255.255.255.0)—which is very common on small networks such as inside a house or small business officeyou are limited to 254 unique IP addresses. Ouch! Some companies have thousands of different servers, without accounting for all of their client computers and devices that also need to connect to the network. Thankfully, we can build out many different subnets within a single IPv4 network in order to increase our usable IP address scope, but this takes careful planning and calculation of those subnets and address spaces, and is the reason that we rely on experienced network administrators to manage this part of the network for us. One invalid subnet configuration in a routing table can tank the network traffic flow. The administration of subnets in a large IPv4 network is not for the faint of heart.

When we are talking about IPv6 addressing, the sky almost seems to be the limit. If you were to calculate all of the unique IPv6 addresses available in the preceding 128-bit space, you would find that there are more than 340 undecillion addresses available to create. In other words, 340 trillion, trillion, trillion addresses. This is the number being touted out there about how many available addresses there are on the IPv6 internet, but what does that mean for our internal networks?

To discuss the number of addresses we could have inside a typical internal network that runs IPv6, let’s first step back and look at the address itself. The address I showed earlier is just something I made up, but we will break down the parts of it here:

2001:AABB:CCDD:AB00:0123:4567:8901:ABCD 

Compared to 192.168.1.5, this thing looks like a monstrosity. That is because we are generally not used to dealing with the hexadecimal format; it is just a different way of looking at data. As we mentioned, this is a 128-bit address. It is broken up into 8 different sections, each section separated by a colon is made up of 16 bits. The first 64 bits (the first half) of the address are routing information, and the latter 64 bits are the unique device ID on the network. Within the first part, we have two different components. The first 48 bits (3 groups of hex) are an organizational prefix that will be the same on all of our devices in the network. Then the fourth set of information, the next 16 bits, can be our subnet ID. This gives us the flexibility of still having many different subnets if we desire in the future, by using multiple numbers here as the subnet ID. After dedicating the first half of the address, we now have the latter half to work with, the last 64 bits. These we can leave for device IDs. This part of the address will be different for every device on the network, and will define the individual static IPv6 addresses that will be used for communication. Let’s lay it all out. We will take the example address from previously, and break it out into the following parts:

  • Organizational prefix: 2001:AABB:CCDD:AB00:0123:4567:8901:ABCD where 2001:AABB:CCDD is the organizational prefix
  • Subnet ID: 2001:AABB:CCDD:AB00:0123:4567:8901:ABCD where AB00 is the subnet ID
  • Device IDs2001:AABB:CCDD:AB00:0123:4567:8901:ABCD where 0123:4567:8901:ABCD is a unique device ID

How many devices can we have in our network with an IP schema such as this? Well, even in our example, where we only allocated one 16-bit section for subnetting, and 64 bits for actual IP addresses, that would provide us with the capability to have more than 65,000 subnets and quintillions of unique device IDs in our IP range. Impressive, isn’t it?

If we stick with this and use just a single subnet to contain all of our machines, the first half of our addresses will always be the same, making these long addresses much easier to remember and deal with. It is surprising how quickly you will get used to seeing these large hex numbers in your environment, but even though you will start to recognize them, you still probably are not going to quickly jump into servers or computers in your network anymore by using the static IP addresses. I know a lot of us are still in the habit of saying: I need to quickly jump into my web server, I’ll just RDP into 192.168.1.5. Just the time that it takes to type out these IPv6 addresses, even if you do remember them, isn’t generally worth it. IPv6 will bring with it a larger reliance on DHCP and DNS to make it more usable.

Now that we understand what sections of the address are going to be used for what purposes, how do we go about assigning the individual device ID numbers for all of the computers, servers, and other devices on our network? You could start with number 1 and go up from there. Another idea is to calculate out the old IPv4 addresses into hex and use this as the last 32 bits of the addressopen up Windows Calculator on your computer, drop down the menu, and change it into Programmer mode. This is a quick and easy tool that you can use to convert decimal into hexadecimal, and vice versa. Let’s take the example of my web server that is running on 192.168.1.5. I want to implement IPv6 inside my network, and I want my server’s IPv6 addresses to reflect the original IPv4 address in the device ID section of the new address. In my calculator, if I type in 192 and then click on HEX, it will show me the corresponding hexadecimal to the decimal of 192, as shown in the following screenshot:

If we do that with each of the octets in our IPv4 address, we will see the following:

192 = C0 
168 = A8 
1 = 01 
5 = 05 

So my 192.168.1.5 factors out to C0A8:0105. I can now utilize that in combination with my organizational prefix and my subnet ID to create a static IPv6 address for my web server:

2001:AABB:CCDD:0001:0000:0000:C0A8:0105 

You’ll notice in the preceding IPv6 address that I input the hex for the device ID at the end, but I also made a couple of other changes. Since we are leaving the last 64 bits available for the device ID, but my old IPv4 address only consumes 32 bits, I am left with the 32 bits in the middle. It would be kind of weird to have data in there that didn’t mean anything to us, so we will simply make it all zeros to simplify my addressing scheme. In addition to that change, I also adjusted my subnet ID to the number 1, since this is the first subnet in my network.

Our new addressing is starting to look a little cleaner, and makes more sense. Now that we see this new address for our web server laid out, I can see that there are some additional clean-up tasks we can perform on the address in order to make it look even better. Right now the address listed earlier is 100% accurate. I could plug this IP address into the NIC properties of my web server, and it would work. However, there are a whole lot of zeros in my address, and it isn’t necessary that I keep them all. Any time you have unnecessary zeros within a 16-bit segment that are preceding the actual number, they can simply be removed. For example, our subnet ID and the first 32 bits of our device ID have a lot of unnecessary zeros, so I can consolidate the address down to the following:

2001:AABB:CCDD:1:0:0:C0A8:0105 

Then, to take it even a step further, any time you have full 16-bit sections that are composed entirely of zeros, they can be fully consolidated into a double colon. So, the first 32 bits of my device ID that are all zeros, I can replace with ::. The following is the full address, and the consolidated address. These numbers look quite different. My consolidated address is much easier on the eyes, but from a technological perspective, they are exactly the same number:

2001:AABB:CCDD:0001:0000:0000:C0A8:0105 
2001:AABB:CCDD:1::C0A8:0105 

In fact, if you are setting up a lab or want to quickly test IPv6, you could use addresses as simple as the following example. The two addresses that I will show you here are exactly the same:

2001:0000:0000:0000:0000:0000:0000:0001 
2001::1 
It is important to note that you can only use a double-colon once within an IP address. If you had two places where it could be applicable within the same address, you can only implement it in one of those places, and you will have to spell out the zeros in the other place.

With the information provided here, you should be able to put together your own semblance of IPv6 and start issuing some IPv6 addresses to computers or servers in your network. There is so much more that could be learned on this subject that a full book could be written, and indeed many have.

Comments are closed.