mirror of https://github.com/bol-van/zapret/
allkatran
5 months ago
committed by
GitHub
GitHub
26 changed files with 661 additions and 448 deletions
@ -0,0 +1,41 @@ |
|||
--- a/src/extra/pktbuff.c
|
|||
+++ b/src/extra/pktbuff.c
|
|||
@@ -14,7 +14,7 @@
|
|||
#include <string.h> /* for memcpy */ |
|||
#include <stdbool.h> |
|||
|
|||
-#include <netinet/if_ether.h>
|
|||
+#include <linux/if_ether.h>
|
|||
#include <netinet/ip.h> |
|||
#include <netinet/tcp.h> |
|||
|
|||
--- a/src/nlmsg.c
|
|||
+++ b/src/nlmsg.c
|
|||
@@ -21,7 +21,7 @@
|
|||
|
|||
#include <linux/netfilter/nfnetlink_queue.h> |
|||
|
|||
-#include <libnetfilter_queue/libnetfilter_queue.h>
|
|||
+// #include <libnetfilter_queue/libnetfilter_queue.h>
|
|||
|
|||
#include "internal.h" |
|||
|
|||
--- a/src/extra/tcp.c
|
|||
+++ b/src/extra/tcp.c
|
|||
@@ -139,12 +139,16 @@ void nfq_tcp_compute_checksum_ipv6(struc
|
|||
* (union is compatible to any of its members) |
|||
* This means this part of the code is -fstrict-aliasing safe now. |
|||
*/ |
|||
+#ifndef __ANDROID__
|
|||
union tcp_word_hdr { |
|||
struct tcphdr hdr; |
|||
uint32_t words[5]; |
|||
}; |
|||
+#endif
|
|||
|
|||
+#ifndef tcp_flag_word
|
|||
#define tcp_flag_word(tp) ( ((union tcp_word_hdr *)(tp))->words[3]) |
|||
+#endif
|
|||
|
|||
/** |
|||
* nfq_pkt_snprintf_tcp_hdr - print tcp header into one buffer in a humnan |
|||
@ -1,133 +0,0 @@ |
|||
Index: WireGuard-0.0.20190123/src/cookie.c
|
|||
===================================================================
|
|||
--- WireGuard-0.0.20190123.orig/src/cookie.c
|
|||
+++ WireGuard-0.0.20190123/src/cookie.c
|
|||
@@ -193,6 +193,8 @@ void wg_cookie_message_create(struct mes
|
|||
xchacha20poly1305_encrypt(dst->encrypted_cookie, cookie, COOKIE_LEN, |
|||
macs->mac1, COOKIE_LEN, dst->nonce, |
|||
checker->cookie_encryption_key); |
|||
+ // MOD : randomize trash
|
|||
+ dst->header.trash = gen_trash();
|
|||
} |
|||
|
|||
void wg_cookie_message_consume(struct message_handshake_cookie *src, |
|||
Index: WireGuard-0.0.20190123/src/messages.h
|
|||
===================================================================
|
|||
--- WireGuard-0.0.20190123.orig/src/messages.h
|
|||
+++ WireGuard-0.0.20190123/src/messages.h
|
|||
@@ -53,23 +53,41 @@ enum limits {
|
|||
MAX_QUEUED_PACKETS = 1024 /* TODO: replace this with DQL */ |
|||
}; |
|||
|
|||
+/*
|
|||
enum message_type { |
|||
- MESSAGE_INVALID = 0,
|
|||
- MESSAGE_HANDSHAKE_INITIATION = 1,
|
|||
- MESSAGE_HANDSHAKE_RESPONSE = 2,
|
|||
- MESSAGE_HANDSHAKE_COOKIE = 3,
|
|||
- MESSAGE_DATA = 4
|
|||
+ MESSAGE_INVALID = 0,
|
|||
+ MESSAGE_HANDSHAKE_INITIATION = 1,
|
|||
+ MESSAGE_HANDSHAKE_RESPONSE = 2,
|
|||
+ MESSAGE_HANDSHAKE_COOKIE = 3,
|
|||
+ MESSAGE_DATA = 4
|
|||
}; |
|||
+*/
|
|||
+
|
|||
+// MOD : message type
|
|||
+enum message_type {
|
|||
+ MESSAGE_INVALID = 0xE319CCD0,
|
|||
+ MESSAGE_HANDSHAKE_INITIATION = 0x48ADE198,
|
|||
+ MESSAGE_HANDSHAKE_RESPONSE = 0xFCA6A8F3,
|
|||
+ MESSAGE_HANDSHAKE_COOKIE = 0x64A3BB18,
|
|||
+ MESSAGE_DATA = 0x391820AA
|
|||
+};
|
|||
+
|
|||
+// MOD : generate fast trash without true RNG
|
|||
+__le32 gen_trash(void);
|
|||
|
|||
struct message_header { |
|||
- /* The actual layout of this that we want is:
|
|||
- * u8 type
|
|||
- * u8 reserved_zero[3]
|
|||
- *
|
|||
- * But it turns out that by encoding this as little endian,
|
|||
- * we achieve the same thing, and it makes checking faster.
|
|||
- */
|
|||
- __le32 type;
|
|||
+ /* The actual layout of this that we want is:
|
|||
+ * u8 type
|
|||
+ * u8 reserved_zero[3]
|
|||
+ *
|
|||
+ * But it turns out that by encoding this as little endian,
|
|||
+ * we achieve the same thing, and it makes checking faster.
|
|||
+ */
|
|||
+
|
|||
+ // MOD : trash field to change message size and add 4 byte offset to all fields
|
|||
+ __le32 trash;
|
|||
+
|
|||
+ __le32 type;
|
|||
}; |
|||
|
|||
struct message_macs { |
|||
Index: WireGuard-0.0.20190123/src/noise.c
|
|||
===================================================================
|
|||
--- WireGuard-0.0.20190123.orig/src/noise.c
|
|||
+++ WireGuard-0.0.20190123/src/noise.c
|
|||
@@ -17,6 +17,24 @@
|
|||
#include <linux/highmem.h> |
|||
#include <crypto/algapi.h> |
|||
|
|||
+
|
|||
+// MOD : trash generator
|
|||
+__le32 gtrash = 0;
|
|||
+__le32 gen_trash(void)
|
|||
+{
|
|||
+ if (gtrash)
|
|||
+ gtrash = gtrash*1103515243 + 12345;
|
|||
+ else
|
|||
+ // first value is true random
|
|||
+ get_random_bytes_wait(>rash, sizeof(gtrash));
|
|||
+ return gtrash;
|
|||
+}
|
|||
+
|
|||
/* This implements Noise_IKpsk2: |
|||
* |
|||
* <- s |
|||
@@ -515,6 +533,10 @@ wg_noise_handshake_create_initiation(str
|
|||
&handshake->entry); |
|||
|
|||
handshake->state = HANDSHAKE_CREATED_INITIATION; |
|||
+
|
|||
+ // MOD : randomize trash
|
|||
+ dst->header.trash = gen_trash();
|
|||
+
|
|||
ret = true; |
|||
|
|||
out: |
|||
@@ -655,6 +677,10 @@ bool wg_noise_handshake_create_response(
|
|||
&handshake->entry); |
|||
|
|||
handshake->state = HANDSHAKE_CREATED_RESPONSE; |
|||
+
|
|||
+ // MOD : randomize trash
|
|||
+ dst->header.trash = gen_trash();
|
|||
+
|
|||
ret = true; |
|||
|
|||
out: |
|||
Index: WireGuard-0.0.20190123/src/send.c
|
|||
===================================================================
|
|||
--- WireGuard-0.0.20190123.orig/src/send.c
|
|||
+++ WireGuard-0.0.20190123/src/send.c
|
|||
@@ -200,6 +200,10 @@ static bool encrypt_packet(struct sk_buf
|
|||
header->header.type = cpu_to_le32(MESSAGE_DATA); |
|||
header->key_idx = keypair->remote_index; |
|||
header->counter = cpu_to_le64(PACKET_CB(skb)->nonce); |
|||
+
|
|||
+ // MOD : randomize trash
|
|||
+ header->header.trash = gen_trash();
|
|||
+
|
|||
pskb_put(skb, trailer, trailer_len); |
|||
|
|||
/* Now we can encrypt the scattergather segments */ |
|||
@ -1,250 +0,0 @@ |
|||
!!! Эта инструкция написана еще до включения wireguard в ядро linux. |
|||
!!! Процесс сборки для in-tree модулей отличается. |
|||
!!! Цель данного чтива - дать идею для программистов как можно исправить исходники wireguard |
|||
!!! для преодоления DPI. Автор не преследует цели поддерживать готовые патчи для актуальных версий. |
|||
!!! Вместо патчинга гораздо проще использовать навесное решение ipobfs. |
|||
|
|||
Посвящено возможной блокировке в РФ VPN протоколов через DPI. |
|||
Предпосылками являются последние законодательные акты и во всю сочащиеся "секретные" записки. |
|||
В РФ разрабатываются и готовятся к применению более продвинутые решения по блокировке трафика. |
|||
Вполне вероятно будут резать стандартные VPN протоколы. Нам надо быть к этому готовыми. |
|||
|
|||
Один из возможных и перспективных путей решения данного вопроса - кустомная модификация |
|||
исходников VPN с целью незначительного изменения протокола, ломающего стандартные модули обнаружения в DPI. |
|||
Это относительно сложно, доступно только для гиков. |
|||
Никто не будет разрабатывать специальные модули обнаружения в DPI, если только кто-то не сделает простое и |
|||
удобное решение для всех, и его станут широко применять. Но это маловероятно, и даже если и так, |
|||
то всегда можно модифицировать протокол чуток по другому. Делать моды для DPI несравненно дольше |
|||
и дороже, чем клепать на коленке изменения протокола для wireguard. |
|||
|
|||
|
|||
ЗАМЕЧЕНИЕ : альтернативой модификации конечного софта для VPN является использование "навесных" |
|||
обфускаторов. см : https://github.com/bol-van/ipobfs |
|||
|
|||
|
|||
Рассмотрю что нам надо пропатчить в wireguard. Модифицированный wireguard проверен на виртуалках |
|||
с десктопным linux, он работает, сообщения в wireshark действительно не вписываются в стандартный |
|||
протокол и не опознаются. |
|||
|
|||
Wireguard протокол очень простой. Все сообщения описаны в messages.h |
|||
Поставим себе целью сделать 2 простые модификации : |
|||
1) Добавим в начало всех сообщений немного мусора, чтобы изменить размер сообщений и смещения полей |
|||
2) Изменим коды типов сообщений |
|||
Этого может быть вполне достаточно для обмана DPI |
|||
|
|||
--messages.h-------------------------- |
|||
/* |
|||
enum message_type { |
|||
MESSAGE_INVALID = 0, |
|||
MESSAGE_HANDSHAKE_INITIATION = 1, |
|||
MESSAGE_HANDSHAKE_RESPONSE = 2, |
|||
MESSAGE_HANDSHAKE_COOKIE = 3, |
|||
MESSAGE_DATA = 4 |
|||
}; |
|||
*/ |
|||
|
|||
// MOD : message type |
|||
enum message_type { |
|||
MESSAGE_INVALID = 0xE319CCD0, |
|||
MESSAGE_HANDSHAKE_INITIATION = 0x48ADE198, |
|||
MESSAGE_HANDSHAKE_RESPONSE = 0xFCA6A8F3, |
|||
MESSAGE_HANDSHAKE_COOKIE = 0x64A3BB18, |
|||
MESSAGE_DATA = 0x391820AA |
|||
}; |
|||
|
|||
// MOD : generate fast trash without true RNG |
|||
__le32 gen_trash(void); |
|||
|
|||
struct message_header { |
|||
/* The actual layout of this that we want is: |
|||
* u8 type |
|||
* u8 reserved_zero[3] |
|||
* |
|||
* But it turns out that by encoding this as little endian, |
|||
* we achieve the same thing, and it makes checking faster. |
|||
*/ |
|||
|
|||
// MOD : trash field to change message size and add 4 byte offset to all fields |
|||
__le32 trash; |
|||
|
|||
__le32 type; |
|||
}; |
|||
-------------------------------------- |
|||
|
|||
Напишем функцию для генерации trash. Функция должна быть быстрая, важно не замедлить скорость. |
|||
Мы не расчитываем, что нас будут специально ловить, иначе бы пришлось делать полноценный обфускатор. |
|||
Задача лишь сломать стандартный модуль обнаружения протокола wireguard. Потому истинная рандомность |
|||
trash не важна. |
|||
Но все же немного "трэша" не повредит. Гонки между тредами так же пофигистичны. Это же трэш. |
|||
|
|||
--noise.c----------------------------- |
|||
// MOD : trash generator |
|||
__le32 gtrash = 0; |
|||
__le32 gen_trash(void) |
|||
{ |
|||
if (gtrash) |
|||
gtrash = gtrash*1103515243 + 12345; |
|||
else |
|||
// first value is true random |
|||
get_random_bytes_wait(>rash, sizeof(gtrash)); |
|||
return gtrash; |
|||
} |
|||
-------------------------------------- |
|||
|
|||
Теперь осталось найти все места, где создаются сообщения и внести туда заполнение поля trash. |
|||
Сообщений всего 4. Их можно найти по присваиванию полю type одного из значений enum message_type. |
|||
|
|||
2 места в noise.c в функциях wg_noise_handshake_create_initiation и wg_noise_handshake_create_response, |
|||
1 место в cookie.c в функции wg_cookie_message_create |
|||
Дописываем в конец инициализации структуры сообщения : |
|||
|
|||
-------------------------------------- |
|||
// MOD : randomize trash |
|||
dst->header.trash = gen_trash(); |
|||
-------------------------------------- |
|||
|
|||
и 1 место в send.c в функции encrypt_packet |
|||
|
|||
-------------------------------------- |
|||
// MOD : randomize trash |
|||
header->header.trash = gen_trash(); |
|||
-------------------------------------- |
|||
|
|||
|
|||
Вот и весь патчинг. Полный patch (версия wireguard 0.0.20190123) лежит в 010-wg-mod.patch. |
|||
Патчинг кода - самое простое. Для десктопного linux дальше все просто. |
|||
Пересобираем через make, устанавливаем через make install, перегружаем |
|||
модуль wireguard, перезапускаем интерфейсы, и все готово. |
|||
|
|||
Настоящий геморой начнется когда вы это попытаетесь засунуть на роутер под openwrt. |
|||
Одна из больших проблем linux - отсутствие совместимости драйверов на уровне бинариков. |
|||
Поэтому собирать необходимо в точности под вашу версию ядра и в точности под его .config. |
|||
Вам придется либо полностью самостоятельно собирать всю прошивку, либо найти SDK в точности |
|||
от вашей версии прошивки для вашей архитектуры и собрать модуль с помощью этого SDK. |
|||
Последний вариант более легкий. |
|||
Для сборки вам понадобится система на linux x86_64. Ее можно установить в виртуалке. |
|||
Теоретически можно пользоваться WSL из win10, но на практике там очень медленное I/O, |
|||
по крайней мере на старых версиях win10. Безумно медленное. Будете собирать вечность. |
|||
Может в новых win10 что-то и улучшили, но я бы сразу расчитывал на полноценный linux. |
|||
|
|||
Находим здесь вашу версию : https://downloads.openwrt.org/ |
|||
Скачиваем файл openwrt-sdk-*.tar.xz или lede-sdk-*.tar.xz |
|||
Например : https://downloads.openwrt.org/releases/18.06.2/targets/ar71xx/generic/openwrt-sdk-18.06.2-ar71xx-generic_gcc-7.3.0_musl.Linux-x86_64.tar.xz |
|||
Если ваша версия непонятна или стара, то проще будет найти последнюю прошивку и перешить роутер. |
|||
Распаковываем SDK. Следующими командами можно собрать оригинальный вариант wireguard : |
|||
|
|||
# scripts/feeds update -a |
|||
# scripts/feeds install -a |
|||
# make defconfig |
|||
# make -j 4 package/wireguard/compile |
|||
|
|||
Сборка будет довольно долгой. Ведь придется подтащить ядро, собрать его, собрать зависимости. |
|||
"-j 4" означает использовать 4 потока. Впишите вместо 4 количество доступных cpu cores. |
|||
|
|||
Получим следующие файлы : |
|||
|
|||
openwrt-sdk-18.06.2-ar71xx-generic_gcc-7.3.0_musl.Linux-x86_64/bin/targets/ar71xx/generic/packages/kmod-wireguard_4.9.152+0.0.20190123-1_mips_24kc.ipk |
|||
openwrt-sdk-18.06.2-ar71xx-generic_gcc-7.3.0_musl.Linux-x86_64/bin/packages/mips_24kc/base/wireguard-tools_0.0.20190123-1_mips_24kc.ipk |
|||
|
|||
Но это будет оригинальный wireguard. Нам нужен патченый. |
|||
Установим quilt и mc для нормального редактора вместо vim : |
|||
|
|||
# sudo apt-get update |
|||
# sudo apt-get install quilt mc |
|||
|
|||
# make package/wireguard/clean |
|||
# make package/wireguard/prepare V=s QUILT=1 |
|||
|
|||
|
|||
Сорцы приготовлены для сборки в : |
|||
openwrt-sdk-18.06.2-ar71xx-generic_gcc-7.3.0_musl.Linux-x86_64/build_dir/target-mips_24kc_musl/linux-ar71xx_generic/WireGuard-0.0.20190123/src |
|||
|
|||
# cd build_dir/target-mips_24kc_musl/linux-ar71xx_generic/WireGuard-0.0.20190123/src |
|||
# quilt push -a |
|||
# quilt new 010-wg-mod.patch |
|||
# export EDITOR=mcedit |
|||
|
|||
Далее будет открываться редактор mcedit, в который нужно вносить изменения в каждый файл : |
|||
|
|||
# quilt edit messages.h |
|||
# quilt edit cookie.c |
|||
# quilt edit noise.c |
|||
# quilt edit send.c |
|||
# quilt diff |
|||
# quilt refresh |
|||
|
|||
Получили файл патча в : |
|||
openwrt-sdk-18.06.2-ar71xx-generic_gcc-7.3.0_musl.Linux-x86_64/build_dir/target-mips_24kc_musl/linux-ar71xx_generic/WireGuard-0.0.20190123/patches/010-wg-mod.patch |
|||
|
|||
Выходим в корень SDK. |
|||
|
|||
# make package/wireguard/compile V=99 |
|||
|
|||
Если не было ошибок, то получили измененные ipk. |
|||
Патч можно зафиксировать в описании пакета : |
|||
|
|||
# make package/wireguard/update |
|||
|
|||
Получим : |
|||
openwrt-sdk-18.06.2-ar71xx-generic_gcc-7.3.0_musl.Linux-x86_64/feeds/base/package/network/services/wireguard/patches/010-wg-mod.patch |
|||
При последующей очистке и пересборке он будет автоматом применяться. |
|||
|
|||
|
|||
АЛЬТЕРНАТИВА : можно не возиться с quilt. |
|||
сделайте |
|||
# make package/wireguard/clean |
|||
# make package/wireguard/prepare |
|||
и напрямую модифицируйте или копируйте файлы в |
|||
openwrt-sdk-18.06.2-ar71xx-generic_gcc-7.3.0_musl.Linux-x86_64/build_dir/target-mips_24kc_musl/linux-ar71xx_generic/WireGuard-0.0.20190123/src |
|||
затем |
|||
# make package/wireguard/compile |
|||
|
|||
Если нужно поменять версию wireguard, то идите в |
|||
openwrt-sdk-18.06.2-ar71xx-generic_gcc-7.3.0_musl.Linux-x86_64/feeds/base/package/network/services/wireguard/Makefile |
|||
поменяйте там версию в PKG_VERSION на последнюю из : https://git.zx2c4.com/WireGuard |
|||
скачайте tar.xz с этой версией , вычислите его sha256sum, впишите в PKG_HASH |
|||
|
|||
1 раз где-нибудь пропатчите файлы последней версии wireguard в текстовом редакторе, скопируйте в build_dir, |
|||
сделайте версию для openwrt. эти же файлы скопируйте на ваш сервер с десктопным linux, сделайте там make / make install |
|||
|
|||
Но имейте в виду, что build_dir - локация для временных файлов. |
|||
make clean оттуда все снесет, включая ваши модификации. Модифицированные файлы лучше сохранить отдельно, |
|||
чтобы потом было легко скопировать обратно. |
|||
|
|||
Полученные ipk копируем на роутер в /tmp, устанавливаем через |
|||
# cd /tmp |
|||
# rm -r /tmp/opkg-lists |
|||
# opkg install *.ipk |
|||
Если требует зависимостей, то |
|||
# opkg update |
|||
# opkg install .... <зависимости> |
|||
# rm -r /tmp/opkg-lists |
|||
# opkg install *.ipk |
|||
|
|||
В /tmp/opkg-lists opkg хранит кэш списка пакетов. Если попытаться установить файл ipk, и такой же пакет |
|||
найдется в репозитории, opkg будет устанавливать из репозитория. А нам это не надо. |
|||
|
|||
# rmmod wireguard |
|||
# kmodloader |
|||
# dmesg | tail |
|||
должны увидеть что-то вроде : |
|||
[8985.415490] wireguard: WireGuard 0.0.20190123 loaded. See www.wireguard.com for information. |
|||
[8985.424178] wireguard: Copyright (C) 2015-2019 Jason A. Donenfeld <[email protected]>. All Rights Reserved. |
|||
значит модуль загрузился |
|||
|
|||
Могут понадобиться ключи opkg --force-reinstall, --force-depends. |
|||
--force-depends поможет при несоответствии hash версии ядра. То есть версия x.x.x та же самая, но hash конфигурации разный. |
|||
При несоответствии x.x.x вы что-то делаете не так, работать это не будет. |
|||
Например : 4.14.56-1-b1186491495127cc6ff81d29c00a91fc, 4.14.56-1-3f8a21a63974cfb7ee67e41f2d4b805d |
|||
Это свидетельствует о несоответствии .config ядра при сборке прошивки и в SDK. |
|||
Если несоответствие легкое, то может все прокатить, но при более серьезной разнице в .config модуль может не загрузиться |
|||
или вызвать стабильные или хаотические падения ядра и перезагрузки (включая вариант беcконечной перезагрузки - bootloop). |
|||
Так что перед --force-depends убедитесь, что знаете как лечится такая ситуация, и не стоит это делать при отсутствии физического |
|||
доступа к девайсу. |
|||
|
|||
Когда поднимите линк, и вдруг ничего не будет работать, то посмотрите в wireshark udp пакеты |
|||
на порт endpoint. Они не должны начинаться с 0,1,2,3,4. В первых 4 байтах должен быть рандом, |
|||
в следующих 4 байтах - значения из измененного enum message_type. Если пакет все еще начинается с 0..4, |
|||
значит модуль wireguard оригинальный, что-то не собралось, не скопировалось, не перезапустилось. |
|||
В противном случае должен подняться линк, пинги ходить. Значит вы победили, поздравляю. |
|||
Регулятору будет намного сложнее поймать ваш VPN. |
|||
Binary file not shown.
@ -0,0 +1,26 @@ |
|||
Code in this dir is taken from musl libc to support old android versions <7.0 |
|||
|
|||
musl as a whole is licensed under the following standard MIT license: |
|||
|
|||
---------------------------------------------------------------------- |
|||
Copyright © 2005-2020 Rich Felker, et al. |
|||
|
|||
Permission is hereby granted, free of charge, to any person obtaining |
|||
a copy of this software and associated documentation files (the |
|||
"Software"), to deal in the Software without restriction, including |
|||
without limitation the rights to use, copy, modify, merge, publish, |
|||
distribute, sublicense, and/or sell copies of the Software, and to |
|||
permit persons to whom the Software is furnished to do so, subject to |
|||
the following conditions: |
|||
|
|||
The above copyright notice and this permission notice shall be |
|||
included in all copies or substantial portions of the Software. |
|||
|
|||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
|||
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
|||
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. |
|||
IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY |
|||
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, |
|||
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE |
|||
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
|||
---------------------------------------------------------------------- |
|||
@ -0,0 +1,216 @@ |
|||
#define _GNU_SOURCE |
|||
#include <errno.h> |
|||
#include <string.h> |
|||
#include <stdlib.h> |
|||
#include <unistd.h> |
|||
#include <ifaddrs.h> |
|||
#include <syscall.h> |
|||
#include <net/if.h> |
|||
#include <netinet/in.h> |
|||
#include "netlink.h" |
|||
|
|||
#define IFADDRS_HASH_SIZE 64 |
|||
|
|||
/* getifaddrs() reports hardware addresses with PF_PACKET that implies
|
|||
* struct sockaddr_ll. But e.g. Infiniband socket address length is |
|||
* longer than sockaddr_ll.ssl_addr[8] can hold. Use this hack struct |
|||
* to extend ssl_addr - callers should be able to still use it. */ |
|||
struct sockaddr_ll_hack { |
|||
unsigned short sll_family, sll_protocol; |
|||
int sll_ifindex; |
|||
unsigned short sll_hatype; |
|||
unsigned char sll_pkttype, sll_halen; |
|||
unsigned char sll_addr[24]; |
|||
}; |
|||
|
|||
union sockany { |
|||
struct sockaddr sa; |
|||
struct sockaddr_ll_hack ll; |
|||
struct sockaddr_in v4; |
|||
struct sockaddr_in6 v6; |
|||
}; |
|||
|
|||
struct ifaddrs_storage { |
|||
struct ifaddrs ifa; |
|||
struct ifaddrs_storage *hash_next; |
|||
union sockany addr, netmask, ifu; |
|||
unsigned int index; |
|||
char name[IFNAMSIZ+1]; |
|||
}; |
|||
|
|||
struct ifaddrs_ctx { |
|||
struct ifaddrs *first; |
|||
struct ifaddrs *last; |
|||
struct ifaddrs_storage *hash[IFADDRS_HASH_SIZE]; |
|||
}; |
|||
|
|||
void freeifaddrs(struct ifaddrs *ifp) |
|||
{ |
|||
struct ifaddrs *n; |
|||
while (ifp) { |
|||
n = ifp->ifa_next; |
|||
free(ifp); |
|||
ifp = n; |
|||
} |
|||
} |
|||
|
|||
static void copy_addr(struct sockaddr **r, int af, union sockany *sa, void *addr, size_t addrlen, int ifindex) |
|||
{ |
|||
uint8_t *dst; |
|||
int len; |
|||
|
|||
switch (af) { |
|||
case AF_INET: |
|||
dst = (uint8_t*) &sa->v4.sin_addr; |
|||
len = 4; |
|||
break; |
|||
case AF_INET6: |
|||
dst = (uint8_t*) &sa->v6.sin6_addr; |
|||
len = 16; |
|||
if (IN6_IS_ADDR_LINKLOCAL(addr) || IN6_IS_ADDR_MC_LINKLOCAL(addr)) |
|||
sa->v6.sin6_scope_id = ifindex; |
|||
break; |
|||
default: |
|||
return; |
|||
} |
|||
if (addrlen < len) return; |
|||
sa->sa.sa_family = af; |
|||
memcpy(dst, addr, len); |
|||
*r = &sa->sa; |
|||
} |
|||
|
|||
static void gen_netmask(struct sockaddr **r, int af, union sockany *sa, int prefixlen) |
|||
{ |
|||
uint8_t addr[16] = {0}; |
|||
int i; |
|||
|
|||
if (prefixlen > 8*sizeof(addr)) prefixlen = 8*sizeof(addr); |
|||
i = prefixlen / 8; |
|||
memset(addr, 0xff, i); |
|||
if (i < sizeof(addr)) addr[i++] = 0xff << (8 - (prefixlen % 8)); |
|||
copy_addr(r, af, sa, addr, sizeof(addr), 0); |
|||
} |
|||
|
|||
static void copy_lladdr(struct sockaddr **r, union sockany *sa, void *addr, size_t addrlen, int ifindex, unsigned short hatype) |
|||
{ |
|||
if (addrlen > sizeof(sa->ll.sll_addr)) return; |
|||
sa->ll.sll_family = AF_PACKET; |
|||
sa->ll.sll_ifindex = ifindex; |
|||
sa->ll.sll_hatype = hatype; |
|||
sa->ll.sll_halen = addrlen; |
|||
memcpy(sa->ll.sll_addr, addr, addrlen); |
|||
*r = &sa->sa; |
|||
} |
|||
|
|||
static int netlink_msg_to_ifaddr(void *pctx, struct nlmsghdr *h) |
|||
{ |
|||
struct ifaddrs_ctx *ctx = pctx; |
|||
struct ifaddrs_storage *ifs, *ifs0; |
|||
struct ifinfomsg *ifi = NLMSG_DATA(h); |
|||
struct ifaddrmsg *ifa = NLMSG_DATA(h); |
|||
struct rtattr *rta; |
|||
int stats_len = 0; |
|||
|
|||
if (h->nlmsg_type == RTM_NEWLINK) { |
|||
for (rta = NLMSG_RTA(h, sizeof(*ifi)); NLMSG_RTAOK(rta, h); rta = RTA_NEXT(rta)) { |
|||
if (rta->rta_type != IFLA_STATS) continue; |
|||
stats_len = RTA_DATALEN(rta); |
|||
break; |
|||
} |
|||
} else { |
|||
for (ifs0 = ctx->hash[ifa->ifa_index % IFADDRS_HASH_SIZE]; ifs0; ifs0 = ifs0->hash_next) |
|||
if (ifs0->index == ifa->ifa_index) |
|||
break; |
|||
if (!ifs0) return 0; |
|||
} |
|||
|
|||
ifs = calloc(1, sizeof(struct ifaddrs_storage) + stats_len); |
|||
if (ifs == 0) return -1; |
|||
|
|||
if (h->nlmsg_type == RTM_NEWLINK) { |
|||
ifs->index = ifi->ifi_index; |
|||
ifs->ifa.ifa_flags = ifi->ifi_flags; |
|||
|
|||
for (rta = NLMSG_RTA(h, sizeof(*ifi)); NLMSG_RTAOK(rta, h); rta = RTA_NEXT(rta)) { |
|||
switch (rta->rta_type) { |
|||
case IFLA_IFNAME: |
|||
if (RTA_DATALEN(rta) < sizeof(ifs->name)) { |
|||
memcpy(ifs->name, RTA_DATA(rta), RTA_DATALEN(rta)); |
|||
ifs->ifa.ifa_name = ifs->name; |
|||
} |
|||
break; |
|||
case IFLA_ADDRESS: |
|||
copy_lladdr(&ifs->ifa.ifa_addr, &ifs->addr, RTA_DATA(rta), RTA_DATALEN(rta), ifi->ifi_index, ifi->ifi_type); |
|||
break; |
|||
case IFLA_BROADCAST: |
|||
copy_lladdr(&ifs->ifa.ifa_broadaddr, &ifs->ifu, RTA_DATA(rta), RTA_DATALEN(rta), ifi->ifi_index, ifi->ifi_type); |
|||
break; |
|||
case IFLA_STATS: |
|||
ifs->ifa.ifa_data = (void*)(ifs+1); |
|||
memcpy(ifs->ifa.ifa_data, RTA_DATA(rta), RTA_DATALEN(rta)); |
|||
break; |
|||
} |
|||
} |
|||
if (ifs->ifa.ifa_name) { |
|||
unsigned int bucket = ifs->index % IFADDRS_HASH_SIZE; |
|||
ifs->hash_next = ctx->hash[bucket]; |
|||
ctx->hash[bucket] = ifs; |
|||
} |
|||
} else { |
|||
ifs->ifa.ifa_name = ifs0->ifa.ifa_name; |
|||
ifs->ifa.ifa_flags = ifs0->ifa.ifa_flags; |
|||
for (rta = NLMSG_RTA(h, sizeof(*ifa)); NLMSG_RTAOK(rta, h); rta = RTA_NEXT(rta)) { |
|||
switch (rta->rta_type) { |
|||
case IFA_ADDRESS: |
|||
/* If ifa_addr is already set we, received an IFA_LOCAL before
|
|||
* so treat this as destination address */ |
|||
if (ifs->ifa.ifa_addr) |
|||
copy_addr(&ifs->ifa.ifa_dstaddr, ifa->ifa_family, &ifs->ifu, RTA_DATA(rta), RTA_DATALEN(rta), ifa->ifa_index); |
|||
else |
|||
copy_addr(&ifs->ifa.ifa_addr, ifa->ifa_family, &ifs->addr, RTA_DATA(rta), RTA_DATALEN(rta), ifa->ifa_index); |
|||
break; |
|||
case IFA_BROADCAST: |
|||
copy_addr(&ifs->ifa.ifa_broadaddr, ifa->ifa_family, &ifs->ifu, RTA_DATA(rta), RTA_DATALEN(rta), ifa->ifa_index); |
|||
break; |
|||
case IFA_LOCAL: |
|||
/* If ifa_addr is set and we get IFA_LOCAL, assume we have
|
|||
* a point-to-point network. Move address to correct field. */ |
|||
if (ifs->ifa.ifa_addr) { |
|||
ifs->ifu = ifs->addr; |
|||
ifs->ifa.ifa_dstaddr = &ifs->ifu.sa; |
|||
memset(&ifs->addr, 0, sizeof(ifs->addr)); |
|||
} |
|||
copy_addr(&ifs->ifa.ifa_addr, ifa->ifa_family, &ifs->addr, RTA_DATA(rta), RTA_DATALEN(rta), ifa->ifa_index); |
|||
break; |
|||
case IFA_LABEL: |
|||
if (RTA_DATALEN(rta) < sizeof(ifs->name)) { |
|||
memcpy(ifs->name, RTA_DATA(rta), RTA_DATALEN(rta)); |
|||
ifs->ifa.ifa_name = ifs->name; |
|||
} |
|||
break; |
|||
} |
|||
} |
|||
if (ifs->ifa.ifa_addr) |
|||
gen_netmask(&ifs->ifa.ifa_netmask, ifa->ifa_family, &ifs->netmask, ifa->ifa_prefixlen); |
|||
} |
|||
|
|||
if (ifs->ifa.ifa_name) { |
|||
if (!ctx->first) ctx->first = &ifs->ifa; |
|||
if (ctx->last) ctx->last->ifa_next = &ifs->ifa; |
|||
ctx->last = &ifs->ifa; |
|||
} else { |
|||
free(ifs); |
|||
} |
|||
return 0; |
|||
} |
|||
|
|||
int getifaddrs(struct ifaddrs **ifap) |
|||
{ |
|||
struct ifaddrs_ctx _ctx, *ctx = &_ctx; |
|||
int r; |
|||
memset(ctx, 0, sizeof *ctx); |
|||
r = __rtnetlink_enumerate(AF_UNSPEC, AF_UNSPEC, netlink_msg_to_ifaddr, ctx); |
|||
if (r == 0) *ifap = ctx->first; |
|||
else freeifaddrs(ctx->first); |
|||
return r; |
|||
} |
|||
@ -0,0 +1,8 @@ |
|||
#pragma once |
|||
|
|||
#include <ifaddrs.h> |
|||
|
|||
#if __ANDROID_API__ < 24 |
|||
void freeifaddrs(struct ifaddrs *); |
|||
int getifaddrs(struct ifaddrs **); |
|||
#endif |
|||
@ -0,0 +1,54 @@ |
|||
#include <errno.h> |
|||
#include <string.h> |
|||
#include <syscall.h> |
|||
#include <sys/socket.h> |
|||
#include <unistd.h> |
|||
|
|||
#include "netlink.h" |
|||
|
|||
static int __netlink_enumerate(int fd, unsigned int seq, int type, int af, |
|||
int (*cb)(void *ctx, struct nlmsghdr *h), void *ctx) |
|||
{ |
|||
struct nlmsghdr *h; |
|||
union { |
|||
uint8_t buf[8192]; |
|||
struct { |
|||
struct nlmsghdr nlh; |
|||
struct rtgenmsg g; |
|||
} req; |
|||
struct nlmsghdr reply; |
|||
} u; |
|||
int r, ret; |
|||
|
|||
memset(&u.req, 0, sizeof(u.req)); |
|||
u.req.nlh.nlmsg_len = sizeof(u.req); |
|||
u.req.nlh.nlmsg_type = type; |
|||
u.req.nlh.nlmsg_flags = NLM_F_DUMP | NLM_F_REQUEST; |
|||
u.req.nlh.nlmsg_seq = seq; |
|||
u.req.g.rtgen_family = af; |
|||
r = send(fd, &u.req, sizeof(u.req), 0); |
|||
if (r < 0) return r; |
|||
|
|||
while (1) { |
|||
r = recv(fd, u.buf, sizeof(u.buf), MSG_DONTWAIT); |
|||
if (r <= 0) return -1; |
|||
for (h = &u.reply; NLMSG_OK(h, (void*)&u.buf[r]); h = NLMSG_NEXT(h)) { |
|||
if (h->nlmsg_type == NLMSG_DONE) return 0; |
|||
if (h->nlmsg_type == NLMSG_ERROR) return -1; |
|||
ret = cb(ctx, h); |
|||
if (ret) return ret; |
|||
} |
|||
} |
|||
} |
|||
|
|||
int __rtnetlink_enumerate(int link_af, int addr_af, int (*cb)(void *ctx, struct nlmsghdr *h), void *ctx) |
|||
{ |
|||
int fd, r; |
|||
|
|||
fd = socket(PF_NETLINK, SOCK_RAW|SOCK_CLOEXEC, NETLINK_ROUTE); |
|||
if (fd < 0) return -1; |
|||
r = __netlink_enumerate(fd, 1, RTM_GETLINK, link_af, cb, ctx); |
|||
if (!r) r = __netlink_enumerate(fd, 2, RTM_GETADDR, addr_af, cb, ctx); |
|||
close(fd); |
|||
return r; |
|||
} |
|||
@ -0,0 +1,94 @@ |
|||
#include <stdint.h> |
|||
|
|||
/* linux/netlink.h */ |
|||
|
|||
#define NETLINK_ROUTE 0 |
|||
|
|||
struct nlmsghdr { |
|||
uint32_t nlmsg_len; |
|||
uint16_t nlmsg_type; |
|||
uint16_t nlmsg_flags; |
|||
uint32_t nlmsg_seq; |
|||
uint32_t nlmsg_pid; |
|||
}; |
|||
|
|||
#define NLM_F_REQUEST 1 |
|||
#define NLM_F_MULTI 2 |
|||
#define NLM_F_ACK 4 |
|||
|
|||
#define NLM_F_ROOT 0x100 |
|||
#define NLM_F_MATCH 0x200 |
|||
#define NLM_F_ATOMIC 0x400 |
|||
#define NLM_F_DUMP (NLM_F_ROOT|NLM_F_MATCH) |
|||
|
|||
#define NLMSG_NOOP 0x1 |
|||
#define NLMSG_ERROR 0x2 |
|||
#define NLMSG_DONE 0x3 |
|||
#define NLMSG_OVERRUN 0x4 |
|||
|
|||
/* linux/rtnetlink.h */ |
|||
|
|||
#define RTM_NEWLINK 16 |
|||
#define RTM_GETLINK 18 |
|||
#define RTM_NEWADDR 20 |
|||
#define RTM_GETADDR 22 |
|||
|
|||
struct rtattr { |
|||
unsigned short rta_len; |
|||
unsigned short rta_type; |
|||
}; |
|||
|
|||
struct rtgenmsg { |
|||
unsigned char rtgen_family; |
|||
}; |
|||
|
|||
struct ifinfomsg { |
|||
unsigned char ifi_family; |
|||
unsigned char __ifi_pad; |
|||
unsigned short ifi_type; |
|||
int ifi_index; |
|||
unsigned ifi_flags; |
|||
unsigned ifi_change; |
|||
}; |
|||
|
|||
/* linux/if_link.h */ |
|||
|
|||
#define IFLA_ADDRESS 1 |
|||
#define IFLA_BROADCAST 2 |
|||
#define IFLA_IFNAME 3 |
|||
#define IFLA_STATS 7 |
|||
|
|||
/* linux/if_addr.h */ |
|||
|
|||
struct ifaddrmsg { |
|||
uint8_t ifa_family; |
|||
uint8_t ifa_prefixlen; |
|||
uint8_t ifa_flags; |
|||
uint8_t ifa_scope; |
|||
uint32_t ifa_index; |
|||
}; |
|||
|
|||
#define IFA_ADDRESS 1 |
|||
#define IFA_LOCAL 2 |
|||
#define IFA_LABEL 3 |
|||
#define IFA_BROADCAST 4 |
|||
|
|||
/* musl */ |
|||
|
|||
#define NETLINK_ALIGN(len) (((len)+3) & ~3) |
|||
#define NLMSG_DATA(nlh) ((void*)((char*)(nlh)+sizeof(struct nlmsghdr))) |
|||
#define NLMSG_DATALEN(nlh) ((nlh)->nlmsg_len-sizeof(struct nlmsghdr)) |
|||
#define NLMSG_DATAEND(nlh) ((char*)(nlh)+(nlh)->nlmsg_len) |
|||
#define NLMSG_NEXT(nlh) (struct nlmsghdr*)((char*)(nlh)+NETLINK_ALIGN((nlh)->nlmsg_len)) |
|||
#define NLMSG_OK(nlh,end) ((char*)(end)-(char*)(nlh) >= sizeof(struct nlmsghdr)) |
|||
|
|||
#define RTA_DATA(rta) ((void*)((char*)(rta)+sizeof(struct rtattr))) |
|||
#define RTA_DATALEN(rta) ((rta)->rta_len-sizeof(struct rtattr)) |
|||
#define RTA_DATAEND(rta) ((char*)(rta)+(rta)->rta_len) |
|||
#define RTA_NEXT(rta) (struct rtattr*)((char*)(rta)+NETLINK_ALIGN((rta)->rta_len)) |
|||
#define RTA_OK(rta,end) ((char*)(end)-(char*)(rta) >= sizeof(struct rtattr)) |
|||
|
|||
#define NLMSG_RTA(nlh,len) ((void*)((char*)(nlh)+sizeof(struct nlmsghdr)+NETLINK_ALIGN(len))) |
|||
#define NLMSG_RTAOK(rta,nlh) RTA_OK(rta,NLMSG_DATAEND(nlh)) |
|||
|
|||
int __rtnetlink_enumerate(int link_af, int addr_af, int (*cb)(void *ctx, struct nlmsghdr *h), void *ctx); |
|||
Loading…
Reference in new issue