គ្រាប់នុយក្លេអ៊ែរលើ ICMP

TL; កុង៖ ខ្ញុំកំពុងសរសេរម៉ូឌុលខឺណែលដែលនឹងអានពាក្យបញ្ជាពី ICMP payload និងប្រតិបត្តិពួកវានៅលើម៉ាស៊ីនមេ ទោះបីជា SSH របស់អ្នកគាំងក៏ដោយ។ សម្រាប់ការអត់ធ្មត់បំផុត កូដទាំងអស់គឺ GitHub.

ប្រយ័ត្ន អ្នកសរសេរកម្មវិធី C ដែលមានបទពិសោធន៍ ប្រថុយស្រក់ទឹកភ្នែក! ខ្ញុំ​អាច​នឹង​ខុស​នៅ​ក្នុង​វាក្យ​សព្ទ​, ប៉ុន្តែ​ការ​រិះគន់​ណា​មួយ​សូម​ស្វាគមន៍​។ ការបង្ហោះនេះគឺមានគោលបំណងសម្រាប់អ្នកដែលមានគំនិតរដុបខ្លាំងនៃការសរសេរកម្មវិធី C ហើយចង់រកមើលផ្នែកខាងក្នុងនៃលីនុច។

នៅក្នុងមតិយោបល់ទៅដំបូងរបស់ខ្ញុំ អត្ថបទ បានលើកឡើងពី SoftEther VPN ដែលអាចធ្វើត្រាប់តាមពិធីការ "ធម្មតា" មួយចំនួន ជាពិសេស HTTPS, ICMP និងសូម្បីតែ DNS ។ ខ្ញុំ​អាច​ស្រមៃ​ឃើញ​តែ​ពួកគេ​ដំបូង​ប៉ុណ្ណោះ​ដែល​ធ្វើការ ព្រោះ​ខ្ញុំ​ស៊ាំ​ជាមួយ HTTP(S) ហើយ​ខ្ញុំ​ត្រូវ​រៀន​ផ្លូវ​រូង​ក្រោម​ដី​លើ ICMP និង DNS។

បាទ/ចាស នៅឆ្នាំ 2020 ខ្ញុំបានដឹងថាអ្នកអាចបញ្ចូលបន្ទុកតាមអំពើចិត្តទៅក្នុងកញ្ចប់ ICMP ។ តែយឺតជាងមិនដែល! ហើយ​ដោយសារ​អ្វី​មួយ​អាច​ត្រូវ​បាន​ធ្វើ​អំពី​វា នោះ​វា​ត្រូវ​តែ​ធ្វើ។ ដោយសារនៅក្នុងជីវិតប្រចាំថ្ងៃរបស់ខ្ញុំ ភាគច្រើនខ្ញុំប្រើបន្ទាត់ពាក្យបញ្ជា រួមទាំងតាមរយៈ SSH គំនិតនៃសែល ICMP បានចូលមកក្នុងគំនិតរបស់ខ្ញុំជាមុនសិន។ ហើយដើម្បីប្រមូលផ្តុំ bullshield bingo ពេញលេញ ខ្ញុំបានសម្រេចចិត្តសរសេរវាជាម៉ូឌុលលីនុចជាភាសាដែលខ្ញុំគ្រាន់តែមានគំនិតរដុបប៉ុណ្ណោះ។ សែលបែបនេះនឹងមិនអាចមើលឃើញនៅក្នុងបញ្ជីនៃដំណើរការទេ អ្នកអាចផ្ទុកវាទៅក្នុងខឺណែល ហើយវានឹងមិនមាននៅលើប្រព័ន្ធឯកសារទេ អ្នកនឹងមិនឃើញអ្វីដែលគួរឱ្យសង្ស័យនៅក្នុងបញ្ជីនៃច្រកស្តាប់ទេ។ នៅក្នុងលក្ខខណ្ឌនៃសមត្ថភាពរបស់វា នេះគឺជា rootkit ពេញលេញ ប៉ុន្តែខ្ញុំសង្ឃឹមថានឹងកែលម្អវា ហើយប្រើវាជាសែលនៃជម្រើសចុងក្រោយ នៅពេលដែល Load Average ខ្ពស់ពេកក្នុងការចូលតាមរយៈ SSH ហើយប្រតិបត្តិយ៉ាងហោចណាស់។ echo i > /proc/sysrq-triggerដើម្បីស្ដារការចូលដំណើរការដោយមិនចាំបាច់ចាប់ផ្ដើមឡើងវិញ។

យើងយកកម្មវិធីនិពន្ធអត្ថបទ ជំនាញសរសេរកម្មវិធីជាមូលដ្ឋាននៅក្នុង Python និង C, Google និង និម្មិត ដែល​អ្នក​មិន​ខ្វល់​នឹង​ការ​ដាក់​នៅ​ក្រោម​កាំបិត​ប្រសិន​បើ​អ្វី​គ្រប់​យ៉ាង​ខូច (ជា​ជម្រើស - Local VirtualBox/KVM/etc) ហើយ​តោះ​ទៅ!

ខាងអតិថិជន

វាហាក់ដូចជាខ្ញុំថាសម្រាប់ផ្នែកអតិថិជនខ្ញុំនឹងត្រូវសរសេរស្គ្រីបដែលមានប្រហែល 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!

នេះគឺជាអ្វីដែលវាមើលទៅដូចជានៅក្នុង sniffer
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. ប្រតិបត្តិការទាំងអស់ឆ្លងកាត់ netfilter អ្នកអាចកំណត់ទំពក់នៅក្នុងវា។ ដើម្បីធ្វើដូចនេះអ្នកត្រូវប្រកាសរចនាសម្ព័ន្ធដែលទំពក់នឹងត្រូវបានកំណត់រចនាសម្ព័ន្ធ។ អ្វីដែលសំខាន់បំផុតគឺត្រូវបញ្ជាក់មុខងារដែលនឹងត្រូវបានប្រតិបត្តិជាទំពក់៖ 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() កំណត់មុខងារផ្សេងទៀតដើម្បីចាប់ផ្តើម និងបញ្ចប់ម៉ូឌុល។

ការទាញយកបន្ទុកឡើងវិញ

ឥឡូវនេះយើងត្រូវទាញយក payload នេះប្រែទៅជាកិច្ចការដ៏លំបាកបំផុត។ ខឺណែលមិនមានមុខងារភ្ជាប់មកជាមួយសម្រាប់ធ្វើការជាមួយបន្ទុកទេ អ្នកអាចញែកតែបឋមកថានៃពិធីការកម្រិតខ្ពស់ប៉ុណ្ណោះ។

#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. ហេតុអ្វីនេះ? ព្រោះ​អ្នក​ចងក្រង​ត្អូញត្អែរ​ពី​វា! ពួកគេបានស្នើមកខ្ញុំរួចហើយថា ខ្ញុំត្រូវតែយល់អំពី stack និង heap នៅថ្ងៃណាមួយ ខ្ញុំពិតជានឹងធ្វើវា ហើយប្រហែលជាថែមទាំងកែកូដទៀតផង។ ខ្ញុំកំណត់បន្ទាត់ដែលនឹងមានពាក្យបញ្ជាភ្លាមៗ៖ char cmd_string[MAX_CMD_LEN];. វា​គួរ​តែ​មើល​ឃើញ​នៅ​ក្នុង​មុខងារ​ទាំង​អស់ ខ្ញុំ​នឹង​និយាយ​អំពី​វា​យ៉ាង​លម្អិត​នៅ​ក្នុង​កថាខណ្ឌ 9 ។
3. ឥឡូវនេះយើងត្រូវចាប់ផ្តើម (struct work_struct my_work;) រចនាសម្ព័ន្ធ និងភ្ជាប់វាជាមួយមុខងារផ្សេងទៀត (DECLARE_WORK(my_work, work_handler);) ខ្ញុំ​ក៏​នឹង​និយាយ​ផងដែរ​អំពី​មូលហេតុ​ដែល​វា​ចាំបាច់​ក្នុង​កថាខណ្ឌ​ទី​ប្រាំបួន​។
4. ឥឡូវនេះខ្ញុំប្រកាសមុខងារមួយ ដែលនឹងក្លាយជាទំពក់។ ប្រភេទ និងអាគុយម៉ង់ដែលទទួលយកត្រូវបានកំណត់ដោយ netfilter យើងចាប់អារម្មណ៍តែប៉ុណ្ណោះ skb. នេះគឺជា socket buffer ដែលជារចនាសម្ព័ន្ធទិន្នន័យជាមូលដ្ឋានដែលមានព័ត៌មានដែលមានទាំងអស់អំពីកញ្ចប់ព័ត៌មាន។
5. ដើម្បីឱ្យមុខងារដំណើរការ អ្នកនឹងត្រូវការរចនាសម្ព័ន្ធពីរ និងអថេរជាច្រើន រួមទាំងឧបករណ៍បំលែងពីរ។

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

6. យើងអាចចាប់ផ្តើមដោយតក្កវិជ្ជា។ ដើម្បីឱ្យម៉ូឌុលដំណើរការ មិនចាំបាច់មានកញ្ចប់ព័ត៌មានផ្សេងក្រៅពី ICMP Echo ទេ ដូច្នេះយើងញែកសតិបណ្ដោះអាសន្នដោយប្រើមុខងារដែលភ្ជាប់មកជាមួយ ហើយបោះចោលកញ្ចប់ព័ត៌មានដែលមិនមែនជា 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;
     }

   ខ្ញុំមិនបានសាកល្បងអ្វីដែលនឹងកើតឡើងដោយមិនបានពិនិត្យបឋមកថា 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 និងស្អាតប្រើប្រាស់ក្របខ័ណ្ឌនេះទាំងស្រុង។ 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 ក៏ដោយ ខ្ញុំអាចសរសេរម៉ូឌុលដែលធ្វើការ ហើយមានអារម្មណ៍ថាដូចជាអ្នកលួចមើលខឺណែល ហើយក្នុងពេលតែមួយ script kiddie ។ លើសពីនេះទៀតខ្ញុំបានទៅឆានែល Kernel Newbies ជាកន្លែងដែលខ្ញុំត្រូវបានគេប្រាប់ឱ្យប្រើ schedule_work() ជំនួសឱ្យការហៅទូរស័ព្ទ call_usermodehelper() នៅខាងក្នុងទំពក់ខ្លួនឯង ហើយធ្វើឱ្យគាត់ខ្មាស់អៀន សង្ស័យថាជាការបោកប្រាស់។ កូដមួយរយបន្ទាត់ធ្វើឱ្យខ្ញុំចំណាយប្រហែលមួយសប្តាហ៍នៃការអភិវឌ្ឍន៍នៅពេលទំនេររបស់ខ្ញុំ។ បទពិសោធន៍ជោគជ័យដែលបានបំផ្លាញទេវកថាផ្ទាល់ខ្លួនរបស់ខ្ញុំអំពីភាពស្មុគស្មាញដ៏លើសលប់នៃការអភិវឌ្ឍន៍ប្រព័ន្ធ។

ប្រសិនបើនរណាម្នាក់យល់ព្រមធ្វើការត្រួតពិនិត្យកូដនៅលើ Github ខ្ញុំនឹងដឹងគុណ។ ខ្ញុំប្រាកដថាខ្ញុំបានធ្វើកំហុសឆ្គងជាច្រើន ជាពិសេសនៅពេលធ្វើការជាមួយខ្សែអក្សរ។

ប្រភព: www.habr.com