utilAZ Logo

IPv6 ULA Generator

Generate IPv6 Unique Local Addresses (ULA) for private networks

Generation Settings

Range: 1-100 ULAs

IPv6 ULA Information

• Prefix: FD (Locally Assigned ULA)
• Format: fd[40-bit Global ID]:[16-bit Subnet]::/64
• Scope: Internal networks only (RFC 4193)
• Collision: Negligible probability (2^40 Global IDs)

Generated IPv6 ULAs

No ULAs Generated

Set the count and click "Generate ULAs" to create IPv6 Unique Local Addresses.

IPv6 ULA Generator Tips

  • • Internal Networks: ULAs are for private networks only, not routable on the internet
  • • Collision Probability: With 2^40 possible Global IDs, collisions are extremely unlikely
  • • Subnet Structure: Each /48 network provides 65,536 /64 subnets
  • • Export Options: Download TXT for documentation or CSV for network management tools
  • • RFC 4193: All generated ULAs follow the official standard for unique local addresses

About IPv6 ULA Generator

Generate IPv6 Unique Local Addresses (ULA) according to RFC 4193 specifications. ULAs are the IPv6 equivalent of private IPv4 addresses, designed for local communication within organizations.

  • RFC 4193 compliant ULA generation
  • Cryptographically secure random generation
  • Support for fc00::/7 address space
  • Generate complete /48 network prefixes
  • Suitable for internal network addressing

How to Use IPv6 ULA Generator

  1. Click Generate - Create a new random ULA prefix
  2. Copy Prefix - Use the generated fc00::/48 or fd00::/48 prefix
  3. Create Subnets - Divide the /48 into /64 subnets for different network segments
  4. Assign Addresses - Use the ULA prefix for internal network addressing

Frequently Asked Questions

How to generate ipv6 ula?

Click Generate on the utilAZ ULA tool. It creates a cryptographically random 40-bit Global ID, prepends the fd prefix, and outputs a /48 prefix like fd12:3456:789a::/48. You can then subnet it into /64 networks for your site. The process follows RFC 4193 Section 3.2.2.

What is an ipv6 unique local address?

A ULA is an IPv6 address from the fd00::/8 range intended for private use within a site or organization. It is the IPv6 equivalent of RFC 1918 private IPv4 space (10.x, 172.16.x, 192.168.x). ULAs are not routed on the public internet but can be routed internally across subnets.

How to create a private ipv6 address?

Use a ULA generator to obtain a /48 prefix (e.g. fd93:ab12:cd34::/48). Subnet it into /64 blocks for each VLAN or segment. Assign interface IDs via SLAAC or DHCPv6. The addresses stay stable regardless of ISP prefix changes and are valid for internal-only communication.

What is rfc 4193?

RFC 4193 defines Unique Local IPv6 Unicast Addresses. It specifies the fd00::/8 prefix for locally-assigned ULAs, the algorithm for generating a pseudo-random 40-bit Global ID, and rules ensuring extremely low collision probability without a central registry.

Difference between ula and link-local?

Link-local (fe80::/10) addresses are confined to a single layer-2 segment and cannot cross routers. ULAs (fd00::/8) are routable across an entire site or organization through internal routers. Use link-local for neighbour discovery; use ULAs for stable internal services reachable across subnets.

Common Use Cases

  • Internal organization networks
  • VPN and private connections
  • Lab and test environments
  • Site-to-site communications
  • Backup and redundant addressing
  • IoT device networks
  • Development environments
  • Multi-site organizations

Technical Details

ULA Structure (RFC 4193):

  • Prefix: fd00::/8 for locally assigned ULAs
  • Global ID: 40-bit pseudo-random identifier
  • Subnet ID: 16-bit field for subnet identification
  • Interface ID: 64-bit interface identifier
  • Format: fd[global_id]:[subnet_id]::[interface_id]

ULA Address Format

fd
XX
XX
XX
XX
XX
YY
YY
Prefix (8 bits) | Global ID (40 bits) | Subnet ID (16 bits)
Example: fd12:3456:789a:bcde::/64

Programming Examples

Python:

import secrets
import ipaddress

def generate_ula_prefix():
    # Generate 40-bit global ID
    global_id = secrets.randbits(40)
    
    # Format as ULA prefix
    prefix_int = (0xfd << 40) | global_id
    prefix_bytes = prefix_int.to_bytes(6, 'big')
    
    # Create IPv6 network
    prefix_hex = prefix_bytes.hex()
    formatted = ':'.join([prefix_hex[i:i+4] for i in range(0, 12, 4)])
    
    return ipaddress.IPv6Network(f"{formatted}::/48", strict=False)

# Example usage
ula_network = generate_ula_prefix()
print(f"ULA Prefix: {ula_network}")

# Create subnets
subnets = list(ula_network.subnets(new_prefix=64))
print(f"First subnet: {subnets[0]}")

JavaScript:

function generateULA() {
    // Generate 5 random bytes for global ID
    const globalId = new Uint8Array(5);
    crypto.getRandomValues(globalId);
    
    // Construct ULA prefix
    const prefix = ['fd'];
    
    // Add global ID as hex groups
    for (let i = 0; i < 5; i += 2) {
        if (i + 1 < 5) {
            prefix.push(
                globalId[i].toString(16).padStart(2, '0') + 
                globalId[i + 1].toString(16).padStart(2, '0')
            );
        } else {
            prefix.push(globalId[i].toString(16).padStart(2, '0') + '00');
        }
    }
    
    return prefix.join(':') + '::/48';
}

// Example usage
const ulaPrefix = generateULA();
console.log('Generated ULA:', ulaPrefix);

function createSubnet(ulaPrefix, subnetId) {
    const base = ulaPrefix.replace('::/48', '');
    return `${base}:${subnetId.toString(16).padStart(4, '0')}::/64`;
}