🥇פגז גרעיני מעל ICMP

TL; DR: אני כותב מודול ליבה שיקרא פקודות ממטען ICMP ויבצע אותן בשרת גם אם ה-SSH שלך קורס. עבור חסרי הסבלנות, כל הקוד הוא GitHub.

זְהִירוּת! מתכנתי C מנוסים מסתכנים בפרוץ בדמעות של דם! יכול להיות שאני אפילו טועה בטרמינולוגיה, אבל כל ביקורת תתקבל בברכה. הפוסט מיועד למי שיש לו מושג גס מאוד על תכנות C ורוצים להסתכל על הצד הפנימי של לינוקס.

בתגובות לראשון שלי статье הזכיר את SoftEther VPN, שיכול לחקות כמה פרוטוקולים "רגילים", בפרט HTTPS, ICMP ואפילו DNS. אני יכול לדמיין שרק הראשון שבהם עובד, מכיוון שאני מכיר מאוד את HTTP(S), והייתי צריך ללמוד מנהור דרך ICMP ו-DNS.

כן, בשנת 2020 למדתי שאתה יכול להכניס מטען שרירותי לתוך מנות ICMP. אבל מוטב מאוחר מאשר אף פעם! ומכיוון שאפשר לעשות משהו בנידון, אז צריך לעשות את זה. מכיוון שבחיי היומיום אני משתמש לרוב בשורת הפקודה, כולל דרך SSH, הרעיון של מעטפת ICMP עלה בראשי בראש. וכדי להרכיב בינגו בול מגן שלם, החלטתי לכתוב אותו כמודול לינוקס בשפה שיש לי רק מושג גס עליה. מעטפת כזו לא תהיה גלויה ברשימת התהליכים, אתה יכול לטעון אותה לתוך הקרנל והיא לא תהיה במערכת הקבצים, לא תראה שום דבר חשוד ברשימת יציאות ההאזנה. מבחינת היכולות שלו, מדובר ב-rootkit מן המניין, אבל אני מקווה לשפר אותו ולהשתמש בו כמעטפת של מוצא אחרון כאשר ממוצע הטעינה גבוה מדי בשביל להיכנס דרך SSH ולהפעיל לפחות echo i > /proc/sysrq-triggerכדי לשחזר גישה ללא אתחול מחדש.

אנחנו לוקחים עורך טקסט, כישורי תכנות בסיסיים ב- Python ו-C, גוגל ו וירטואלי שלא אכפת לך לשים מתחת לסכין אם הכל נשבר (אופציונלי - 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 בעצמה. לדביאן יש חבילה בשם 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

המטען בחבילת התגובות אינו משתנה.

מודול ליבה

כדי לבנות מכונה וירטואלית של דביאן תצטרך לפחות 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);

מה קורה פה:

שני קבצי כותרות נמשכים כדי לתפעל את המודול עצמו ואת ה-netfilter.
כל הפעולות עוברות דרך netfilter, אפשר להגדיר בו ווים. כדי לעשות זאת, אתה צריך להכריז על המבנה שבו הוו יוגדר. הדבר החשוב ביותר הוא לציין את הפונקציה שתתבצע כ-hook: nfho.hook = icmp_cmd_executor; אני אגיע לפונקציה עצמה מאוחר יותר.
ואז קבעתי את זמן העיבוד של החבילה: NF_INET_PRE_ROUTING מציין לעבד את החבילה כאשר היא מופיעה לראשונה בקרנל. יכול לשמש NF_INET_POST_ROUTING לעבד את החבילה כשהיא יוצאת מהקרנל.
הגדרתי את המסנן ל-IPv4: nfho.pf = PF_INET;.
אני נותן להוק שלי את העדיפות הגבוהה ביותר: nfho.priority = NF_IP_PRI_FIRST;
ואני רושם את מבנה הנתונים בתור ה-hook בפועל: 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);). אני גם אדבר על למה זה נחוץ בפסקה התשיעית.
עכשיו אני מכריז על פונקציה, שתהיה הוק. הסוג והטיעונים המקובלים מוכתבים על ידי ה-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