ICMP ਉੱਤੇ ਪ੍ਰਮਾਣੂ ਸ਼ੈੱਲ

TL; ਡਾ: ਮੈਂ ਇੱਕ ਕਰਨਲ ਮੋਡੀਊਲ ਲਿਖ ਰਿਹਾ ਹਾਂ ਜੋ ICMP ਪੇਲੋਡ ਤੋਂ ਕਮਾਂਡਾਂ ਨੂੰ ਪੜ੍ਹੇਗਾ ਅਤੇ ਉਹਨਾਂ ਨੂੰ ਸਰਵਰ 'ਤੇ ਚਲਾਏਗਾ ਭਾਵੇਂ ਤੁਹਾਡਾ SSH ਕਰੈਸ਼ ਹੋ ਜਾਵੇ। ਸਭ ਤੋਂ ਬੇਸਬਰ ਲਈ, ਸਭ ਕੋਡ ਹੈ GitHub.

ਸਾਵਧਾਨ ਤਜਰਬੇਕਾਰ C ਪ੍ਰੋਗਰਾਮਰ ਖੂਨ ਦੇ ਹੰਝੂਆਂ ਵਿੱਚ ਫੁੱਟਣ ਦਾ ਜੋਖਮ ਲੈਂਦੇ ਹਨ! ਮੈਂ ਸ਼ਬਦਾਵਲੀ ਵਿੱਚ ਗਲਤ ਵੀ ਹੋ ਸਕਦਾ ਹਾਂ, ਪਰ ਕਿਸੇ ਵੀ ਆਲੋਚਨਾ ਦਾ ਸਵਾਗਤ ਹੈ. ਪੋਸਟ ਉਹਨਾਂ ਲਈ ਤਿਆਰ ਕੀਤੀ ਗਈ ਹੈ ਜਿਨ੍ਹਾਂ ਨੂੰ ਸੀ ਪ੍ਰੋਗਰਾਮਿੰਗ ਦਾ ਬਹੁਤ ਮਾੜਾ ਵਿਚਾਰ ਹੈ ਅਤੇ ਉਹ ਲੀਨਕਸ ਦੇ ਅੰਦਰਲੇ ਹਿੱਸੇ ਨੂੰ ਵੇਖਣਾ ਚਾਹੁੰਦੇ ਹਨ.

ਮੇਰੀ ਪਹਿਲੀ ਕਰਨ ਲਈ ਟਿੱਪਣੀ ਵਿੱਚ ਲੇਖ ਸਾਫਟਈਥਰ ਵੀਪੀਐਨ ਦਾ ਜ਼ਿਕਰ ਕੀਤਾ, ਜੋ ਕਿ ਕੁਝ "ਨਿਯਮਿਤ" ਪ੍ਰੋਟੋਕੋਲਾਂ ਦੀ ਨਕਲ ਕਰ ਸਕਦਾ ਹੈ, ਖਾਸ ਕਰਕੇ 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:, ਸਾਨੂੰ ਬੇਤਰਤੀਬ ਪੇਲੋਡ ਵਾਲੇ ਪੈਕੇਜਾਂ ਨੂੰ ਬਾਹਰ ਕੱਢਣ ਲਈ ਇਸਦੀ ਲੋੜ ਪਵੇਗੀ।

ਕਰਨਲ ਨੂੰ ਪੈਕੇਜ ਬਣਾਉਣ ਲਈ ਵਿਸ਼ੇਸ਼ ਅਧਿਕਾਰਾਂ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਇਸਲਈ ਸਕ੍ਰਿਪਟ ਨੂੰ ਸੁਪਰਯੂਜ਼ਰ ਵਜੋਂ ਚਲਾਉਣਾ ਪਵੇਗਾ। ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਅਨੁਮਤੀਆਂ ਦੇਣਾ ਅਤੇ ਸਕੈਪੀ ਨੂੰ ਖੁਦ ਸਥਾਪਿਤ ਕਰਨਾ ਨਾ ਭੁੱਲੋ। ਡੇਬੀਅਨ ਕੋਲ ਇੱਕ ਪੈਕੇਜ ਹੈ ਜਿਸਨੂੰ ਕਹਿੰਦੇ ਹਨ 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);

ਇੱਥੇ ਕੀ ਹੋ ਰਿਹਾ ਹੈ:

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;
     }

   ਮੈਂ ਇਹ ਜਾਂਚ ਨਹੀਂ ਕੀਤੀ ਹੈ ਕਿ 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 ਅਤੇ ਇਸ ਵਿੱਚ ਬੇਨਤੀ ਭੇਜੀ ਗਈ ਮਿਤੀ ਹੈ, ਜਿਸਦਾ ਮਤਲਬ ਹੈ ਕਿ ਤੁਸੀਂ ਸਭ ਕੁਝ ਠੀਕ ਕੀਤਾ ਅਤੇ ਮੈਂ ਸਭ ਕੁਝ ਠੀਕ ਕੀਤਾ।

ਸਿੱਟਾ

ਪਰਮਾਣੂ ਵਿਕਾਸ ਦੇ ਨਾਲ ਮੇਰਾ ਪਹਿਲਾ ਅਨੁਭਵ ਮੇਰੀ ਉਮੀਦ ਨਾਲੋਂ ਬਹੁਤ ਸੌਖਾ ਸੀ। ਇੱਥੋਂ ਤੱਕ ਕਿ ਸੀ ਵਿੱਚ ਵਿਕਸਤ ਹੋਣ ਦੇ ਤਜ਼ਰਬੇ ਤੋਂ ਬਿਨਾਂ, ਕੰਪਾਈਲਰ ਸੰਕੇਤਾਂ ਅਤੇ ਗੂਗਲ ਨਤੀਜਿਆਂ 'ਤੇ ਧਿਆਨ ਕੇਂਦਰਤ ਕਰਦੇ ਹੋਏ, ਮੈਂ ਇੱਕ ਕੰਮ ਕਰਨ ਵਾਲੇ ਮੋਡੀਊਲ ਨੂੰ ਲਿਖਣ ਅਤੇ ਇੱਕ ਕਰਨਲ ਹੈਕਰ ਵਾਂਗ ਮਹਿਸੂਸ ਕਰਨ ਦੇ ਯੋਗ ਸੀ, ਅਤੇ ਉਸੇ ਸਮੇਂ ਇੱਕ ਸਕ੍ਰਿਪਟ ਕਿਡੀ. ਇਸ ਤੋਂ ਇਲਾਵਾ, ਮੈਂ ਕਰਨਲ ਨਿਊਬੀਜ਼ ਚੈਨਲ 'ਤੇ ਗਿਆ, ਜਿੱਥੇ ਮੈਨੂੰ ਵਰਤਣ ਲਈ ਕਿਹਾ ਗਿਆ ਸੀ schedule_work() ਕਾਲ ਕਰਨ ਦੀ ਬਜਾਏ call_usermodehelper() ਆਪਣੇ ਆਪ ਨੂੰ ਹੁੱਕ ਦੇ ਅੰਦਰ ਅਤੇ ਉਸ ਨੂੰ ਸ਼ਰਮਿੰਦਾ ਕੀਤਾ, ਸਹੀ ਤੌਰ 'ਤੇ ਇੱਕ ਘੁਟਾਲੇ ਦਾ ਸ਼ੱਕ. ਕੋਡ ਦੀਆਂ ਸੌ ਲਾਈਨਾਂ ਨੇ ਮੇਰੇ ਖਾਲੀ ਸਮੇਂ ਵਿੱਚ ਵਿਕਾਸ ਦੇ ਇੱਕ ਹਫ਼ਤੇ ਦਾ ਖਰਚਾ ਕੀਤਾ. ਇੱਕ ਸਫਲ ਤਜਰਬਾ ਜਿਸ ਨੇ ਸਿਸਟਮ ਦੇ ਵਿਕਾਸ ਦੀ ਭਾਰੀ ਗੁੰਝਲਤਾ ਬਾਰੇ ਮੇਰੀ ਨਿੱਜੀ ਮਿੱਥ ਨੂੰ ਨਸ਼ਟ ਕਰ ਦਿੱਤਾ।

ਜੇ ਕੋਈ ਗਿਥਬ 'ਤੇ ਕੋਡ ਸਮੀਖਿਆ ਕਰਨ ਲਈ ਸਹਿਮਤ ਹੁੰਦਾ ਹੈ, ਤਾਂ ਮੈਂ ਧੰਨਵਾਦੀ ਹੋਵਾਂਗਾ. ਮੈਨੂੰ ਪੂਰਾ ਯਕੀਨ ਹੈ ਕਿ ਮੈਂ ਬਹੁਤ ਸਾਰੀਆਂ ਮੂਰਖ ਗਲਤੀਆਂ ਕੀਤੀਆਂ ਹਨ, ਖਾਸ ਕਰਕੇ ਜਦੋਂ ਸਤਰ ਨਾਲ ਕੰਮ ਕਰਦੇ ਹੋ।

ਸਰੋਤ: www.habr.com