ഐസിഎംപിക്ക് മുകളിലുള്ള ന്യൂക്ലിയർ ഷെൽ

അച്ചു ഡി.ആർ.: ഞാൻ ഒരു കേർണൽ മൊഡ്യൂൾ എഴുതുകയാണ്, അത് ICMP പേലോഡിൽ നിന്നുള്ള കമാൻഡുകൾ വായിക്കുകയും നിങ്ങളുടെ SSH ക്രാഷായാലും സെർവറിൽ എക്സിക്യൂട്ട് ചെയ്യുകയും ചെയ്യും. ഏറ്റവും അക്ഷമർക്ക്, എല്ലാ കോഡും സാമൂഹികം.

മുന്നറിയിപ്പ്! പരിചയസമ്പന്നരായ സി പ്രോഗ്രാമർമാർ പൊട്ടിക്കരയാൻ സാധ്യതയുണ്ട്! പദാവലിയിൽ പോലും എനിക്ക് തെറ്റുപറ്റിയേക്കാം, എന്നാൽ ഏത് വിമർശനവും സ്വാഗതം ചെയ്യുന്നു. സി പ്രോഗ്രാമിംഗിനെക്കുറിച്ച് വളരെ ഏകദേശ ധാരണയുള്ളവരും ലിനക്സിന്റെ ഉൾവശം പരിശോധിക്കാൻ ആഗ്രഹിക്കുന്നവരുമായവരെ ഉദ്ദേശിച്ചുള്ളതാണ് പോസ്റ്റ്.

എന്റെ ആദ്യത്തെ കമന്റിൽ ലേഖനം ചില "പതിവ്" പ്രോട്ടോക്കോളുകളെ അനുകരിക്കാൻ കഴിയുന്ന SoftEther VPN-നെ പരാമർശിച്ചു, പ്രത്യേകിച്ചും HTTPS, ICMP, DNS എന്നിവപോലും. എനിക്ക് HTTP(S) വളരെ പരിചിതമായതിനാൽ, ICMP, DNS എന്നിവയിലൂടെ ടണലിംഗ് പഠിക്കേണ്ടി വന്നതിനാൽ, അവരിൽ ആദ്യത്തേത് മാത്രമേ പ്രവർത്തിക്കൂ എന്ന് എനിക്ക് ഊഹിക്കാവുന്നതേയുള്ളൂ.

അതെ, 2020-ൽ നിങ്ങൾക്ക് ICMP പാക്കറ്റുകളിലേക്ക് ഒരു അനിയന്ത്രിതമായ പേലോഡ് ചേർക്കാൻ കഴിയുമെന്ന് ഞാൻ മനസ്സിലാക്കി. എന്നാൽ ഒരിക്കലും വൈകിയതിനേക്കാൾ നല്ലത്! അതിനെക്കുറിച്ച് എന്തെങ്കിലും ചെയ്യാൻ കഴിയുമെന്നതിനാൽ, അത് ചെയ്യേണ്ടതുണ്ട്. എന്റെ ദൈനംദിന ജീവിതത്തിൽ ഞാൻ മിക്കപ്പോഴും കമാൻഡ് ലൈൻ ഉപയോഗിക്കുന്നതിനാൽ, SSH വഴി ഉൾപ്പെടെ, ഒരു ICMP ഷെൽ എന്ന ആശയം ആദ്യം എന്റെ മനസ്സിൽ വന്നു. ഒരു സമ്പൂർണ്ണ ബുൾഷീൽഡ് ബിങ്കോ കൂട്ടിച്ചേർക്കുന്നതിന്, എനിക്ക് ഏകദേശ ധാരണ മാത്രമുള്ള ഒരു ഭാഷയിൽ ഇത് ഒരു ലിനക്സ് മൊഡ്യൂളായി എഴുതാൻ ഞാൻ തീരുമാനിച്ചു. പ്രക്രിയകളുടെ പട്ടികയിൽ അത്തരം ഒരു ഷെൽ ദൃശ്യമാകില്ല, നിങ്ങൾക്ക് അത് കേർണലിലേക്ക് ലോഡ് ചെയ്യാം, അത് ഫയൽ സിസ്റ്റത്തിൽ ഉണ്ടാകില്ല, ലിസണിംഗ് പോർട്ടുകളുടെ പട്ടികയിൽ സംശയാസ്പദമായ ഒന്നും നിങ്ങൾ കാണില്ല. അതിന്റെ കഴിവുകളുടെ കാര്യത്തിൽ, ഇതൊരു പൂർണ്ണമായ റൂട്ട്കിറ്റാണ്, എന്നാൽ ഇത് മെച്ചപ്പെടുത്താനും SSH വഴി ലോഗിൻ ചെയ്യാനും കുറഞ്ഞത് എക്സിക്യൂട്ട് ചെയ്യാനും ലോഡ് ശരാശരി വളരെ കൂടുതലായിരിക്കുമ്പോൾ ഇത് അവസാന ആശ്രയമായി ഉപയോഗിക്കുമെന്ന് ഞാൻ പ്രതീക്ഷിക്കുന്നു. 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:, റാൻഡം പേലോഡുകളുള്ള പാക്കേജുകൾ ഒഴിവാക്കാൻ ഞങ്ങൾക്ക് ഇത് ആവശ്യമാണ്.

കെർണലിന് പാക്കേജുകൾ തയ്യാറാക്കാൻ പ്രത്യേകാവകാശങ്ങൾ ആവശ്യമാണ്, അതിനാൽ സ്ക്രിപ്റ്റ് സൂപ്പർ യൂസറായി പ്രവർത്തിപ്പിക്കേണ്ടതുണ്ട്. എക്സിക്യൂഷൻ പെർമിഷനുകൾ നൽകാനും 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);

എന്താണ് ഇവിടെ നടക്കുന്നത്:

1. മൊഡ്യൂളും നെറ്റ്ഫിൽറ്ററും കൈകാര്യം ചെയ്യാൻ രണ്ട് ഹെഡ്ഡർ ഫയലുകൾ വലിച്ചിടുന്നു.
2. എല്ലാ പ്രവർത്തനങ്ങളും ഒരു നെറ്റ്ഫിൽട്ടറിലൂടെ കടന്നുപോകുന്നു, നിങ്ങൾക്ക് അതിൽ കൊളുത്തുകൾ സജ്ജമാക്കാൻ കഴിയും. ഇത് ചെയ്യുന്നതിന്, ഹുക്ക് കോൺഫിഗർ ചെയ്യുന്ന ഘടന നിങ്ങൾ പ്രഖ്യാപിക്കേണ്ടതുണ്ട്. ഒരു ഹുക്ക് ആയി എക്സിക്യൂട്ട് ചെയ്യുന്ന ഫംഗ്ഷൻ വ്യക്തമാക്കുക എന്നതാണ് ഏറ്റവും പ്രധാനപ്പെട്ട കാര്യം: 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() മൊഡ്യൂൾ ആരംഭിക്കുന്നതിനും അവസാനിപ്പിക്കുന്നതിനും മറ്റ് ഫംഗ്ഷനുകൾ സജ്ജമാക്കുക.

പേലോഡ് വീണ്ടെടുക്കുന്നു

ഇപ്പോൾ നമുക്ക് പേലോഡ് എക്‌സ്‌ട്രാക്‌റ്റ് ചെയ്യേണ്ടതുണ്ട്, ഇത് ഏറ്റവും ബുദ്ധിമുട്ടുള്ള കാര്യമായി മാറി. പേലോഡുകൾക്കൊപ്പം പ്രവർത്തിക്കുന്നതിന് കേർണലിന് ബിൽറ്റ്-ഇൻ ഫംഗ്ഷനുകൾ ഇല്ല; നിങ്ങൾക്ക് ഉയർന്ന തലത്തിലുള്ള പ്രോട്ടോക്കോളുകളുടെ തലക്കെട്ടുകൾ മാത്രമേ പാഴ്‌സ് ചെയ്യാൻ കഴിയൂ.

#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. എന്തുകൊണ്ടാണ് ഇത് കൃത്യമായി? കാരണം കംപൈലർ അതിനെക്കുറിച്ച് പരാതിപ്പെടുന്നു! എനിക്ക് സ്റ്റാക്കും കൂമ്പാരവും മനസിലാക്കണമെന്ന് അവർ ഇതിനകം എന്നോട് നിർദ്ദേശിച്ചിട്ടുണ്ട്, എന്നെങ്കിലും ഞാൻ തീർച്ചയായും ഇത് ചെയ്യും, ഒരുപക്ഷേ കോഡ് ശരിയാക്കാം. കമാൻഡ് അടങ്ങിയിരിക്കുന്ന ലൈൻ ഞാൻ ഉടൻ സജ്ജമാക്കി: char cmd_string[MAX_CMD_LEN];. ഇത് എല്ലാ ഫംഗ്ഷനുകളിലും ദൃശ്യമായിരിക്കണം; ഖണ്ഡിക 9 ൽ ഞാൻ ഇതിനെക്കുറിച്ച് കൂടുതൽ വിശദമായി സംസാരിക്കും.
3. ഇപ്പോൾ നമ്മൾ ആരംഭിക്കേണ്ടതുണ്ട് (struct work_struct my_work;) ഘടനയും മറ്റൊരു ഫംഗ്ഷനുമായി ബന്ധിപ്പിക്കുക (DECLARE_WORK(my_work, work_handler);). ഒമ്പതാം ഖണ്ഡികയിൽ ഇത് എന്തുകൊണ്ട് ആവശ്യമാണ് എന്നതിനെക്കുറിച്ചും ഞാൻ സംസാരിക്കും.
4. ഇപ്പോൾ ഞാൻ ഒരു ഫംഗ്ഷൻ പ്രഖ്യാപിക്കുന്നു, അത് ഒരു ഹുക്ക് ആയിരിക്കും. തരവും സ്വീകാര്യമായ ആർഗ്യുമെന്റുകളും നെറ്റ്ഫിൽറ്റർ നിർദ്ദേശിക്കുന്നു, ഞങ്ങൾക്ക് താൽപ്പര്യമുള്ളത് മാത്രമാണ് skb. ഇതൊരു സോക്കറ്റ് ബഫർ ആണ്, ഒരു പാക്കറ്റിനെക്കുറിച്ച് ലഭ്യമായ എല്ലാ വിവരങ്ങളും അടങ്ങുന്ന അടിസ്ഥാന ഡാറ്റാ ഘടന.
5. ഫംഗ്‌ഷൻ പ്രവർത്തിക്കുന്നതിന്, നിങ്ങൾക്ക് രണ്ട് ഇറ്ററേറ്ററുകൾ ഉൾപ്പെടെ രണ്ട് ഘടനകളും നിരവധി വേരിയബിളുകളും ആവശ്യമാണ്.

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

6. നമുക്ക് യുക്തിയിൽ നിന്ന് ആരംഭിക്കാം. മൊഡ്യൂൾ പ്രവർത്തിക്കുന്നതിന്, 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;
     }

   ഐപി തലക്കെട്ടുകൾ പരിശോധിക്കാതെ എന്ത് സംഭവിക്കുമെന്ന് ഞാൻ പരീക്ഷിച്ചിട്ടില്ല. അധിക പരിശോധനകളില്ലാതെ ഭയങ്കരമായ എന്തെങ്കിലും സംഭവിക്കുമെന്ന് സിയെക്കുറിച്ചുള്ള എന്റെ ഏറ്റവും കുറഞ്ഞ അറിവ് എന്നോട് പറയുന്നു. നിങ്ങൾ ഇതിൽ നിന്ന് എന്നെ പിന്തിരിപ്പിച്ചാൽ ഞാൻ സന്തോഷിക്കും!

7. ഇപ്പോൾ പാക്കേജ് നിങ്ങൾക്ക് ആവശ്യമുള്ള തരത്തിലുള്ളതാണ്, നിങ്ങൾക്ക് ഡാറ്റ എക്‌സ്‌ട്രാക്‌റ്റുചെയ്യാനാകും. ഒരു ബിൽറ്റ്-ഇൻ ഫംഗ്‌ഷൻ ഇല്ലാതെ, നിങ്ങൾ ആദ്യം പേലോഡിന്റെ തുടക്കത്തിലേക്ക് ഒരു പോയിന്റർ നേടേണ്ടതുണ്ട്. ഇത് ഒരിടത്ത് ചെയ്തു, നിങ്ങൾ ഐസിഎംപി തലക്കെട്ടിന്റെ തുടക്കത്തിലേക്ക് പോയിന്റർ എടുത്ത് ഈ ഹെഡറിന്റെ വലുപ്പത്തിലേക്ക് നീക്കേണ്ടതുണ്ട്. എല്ലാം ഘടന ഉപയോഗിക്കുന്നു 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 അഭ്യർത്ഥന അയച്ച തീയതി അതിൽ അടങ്ങിയിരിക്കുന്നു, അതിനർത്ഥം നിങ്ങൾ എല്ലാം ശരിയായി ചെയ്തുവെന്നും ഞാൻ എല്ലാം ശരിയായി ചെയ്തുവെന്നും അർത്ഥമാക്കുന്നു.

തീരുമാനം

ആണവ വികസനവുമായി ബന്ധപ്പെട്ട എന്റെ ആദ്യ അനുഭവം ഞാൻ പ്രതീക്ഷിച്ചതിലും വളരെ എളുപ്പമായിരുന്നു. കംപൈലർ സൂചനകളിലും ഗൂഗിൾ ഫലങ്ങളിലും ശ്രദ്ധ കേന്ദ്രീകരിച്ച് സിയിൽ വികസിപ്പിച്ച അനുഭവം ഇല്ലെങ്കിലും, എനിക്ക് ഒരു വർക്കിംഗ് മൊഡ്യൂൾ എഴുതാനും ഒരു കേർണൽ ഹാക്കറെപ്പോലെ തോന്നാനും അതേ സമയം ഒരു സ്‌ക്രിപ്റ്റ് കിഡ്ഡിയെപ്പോലെ തോന്നാനും കഴിഞ്ഞു. കൂടാതെ, ഞാൻ കേർണൽ ന്യൂബീസ് ചാനലിലേക്ക് പോയി, അവിടെ അവർ എന്നോട് ഉപയോഗിക്കാൻ പറഞ്ഞു schedule_work() വിളിക്കുന്നതിനു പകരം call_usermodehelper() ഹുക്ക് ഉള്ളിൽ തന്നെ അവനെ ലജ്ജിപ്പിച്ചു, ഒരു അഴിമതിയെ ശരിയായി സംശയിച്ചു. എന്റെ ഒഴിവുസമയങ്ങളിൽ ഒരു ആഴ്‌ചയിലെ വികസനത്തിന് നൂറ് വരി കോഡ് ചെലവായി. സിസ്റ്റം വികസനത്തിന്റെ സങ്കീർണ്ണതയെക്കുറിച്ചുള്ള എന്റെ വ്യക്തിപരമായ മിഥ്യയെ നശിപ്പിച്ച ഒരു വിജയകരമായ അനുഭവം.

Github-ൽ ഒരു കോഡ് അവലോകനം നടത്താൻ ആരെങ്കിലും സമ്മതിക്കുകയാണെങ്കിൽ, ഞാൻ നന്ദിയുള്ളവനായിരിക്കും. ഞാൻ ഒരുപാട് മണ്ടത്തരങ്ങൾ ചെയ്തിട്ടുണ്ടെന്ന് എനിക്ക് ഉറപ്പുണ്ട്, പ്രത്യേകിച്ച് സ്ട്രിംഗുകൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കുമ്പോൾ.

അവലംബം: www.habr.com