ProHoster > බ්ලොග් > පරිපාලනය > ICMP හරහා න්‍යෂ්ටික කවචය

ICMP හරහා න්‍යෂ්ටික කවචය

ICMP හරහා න්‍යෂ්ටික කවචය

TL; ඩී: මම කර්නල් මොඩියුලයක් ලියන්නේ එය ICMP ගෙවීමෙන් විධාන කියවා ඔබේ SSH බිඳවැටුනත් ඒවා සේවාදායකයේ ක්‍රියාත්මක කරයි. වඩාත්ම නොඉවසිලිමත් අය සඳහා, සියලු කේතය වේ github.

අවවාදයයි පළපුරුදු C ක්‍රමලේඛකයින් ලේ කඳුළු සැලීමේ අවදානමක් ඇත! මම පාරිභාෂිතය තුළ පවා වැරදි විය හැක, නමුත් ඕනෑම විවේචනයක් සාදරයෙන් පිළිගනිමු. පෝස්ට් එක අදහස් කරන්නේ C ක්‍රමලේඛනය පිළිබඳ ඉතා දළ අදහසක් ඇති සහ Linux හි අභ්‍යන්තරය සොයා බැලීමට කැමති අය සඳහා ය.

මගේ පළමු කමෙන්ට් වල ලිපියයි සමහර "සාමාන්‍ය" ප්‍රොටෝකෝල අනුකරණය කළ හැකි SoftEther VPN සඳහන් කර ඇත, විශේෂයෙන් HTTPS, ICMP සහ DNS පවා. මම HTTP(S) සමඟ ඉතා හුරුපුරුදු බැවින්, මට ICMP සහ DNS හරහා උමං මාර්ග ඉගෙන ගැනීමට සිදු වූ බැවින්, ඔවුන්ගෙන් පළමුවැන්නා පමණක් වැඩ කරන්නේ යැයි මට සිතාගත හැකිය.

ICMP හරහා න්‍යෂ්ටික කවචය

ඔව්, 2020 දී මම ඉගෙන ගත්තා ඔබට ICMP පැකට් වලට අත්තනෝමතික ගෙවීමක් ඇතුළු කළ හැකි බව. නමුත් වෙනදාට වඩා ප්‍රමාද වීම හොඳය! ඒ සඳහා යමක් කළ හැකි බැවින්, එය කළ යුතු ය. මගේ එදිනෙදා ජීවිතයේදී මම බොහෝ විට SSH හරහා ඇතුළුව විධාන රේඛාව භාවිතා කරන බැවින්, ICMP කවචයක් පිළිබඳ අදහස මුලින්ම මගේ මනසට පැමිණියේය. සහ සම්පූර්ණ bullshield බිංගෝ එකලස් කිරීම සඳහා, මම එය ලිනක්ස් මොඩියුලයක් ලෙස මට දළ අදහසක් පමණක් ඇති භාෂාවකින් ලිවීමට තීරණය කළෙමි. ක්‍රියාවලි ලැයිස්තුවේ එවැනි කවචයක් නොපෙනේ, ඔබට එය කර්නලය වෙත පැටවිය හැකි අතර එය ගොනු පද්ධතියේ නොපවතිනු ඇත, සවන් දෙන වරායන් ලැයිස්තුවේ සැක සහිත කිසිවක් ඔබට නොපෙනේ. එහි හැකියාවන් අනුව, මෙය අංගසම්පූර්ණ rootkit වේ, නමුත් SSH හරහා ලොග් වී අවම වශයෙන් ක්‍රියාත්මක කිරීමට නොහැකි තරම් බර පැටවීමේ සාමාන්‍යය වැඩි වූ විට එය වැඩිදියුණු කර අවසාන විසඳුම ලෙස භාවිතා කිරීමට මම බලාපොරොත්තු වෙමි. echo i > /proc/sysrq-triggerනැවත පණගැන්වීමකින් තොරව ප්රවේශය ප්රතිෂ්ඨාපනය කිරීමට.

අපි ටෙක්ස්ට් එඩිටරයක් ​​ගන්නවා, මූලික ක්‍රමලේඛන කුසලතා Python සහ C, Google සහ අතථ්ය සියල්ල කැඩී ගියහොත් පිහිය යට තැබීමට ඔබට කමක් නැත (විකල්ප - දේශීය 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 ස්ථාපනය කිරීමට අමතක නොකරන්න. ඩේබියන් නම් පැකේජයක් ඇත 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);

මොකද මෙතන වෙන්නෙ:

  1. මොඩියුලය සහ නෙට්ෆිල්ටරය හැසිරවීමට ශීර්ෂ ගොනු දෙකක් ඇද දමනු ලැබේ.
  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() මොඩියුලය ආරම්භ කිරීමට සහ අවසන් කිරීමට වෙනත් කාර්යයන් සකසන්න.

ගෙවීම ආපසු ලබා ගැනීම

දැන් අපි ගෙවීමේ බර උකහා ගත යුතුයි, මෙය වඩාත්ම දුෂ්කර කාර්යය බවට පත් විය. කර්නලයට ගෙවීම් සමඟ වැඩ කිරීම සඳහා ගොඩනඟන ලද කාර්යයන් නොමැත; ඔබට උසස් මට්ටමේ ප්‍රොටෝකෝලවල ශීර්ෂයන් පමණක් විග්‍රහ කළ හැකිය.

#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. දැන් මම ශ්‍රිතයක් ප්‍රකාශ කරමි, එය කොක්කක් වනු ඇත. වර්ගය සහ පිළිගත් තර්ක netfilter විසින් නියම කරනු ලැබේ, අපි උනන්දු වන්නේ පමණි skb. මෙය සොකට් බෆරයක් වන අතර, පැකට්ටුවක් පිළිබඳ පවතින සියලුම තොරතුරු අඩංගු මූලික දත්ත ව්‍යුහයකි.
  5. ශ්‍රිතය ක්‍රියා කිරීම සඳහා, ඔබට ව්‍යුහ දෙකක් සහ පුනරාවර්තක දෙකක් ඇතුළුව විචල්‍ය කිහිපයක් අවශ්‍ය වේ. 
      struct iphdr *iph;
  struct icmphdr *icmph;

  unsigned char *user_data;
  unsigned char *tail;
  unsigned char *i;
  int j = 0;
  6. අපට තර්කයෙන් පටන් ගත හැකිය. මොඩියුලය ක්‍රියා කිරීමට, 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 පිළිබඳ මගේ අවම දැනුම මට පවසන්නේ අමතර පරීක්ෂාවන් නොමැතිව භයානක දෙයක් සිදුවනු ඇති බවයි. ඔබ මාව මෙයින් ඉවත් කරන්නේ නම් මම සතුටු වෙමි!

  7. දැන් පැකේජය ඔබට අවශ්‍ය නියම වර්ගයට අයත් බැවින් ඔබට දත්ත උපුටා ගත හැක. බිල්ට්-ඉන් ශ්‍රිතයක් නොමැතිව, ඔබ ප්‍රථමයෙන් ගෙවීමේ ආරම්භයට පොයින්ටරයක් ​​ලබා ගත යුතුය. මෙය එක් ස්ථානයක සිදු කරනු ලැබේ, ඔබ ICMP ශීර්ෂයේ ආරම්භයට පොයින්ටරය ගෙන මෙම ශීර්ෂයේ ප්‍රමාණයට ගෙන යා යුතුය. සෑම දෙයක්ම ව්යුහය භාවිතා කරයි icmph: user_data = (unsigned char *)((unsigned char *)icmph + (sizeof(icmph)));
    ශීර්ෂයේ අවසානය ගෙවීමේ අවසානයට අනුරූප විය යුතුය skb, එබැවින් අපි එය අනුරූප ව්යුහයෙන් න්යෂ්ටික ක්රම භාවිතයෙන් ලබා ගනිමු: tail = skb_tail_pointer(skb);.

    ICMP හරහා න්‍යෂ්ටික කවචය

    පින්තූරය සොරකම් කර ඇත මෙතනින්, ඔබට සොකට් බෆරය ගැන වැඩිදුර කියවිය හැක.

  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 සහ පිරිසිදු ඉලක්ක මෙම රාමුව සම්පූර්ණයෙන්ම භාවිතා කරයි. තුල 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 හි වර්ධනය වීමේ අත්දැකීමක් නොමැතිව වුවද, සම්පාදක ඉඟි සහ ගූගල් ප්‍රති results ල කෙරෙහි අවධානය යොමු කරමින්, මට වැඩ කරන මොඩියුලයක් ලිවීමට සහ කර්නල් හැකර් කෙනෙකු මෙන් දැනීමටත්, ඒ සමඟම ස්ක්‍රිප්ට් කිඩ්ඩියෙකු වීමටත් මට හැකි විය. ඊට අමතරව, මම Kernel Newbies නාලිකාවට ගියා, එහිදී මට භාවිතා කරන්න කිව්වා schedule_work() ඇමතුම වෙනුවට call_usermodehelper() කොක්ක තුළම ඔහුව ලැජ්ජාවට පත් කළේය, වංචාවක් ගැන නිවැරදිව සැක කරයි. කේත පේළි සියයක් මගේ නිදහස් කාලය තුළ සංවර්ධනය සඳහා සතියක් පමණ වැය විය. පද්ධති සංවර්ධනයේ අතිමහත් සංකීර්ණත්වය පිළිබඳ මගේ පෞද්ගලික මිථ්‍යාව විනාශ කළ සාර්ථක අත්දැකීමක්.

Github හි කේත සමාලෝචනයක් කිරීමට යමෙකු එකඟ වන්නේ නම්, මම කෘතඥ වෙනවා. විශේෂයෙන් නූල් සමඟ වැඩ කිරීමේදී මම බොහෝ මෝඩ වැරදි සිදු කළ බව මට හොඳටම විශ්වාසයි.

ICMP හරහා න්‍යෂ්ටික කවචය

මූලාශ්රය: www.habr.com

අදහස් එක් කරන්න