🥇ბირთვული ჭურვი ICMP-ზე

TL; DR: მე ვწერ ბირთვის მოდულს, რომელიც წაიკითხავს ბრძანებებს ICMP დატვირთვიდან და შეასრულებს მათ სერვერზე მაშინაც კი, თუ თქვენი SSH ავარიულია. ყველაზე მოუთმენლებისთვის, ყველა კოდი არის გითუბი.

სიფრთხილით! გამოცდილი C პროგრამისტები რისკავს სისხლის ცრემლებით ადიდებას! შეიძლება ტერმინოლოგიაშიც კი ვცდები, მაგრამ ნებისმიერი კრიტიკა მისასალმებელია. პოსტი განკუთვნილია მათთვის, ვისაც აქვს ძალიან უხეში წარმოდგენა C პროგრამირების შესახებ და სურს შეისწავლოს Linux-ის შიგნით.

ჩემი პირველის კომენტარებში მუხლი ნახსენები SoftEther VPN, რომელსაც შეუძლია მიბაძოს ზოგიერთი „რეგულარული“ პროტოკოლი, კერძოდ, HTTPS, ICMP და თუნდაც DNS. წარმომიდგენია მათგან მხოლოდ პირველი მუშაობს, რადგან კარგად ვიცნობ HTTP(S) და მომიწია გვირაბის სწავლა ICMP და DNS-ზე.

დიახ, 2020 წელს გავიგე, რომ შეგიძლიათ თვითნებური დატვირთვის ჩასმა ICMP პაკეტებში. მაგრამ სჯობს გვიან ვიდრე არასდროს! და რადგანაც შეიძლება რაღაცის გაკეთება, მაშინ ეს უნდა გაკეთდეს. მას შემდეგ, რაც ჩემს ყოველდღიურ ცხოვრებაში ყველაზე ხშირად ვიყენებ ბრძანების ხაზს, მათ შორის SSH-ის საშუალებით, პირველი ICMP ჭურვის იდეა გამიჩნდა. და იმისათვის, რომ შემექმნა სრული bullshield ბინგო, გადავწყვიტე დამეწერა ის Linux მოდულის სახით იმ ენაზე, რომელზეც მხოლოდ უხეში წარმოდგენა მაქვს. ასეთი ჭურვი არ იქნება ხილული პროცესების სიაში, შეგიძლიათ ჩატვირთოთ ის ბირთვში და არ იქნება ფაილურ სისტემაში, ვერაფერს ნახავთ საეჭვოს მოსასმენ პორტების სიაში. მისი შესაძლებლობების თვალსაზრისით, ეს არის სრულფასოვანი rootkit, მაგრამ ვიმედოვნებ, რომ გავაუმჯობესებ და გამოვიყენებ, როგორც ბოლო ინსტრუმენტს, როდესაც დატვირთვის საშუალო ძალიან მაღალია 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);

Რა ხდება აქ:

ორი სათაურის ფაილი შეყვანილია თავად მოდულისა და ქსელის ფილტრის მანიპულირებისთვის.
ყველა ოპერაცია გადის ქსელის ფილტრში, შეგიძლიათ დააყენოთ კაკვები მასში. ამისათვის თქვენ უნდა გამოაცხადოთ სტრუქტურა, რომელშიც დაკონფიგურირებული იქნება კაკალი. ყველაზე მნიშვნელოვანი ის არის, რომ მიუთითოთ ფუნქცია, რომელიც შესრულდება კაუჭის სახით: 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);
საბოლოო ფუნქცია ხსნის კაკს.
ლიცენზია მკაფიოდ არის მითითებული, რომ შემდგენელი არ უჩიოდეს.
ფუნქციები 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;
}

Რა ხდება:

მე მომიწია დამატებითი სათაურის ფაილების ჩასმა, ამჯერად IP და ICMP სათაურების მანიპულირებისთვის.
მე დავაყენე ხაზის მაქსიმალური სიგრძე: #define MAX_CMD_LEN 1976. რატომ ზუსტად ეს? იმიტომ რომ შემდგენელი ჩივის! მათ უკვე შემომთავაზეს, რომ უნდა გავიგო სტეკი და გროვა, ოდესმე ამას აუცილებლად გავაკეთებ და შესაძლოა კოდიც გამოვასწორო. მე მაშინვე დავაყენე ხაზი, რომელიც შეიცავს ბრძანებას: char cmd_string[MAX_CMD_LEN];. ეს უნდა იყოს ხილული ყველა ფუნქციით; ამის შესახებ უფრო დეტალურად მე-9 პუნქტში ვისაუბრებ.
ახლა ჩვენ გვჭირდება ინიციალიზაცია (struct work_struct my_work;) სტრუქტურა და დააკავშირეთ იგი სხვა ფუნქციასთან (DECLARE_WORK(my_work, work_handler);). მე ასევე ვისაუბრებ იმაზე, თუ რატომ არის ეს აუცილებელი მეცხრე აბზაცში.
ახლა ვაცხადებ ფუნქციას, რომელიც იქნება hook. ტიპი და მიღებული არგუმენტები ნაკარნახევია netfilter-ის მიერ, ჩვენ მხოლოდ გვაინტერესებს skb. ეს არის სოკეტის ბუფერი, მონაცემთა ფუნდამენტური სტრუქტურა, რომელიც შეიცავს ყველა არსებულ ინფორმაციას პაკეტის შესახებ.
იმისათვის, რომ ფუნქცია იმუშაოს, დაგჭირდებათ ორი სტრუქტურა და რამდენიმე ცვლადი, მათ შორის ორი იტერატორი.
```
  struct iphdr *iph;
  struct icmphdr *icmph;

  unsigned char *user_data;
  unsigned char *tail;
  unsigned char *i;
  int j = 0;
```
შეგვიძლია დავიწყოთ ლოგიკით. იმისათვის, რომ მოდული იმუშაოს, 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-ზე მეუბნება, რომ დამატებითი შემოწმების გარეშე, რაღაც საშინელება აუცილებლად მოხდება. მოხარული ვიქნები, თუ ამაში თავს დამაკავებთ!
ახლა, როდესაც პაკეტი არის ზუსტად იმ ტიპის, რომელიც გჭირდებათ, შეგიძლიათ მონაცემების ამოღება. ჩაშენებული ფუნქციის გარეშე, თქვენ ჯერ უნდა მიიღოთ მაჩვენებელი დატვირთვის დასაწყისში. ეს კეთდება ერთ ადგილას, თქვენ უნდა აიღოთ მაჩვენებელი ICMP სათაურის დასაწყისში და გადაიტანოთ იგი ამ სათაურის ზომაზე. ყველაფერი იყენებს სტრუქტურას icmph: user_data = (unsigned char *)((unsigned char *)icmph + (sizeof(icmph)));
სათაურის ბოლო უნდა ემთხვეოდეს დატვირთვის დასასრულს skbმაშასადამე, მას ვიღებთ ბირთვული საშუალებების გამოყენებით შესაბამისი სტრუქტურიდან: tail = skb_tail_pointer(skb);.

სურათი მოიპარეს აქედან გამომდინარე,, შეგიძლიათ მეტი წაიკითხოთ სოკეტის ბუფერის შესახებ.
როდესაც თქვენ გექნებათ მაჩვენებლები დასაწყისისა და დასასრულისკენ, შეგიძლიათ დააკოპიროთ მონაცემები სტრიქონში cmd_string, შეამოწმეთ იგი პრეფიქსის არსებობისთვის run: და, ან გადააგდეთ პაკეტი, თუ ის აკლია, ან გადაწერეთ ხაზი ხელახლა, ამ პრეფიქსის ამოღებით.
ეს ყველაფერი, ახლა შეგიძლიათ სხვა დამმუშავებლის დარეკვა: schedule_work(&my_work);. ვინაიდან შეუძლებელი იქნება პარამეტრის გადაცემა ასეთ ზარზე, ბრძანების ხაზი უნდა იყოს გლობალური. schedule_work() განათავსებს გავლილ სტრუქტურასთან დაკავშირებულ ფუნქციას დავალების განრიგის გენერალურ რიგში და დაასრულებს, რაც საშუალებას მოგცემთ არ დაელოდოთ ბრძანების დასრულებას. ეს აუცილებელია, რადგან კაკალი უნდა იყოს ძალიან სწრაფი. წინააღმდეგ შემთხვევაში, თქვენი არჩევანია, რომ არაფერი დაიწყოს ან თქვენ გექნებათ ბირთვის პანიკა. დაგვიანება სიკვდილს ჰგავს!
ეს არის ის, შეგიძლიათ მიიღოთ პაკეტი შესაბამისი დაბრუნებით.

პროგრამის გამოძახება მომხმარებელთა სივრცეში

ეს ფუნქცია ყველაზე გასაგებია. მისი სახელი მიენიჭა 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);
}

დააყენეთ არგუმენტები სტრიქონების მასივზე argv[]. მე ვივარაუდებ, რომ ყველამ იცის, რომ პროგრამები რეალურად შესრულებულია ამ გზით და არა როგორც უწყვეტი ხაზი სივრცეებით.
გარემოს ცვლადების დაყენება. მე ჩავდე მხოლოდ PATH ბილიკების მინიმალური ნაკრებით, იმ იმედით, რომ ისინი უკვე გაერთიანებული იყო /bin с /usr/bin и /sbin с /usr/sbin. სხვა გზებს პრაქტიკაში იშვიათად აქვს მნიშვნელობა.
დასრულებულია, მოდით გავაკეთოთ! ბირთვის ფუნქცია call_usermodehelper() იღებს შესვლას. გზა ბინარამდე, არგუმენტების მასივი, გარემოს ცვლადების მასივი. აქ ასევე ვვარაუდობ, რომ ყველას ესმის შესრულებადი ფაილის გზის ცალკე არგუმენტად გადაცემის მნიშვნელობა, მაგრამ შეგიძლიათ იკითხოთ. ბოლო არგუმენტი განსაზღვრავს, დაველოდოთ თუ არა პროცესის დასრულებას (UMH_WAIT_PROC), პროცესის დაწყება (UMH_WAIT_EXEC) ან საერთოდ არ დაველოდოთ (UMH_NO_WAIT). კიდევ არის კიდევ UMH_KILLABLE, არ შემიხედავს.

ასამბლეა

ბირთვის მოდულების აწყობა ხორციელდება ბირთვის მაკიაჟის მეშვეობით. დაურეკა make ბირთვის ვერსიასთან მიბმული სპეციალურ დირექტორიაში (განსაზღვრული აქ: KERNELDIR:=/lib/modules/$(shell uname -r)/build), და მოდულის მდებარეობა გადაეცემა ცვლადს M არგუმენტებში. icmpshell.ko და სუფთა სამიზნეები მთლიანად იყენებენ ამ ჩარჩოს. 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-ში განვითარების გამოცდილების გარეშეც, კომპილერის მინიშნებებზე და გუგლის შედეგებზე ფოკუსირების გარეშე, მე შევძელი სამუშაო მოდულის დაწერა და თავს ბირთვის ჰაკერად და ამავე დროს სკრიპტის ბავშვად ვგრძნობდი. გარდა ამისა, მივედი Kernel Newbies არხზე, სადაც მითხრეს გამომეყენებინა schedule_work() დარეკვის ნაცვლად call_usermodehelper() თავად კაკვის შიგნით და შეარცხვინა იგი, სამართლიანად ეჭვობდა თაღლითობაში. კოდის ასი ხაზი დამიჯდა თავისუფალ დროს განვითარების დაახლოებით ერთი კვირა. წარმატებული გამოცდილება, რომელმაც გაანადგურა ჩემი პირადი მითი სისტემის განვითარების აბსოლუტური სირთულის შესახებ.

თუ ვინმე თანახმაა Github-ზე კოდის განხილვაზე, მადლობელი ვიქნები. დარწმუნებული ვარ, ბევრი სულელური შეცდომა დავუშვი, განსაკუთრებით სიმებზე მუშაობისას.

წყარო: www.habr.com

ბირთვული ჭურვი ICMP-ზე