// Helper function to expand compressed IPv6 addresses (e.g., 2001:db8::1 to 2001:0db8:0000:0000:0000:0000:0000:0001)
function expandIPv6Address(address) {
var parts = address.split('::');
if (parts.length === 1) { // No '::'
var hextets = parts[0].split(':');
if (hextets.length !== 8) throw new Error("Invalid IPv6 address: incorrect number of hextets.");
return hextets.map(function(h) { return ('0000' + h).slice(-4); }).join(':');
} else if (parts.length === 2) { // One '::'
var left = parts[0].split(':').filter(Boolean);
var right = parts[1].split(':').filter(Boolean);
var missing = 8 – (left.length + right.length);
if (missing < 0) throw new Error("Invalid IPv6 address: too many hextets.");
var middle = Array(missing).fill('0000');
return left.concat(middle, right).map(function(h) { return ('0000' + h).slice(-4); }).join(':');
} else {
throw new Error("Invalid IPv6 address: multiple '::' found.");
}
}
// Helper to convert expanded IPv6 hextets to BigInt
function hextetsToBigInt(hextetsArray) {
var bigInt = BigInt(0);
for (var i = 0; i < hextetsArray.length; i++) {
bigInt = (bigInt <> BigInt(maskBits)) << BigInt(maskBits);
var hextets = [];
var tempBigInt = maskedBigInt;
for (var i = 0; i > BigInt(16);
}
// Pad hextets with leading zeros for internal processing, then remove for compression
var paddedHextets = hextets.map(function(h) { return ('0000' + h).slice(-4); });
// Compress the address (find longest sequence of zeros)
var bestStart = -1;
var bestLength = 0;
var currentStart = -1;
var currentLength = 0;
for (var i = 0; i bestLength) {
bestLength = currentLength;
bestStart = currentStart;
}
currentStart = -1;
currentLength = 0;
}
}
if (currentLength > bestLength) { // Check after loop
bestLength = currentLength;
bestStart = currentStart;
}
// Only compress if length is at least 2 '0000' hextets
if (bestLength >= 2) {
var compressed = [];
for (var i = 0; i < bestStart; i++) {
compressed.push(parseInt(paddedHextets[i], 16).toString(16));
}
compressed.push(''); // The '::' part
for (var i = bestStart + bestLength; i = Number.MAX_SAFE_INTEGER) {
return num.toExponential(2); // Use scientific notation for very large numbers
}
return num.toLocaleString();
}
function calculateIPv6Subnets() {
var ipv6NetworkAddressInput = document.getElementById("ipv6NetworkAddress").value.trim();
var desiredPrefixLengthInput = document.getElementById("desiredPrefixLength").value;
var resultDiv = document.getElementById("result");
resultDiv.innerHTML = ""; // Clear previous results
// — Input Validation —
if (!ipv6NetworkAddressInput) {
resultDiv.innerHTML = "Please enter an IPv6 Network Address.";
return;
}
var parts = ipv6NetworkAddressInput.split('/');
var ipv6AddressStr = parts[0];
var originalPrefixLengthStr = parts[1];
if (!originalPrefixLengthStr) {
resultDiv.innerHTML = "IPv6 Network Address must include a prefix length (e.g., /48).";
return;
}
var originalPrefixLength = parseInt(originalPrefixLengthStr, 10);
var desiredPrefixLength = parseInt(desiredPrefixLengthInput, 10);
if (isNaN(originalPrefixLength) || originalPrefixLength 128) {
resultDiv.innerHTML = "Invalid original prefix length. Must be between 0 and 128.";
return;
}
if (isNaN(desiredPrefixLength) || desiredPrefixLength 128) {
resultDiv.innerHTML = "Invalid desired prefix length. Must be between 0 and 128.";
return;
}
if (desiredPrefixLength < originalPrefixLength) {
resultDiv.innerHTML = "Desired prefix length must be greater than or equal to the original prefix length for subnetting.";
return;
}
var expandedAddress;
try {
expandedAddress = expandIPv6Address(ipv6AddressStr);
} catch (e) {
resultDiv.innerHTML = "" + e.message + "";
return;
}
// — Calculations —
var subnetBits = desiredPrefixLength – originalPrefixLength;
var numberOfSubnets = Math.pow(2, subnetBits);
var hostsPerSubnet = Math.pow(2, (128 – desiredPrefixLength));
// — Generate Example Subnets —
var subnetExamples = [];
var maxExamples = Math.min(numberOfSubnets, 5); // Show up to 5 examples
// Convert the original network address (up to originalPrefixLength) to BigInt
var hextets = expandedAddress.split(':');
var originalNetworkBigInt = hextetsToBigInt(hextets);
var originalNetworkMask = (BigInt(1) << BigInt(128 – originalPrefixLength)) – BigInt(1); // Mask for host bits
originalNetworkBigInt = originalNetworkBigInt & (~originalNetworkMask); // Zero out host bits of original network
// Loop to generate example subnets
for (var i = 0; i < maxExamples; i++) {
var subnetIdBigInt = BigInt(i);
// Shift the subnet ID into the bits between originalPrefixLength and desiredPrefixLength
var shiftAmount = 128 – desiredPrefixLength;
var currentSubnetBigInt = originalNetworkBigInt | (subnetIdBigInt << BigInt(shiftAmount));
var currentSubnetAddress = bigIntToIPv6(currentSubnetBigInt, desiredPrefixLength);
subnetExamples.push(currentSubnetAddress + "/" + desiredPrefixLength);
}
// — Display Results —
var output = "
IPv6 subnetting is the process of dividing a larger IPv6 network into smaller, more manageable subnetworks. Unlike IPv4, which often requires complex calculations due to limited address space and concepts like NAT (Network Address Translation), IPv6 offers an enormous address space (128 bits) that simplifies subnetting considerably. The primary goal of IPv6 subnetting is to organize networks logically, improve routing efficiency, and enhance security.
Why Subnet in IPv6?
Organization: Subnetting allows administrators to segment their network into logical units (e.g., departments, floors, data centers), making management easier.
Routing Efficiency: Smaller subnets can lead to more efficient routing tables and faster packet forwarding within an organization.
Security: Network segmentation can help contain security breaches and allow for more granular access control policies.
Stateless Address Autoconfiguration (SLAAC): IPv6 typically uses a /64 prefix for individual links, which is required for SLAAC to function correctly, allowing devices to automatically configure their own IPv6 addresses.
Key Concepts in IPv6 Subnetting
An IPv6 address is 128 bits long, typically represented in eight groups of four hexadecimal digits, separated by colons (e.g., 2001:0db8:85a3:0000:0000:8a2e:0370:7334). For brevity, leading zeros in a hextet can be omitted, and a single '::' can replace one or more consecutive groups of '0000'.
Prefix Length: Similar to IPv4's subnet mask, the prefix length (e.g., /64, /48) indicates the number of bits in the network portion of the address. The remaining bits are for the host portion.
Network Portion: The part of the IPv6 address defined by the prefix length. This identifies the specific subnet.
Host Portion: The part of the IPv6 address that identifies a specific interface within a subnet. For most IPv6 subnets, this is 64 bits long.
No Broadcast Addresses: IPv6 does not use broadcast addresses. Instead, it uses multicast for group communication.
No Network Address: While a subnet has a network prefix, there isn't a specific "network address" that is unusable by hosts, unlike IPv4. The first address in a /64 subnet (e.g., 2001:db8:abcd:0000::) can be assigned to a host.
How the Calculator Works
This IPv6 Subnetting Calculator helps you understand how a larger IPv6 network can be divided. You provide:
IPv6 Network Address: Your starting IPv6 network, including its current prefix length (e.g., 2001:db8:abcd::/48). This defines the network portion you own.
Desired Subnet Prefix Length: The new, longer prefix length you want for your subnets (e.g., 64). This determines how many bits you "borrow" from the host portion of your original network to create new subnets.
The calculator then determines:
Bits borrowed for Subnetting: The difference between your desired prefix length and the original prefix length. Each borrowed bit doubles the number of possible subnets.
Total Number of Subnets Created: Calculated as 2 raised to the power of the borrowed bits.
Number of Hosts per Subnet: Calculated as 2 raised to the power of (128 – desired prefix length). For a /64 subnet, this is 264, an astronomically large number.
Example Subnets: It provides a few examples of the new subnets created, showing how the subnet ID increments.
Example Usage:
Suppose you are assigned the IPv6 network 2001:db8:abcd::/48 and you want to create /64 subnets for your various departments.
IPv6 Network Address:2001:db8:abcd::/48
Desired Subnet Prefix Length:64
The calculator will show that you are borrowing 16 bits (64 – 48 = 16). This allows you to create 216 = 65,536 subnets. Each of these /64 subnets can then accommodate 264 hosts, which is more than enough for any practical purpose.
The first few subnets would look like:
2001:db8:abcd:0000::/64
2001:db8:abcd:0001::/64
2001:db8:abcd:0002::/64
…and so on, up to 2001:db8:abcd:ffff::/64.
This tool simplifies the planning and allocation of IPv6 addresses within your network infrastructure.