🥇Tuuma shell ICMP üle

TL;DR: kirjutan tuuma moodulit, mis loeb käsklusi ICMP koormusest ja täidab neid serveris isegi juhul, kui teie SSH on kokku kukkunud. Kõik kood on github.

Olge ettevaatlik! Kogenud C-programmeerijad võivad nutma puhkeda! Võin eksida terminoloogias, kuid kõik kriitika on teretulnud. Postitus on mõeldud neile, kes omavad vähemalt ligikaudset ettekujutust C-programmeerimisest ja soovivad pilku heita Linuxi sisemusse.

Minu esimeses postituses artiklis mainiti SoftEther VPN-i, mis oskab varjata end teatud «tavaliste» protokollide all, sealhulgas HTTPS, ICMP ja isegi DNS. Kujutan ette ainult esimese tööpõhimõtet, kuna tunnen HTTP(S)-ga hästi, kuid pidin õppima ka ICMP ja DNS kaudu tunneldamist.

Jah, sain 2020. aastal teada, et ICMP-pakettidesse on võimalik sisestada suvaline koormus. Kuid parem hilja kui mitte kunagi! Ja kuna sellega on võimalik midagi teha, tuleb seda ka teha. Kuna igapäevaselt kasutan enamasti käsuviiba, sealhulgas SSH kaudu, tuli ICMP-shelli idee mulle esimesena. Ja et luua täisvereline bullshiti бинго, otsustasin kirjutada selle Linuxi moodulina keeles, millest mul on vaid ligikaudne arusaam. Selline shell ei ilmu protsesside nimekirja, seda saab laadida tuuma ja see ei asu failisüsteemis, te ei näe midagi kahtlast kuulamisportide nimekirjas. Oma võimaluste poolest on see täieõiguslik rootkit, kuid loodan seda täiustada ja kasutada seda hädaabi shellina, kui Load Average on liiga kõrge, et SSH kaudu sisse logida ja vähemalt echo i > /proc/sysrq-trigger, et taastada juurdepääs ilma taaskäivitamiseta.

Võtame tekstiredaktori, põhioskused Pythonis ja C-s, Google'i ja virtuaalmasina mida ei ole kahju katki teha, kui kõik kokku kukub (valikuliselt — kohalik VirtualBox/KVM jne) ja minna!

Kliendi osa

Mulle tundus, et kliendi osa jaoks tuleb kirjutada umbes 80 rida skripti, kuid leidusid head inimesed, kes tegid töö minu eest kogu töö. Kood osutus üllatavalt lihtsaks, mahtudes 10 olulisse ritta:

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

if len(sys.argv) < 3:
    print('Kasutus: {} IP "käsk"'.format(sys.argv[0]))
    exit(0)

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

Skript võtab vastu kaks argumenti, aadress ja koormus. Enne saatmist eelneks koormus võtmega run:, me vajatakse, et välistada pakette juhusliku payloadiga.

Yda nõuab privileege pakettide koostamiseks, seega tuleb skript käivitada superkasutaja õigustes. Ärge unustage anda täitmisõigused ja installida ise scapy. Debiani puhul on olemas pakett, nimetusega python3-scapy. Nüüd saab kontrollida, kuidas see kõik töötab.

Käivitamine ja käsu väljund
morq@laptop:~\/icmpshell$ sudo .\/send.py 45.11.26.232 "Tere, maailm!" Emissioon algab: .Saadetud 1 pakett lõpetatud. * Sai 2 paketti, saadi 1 vastus, jäänud 0 paketti ###[ IP ]### versioon = 4 ihl = 5 tos = 0x0 pikkus = 45 id = 17218 lipud = frag = 0 ttl = 58 proto = icmp chksum = 0x3403 src = 45.11.26.232 dst = 192.168.0.240 options ###[ ICMP ]### tüüp = echo-vastus kood = 0 chksum = 0xde03 id = 0x0 seq = 0x0 ###[ Raw ]### koormus = 'käivita:Tere, maailm!

Nii see välja näeb snifferis
morq@laptop:~\/icmpshell$ sudo tshark -i wlp1s0 -O icmp -f "icmp and host 45.11.26.232" Käivitamine kasutajana "root" ja grupina "root". See võib olla ohtlik. Salvestamine 'wlp1s0' peal Raam 1: 59 bitti traadis (472 bitti), 59 bitti salvestatud (472 bitti) liidesel wlp1s0, id 0 Internetiprotokolli versioon 4, Src: 192.168.0.240, Dst: 45.11.26.232 Internet Control Message Protocol Tüüp: 8 (Echo (ping) päring) Kood: 0 Kontrollsumma: 0xd603 [õige] [Kontrollsumma olek: Hea] Identifikaator (BE): 0 (0x0000) Identifikaator (LE): 0 (0x0000) Järjekorra number (BE): 0 (0x0000) Järjekorra number (LE): 0 (0x0000) Andmed (17 bitti)

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

Raam 2: 59 bitti juhtmes (472 bitti), 59 bitti salvestatud (472 bitti) liidesel wlp1s0, id 0
Interneti protokoll versioon 4, Src: 45.11.26.232, Dst: 192.168.0.240
Internet Control Message Protocol
Tüüp: 0 (Echo (ping) vastus)
Kood: 0
Kontrollsumma: 0xde03 [õige]
[Kontrollsumma olek: Hea]
Identifikaator (BE): 0 (0x0000)
Identifikaator (LE): 0 (0x0000)
Järjekorra number (BE): 0 (0x0000)
Järjekorra number (LE): 0 (0x0000)
[Päringu raam: 1]
[Vastuse aeg: 19.094 ms]
Andmed (17 bitti)

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

^C2 paketti salvestatud

Payload vastuspaketis ei muutu.

Ydamoodul

Debiani virtuaalmasinas kokku panemiseks on vajalik vähemalt tee ja linux-headers-amd64, ülejäänud tõmmatakse sõltuvustena. Artikkel ei too kogu koodi, saate selle kloonida GitHubis.

Hooki seadistamine

Esialgu vajame kahte funktsiooni, et moodulit laadida ja laadida välja. Väljavõtmise funktsioon ei ole kohustuslik, kuid siis ei ole võimalik rmmod teostada, moodul laaditakse välja ainult välja lülitamisel.

#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);

Mis siin toimub:

Tõmmatakse kaks pealkirjafaili, et manipuleerida tegelikult mooduli ja netfilteriga.
Kõik operatsioonid toimuvad läbi netfilteri, seal saab määrata hooke. Selleks tuleb deklareerida struktuur, milles hook seadistatakse. Kõige olulisem on määrata funktsioon, mis täidetakse hookina: nfho.hook = icmp_cmd_executor; jõuan veel funktsiooni juurde.
Seejärel määrasin paketi töötlemise hetke: NF_INET_PRE_ROUTING näitab, et pakett töödelda, kui see just kernelisse ilmus. Saate kasutada NF_INET_POST_ROUTING paketi töötlemiseks kernelist väljumisel.
Kannan IPv4 filtrit: nfho.pf = PF_INET;.
Määran oma hookile kõrgeima prioriteedi: nfho.priority = NF_IP_PRI_FIRST;
Ja registreerin andmestruktuuri moona hookina: nf_register_net_hook(&init_net, &nfho);
Lõppfunktsioonis eemaldatakse hook.
Litsents on selgelt määratletud, et kompilaator ei nuriseks.
Funktsioonid module_init() ja module_exit() määravad teised funktsioonid modulite initsialiseerimise ja lõpetamise jaoks.

Payloadi eemaldamine

Nüüd tuleb püsivalt andmed kätte saada, see osutus kõige keerulisemaks ülesandeks. Süsteemis ei ole sisseehitatud funktsioone püsiva andmekogumi töötlemiseks, saab ainult erinevaid pealkirju rohkemate kõrgema taseme protokollide langt tööteldes.

#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;
}

Mis toimub:

Pidin lisama täiendavaid pealkirjade faile, seekord IP- ja ICMP-pealkirjade manipulatsiooniks.
Määran stringi maksimaalse pikkuse: #define MAX_CMD_LEN 1976. Miks just selline? Sest suurema pikkuse korral viskab kompilaator vea! Keegi juba soovitas mul tegeleda virna ja hunnikuga, kunagi kindlasti teen seda ja võib-olla isegi parandan koodi. Koheselt määran stringi, milles on käsk: char cmd_string[MAX_CMD_LEN];. See peab olema nähtav kõikides funktsioonides, sellest räägin lähemalt punktis 9.
Nüüd on vaja initsialiseerida (struct work_struct my_work;) struktuur ja siduda see veel ühe funktsiooniga (DECLARE_WORK(my_work, work_handler);). Selleks, miks seda tehakse, räägin samuti üheksandas punktis.
Nüüd kuulutan välja funktsiooni, mis ongi hübriid. Tüüp ja vastu võetavad argumendid määratakse netfiltriga, meid huvitab ainult skb. See on soketi bufr, põhistruktuur andmete salvestamiseks, mis sisaldab kogu teavet paketi kohta.

Funktsiooni tööks on vaja kahte struktuuri ja mitmeid muutujaid, sealhulgas kahte iteratsiooni.

  struct iphdr *iph;
  struct icmphdr *icmph;

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

Saame minna loogika juurde. Mooduli tööks ei ole vaja ühtegi paketti peale ICMP Echo, seega töötleme bufrit sisseehitatud funktsioonide abil ja eemaldame kõik mitte-ICMP- ja mitte-Echo-paketid. Tagastamine NF_ACCEPT tähendab paketi aktsepteerimist, aga võite ka pakette maha võtta, tagastades 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;
  }
```
Ma ei ole kontrollinud, mis juhtub, kui IP-pealkirju ei kontrollita. Minu minimaalne C-teadmiste tase ütleb, et ilma täiendavate kontrollideta juhtub kindlasti midagi kohutavat. Olen õnnelik, kui teid suudan sellesse kahtlusesse panna!
Nüüd, kui pakett on täpselt õiget tüüpi, on võimalik andmed välja võtta. Ilma sisseehitatud funktsioonita tuleb algselt saada näidik püsiva andmekogumi algusesse. Seda tehakse läbi ühe koha, peame võtma näidikule ICMP-pealkirja algusesse ja liigutama seda selle pealkirja suuruse võrra. Kõik see toimub struktuuri icmph: user_data = (unsigned char *)((unsigned char *)icmph + (sizeof(icmph)));
Pealkiri peab lõppema sama arvu andmetega, skb, seega saame selle tuumade kaudu vastavast struktuurist: tail = skb_tail_pointer(skb);.

Pilt on ära võetud siit, võite lugeda rohkem soketi puhvri kohta.
Saades näidikud alguse ja lõpuni, saab andmed kopeerida rea cmd_string, kontrollida selle eesliide olemasolu run: ja kas visata pakett välja selle puudumisel või kirjutada rida uuesti, eemaldades selle eesliite.
Noh, nüüd saab kutsuda veel ühe käitleja: schedule_work(&my_work);. Kuna sellise kutsungi korral lähtestada parameetrit ei õnnestu, peab käsk olema globaalne. schedule_work() paigutab funktsiooni, mis on seotud edastatud struktuuriga, ülesande planeerimise üldisse järjekorda ja lõpetab, võimaldades mitte oodata käsu lõpetamist. See on vajalik, kuna haak peab olema väga kiire. Vastasel juhul ei juhtu mitte midagi või saate kernel panic'i. Viivitus on surmaga sarnane!
Nüüd saab paketti vastava tagastusega vastu võtta.

Programmi kutsumine kasutajaruumi

See funktsioon on kõige arusaadavam. Selle nimi oli määratud DECLARE_WORK(), tüüp ja vastuvõetavad argumendid ei huvita. Võtame käsurea ja edastame selle täielikult shell'ile. Las ta lahendab parsimise, binaaride leidmise ja kõik muu.

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);
}

Määrame argumendid stringide massiivi argv[]. Eeldan, et kõik teavad, et programmid tegelikult käivitatakse just nii, mitte lihtsalt ühtse stringiga, kus on tühikud.
Määrame keskkonnamuutujad. Panin sisse ainult PATH minimaalse tee kogumiga, lootes, et kõigil on need juba ühendatud /bin jot /usr/bin ja /sbin jot /usr/sbin. Teised teed on praktikas üsna harva olulised.
Valmis, käivitame! Süsteemi funktsioon call_usermodehelper() võtab sisendiks. tee binaari, argumendimassiiv, keskkonnamuutujate massiiv. Siin eeldan samuti, et kõik mõistavad, miks on vajalik edastada tee täitmise failile eraldi argumendina, aga võite küsida. Viimane argument näitab, kas oodata protsessi lõpetamist (UMH_WAIT_PROC), protsessi käivitamisest (UMH_WAIT_EXEC) või mitte oodata üldse (UMH_NO_WAIT). On ka UMH_KILLABLE, ma ei hakka sellega pudima.

Kogumine

Kerneli moodulite kogumine toimub kerneli enda make raamistikuga. Kutse antakse tee eriti spetsiaalses kaustas, mis on seotud tuuma versiooniga (määratakse siin: KERNELDIR:=/lib/modules/$(shell uname -r)/build), ning mooduli asukoht antakse muutuja kaudu M argumentides. Sihtmärkides icmpshell.ko ja clean kasutatakse täielikult seda raamistikku. obj-m näitab objekti faili, mis muudetakse mooduliks. Süntaks, mis muudab main.o ja icmpshell.o (icmpshell-objs = main.o) minu jaoks tundub mitte väga loogiline, kuid olgu siis nii.

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

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

kõik: icmpshell.ko

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

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

Kogume: tee. Laadime: insmod icmpshell.ko. Valmis, saab kontrollida: sudo ./send.py 45.11.26.232 "date > /tmp/test". Kui teie masinas on tekkinud fail /tmp/test ja selles on päringu saatmise kuupäev, tähendab, et olete kõik õigesti teinud ja mina tegin kõik õigesti.

Kokkuvõte

Minu esimene tuuma arenduse kogemus osutus palju lihtsamaks, kui ma ootasin. Isegi ilma C-arenduse kogemuseta, toetudes kompilaatori vihjetele ja Google'i tulemustele, suutsin kirjutada töötava mooduli ja tunda end tuumahäkkerina, samuti skript-lasteina. Lisaks külastasin Kernel Newbies kanalit, kus soovitati mul kasutada schedule_work() asemel kutset call_usermodehelper() otse enda hookis ja häbistas mind õigustatult, kahtlustades petmist. Saja koodi rida maksis mulle kuskil nädal aega vabast ajast. Edukas kogemus, mis purustas minu isikliku müüdi süsteemse arenduse uskumatust keerukusest.

Kui keegi on nõus Githubis koodikontrolli tegema, oleksin tänulik. Olen peaaegu kindel, et tegin palju tobedaid vigu, eriti stringide töötlemises.

Allikas: habr.com