IPv4 внутри IPv6: почему netip в Go не видит адрес в префиксе и как работает UnmapСтатья · дайджест за 8 ноября
Модульная визуализация структуры netip.Addr в стиле конструктора Bauhaus, разделяющая контейнер IPv6 и распакованный IPv4.
Статья4 раздела≈ 7 мин

IPv4 внутри IPv6: почему netip в Go не видит адрес в префиксе и как работает Unmap

Признаюсь честно: двойная запись сетевых адресов на стыке старого и нового протоколов поначалу путает даже тех, кто пишет серверный код не первый год. Когда ты смотришь в журнал подключений и видишь строку с префиксом ::ffff: перед привычными числами с точками, взгляд машинально выхватывает знакомую правую часть. Кажется естественным, что и сетевая библиотека воспримет такой адрес как обычный клиентский адрес старого образца в служебной обертке.

На деле здесь кроется коварное расхождение, на которое обратили внимание авторы канала «Библиотека Go-разработчика». Представь задачу: внутренний сервис на Go проверяет входящие запросы по белому списку подсети 192.0.2.0/24 через стандартный пакет net/netip. Когда к серверу стучится клиент с адресом ::ffff:192.0.2.10, метод Contains внезапно возвращает false и отвергает запрос. Почему строгая типизация в Go не узнает IPv4 внутри шестнадцатеричной обертки, как метод Unmap() возвращает фильтрам предсказуемость и почему для защиты от подделки серверных запросов (SSRF) одной распаковки адреса мало?

Анатомия двойных адресов: откуда берется обертка IPv6 и как устроен тип Addr

Чтобы понять, откуда в соединении берется приставка ::ffff:, заглянем на уровень сетевых сокетов операционной системы. Современные серверы работают в гибридном режиме (dual-stack), принимая трафик и от клиентов IPv4, и от сетей IPv6 через единый универсальный сокет IPv6.

Работает это как переходник для розетки. Когда к универсальному порту подключается клиент по 32-битному протоколу IPv4, ядро ОС укладывает его четыре байта в конец 128-битного контейнера IPv6, а спереди ставит 96-битную метку ::ffff: (диапазон ::ffff:0:0/96 по стандарту RFC 4291). Такая запись называется отображенным адресом (IPv4-mapped IPv6 address): по сети пришел пакет IPv4, но программа видит его в «переходнике» ::ffff:192.0.2.10.

Старый срез net.IP из пакета net требовал аллокаций в куче и не подходил для ключей map, зато метод net.IP.To4() молча отрезал префикс ::ffff: и приводил двойной адрес к обычному IPv4. Пакет net/netip (появился в Go 1.18, поведение проверено в Go 1.27.3) устроен строго. Его тип netip.Addr — неизменяемая структура-значение размером 24 байта. Она живет на стеке, бережет память, сравнивается через == и работает ключом в map[netip.Addr]T. Подобно тому как в сетевом фильтре Linux выражения ip saddr и ip6 saddr остаются разными сущностями внутри таблицы inet (см. руководство по переходу с iptables на Nftables), netip.Addr жестко разделяет семейства протоколов: у ::ffff:192.0.2.10 битовая длина BitLen() равна 128, а не 32.

Ловушка метода Contains: почему адрес тот же, но семейство другое

Разделение 32-битного и 128-битного миров в netip.Addr определяет работу подсетей netip.Prefix в нотации CIDR (RFC 4632 и RFC 4291). Префикс 192.0.2.0/24 хранит базовый адрес и длину маски (Bits()): первые 24 бита (192.0.2.) фиксированы, а 8 бит отведены под узлы. При вызове prefix.Contains(addr) метод не отрезает шестнадцатеричную шапку сам. Сначала он сверяет семейства: IPv4 не совпадет с префиксом IPv6, а отображенный IPv4-in-IPv6 не войдет в префикс IPv4 (так же Contains вернет false для любого IPv6 с зоной интерфейса вроде %eth0).

Проверим, что произойдет в нашем сценарии, когда сервис сверяет входящий адрес ::ffff:192.0.2.10 с доверенной подсетью 192.0.2.0/24 без нормализации:

package main

import (
    "fmt"
    "net/netip"
)

func main() {
    p := netip.MustParsePrefix("192.0.2.0/24")
    a := netip.MustParseAddr("::ffff:192.0.2.10")

    fmt.Println("Contains(a):", p.Contains(a))
    fmt.Printf("Is4: %v, Is6: %v, Is4In6: %v, BitLen: %d\n",
        a.Is4(), a.Is6(), a.Is4In6(), a.BitLen())
}
// Вывод (Go 1.27.3): Contains(a): false | Is4: false, Is6: true, Is4In6: true, BitLen: 128

Для сервиса итог оказывается неприятным: p.Contains(a) выдает false, и клиент из разрешенной подсети получает отказ. Причина видна в методах: a.Is4() равен false, а a.Is6() и индикатор a.Is4In6() возвращают true. Для net/netip это 128-битный адрес IPv6, который не может лежать в 32-битной маске /24.

Эта деталь еще опаснее в черных списках. Когда фильтр блокирует обращения к локальной петле 127.0.0.0/8 или приватным сетям (10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16), ответ false от Contains играет на руку атакующему: запрос на ::ffff:127.0.0.1 признается «не входящим» в запрещенный IPv4-префикс и проходит внутрь периметра.

Нормализация через Unmap: как снять IPv6-обертку или отсечь двойные адреса на входе

На входе в сервис ты выбираешь из двух политик. Если правила приложения считают 192.0.2.10 и ::ffff:192.0.2.10 одним адресом, сначала вызывают Unmap(). Он проверяет метку Is4In6(): если внутри лежит отображенный IPv4, Unmap() снимает обертку ::ffff: и возвращает чистый 32-битный Addr семейства IPv4. Обычные адреса IPv4 и настоящие IPv6 (2001:db8::1) метод возвращает без изменений. Вторая допустимая политика — сразу отсекать любые пакеты с меткой a.Is4In6() == true, если прокси перед сервисом обязан передавать только чистые адреса.

Добавим вызов Unmap() в проверку нашего сервиса для подсети 192.0.2.0/24 и клиента ::ffff:192.0.2.10:

package main

import (
    "fmt"
    "net/netip"
)

func main() {
    p := netip.MustParsePrefix("192.0.2.0/24")
    a := netip.MustParseAddr("::ffff:192.0.2.10")
    clean := a.Unmap()

    fmt.Println("До Unmap:", p.Contains(a))
    fmt.Println("После Unmap:", p.Contains(clean))
    fmt.Printf("Чистый адрес: %s (Is4: %v, BitLen: %d)\n",
        clean.String(), clean.Is4(), clean.BitLen())
}
// Вывод (Go 1.27.3): До Unmap: false | После Unmap: true | Чистый адрес: 192.0.2.10 (Is4: true, BitLen: 32)

Вызов a.Unmap() снимает конфликт семейств: clean становится 32-битным адресом 192.0.2.10 (Is4() == true), и p.Contains(clean) возвращает true. Сервис пропускает клиента из 192.0.2.0/24, а в черных списках ::ffff:127.0.0.1 раскрывается в 127.0.0.1 и блокируется правилом 127.0.0.0/8. Заодно Unmap() защищает структуры в памяти: когда netip.Addr служит ключом в map для подсчета лимитов запросов, распаковка не дает одному клиенту получить две квоты под ключами 192.0.2.10 и ::ffff:192.0.2.10.

Границы применимости: почему одного Unmap мало для защиты от SSRF

Распаковка через Unmap() решает задачу проверки известного IP, но при защите от SSRF (Server-Side Request Forgery) — когда сервис загружает данные по внешней ссылке пользователя и рискует обратиться к внутренним узлам или метаданным облака (169.254.169.254) — этого мало. Между разбором URL и соединением лежат два этапа:

  1. Проверка адреса после ответа DNS (защита от DNS Rebinding). Если проверить IP домена до передачи ссылки в http.Client, DNS-сервер атакующего может сначала вернуть разрешенный адрес 192.0.2.10, а в момент открытия сокета отдать 127.0.0.1 или ::ffff:169.254.169.254 (о влиянии динамических ответов DNS на фильтрацию мы писали в разборе контроллера fqdn-network-policy для Kubernetes). Поэтому Unmap() и сверку префиксов выполняют после разрешения DNS — внутри хука net.Dialer.Control на фактическом адресе подключения.
  2. Проверка редиректов. Узел 192.0.2.10 может пройти проверку, но ответить кодом 302 Found с перенаправлением на http://[::ffff:127.0.0.1]/admin. Безопасный клиент либо запрещает редиректы, либо проверяет каждый переход на уровне сокета.
Почему нельзя строить защиту вокруг метода Addr.IsPrivate()

Документация net/netip предупреждает: Addr.IsPrivate() не подходит для контроля доступа. Он проверяет только приватные сети RFC 1918 (10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16) и RFC 4193 (fc00::/7), пропуская петлю 127.0.0.0/8 (::1/128) и метаданные 169.254.0.0/16. К тому же без Unmap() на ::ffff:10.0.0.1 он тоже вернет false.

Впрочем, городить перехватчики сокетов в каждом внутреннем скрипте не нужно. Здравый смысл требует соизмерять защиту с задачей: если служба общается только со своей базой и фиксированными API внутри закрытого контура, сложные обертки над net.Dialer лишь захламят код. Достаточно сделать короткий вызов .Unmap() базовой привычкой при любой сверке IP с Prefix.Contains, а фильтрацию сокетов после DNS и контроль редиректов включать там, где сервер ходит по ссылкам из чужих рук.

Хочу подробный разборГолоса помогают выбрать, что разобрать подробно. За этот материал 0 голосов.
Источники · 2