Признаюсь честно: двойная запись сетевых адресов на стыке старого и нового протоколов поначалу путает даже тех, кто пишет серверный код не первый год. Когда ты смотришь в журнал подключений и видишь строку с префиксом ::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 и соединением лежат два этапа:
- Проверка адреса после ответа 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на фактическом адресе подключения. - Проверка редиректов. Узел
192.0.2.10может пройти проверку, но ответить кодом302 Foundс перенаправлением наhttp://[::ffff:127.0.0.1]/admin. Безопасный клиент либо запрещает редиректы, либо проверяет каждый переход на уровне сокета.
Документация 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 и контроль редиректов включать там, где сервер ходит по ссылкам из чужих рук.


