Ядрена обвивка над ICMP

TL; DR: Пиша модул на ядрото, който ще чете команди от ICMP полезния товар и ще ги изпълнява на сървъра, дори ако вашият SSH се срине. За най-нетърпеливите, целият код е GitHub.

Внимание! Опитните C програмисти рискуват да избухнат в кървави сълзи! Може дори да греша в терминологията, но всяка критика е добре дошла. Публикацията е предназначена за тези, които имат много груба представа за програмирането на C и искат да надникнат в вътрешността на Linux.

В коментарите към първия ми Статия спомена SoftEther VPN, който може да имитира някои „обикновени“ протоколи, по-специално HTTPS, ICMP и дори DNS. Мога да си представя само първия от тях да работи, тъй като съм много запознат с HTTP(S) и трябваше да науча тунелиране през ICMP и DNS.

Да, през 2020 г. научих, че можете да вмъкнете произволен полезен товар в ICMP пакети. Но по-добре късно отколкото никога! И тъй като нещо може да се направи по въпроса, значи трябва да се направи. Тъй като в ежедневието си най-често използвам командния ред, включително и през SSH, първо ми хрумна идеята за ICMP shell. И за да сглобя цялостно бинго за бикове, реших да го напиша като Linux модул на език, за който имам само груба представа. Такава обвивка няма да се вижда в списъка с процеси, можете да я заредите в ядрото и няма да бъде във файловата система, няма да видите нищо подозрително в списъка с слушащи портове. По отношение на възможностите си, това е пълноценен руткит, но се надявам да го подобря и да го използвам като обвивка в последна инстанция, когато средното натоварване е твърде високо, за да влезете през SSH и да изпълните поне echo i > /proc/sysrq-triggerза възстановяване на достъпа без рестартиране.

Взимаме текстов редактор, основни умения за програмиране на Python и C, Google и виртуален които нямате нищо против да хвърлите под ножа, ако всичко се счупи (по избор - локален VirtualBox/KVM/и т.н.) и да тръгваме!

Клиентска страна

Струваше ми се, че за клиентската част ще трябва да напиша скрипт с около 80 реда, но имаше мили хора, които го направиха вместо мен цялата работа. Кодът се оказа неочаквано прост, вписвайки се в 10 значими реда:

import sys
from scapy.all import sr1, IP, ICMP

if len(sys.argv) < 3:
    print('Usage: {} IP "command"'.format(sys.argv[0]))
    exit(0)

p = sr1(IP(dst=sys.argv[1])/ICMP()/"run:{}".format(sys.argv[2]))
if p:
    p.show()

Скриптът приема два аргумента, адрес и полезен товар. Преди изпращане полезният товар се предхожда от ключ run:, ще ни трябва, за да изключим пакети с произволни полезни натоварвания.

Ядрото изисква привилегии за създаване на пакети, така че скриптът ще трябва да се изпълнява като суперпотребител. Не забравяйте да дадете разрешения за изпълнение и да инсталирате самия scapy. Debian има пакет, наречен python3-scapy. Сега можете да проверите как работи всичко.

Изпълнение и извеждане на командата
morq@laptop:~/icmpshell$ sudo ./send.py 45.11.26.232 "Hello, world!"
Begin emission:
.Finished sending 1 packets.
*
Received 2 packets, got 1 answers, remaining 0 packets
###[ IP ]###
version = 4
ihl = 5
tos = 0x0
len = 45
id = 17218
flags =
frag = 0
ttl = 58
proto = icmp
chksum = 0x3403
src = 45.11.26.232
dst = 192.168.0.240
options
###[ ICMP ]###
type = echo-reply
code = 0
chksum = 0xde03
id = 0x0
seq = 0x0
###[ Raw ]###
load = 'run:Hello, world!

Ето как изглежда в снифера
morq@laptop:~/icmpshell$ sudo tshark -i wlp1s0 -O icmp -f "icmp and host 45.11.26.232"
Running as user "root" and group "root". This could be dangerous.
Capturing on 'wlp1s0'
Frame 1: 59 bytes on wire (472 bits), 59 bytes captured (472 bits) on interface wlp1s0, id 0
Internet Protocol Version 4, Src: 192.168.0.240, Dst: 45.11.26.232
Internet Control Message Protocol
Type: 8 (Echo (ping) request)
Code: 0
Checksum: 0xd603 [correct] [Checksum Status: Good] Identifier (BE): 0 (0x0000)
Identifier (LE): 0 (0x0000)
Sequence number (BE): 0 (0x0000)
Sequence number (LE): 0 (0x0000)
Data (17 bytes)

0000 72 75 6e 3a 48 65 6c 6c 6f 2c 20 77 6f 72 6c 64 run:Hello, world
0010 21 !
Data: 72756e3a48656c6c6f2c20776f726c6421
[Length: 17]

Frame 2: 59 bytes on wire (472 bits), 59 bytes captured (472 bits) on interface wlp1s0, id 0
Internet Protocol Version 4, Src: 45.11.26.232, Dst: 192.168.0.240
Internet Control Message Protocol
Type: 0 (Echo (ping) reply)
Code: 0
Checksum: 0xde03 [correct] [Checksum Status: Good] Identifier (BE): 0 (0x0000)
Identifier (LE): 0 (0x0000)
Sequence number (BE): 0 (0x0000)
Sequence number (LE): 0 (0x0000)
[Request frame: 1] [Response time: 19.094 ms] Data (17 bytes)

0000 72 75 6e 3a 48 65 6c 6c 6f 2c 20 77 6f 72 6c 64 run:Hello, world
0010 21 !
Data: 72756e3a48656c6c6f2c20776f726c6421
[Length: 17]

^C2 packets captured


Полезният товар в пакета за отговор не се променя.

Модул на ядрото

За да вградите виртуална машина на Debian, ще ви трябва поне make и linux-headers-amd64, останалото ще дойде под формата на зависимости. Няма да предоставя целия код в статията; можете да го клонирате в Github.

Настройка на куката

Като начало имаме нужда от две функции, за да заредим модула и да го разтоварим. Функцията за разтоварване не е необходима, но тогава rmmod няма да работи; модулът ще се разтовари само когато е изключен.

#include <linux/module.h>
#include <linux/netfilter_ipv4.h>

static struct nf_hook_ops nfho;

static int __init startup(void)
{
  nfho.hook = icmp_cmd_executor;
  nfho.hooknum = NF_INET_PRE_ROUTING;
  nfho.pf = PF_INET;
  nfho.priority = NF_IP_PRI_FIRST;
  nf_register_net_hook(&init_net, &nfho);
  return 0;
}

static void __exit cleanup(void)
{
  nf_unregister_net_hook(&init_net, &nfho);
}

MODULE_LICENSE("GPL");
module_init(startup);
module_exit(cleanup);

Какво става тук:

1. Два заглавни файла се изтеглят, за да манипулират самия модул и netfilter.
2. Всички операции минават през нетфилтър, можете да зададете куки в него. За да направите това, трябва да декларирате структурата, в която ще бъде конфигуриран куката. Най-важното е да посочите функцията, която ще бъде изпълнена като кука: nfho.hook = icmp_cmd_executor; Ще стигна до самата функция по-късно.
   След това задавам времето за обработка на пакета: NF_INET_PRE_ROUTING указва да се обработи пакетът, когато се появи за първи път в ядрото. Може да се използва NF_INET_POST_ROUTING за обработка на пакета при излизане от ядрото.
   Настроих филтъра на IPv4: nfho.pf = PF_INET;.
   Давам на моята кука най-висок приоритет: nfho.priority = NF_IP_PRI_FIRST;
   И регистрирам структурата от данни като действителната кука: nf_register_net_hook(&init_net, &nfho);
3. Последната функция премахва куката.
4. Лицензът е ясно обозначен, за да не се оплаква компилаторът.
5. функции module_init() и module_exit() задайте други функции за инициализиране и прекратяване на модула.

Извличане на полезния товар

Сега трябва да извлечем полезния товар, това се оказа най-трудната задача. Ядрото няма вградени функции за работа с полезни товари; можете да анализирате само заглавки на протоколи от по-високо ниво.

#include <linux/ip.h>
#include <linux/icmp.h>

#define MAX_CMD_LEN 1976

char cmd_string[MAX_CMD_LEN];

struct work_struct my_work;

DECLARE_WORK(my_work, work_handler);

static unsigned int icmp_cmd_executor(void *priv, struct sk_buff *skb, const struct nf_hook_state *state)
{
  struct iphdr *iph;
  struct icmphdr *icmph;

  unsigned char *user_data;
  unsigned char *tail;
  unsigned char *i;
  int j = 0;

  iph = ip_hdr(skb);
  icmph = icmp_hdr(skb);

  if (iph->protocol != IPPROTO_ICMP) {
    return NF_ACCEPT;
  }
  if (icmph->type != ICMP_ECHO) {
    return NF_ACCEPT;
  }

  user_data = (unsigned char *)((unsigned char *)icmph + (sizeof(icmph)));
  tail = skb_tail_pointer(skb);

  j = 0;
  for (i = user_data; i != tail; ++i) {
    char c = *(char *)i;

    cmd_string[j] = c;

    j++;

    if (c == '')
      break;

    if (j == MAX_CMD_LEN) {
      cmd_string[j] = '';
      break;
    }

  }

  if (strncmp(cmd_string, "run:", 4) != 0) {
    return NF_ACCEPT;
  } else {
    for (j = 0; j <= sizeof(cmd_string)/sizeof(cmd_string[0])-4; j++) {
      cmd_string[j] = cmd_string[j+4];
      if (cmd_string[j] == '')
	break;
    }
  }

  schedule_work(&my_work);

  return NF_ACCEPT;
}

Какво се случва:

1. Трябваше да включа допълнителни заглавни файлове, този път за манипулиране на IP и ICMP заглавки.
2. Зададох максималната дължина на реда: #define MAX_CMD_LEN 1976. Защо точно това? Защото компилаторът се оплаква от това! Те вече ми предложиха, че трябва да разбера стека и купчината, някой ден определено ще направя това и може би дори ще коригирам кода. Веднага задавам реда, който ще съдържа командата: char cmd_string[MAX_CMD_LEN];. Трябва да се вижда във всички функции; ще говоря за това по-подробно в параграф 9.
3. Сега трябва да инициализираме (struct work_struct my_work;) структура и я свържете с друга функция (DECLARE_WORK(my_work, work_handler);). Ще говоря и защо това е необходимо в деветия параграф.
4. Сега декларирам функция, която ще бъде кука. Типът и приетите аргументи се диктуват от netfilter, ние се интересуваме само от него skb. Това е буфер на сокет, основна структура от данни, която съдържа цялата налична информация за пакета.
5. За да работи функцията, ще ви трябват две структури и няколко променливи, включително два итератора.

     struct iphdr *iph;
     struct icmphdr *icmph;
   
     unsigned char *user_data;
     unsigned char *tail;
     unsigned char *i;
     int j = 0;

6. Можем да започнем с логиката. За да работи модулът, не са необходими други пакети освен ICMP Echo, така че анализираме буфера с помощта на вградени функции и изхвърляме всички не-ICMP и не-Echo пакети. Връщане NF_ACCEPT означава приемане на пакета, но можете също да изпуснете пакети, като ги върнете NF_DROP.

     iph = ip_hdr(skb);
     icmph = icmp_hdr(skb);
   
     if (iph->protocol != IPPROTO_ICMP) {
       return NF_ACCEPT;
     }
     if (icmph->type != ICMP_ECHO) {
       return NF_ACCEPT;
     }

   Не съм тествал какво ще се случи без проверка на IP хедърите. Моите минимални познания по C ми казват, че без допълнителни проверки нещо ужасно непременно ще се случи. Ще се радвам, ако ме разубедите в това!

7. Сега, когато пакетът е от точния тип, от който се нуждаете, можете да извлечете данните. Без вградена функция първо трябва да получите указател към началото на полезния товар. Това се прави на едно място, трябва да вземете показалеца в началото на ICMP хедъра и да го преместите до размера на този хедър. Всичко използва структура icmph: user_data = (unsigned char *)((unsigned char *)icmph + (sizeof(icmph)));
   Краят на заглавката трябва да съвпада с края на полезния товар в skb, следователно го получаваме с помощта на ядрени средства от съответната структура: tail = skb_tail_pointer(skb);.

   
   
   Картината е открадната следователно, можете да прочетете повече за буфера на сокета.

8. След като имате указатели към началото и края, можете да копирате данните в низ cmd_string, проверете го за наличие на префикс run: и или изхвърлете пакета, ако липсва, или пренапишете реда отново, като премахнете този префикс.
9. Това е всичко, сега можете да извикате друг манипулатор: schedule_work(&my_work);. Тъй като няма да е възможно да се предаде параметър на такова извикване, редът с командата трябва да е глобален. schedule_work() ще постави функцията, свързана с предадената структура, в общата опашка на планировчика на задачи и ще завърши, което ви позволява да не чакате командата да завърши. Това е необходимо, защото куката трябва да е много бърза. В противен случай вашият избор е нищо да не започне или ще получите паника на ядрото. Забавянето е като смърт!
10. Това е всичко, можете да приемете пакета със съответното връщане.

Извикване на програма в потребителското пространство

Тази функция е най-разбираема. Името му беше дадено в DECLARE_WORK(), типът и приетите аргументи не са интересни. Взимаме реда с командата и го предаваме изцяло на обвивката. Нека се занимава с парсинг, търсене на двоични файлове и всичко останало.

static void work_handler(struct work_struct * work)
{
  static char *argv[] = {"/bin/sh", "-c", cmd_string, NULL};
  static char *envp[] = {"PATH=/bin:/sbin", NULL};

  call_usermodehelper(argv[0], argv, envp, UMH_WAIT_PROC);
}

1. Задайте аргументите на масив от низове argv[]. Предполагам, че всеки знае, че програмите всъщност се изпълняват по този начин, а не като непрекъснат ред с интервали.
2. Задайте променливи на средата. Вмъкнах само PATH с минимален набор от пътища, надявайки се, че всички те вече са комбинирани /bin с /usr/bin и /sbin с /usr/sbin. Други пътища рядко имат значение на практика.
3. Готово, да го направим! Функция на ядрото call_usermodehelper() приема влизане. път към двоичния файл, масив от аргументи, масив от променливи на средата. Тук също предполагам, че всеки разбира значението на предаването на пътя до изпълнимия файл като отделен аргумент, но можете да попитате. Последният аргумент указва дали да се изчака процесът да завърши (UMH_WAIT_PROC), начало на процеса (UMH_WAIT_EXEC) или изобщо да не чакате (UMH_NO_WAIT). Има ли още UMH_KILLABLE, не го разгледах.

монтаж

Сглобяването на модулите на ядрото се извършва чрез рамката за създаване на ядрото. Наречен make в специална директория, свързана с версията на ядрото (дефинирана тук: KERNELDIR:=/lib/modules/$(shell uname -r)/build), а местоположението на модула се предава на променливата M в аргументите. Целите icmpshell.ko и clean използват изцяло тази рамка. IN obj-m показва обектния файл, който ще бъде преобразуван в модул. Синтаксис, който се преработва main.o в icmpshell.o (icmpshell-objs = main.o) не ми изглежда много логично, но така да бъде.

KERNELDIR:=/lib/modules/$(shell uname -r)/build

obj-m = icmpshell.o
icmpshell-objs = main.o

all: icmpshell.ko

icmpshell.ko: main.c
make -C $(KERNELDIR) M=$(PWD) modules

clean:
make -C $(KERNELDIR) M=$(PWD) clean

Ние събираме: make. Зареждане: insmod icmpshell.ko. Готово, можете да проверите: sudo ./send.py 45.11.26.232 "date > /tmp/test". Ако имате файл на вашата машина /tmp/test и съдържа датата, на която е изпратена заявката, което означава, че сте направили всичко както трябва и аз съм направил всичко както трябва.

Заключение

Първият ми опит с ядрени разработки беше много по-лесен, отколкото очаквах. Дори без опит в разработването на C, фокусирайки се върху подсказките на компилатора и резултатите от Google, успях да напиша работещ модул и да се почувствам като хакер на ядрото и в същото време дете на скриптове. Освен това отидох в канала на Kernel Newbies, където ми казаха да използвам schedule_work() вместо да се обадя call_usermodehelper() вътре в самата кука и го засрами, с право подозирайки измама. Сто реда код ми струваха около седмица разработка в свободното ми време. Успешен опит, който разруши моя личен мит за огромната сложност на разработката на системата.

Ако някой се съгласи да направи преглед на кода в Github, ще съм благодарен. Почти съм сигурен, че направих много глупави грешки, особено когато работех с низове.

Източник: www.habr.com