ਪਾਇਥਨ ਸਕੈਪੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ .pcap ਫਾਈਲਾਂ ਵਿੱਚ ਸਟ੍ਰਿੰਗਸ ਨੂੰ ਸੋਧਣਾ ਬਿਨਾਂ ਗਲਤੀਆਂ ਦੇ

ਪਹੁੰਚ 1: ਪੁਨਰ-ਗਣਨਾ ਕੀਤੇ ਚੈੱਕਸਮਾਂ ਨਾਲ ਪੈਕੇਟਾਂ ਨੂੰ ਸੋਧਣ ਲਈ Scapy ਦੀ ਵਰਤੋਂ ਕਰਨਾ

ਇਹ ਹੱਲ Python ਦੀ Scapy ਲਾਇਬ੍ਰੇਰੀ ਨੂੰ `.pcap` ਫਾਈਲਾਂ ਨੂੰ ਸੋਧਣ ਲਈ ਵਰਤਦਾ ਹੈ। ਇਹ ਇਕਸਾਰਤਾ ਲਈ ਲੰਬਾਈ ਅਤੇ ਚੈੱਕਸਮ ਖੇਤਰਾਂ ਦੀ ਮੁੜ ਗਣਨਾ ਕਰਨ 'ਤੇ ਕੇਂਦ੍ਰਤ ਕਰਦਾ ਹੈ।

from scapy.all import *  # Import Scapy's core functions
def modify_server_string(packets):
    for packet in packets:
        if packet.haslayer(Raw):
            raw_data = packet[Raw].load
            if b"SimpleHTTP/0.6 Python/3.11.8" in raw_data:
                new_data = raw_data.replace(b"SimpleHTTP/0.6 Python/3.11.8", b"A custom one")
                packet[Raw].load = new_data
                if packet.haslayer(IP):
                    del packet[IP].len, packet[IP].chksum  # Recalculate IP fields
                if packet.haslayer(TCP):
                    del packet[TCP].chksum  # Recalculate TCP checksum
    return packets
# Read, modify, and write packets
if __name__ == "__main__":
    packets = rdpcap("input.pcap")
    modified_packets = modify_server_string(packets)
    wrpcap("output.pcap", modified_packets)

ਪਹੁੰਚ 2: ਮੈਨੁਅਲ ਹੈਡਰ ਐਡਜਸਟਮੈਂਟਸ ਦੇ ਨਾਲ ਵਿਕਲਪਿਕ

ਇਸ ਵਿਧੀ ਵਿੱਚ, Scapy ਦੁਆਰਾ ਸਵੈਚਲਿਤ ਮੁੜ ਗਣਨਾ 'ਤੇ ਨਿਰਭਰ ਕੀਤੇ ਬਿਨਾਂ ਫੀਲਡਾਂ ਨੂੰ ਹੱਥੀਂ ਅੱਪਡੇਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

from scapy.all import *  # Core library for packet manipulation
def modify_and_adjust_headers(packets):
    for packet in packets:
        if packet.haslayer(Raw):
            raw_payload = packet[Raw].load
            if b"SimpleHTTP/0.6 Python/3.11.8" in raw_payload:
                modified_payload = raw_payload.replace(b"SimpleHTTP/0.6 Python/3.11.8", b"A custom one")
                packet[Raw].load = modified_payload
                # Manually update IP header
                if packet.haslayer(IP):
                    packet[IP].len = len(packet)
                    packet[IP].chksum = packet[IP].compute_checksum()
                # Manually update TCP header
                if packet.haslayer(TCP):
                    packet[TCP].chksum = packet[TCP].compute_checksum()
    return packets
# Processing and writing packets
if __name__ == "__main__":
    packets = rdpcap("input.pcap")
    adjusted_packets = modify_and_adjust_headers(packets)
    wrpcap("output_adjusted.pcap", adjusted_packets)

ਪਹੁੰਚ 3: ਪੈਕੇਟ ਇਕਸਾਰਤਾ ਲਈ ਯੂਨਿਟ ਟੈਸਟ ਜੋੜਨਾ

ਇਹ ਸਕ੍ਰਿਪਟ ਇਹ ਪ੍ਰਮਾਣਿਤ ਕਰਨ ਲਈ ਯੂਨਿਟ ਟੈਸਟਾਂ ਨੂੰ ਏਕੀਕ੍ਰਿਤ ਕਰਦੀ ਹੈ ਕਿ ਸੋਧੇ ਹੋਏ ਪੈਕੇਟ ਗਲਤੀ-ਮੁਕਤ ਹਨ।

import unittest
from scapy.all import rdpcap, wrpcap
class TestPacketModification(unittest.TestCase):
    def setUp(self):
        self.packets = rdpcap("test_input.pcap")
    def test_modification(self):
        modified_packets = modify_server_string(self.packets)
        for packet in modified_packets:
            self.assertNotIn(b"SimpleHTTP/0.6 Python/3.11.8", packet[Raw].load)
    def test_integrity(self):
        modified_packets = modify_server_string(self.packets)
        for packet in modified_packets:
            if packet.haslayer(IP):
                self.assertEqual(packet[IP].len, len(packet))
    def test_save_and_load(self):
        modified_packets = modify_server_string(self.packets)
        wrpcap("test_output.pcap", modified_packets)
        reloaded_packets = rdpcap("test_output.pcap")
        self.assertEqual(len(modified_packets), len(reloaded_packets))
if __name__ == "__main__":
    unittest.main()

Scapy ਨਾਲ PCAP ਫਾਈਲਾਂ ਨੂੰ ਸੋਧਣ ਬਾਰੇ ਆਮ ਸਵਾਲ

1. ਮੈਂ ਇੱਕ `.pcap` ਫਾਈਲ ਵਿੱਚ ਸਿਰਫ਼ ਖਾਸ ਪੈਕੇਟਾਂ ਨੂੰ ਕਿਵੇਂ ਸੋਧਾਂ?
2. ਤੁਸੀਂ ਵਰਤ ਸਕਦੇ ਹੋ packet.haslayer() ਖਾਸ ਲੇਅਰਾਂ ਜਾਂ ਵਰਤੋਂ ਵਾਲੇ ਪੈਕੇਟਾਂ ਨੂੰ ਨਿਸ਼ਾਨਾ ਬਣਾਉਣ ਲਈ ਫੰਕਸ਼ਨ packet[Raw].load ਖਾਸ ਪੇਲੋਡ ਸਮੱਗਰੀ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ।
3. ਕੀ ਹੁੰਦਾ ਹੈ ਜੇਕਰ ਮੈਂ ਪੈਕੇਟਾਂ ਨੂੰ ਸੋਧਣ ਤੋਂ ਬਾਅਦ ਚੈੱਕਸਮਾਂ ਦੀ ਮੁੜ ਗਣਨਾ ਨਹੀਂ ਕਰਦਾ ਹਾਂ?
4. ਜਿਵੇਂ ਕਮਾਂਡਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਚੈਕਸਮ ਪੁਨਰ-ਗਣਨਾ ਨੂੰ ਛੱਡਣਾ del packet[TCP].chksum ਜਾਂ del packet[IP].chksum ਦੇ ਨਤੀਜੇ ਵਜੋਂ ਖਰਾਬ ਪੈਕੇਟ ਹੋਣਗੇ ਜੋ ਜ਼ਿਆਦਾਤਰ ਸਿਸਟਮਾਂ ਦੁਆਰਾ ਰੱਦ ਕੀਤੇ ਜਾਂਦੇ ਹਨ।
5. ਕੀ Scapy `.pcap` ਫਾਈਲਾਂ ਵਿੱਚ ਐਨਕ੍ਰਿਪਟਡ ਡੇਟਾ ਨੂੰ ਸੰਭਾਲ ਸਕਦਾ ਹੈ?
6. Scapy ਐਨਕ੍ਰਿਪਟਡ ਡੇਟਾ ਨੂੰ ਸਿੱਧੇ ਤੌਰ 'ਤੇ ਡੀਕ੍ਰਿਪਟ ਨਹੀਂ ਕਰ ਸਕਦਾ ਹੈ, ਪਰ ਤੁਸੀਂ ਪ੍ਰੋਸੈਸਿੰਗ ਤੋਂ ਪਹਿਲਾਂ ਅਣਏਨਕ੍ਰਿਪਟ ਕੀਤੇ ਭਾਗਾਂ ਨੂੰ ਸੋਧ ਸਕਦੇ ਹੋ ਜਾਂ ਡੀਕ੍ਰਿਪਸ਼ਨ ਲਈ ਬਾਹਰੀ ਟੂਲਸ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ।
7. ਕੀ ਸੋਧ ਦੇ ਦੌਰਾਨ ਪੈਕੇਟਾਂ ਵਿੱਚ ਨਵੀਆਂ ਲੇਅਰਾਂ ਜੋੜਨ ਦਾ ਕੋਈ ਤਰੀਕਾ ਹੈ?
8. ਹਾਂ, ਸਕੈਪੀ ਤੁਹਾਨੂੰ ਓਪਰੇਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਲੇਅਰਾਂ ਜੋੜਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ ਜਿਵੇਂ ਕਿ packet = Ether() / IP() / TCP(), ਜਿੱਥੇ ਤੁਸੀਂ ਆਪਣੇ ਸੋਧਾਂ ਨਾਲ ਇੱਕ ਨਵਾਂ ਸਟੈਕ ਪਰਿਭਾਸ਼ਿਤ ਕਰ ਸਕਦੇ ਹੋ।
9. ਪੈਕੇਟਾਂ ਨੂੰ ਸੋਧਣ ਤੋਂ ਬਾਅਦ ਮੈਂ ਟਾਈਮਸਟੈਂਪ ਦੀ ਸ਼ੁੱਧਤਾ ਨੂੰ ਕਿਵੇਂ ਯਕੀਨੀ ਬਣਾਵਾਂ?
10. ਪਾਈਥਨ ਦੀ ਵਰਤੋਂ ਕਰੋ time ਮੋਡੀਊਲ ਟਾਈਮਸਟੈਂਪਾਂ ਨੂੰ ਹੱਥੀਂ ਅੱਪਡੇਟ ਕਰਨ ਲਈ ਜਾਂ ਸੋਧਾਂ ਦੌਰਾਨ ਸਬੰਧਿਤ ਪੈਕੇਟ ਪ੍ਰਵਾਹ ਨਾਲ ਸਮਕਾਲੀਕਰਨ ਕਰਨ ਲਈ।
11. ਕੀ ਪੈਕੇਟ ਡੇਟਾ ਨੂੰ ਸੋਧਣ ਵੇਲੇ ਆਕਾਰ ਦੀਆਂ ਕਮੀਆਂ ਹਨ?
12. ਹਾਂ, Scapy ਲਈ ਲੋੜ ਹੈ ਕਿ ਸੋਧਾਂ ਮੌਜੂਦਾ MTU ਦੇ ਅੰਦਰ ਫਿੱਟ ਹੋਣ ਜਦੋਂ ਤੱਕ ਤੁਸੀਂ ਵੱਡੇ ਪੈਕੇਟਾਂ ਲਈ ਫਰੈਗਮੈਂਟੇਸ਼ਨ ਨੂੰ ਸਪੱਸ਼ਟ ਤੌਰ 'ਤੇ ਨਹੀਂ ਸੰਭਾਲਦੇ।
13. ਕੀ ਮੈਂ Scapy ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਰੀਅਲ-ਟਾਈਮ ਵਿੱਚ ਪੈਕੇਟਾਂ ਨੂੰ ਸੋਧ ਸਕਦਾ ਹਾਂ?
14. ਜਦੋਂ ਕਿ Scapy ਅਸਲ-ਸਮੇਂ ਵਿੱਚ ਪੈਕਟਾਂ ਨੂੰ ਤਿਆਰ ਅਤੇ ਇੰਜੈਕਟ ਕਰ ਸਕਦਾ ਹੈ, `.pcap` ਫਾਈਲ ਸੋਧਾਂ ਆਮ ਤੌਰ 'ਤੇ ਔਫਲਾਈਨ ਹੁੰਦੀਆਂ ਹਨ।
15. `.pcap` ਫਾਈਲਾਂ ਵਿੱਚ ਕੀਤੀਆਂ ਸੋਧਾਂ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰਨ ਦਾ ਸਭ ਤੋਂ ਵਧੀਆ ਤਰੀਕਾ ਕੀ ਹੈ?
16. ਸੰਸ਼ੋਧਿਤ ਫਾਈਲ ਨੂੰ ਇੱਕ ਪੈਕੇਟ ਵਿਸ਼ਲੇਸ਼ਣ ਟੂਲ ਜਿਵੇਂ ਕਿ Wireshark ਦੁਆਰਾ ਚਲਾਓ ਜਾਂ Scapy ਦੇ ਇਨ-ਬਿਲਟ ਵੈਰੀਫਿਕੇਸ਼ਨ ਕਮਾਂਡਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ ਜਿਵੇਂ ਕਿ ls().
17. ਮੈਂ ਅਸਲ ਪੈਕੇਟਾਂ ਦੇ ਪ੍ਰਵਾਹ ਨੂੰ ਕਿਵੇਂ ਸੁਰੱਖਿਅਤ ਰੱਖਾਂ?
18. ਮੂਲ ਕ੍ਰਮ ਨੰਬਰਾਂ ਅਤੇ ਟਾਈਮਸਟੈਂਪਾਂ ਨੂੰ ਕਾਇਮ ਰੱਖ ਕੇ ਸੋਧਾਂ ਦੇ ਦੌਰਾਨ ਪੈਕੇਟਾਂ ਦੇ ਕ੍ਰਮ ਅਤੇ ਸਮੇਂ ਨੂੰ ਸੁਰੱਖਿਅਤ ਰੱਖੋ।
19. ਕੀ Scapy ਗੈਰ-HTTP ਟ੍ਰੈਫਿਕ ਨੂੰ ਸੋਧਣ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ?
20. ਹਾਂ, Scapy ਪ੍ਰੋਟੋਕੋਲ ਦੀ ਇੱਕ ਵਿਸ਼ਾਲ ਸ਼੍ਰੇਣੀ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ, ਅਤੇ ਤੁਸੀਂ DNS, TCP, ਅਤੇ UDP ਸਮੇਤ ਕਿਸੇ ਵੀ ਟ੍ਰੈਫਿਕ ਕਿਸਮ ਨੂੰ ਸੋਧ ਸਕਦੇ ਹੋ।
21. ਸੋਧੇ ਹੋਏ ਪੈਕੇਟ ਨੂੰ `.pcap` ਫਾਈਲ ਵਿੱਚ ਲਿਖਣ ਵੇਲੇ ਮੈਂ ਗਲਤੀਆਂ ਤੋਂ ਕਿਵੇਂ ਬਚ ਸਕਦਾ ਹਾਂ?
22. ਵਰਤੋ wrpcap() ਇੱਕ ਨਿਰਵਿਘਨ ਲਿਖਣ ਦੀ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਹਰੇਕ ਪੈਕੇਟ ਦੀ ਇਕਸਾਰਤਾ ਦੀ ਪੁਸ਼ਟੀ ਕਰਨ ਤੋਂ ਬਾਅਦ ਧਿਆਨ ਨਾਲ.

ਪੈਕੇਟ ਸੋਧਾਂ 'ਤੇ ਅੰਤਿਮ ਵਿਚਾਰ

ਵਰਗੇ ਸਾਧਨਾਂ ਨਾਲ ਕੰਮ ਕਰਨਾ ਸਕੈਪੀ '.pcap' ਫਾਈਲਾਂ ਨੂੰ ਸੋਧਣ ਲਈ ਬੇਮਿਸਾਲ ਲਚਕਤਾ ਦੀ ਪੇਸ਼ਕਸ਼ ਕਰਦਾ ਹੈ, ਪਰ ਪੈਕੇਟ ਦੀ ਇਕਸਾਰਤਾ ਨੂੰ ਬਣਾਈ ਰੱਖਣ ਲਈ ਵੇਰਵੇ ਵੱਲ ਧਿਆਨ ਦੇਣਾ ਜ਼ਰੂਰੀ ਹੈ। ਲੰਬਾਈ ਅਤੇ ਚੈਕਸਮ ਵਰਗੇ ਖੇਤਰਾਂ ਨੂੰ ਅਡਜੱਸਟ ਕਰਨਾ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ ਕਿ ਤਬਦੀਲੀਆਂ ਤੋਂ ਬਾਅਦ ਨੈੱਟਵਰਕ ਕਾਰਜਸ਼ੀਲ ਅਤੇ ਗਲਤੀ-ਮੁਕਤ ਰਹਿੰਦਾ ਹੈ।

Scapy ਦੇ ਨਾਲ, HTTP ਸਿਰਲੇਖਾਂ ਨੂੰ ਬਦਲਣ ਵਰਗੇ ਗੁੰਝਲਦਾਰ ਕੰਮ ਵੀ ਪ੍ਰਬੰਧਨਯੋਗ ਬਣ ਜਾਂਦੇ ਹਨ ਜਦੋਂ ਧਿਆਨ ਨਾਲ ਸੰਭਾਲਿਆ ਜਾਂਦਾ ਹੈ। ਭਾਵੇਂ ਨੈੱਟਵਰਕ ਵਿਸ਼ਲੇਸ਼ਣ ਜਾਂ ਪ੍ਰੋਟੋਕੋਲ ਟੈਸਟਿੰਗ ਲਈ, ਇਹਨਾਂ ਤਕਨੀਕਾਂ ਵਿੱਚ ਮੁਹਾਰਤ ਹਾਸਲ ਕਰਨ ਨਾਲ ਡਿਵੈਲਪਰਾਂ ਨੂੰ ਅਸਲ-ਸੰਸਾਰ ਦੇ ਮੁੱਦਿਆਂ ਨੂੰ ਕੁਸ਼ਲਤਾ ਅਤੇ ਭਰੋਸੇ ਨਾਲ ਨਜਿੱਠਣ ਵਿੱਚ ਮਦਦ ਮਿਲਦੀ ਹੈ। 🚀