🥇ICMP પર પરમાણુ શેલ | પ્રોહોસ્ટર

TL; DR: હું કર્નલ મોડ્યુલ લખી રહ્યો છું જે ICMP પેલોડમાંથી આદેશો વાંચશે અને તમારો SSH ક્રેશ થાય તો પણ તેને સર્વર પર એક્ઝિક્યુટ કરશે. સૌથી અધીરા માટે, બધા કોડ છે GitHub.

સાવધાન! અનુભવી સી પ્રોગ્રામરો લોહીના આંસુમાં ફૂટવાનું જોખમ લે છે! પરિભાષામાં હું ખોટો પણ હોઈ શકું, પરંતુ કોઈપણ ટીકા આવકાર્ય છે. આ પોસ્ટ એવા લોકો માટે બનાવાયેલ છે જેમને C પ્રોગ્રામિંગનો ખૂબ જ રફ આઈડિયા છે અને જેઓ Linux ની અંદરની તરફ જોવા માગે છે.

મારી પ્રથમ ટિપ્પણીઓમાં લેખ SoftEther VPN નો ઉલ્લેખ કર્યો છે, જે અમુક "નિયમિત" પ્રોટોકોલની નકલ કરી શકે છે, ખાસ કરીને HTTPS, ICMP અને DNS. હું કલ્પના કરી શકું છું કે તેમાંથી માત્ર પ્રથમ કામ કરે છે, કારણ કે હું HTTP(S) થી ખૂબ જ પરિચિત છું, અને મારે ICMP અને DNS પર ટનલિંગ શીખવું પડ્યું હતું.

હા, 2020 માં મેં શીખ્યા કે તમે ICMP પેકેટ્સમાં મનસ્વી પેલોડ દાખલ કરી શકો છો. પરંતુ ક્યારેય કરતાં મોડું સારું! અને કારણ કે તેના વિશે કંઈક કરી શકાય છે, તો તે કરવાની જરૂર છે. મારા રોજિંદા જીવનમાં હું મોટાભાગે કમાન્ડ લાઇનનો ઉપયોગ કરું છું, જેમાં SSH દ્વારા સમાવેશ થાય છે, ICMP શેલનો વિચાર પ્રથમ મારા મગજમાં આવ્યો. અને સંપૂર્ણ બુલશિલ્ડ બિન્ગો એસેમ્બલ કરવા માટે, મેં તેને એક એવી ભાષામાં લિનક્સ મોડ્યુલ તરીકે લખવાનું નક્કી કર્યું કે જેનો મને માત્ર અંદાજ છે. આવા શેલ પ્રક્રિયાઓની સૂચિમાં દેખાશે નહીં, તમે તેને કર્નલમાં લોડ કરી શકો છો અને તે ફાઇલ સિસ્ટમ પર નહીં હોય, સાંભળવાના પોર્ટ્સની સૂચિમાં તમને શંકાસ્પદ કંઈપણ દેખાશે નહીં. તેની ક્ષમતાઓના સંદર્ભમાં, આ એક સંપૂર્ણ સુવિધાયુક્ત રુટકિટ છે, પરંતુ હું તેને સુધારવાની આશા રાખું છું અને SSH દ્વારા લોગ ઇન કરવા અને ઓછામાં ઓછા એક્ઝિક્યુટ કરવા માટે લોડ એવરેજ ખૂબ વધારે હોય ત્યારે છેલ્લા ઉપાયના શેલ તરીકે તેનો ઉપયોગ કરવાની આશા રાખું છું. echo i > /proc/sysrq-triggerરીબૂટ કર્યા વિના ઍક્સેસ પુનઃસ્થાપિત કરવા માટે.

અમે એક ટેક્સ્ટ એડિટર લઈએ છીએ, Python અને C, Google અને માં મૂળભૂત પ્રોગ્રામિંગ કુશળતા વર્ચ્યુઅલ જો બધું તૂટી જાય તો તમને છરીની નીચે મુકવામાં કોઈ વાંધો નથી (વૈકલ્પિક - સ્થાનિક વર્ચ્યુઅલબોક્સ/કેવીએમ/વગેરે) અને ચાલો જઈએ!

ગ્રાહક બાજુ

મને એવું લાગતું હતું કે ક્લાયંટના ભાગ માટે મારે લગભગ 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, બાકીના નિર્ભરતાના સ્વરૂપમાં આવશે. હું લેખમાં સંપૂર્ણ કોડ પ્રદાન કરીશ નહીં; તમે તેને ગીથબ પર ક્લોન કરી શકો છો.

હૂક સેટઅપ

શરૂ કરવા માટે, અમને મોડ્યુલ લોડ કરવા અને તેને અનલોડ કરવા માટે બે કાર્યોની જરૂર છે. અનલોડિંગ માટે કાર્ય જરૂરી નથી, પરંતુ પછી 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;
  }
```
IP હેડરોને તપાસ્યા વિના શું થશે તે મેં પરીક્ષણ કર્યું નથી. સી વિશેનું મારું ન્યૂનતમ જ્ઞાન મને કહે છે કે વધારાની તપાસ વિના, કંઈક ભયંકર બનવાનું છે. જો તમે મને આનાથી ના પાડશો તો મને આનંદ થશે!
હવે જ્યારે પેકેજ તમને જરૂર છે તે ચોક્કસ પ્રકારનું છે, તમે ડેટા કાઢી શકો છો. બિલ્ટ-ઇન ફંક્શન વિના, તમારે પહેલા પેલોડની શરૂઆતમાં એક પોઇન્ટર મેળવવું પડશે. આ એક જગ્યાએ કરવામાં આવે છે, તમારે પોઇન્ટરને 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 અને તેમાં વિનંતી મોકલવામાં આવેલી તારીખનો સમાવેશ થાય છે, જેનો અર્થ છે કે તમે બધું બરાબર કર્યું અને મેં બધું બરાબર કર્યું.

નિષ્કર્ષ

પરમાણુ વિકાસ સાથેનો મારો પ્રથમ અનુભવ મારી અપેક્ષા કરતાં ઘણો સરળ હતો. કમ્પાઇલર સંકેતો અને Google પરિણામો પર ધ્યાન કેન્દ્રિત કરીને, C માં વિકાસ કર્યાના અનુભવ વિના પણ, હું એક વર્કિંગ મોડ્યુલ લખી શક્યો અને કર્નલ હેકર જેવો અનુભવ કરી શક્યો, અને તે જ સમયે સ્ક્રિપ્ટ કિડી. વધુમાં, હું કર્નલ ન્યૂબીઝ ચેનલ પર ગયો, જ્યાં મને ઉપયોગ કરવાનું કહેવામાં આવ્યું schedule_work() કૉલ કરવાને બદલે call_usermodehelper() હૂકની અંદર જ અને તેને શરમજનક, યોગ્ય રીતે કૌભાંડની શંકા. કોડની સો લીટીઓ મારા ફ્રી ટાઇમમાં વિકાસના એક અઠવાડિયા વિશે ખર્ચ કરે છે. એક સફળ અનુભવ જેણે સિસ્ટમના વિકાસની જબરજસ્ત જટિલતા વિશેની મારી અંગત માન્યતાનો નાશ કર્યો.

જો કોઈ ગીથબ પર કોડ સમીક્ષા કરવા માટે સંમત થાય, તો હું આભારી રહીશ. મને ખાતરી છે કે મેં ઘણી મૂર્ખ ભૂલો કરી છે, ખાસ કરીને જ્યારે શબ્દમાળાઓ સાથે કામ કરતી વખતે.

સોર્સ: www.habr.com

ICMP પર પરમાણુ શેલ