IPv6, the successor to IPv4, uses a 128-bit address space, providing a vastly larger pool of unique addresses. Unlike IPv4, which traditionally used dotted-decimal notation and subnet masks, IPv6 primarily uses CIDR (Classless Inter-Domain Routing) notation. This notation, like 2001:db8::/64, consists of the IPv6 address followed by a slash and a prefix length (0-128). The prefix length defines the network portion of the address.
The "netmask" in IPv6 is implicitly defined by the CIDR prefix length. A prefix length of /64 means the first 64 bits identify the network, and the remaining 64 bits are available for host addresses within that network. This is the most common prefix length for end-user subnets.
How the Calculator Works:
Input Parsing: The calculator takes an IPv6 address and its CIDR prefix length (e.g., 2001:db8:1:1::/64).
Prefix Length: The number after the slash (e.g., 64) is the prefix length.
Subnet Mask (CIDR): This is directly represented by the prefix length. For /64, the first 64 bits are set to '1' and the remaining 64 bits are '0'.
Network Address: To find the network address, the host portion (bits after the prefix length) of the given IPv6 address is set to all zeros.
Broadcast Address: In IPv6, the concept of a single "broadcast address" like in IPv4 is replaced by link-local multicast addresses. However, for the purpose of subnetting calculations and understanding the range, the address where all host bits are set to '1' is often considered the "subnet-directed broadcast" equivalent (though not used for broadcasting in the same way).
Usable Host Range:
The start of the usable host range is the network address plus one (host bits incremented by 1).
The end of the usable host range is the subnet-directed broadcast address minus one (host bits set to '1' then decremented by 1).
Total Addresses: This is calculated as 2(128 – prefix length).
Usable Host Addresses: In IPv6, the first address (network address) and the last address (subnet-directed broadcast equivalent) are typically reserved. Therefore, the number of usable host addresses is Total Addresses – 2. For prefix lengths shorter than /112, special considerations apply regarding the use of the subnet-directed broadcast address. For simplicity, this calculator assumes the standard practice of reserving the first and last addresses.
IPv6 Address Structure:
An IPv6 address is 128 bits long, typically represented as eight groups of four hexadecimal digits, separated by colons (e.g., 2001:0db8:85a3:0000:0000:8a2e:0370:7334).
CIDR Notation Breakdown:
Network Prefix: The bits from the beginning of the address, as defined by the prefix length. These bits uniquely identify the network or subnet.
Interface Identifier (Host Portion): The remaining bits after the network prefix. These bits are used to identify a specific device (host) on the network.
For example, with 2001:db8:abcd:1::/64:
2001:db8:abcd:1:: is the IPv6 address.
/64 indicates that the first 64 bits form the network prefix.
The first 64 bits are 0010000000000001000011011010101110101100101010110000000000000001
The last 64 bits are the interface identifier, which for the network address are all zeros.
Use Cases:
Network Planning: Designing IPv6 subnetting schemes for organizations.
Address Allocation: Determining the range of assignable addresses within a subnet.
Troubleshooting: Verifying network configurations and identifying correct network boundaries.
Network Security: Implementing firewall rules and access control lists based on specific network prefixes.
Educational Purposes: Understanding the fundamentals of IPv6 addressing and subnetting.
This calculator simplifies the process of determining key subnetting parameters for IPv6 networks, making it an invaluable tool for network administrators, engineers, and students.
function ipToBigInt(ip) {
var parts = ip.split(':');
var bigInt = 0n;
for (var i = 0; i < parts.length; i++) {
bigInt = (bigInt << 16n) | BigInt('0x' + (parts[i].length === 0 ? '0' : parts[i]).padStart(4, '0'));
}
return bigInt;
}
function bigIntToIp(bigIntValue) {
var ip = '';
for (var i = 0; i > BigInt((7 – i) * 16)).toString(16).padStart(4, '0');
ip += hex + ':';
}
// Remove trailing colon and shorten by removing leading zeros from groups
ip = ip.slice(0, -1);
var ipParts = ip.split(':');
var shortenedParts = [];
for (var j = 0; j 1 && part.startsWith('0')) {
part = part.substring(1);
}
shortenedParts.push(part);
}
// Further shorten by removing consecutive groups of '0'
var finalIp = shortenedParts.join(':');
var doubleColonIndex = finalIp.indexOf('::');
if (doubleColonIndex !== -1) {
var partsBefore = finalIp.substring(0, doubleColonIndex).split(':');
var partsAfter = finalIp.substring(doubleColonIndex + 2).split(':');
// Avoid replacing '::' if it results in an invalid IP (e.g., multiple '::')
if (partsBefore.length + partsAfter.length p !== ").join(':') + '::' + partsAfter.filter(p => p !== ").join(':');
// Handle edge case where initial part is empty after filter
if (finalIp.startsWith('::') && partsBefore.length === 0) {
// Keep it as ::
} else if (finalIp.startsWith(':') && !finalIp.startsWith('::')) {
finalIp = finalIp.substring(1);
}
}
}
// Ensure '::' is handled correctly if it's at the beginning or end
if (finalIp === ':' && ipParts.length === 1) finalIp = '::';
if (finalIp.endsWith(':') && !finalIp.endsWith('::')) finalIp = finalIp.slice(0, -1);
return finalIp;
}
function calculateNetmask() {
var prefixInput = document.getElementById("ipv6Prefix").value.trim();
var errorDiv = document.getElementById("errorMsg");
errorDiv.style.display = 'none';
errorDiv.textContent = ";
var ipv6Regex = /^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$|^((?:[0-9a-fA-F]{1,4}(?::[0-9a-fA-F]{1,4})*)?)::((?:[0-9a-fA-F]{1,4}(?::[0-9a-fA-F]{1,4})*)?)$/;
var cidrRegex = /^\/([0-9]|[1-9][0-9]|1[0-1][0-9]|12[0-8])$/; // CIDR prefix 0-128
var ipAddress = ";
var prefixLength = 0;
var parts = prefixInput.split('/');
if (parts.length === 2) {
ipAddress = parts[0].trim();
var prefixPart = parts[1].trim();
if (!cidrRegex.test('/' + prefixPart)) {
errorDiv.textContent = 'Invalid CIDR prefix length. Must be between 0 and 128.';
errorDiv.style.display = 'block';
return;
}
prefixLength = parseInt(prefixPart, 10);
// Basic validation for IPv6 address format
if (ipAddress.length === 0 || (!ipv6Regex.test(ipAddress) && !isCanonicalIPv6(ipAddress))) {
errorDiv.textContent = 'Invalid IPv6 address format.';
errorDiv.style.display = 'block';
return;
}
} else {
errorDiv.textContent = 'Please enter the IPv6 address in CIDR notation (e.g., 2001:db8::/64).';
errorDiv.style.display = 'block';
return;
}
try {
var ipBigInt = ipToBigInt(ipAddress);
var mask = (0xFFFFFFFFFFFFFFFFn << BigInt(128 – prefixLength)) & 0xFFFFFFFFFFFFFFFFn ; // Mask for 128 bits
var networkAddressBigInt = ipBigInt & mask;
var networkAddress = bigIntToIp(networkAddressBigInt);
// Calculate broadcast address (all host bits set to 1)
// This is the "subnet-directed broadcast" equivalent in IPv6
var broadcastAddressBigInt = networkAddressBigInt | ( (1n << BigInt(128 – prefixLength)) – 1n );
var broadcastAddress = bigIntToIp(broadcastAddressBigInt);
// Usable host range start: network address + 1
var usableHostRangeStartBigInt = networkAddressBigInt + 1n;
var usableHostRangeStart = bigIntToIp(usableHostRangeStartBigInt);
// Usable host range end: broadcast address – 1
var usableHostRangeEndBigInt = broadcastAddressBigInt – 1n;
var usableHostRangeEnd = bigIntToIp(usableHostRangeEndBigInt);
var totalAddresses = 1n <= 2n) ? totalAddresses – 2n : 0n;
document.getElementById("subnetMaskResult").querySelector('.result-value').textContent = `/${prefixLength}`;
document.getElementById("networkAddressResult").querySelector('.result-value').textContent = networkAddress;
document.getElementById("broadcastAddressResult").querySelector('.result-value').textContent = broadcastAddress;
document.getElementById("usableHostRangeStartResult").querySelector('.result-value').textContent = usableHostRangeStart;
document.getElementById("usableHostRangeEndResult").querySelector('.result-value').textContent = usableHostRangeEnd;
document.getElementById("totalAddressesResult").querySelector('.result-value').textContent = totalAddresses.toLocaleString();
document.getElementById("usableAddressesResult").querySelector('.result-value').textContent = usableAddresses.toLocaleString();
} catch (e) {
errorDiv.textContent = 'An error occurred during calculation. Please check your input.';
errorDiv.style.display = 'block';
console.error("Calculation error:", e);
}
}
// Helper function to check if an IP string is in a canonical (uncompressed) format
// This is a simplified check, full validation is complex.
function isCanonicalIPv6(ip) {
return ip.split(':').length === 8;
}