IPv6 Support Implementation Plan - Issue #1111

[acul71]

IPv6 Support Analysis for py-libp2p

Issue Summary

GitHub Issue: #1111

Problem: When attempting to create peers that communicate over IPv6, the code fails with:

ProtocolLookupError: MultiAddr '/ip6/::1/tcp/0' does not contain protocol Protocol(code=4, name='ip4', codec='ip4')

The error occurs because the codebase has hardcoded IPv4 protocol lookups in multiple places, preventing IPv6 addresses from being properly handled.

Root Cause Analysis

The codebase currently assumes IPv4 addresses in several critical areas:

1. TCP transport hardcodes ip4 protocol lookups
2. WebSocket transport has some IPv6 support but inconsistent handling
3. Network swarm resource manager only checks for ip4
4. Socket address conversion assumes IPv4 format
5. Address validation utilities have IPv6 disabled with TODO comments

Modules and Files Requiring Modification

1. Core Transport Layer

1.1 TCP Transport

File: libp2p/transport/tcp/tcp.py

Issues:

• Line 91: ip4_host_str = maddr.value_for_protocol("ip4") - Hardcoded IPv4 lookup in TCPListener.listen()
• Line 141: host_str = maddr.value_for_protocol("ip4") - Hardcoded IPv4 lookup in TCP.dial()
• Line 198: _multiaddr_from_socket() function always creates /ip4/... multiaddr regardless of actual socket family

Required Changes:

• Replace hardcoded value_for_protocol("ip4") with a helper function that tries both ip4 and ip6
• Update _multiaddr_from_socket() to detect socket family (AF_INET vs AF_INET6) and create appropriate multiaddr
• Ensure trio.serve_tcp() and trio.open_tcp_stream() work correctly with IPv6 addresses

Priority: CRITICAL - This is the primary source of the reported error

---

1.2 WebSocket Transport

File: libp2p/transport/websocket/transport.py

Current State: Partially supports IPv6 (has fallback logic)

Issues:

• Lines 589, 682, 764: Multiple places check ip4 first, then ip6 as fallback
• While this works, the pattern should be standardized across all transports

Required Changes:

• Standardize IPv6/IPv4 handling to use a shared helper function
• Ensure consistent behavior across all WebSocket connection paths

Priority: MEDIUM - Already has some IPv6 support but needs standardization

---

File: libp2p/transport/websocket/listener.py

Current State: Has IPv6 detection logic (lines 299-323)

Issues:

• Line 229: Checks ip4 first, then ip6 - should use helper function
• IPv6 detection logic exists but could be more robust

Required Changes:

• Use standardized helper function for IP address extraction
• Ensure socket family detection works correctly

Priority: LOW - Already has IPv6 support, needs minor refactoring

---

1.3 QUIC Transport

File: libp2p/transport/quic/utils.py

Current State: Already supports IPv6 properly in implementation

Evidence of IPv6 Support:

• Lines 109-120: quic_multiaddr_to_endpoint() correctly handles both IPv4 and IPv6

  # Try to get IPv4 address
  try:
      host = maddr.value_for_protocol(multiaddr.protocols.P_IP4)
  except Exception:
      pass
  
  # Try to get IPv6 address if IPv4 not found
  if host is None:
      try:
          host = maddr.value_for_protocol(multiaddr.protocols.P_IP6)

• Lines 191-196: create_quic_multiaddr() correctly detects IP version using ipaddress module
• File: libp2p/transport/quic/listener.py (lines 1241-1246): Socket creation detects IPv6 and uses AF_INET6

  ip = ipaddress.ip_address(host)
  family = socket.AF_INET if ip.version == 4 else socket.AF_INET6

Test Coverage:

• tests/core/transport/quic/test_utils.py:
  • test_ipv6_extraction() - Tests IPv6 address extraction (lines 86-96)
  • test_ipv6_creation() - Tests IPv6 multiaddr creation (lines 160-169)
  • Test cases include: /ip6/::1/udp/4001/quic-v1, /ip6/2001:db8::1/udp/5000/quic
• tests/core/transport/quic/test_transport.py:
  • test_can_dial_quic_addresses() includes IPv6 addresses in valid test cases (lines 68-70, 77-79)
• examples/interop/local_ping_test.py:
  • _build_quic_addr() method handles IPv6 detection (lines 185-192)

Required Changes:

• NONE - QUIC transport implementation already handles IPv6 correctly
• Note: While unit tests exist for IPv6 parsing/creation, end-to-end integration tests with actual IPv6 listening/dialing may need verification

Priority: VERIFICATION - Implementation appears correct, but should verify end-to-end IPv6 connectivity works in practice

---

File: libp2p/transport/quic/listener.py

Current State: Uses quic_multiaddr_to_endpoint() which handles IPv6

Issues:

• Line 1219: getsockname() returns address that may be IPv6
• Line 1221: Uses create_quic_multiaddr() which should handle IPv6 correctly

Required Changes:

• Verify that create_quic_multiaddr() correctly handles IPv6 addresses from getsockname()
• Test IPv6 socket address conversion

Priority: LOW - Should work but needs verification

---

2. Network Layer

2.1 Swarm Resource Manager

File: libp2p/network/swarm.py

Issues:

• Line 352: ep = addr.value_for_protocol("ip4") - Hardcoded IPv4 lookup for resource manager endpoint tracking
• This is used for connection admission control and rate limiting

Required Changes:

• Replace with helper function that extracts IP address (IPv4 or IPv6) for endpoint identification
• Ensure resource manager can track IPv6 endpoints correctly

Priority: HIGH - Affects connection management and resource limits

---

3. Address Utilities

3.1 Address Validation

File: libp2p/utils/address_validation.py

Issues:

• Lines 67-83: IPv6 support is commented out with TODO explaining handshake issues
• The TODO mentions:
  • libp2p security handshake over IPv6
  • multiselect protocol over IPv6
  • connection establishment over IPv6

Required Changes:

• Re-enable IPv6 interface enumeration once transport layer supports IPv6
• Update get_wildcard_address() to support IPv6 wildcard (::)
• Update get_optimal_binding_address() to prefer IPv6 when available

Priority: MEDIUM - Should be enabled after transport fixes

---

3.2 Relay/NAT Utilities

File: libp2p/relay/circuit_v2/nat.py

Current State: Has some IPv6 support

Issues:

• Line 57: ip_to_int() function handles both IPv4 and IPv6 (uses ipaddress module)
• Lines 139-145: extract_ip_from_multiaddr() checks IPv4 first, then IPv6 (lines 147-152)

Required Changes:

• Verify IPv6 extraction works correctly
• Consider using standardized helper function

Priority: LOW - Already has IPv6 support, needs verification

---

4. Transport Registry

4.1 Transport Selection

File: libp2p/transport/transport_registry.py

Current State: Already recognizes IPv6 in validation

Issues:

• Line 60: _is_valid_tcp_multiaddr() already checks for both ip4 and ip6 protocols
• Comments mention IPv6 examples (line 52)

Required Changes:

• NONE - Already supports IPv6 in validation

Priority: NONE - No changes needed

---

5. Identity/Identify Protocol

5.1 Address Conversion

File: libp2p/identity/identify/identify.py

Current State: Has IPv6 support

Issues:

• Lines 42-57: _remote_address_to_multiaddr() correctly detects IPv6 by checking for : in host string
• Creates appropriate /ip6/... or /ip4/... multiaddr

Required Changes:

• NONE - Already handles IPv6 correctly

Priority: NONE - No changes needed

---

6. I/O Layer

6.1 Trio I/O

File: libp2p/io/trio.py

Issues:

• Line 54: get_remote_address() uses getpeername() which may return IPv6 addresses
• Need to verify address format conversion

Required Changes:

• Verify that remote address conversion handles IPv6 correctly
• May need to detect socket family and format accordingly

Priority: LOW - Needs verification

---

Implementation Strategy

Phase 1: Core Transport Fixes (Critical)

1. Create helper function for IP address extraction:

   def extract_ip_from_multiaddr(maddr: Multiaddr) -> str | None:
       """Extract IPv4 or IPv6 address from multiaddr."""
       try:
           return maddr.value_for_protocol("ip4")
       except Exception:
           try:
               return maddr.value_for_protocol("ip6")
           except Exception:
               return None

2. Fix TCP transport (libp2p/transport/tcp/tcp.py):

   • Replace hardcoded ip4 lookups with helper function
   • Fix _multiaddr_from_socket() to detect socket family
   • Test with both IPv4 and IPv6 addresses

3. Fix Swarm resource manager (libp2p/network/swarm.py):

   • Use helper function for endpoint extraction

Phase 2: Standardization (Medium Priority)

1. Standardize WebSocket transport to use shared helper function
2. Re-enable IPv6 in address validation utilities
3. Update wildcard address functions to support IPv6

Phase 3: Testing and Verification (Low Priority)

1. Verify QUIC transport IPv6 handling (should already work)
2. Test security handshake over IPv6 (mentioned in TODO)
3. Test multiselect protocol over IPv6
4. Integration testing with IPv6-only networks

Security Considerations

The TODO comment in address_validation.py mentions security handshake issues with IPv6. These need to be investigated:

1. Security Protocol Negotiation: Verify that security protocols (Noise, TLS, etc.) work correctly over IPv6
2. Multiselect Protocol: Ensure protocol selection works over IPv6 connections
3. Connection Establishment: Test full connection lifecycle with IPv6

Testing Requirements

Unit Tests

• Test TCP transport with IPv6 addresses (/ip6/::1/tcp/0)
• Test WebSocket transport with IPv6 addresses
• Test QUIC transport with IPv6 addresses (should already work)
• Test address extraction helper function
• Test socket address conversion for both IPv4 and IPv6

Integration Tests

• Test peer connection over IPv6
• Test security handshake with IPv6
• Test protocol negotiation with IPv6
• Test the minimal example from issue ipv6 error: MultiAddr '/ip6/::1/tcp/0' does not contain protocol ip4 #1111

Test Files to Update

• tests/core/transport/tcp/test_tcp.py - Add IPv6 test cases
• tests/core/transport/websocket/test_websocket.py - Add IPv6 test cases
• tests/core/network/test_swarm.py - Add IPv6 test cases
• Create new test file: tests/core/transport/test_ipv6_support.py

Files Summary

Critical Changes Required

1. libp2p/transport/tcp/tcp.py - PRIMARY FIX
2. libp2p/network/swarm.py - Resource manager endpoint tracking

Medium Priority Changes

3. libp2p/utils/address_validation.py - Re-enable IPv6 support
4. libp2p/transport/websocket/transport.py - Standardize IPv6 handling
5. libp2p/transport/websocket/listener.py - Minor refactoring

Low Priority / Verification

6. libp2p/transport/quic/listener.py - Verify IPv6 handling
7. libp2p/io/trio.py - Verify remote address handling
8. libp2p/relay/circuit_v2/nat.py - Verify IPv6 extraction

No Changes Needed (Already Support IPv6)

• libp2p/transport/quic/utils.py - Reference implementation for IPv6 support
• libp2p/transport/quic/listener.py - Socket creation handles IPv6 correctly
• libp2p/transport/transport_registry.py - Validation accepts IPv6
• libp2p/identity/identify/identify.py - Address conversion handles IPv6

Note: QUIC transport can serve as a reference implementation for how to properly handle IPv6 in other transports. See quic_multiaddr_to_endpoint() and _create_socket() methods.

Helper Function Implementation

Create a new utility function that can be shared across all modules:

Location: libp2p/utils/address_validation.py or new file libp2p/utils/multiaddr_utils.py

def extract_ip_from_multiaddr(maddr: Multiaddr) -> str | None:
    """
    Extract IP address (IPv4 or IPv6) from multiaddr.
    
    :param maddr: Multiaddr to extract from
    :return: IP address string or None if not found
    """
    # Try IPv4 first (for backward compatibility)
    try:
        ip4 = maddr.value_for_protocol("ip4")
        if ip4:
            return ip4
    except Exception:
        pass
    
    # Try IPv6
    try:
        ip6 = maddr.value_for_protocol("ip6")
        if ip6:
            return ip6
    except Exception:
        pass
    
    return None


def get_ip_protocol_from_multiaddr(maddr: Multiaddr) -> str | None:
    """
    Get the IP protocol name (ip4 or ip6) from multiaddr.
    
    :param maddr: Multiaddr to check
    :return: Protocol name ("ip4" or "ip6") or None
    """
    try:
        maddr.value_for_protocol("ip4")
        return "ip4"
    except Exception:
        try:
            maddr.value_for_protocol("ip6")
            return "ip6"
        except Exception:
            return None


def multiaddr_from_socket(socket: trio.socket.SocketType) -> Multiaddr:
    """
    Create multiaddr from socket, detecting IPv4 or IPv6.
    
    :param socket: Socket to get address from
    :return: Multiaddr with appropriate IP protocol
    """
    ip, port = socket.getsockname()
    family = socket.family
    
    if family == socket.AF_INET6:
        return Multiaddr(f"/ip6/{ip}/tcp/{port}")
    else:
        # Default to IPv4 for AF_INET and unknown families
        return Multiaddr(f"/ip4/{ip}/tcp/{port}")

Additional Notes

1. Trio Socket Support: Trio's socket API supports IPv6, so the underlying transport should work. The issue is in the multiaddr protocol extraction.

2. Backward Compatibility: All changes should maintain backward compatibility with existing IPv4 code. The helper functions should try IPv4 first for compatibility.

3. Error Messages: Update error messages to mention both IPv4 and IPv6 when address extraction fails.

4. Documentation: Update docstrings and comments to reflect IPv6 support.

5. Example Code: The minimal example from issue ipv6 error: MultiAddr '/ip6/::1/tcp/0' does not contain protocol ip4 #1111 should work after these changes.

References

• Issue #1111 - Original bug report
• Multiaddr Specification - Protocol specification
• Trio Documentation - Async I/O library documentation