பிழைகள் இல்லாமல் பைதான் ஸ்கேபியைப் பயன்படுத்தி .pcap கோப்புகளில் சரங்களை மாற்றுதல்

அணுகுமுறை 1: மீண்டும் கணக்கிடப்பட்ட செக்சம்களுடன் பாக்கெட்டுகளை மாற்ற ஸ்கேபியைப் பயன்படுத்துதல்

இந்த தீர்வு `.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()

ஸ்கேபி மூலம் PCAP கோப்புகளை மாற்றுவது பற்றிய பொதுவான கேள்விகள்

1. `.pcap` கோப்பில் குறிப்பிட்ட பாக்கெட்டுகளை மட்டும் எப்படி மாற்றுவது?
2. நீங்கள் பயன்படுத்தலாம் packet.haslayer() குறிப்பிட்ட அடுக்குகள் அல்லது பயன்பாடு கொண்ட பாக்கெட்டுகளை குறிவைக்கும் செயல்பாடு packet[Raw].load குறிப்பிட்ட பேலோட் உள்ளடக்கத்தை சரிபார்க்க.
3. பாக்கெட்டுகளை மாற்றிய பிறகு நான் செக்சம்களை மீண்டும் கணக்கிடவில்லை என்றால் என்ன நடக்கும்?
4. போன்ற கட்டளைகளைப் பயன்படுத்தி செக்சம் மறு கணக்கீடுகளைத் தவிர்க்கிறது del packet[TCP].chksum அல்லது del packet[IP].chksum பெரும்பாலான அமைப்புகளால் நிராகரிக்கப்படும் சிதைந்த பாக்கெட்டுகளுக்கு வழிவகுக்கும்.
5. `.pcap` கோப்புகளில் என்க்ரிப்ட் செய்யப்பட்ட தரவை ஸ்கேபி கையாள முடியுமா?
6. Scapy நேரடியாக மறைகுறியாக்கப்பட்ட தரவை மறைகுறியாக்க முடியாது, ஆனால் நீங்கள் குறியாக்கம் செய்யப்படாத பகுதிகளை மாற்றலாம் அல்லது செயலாக்கத்திற்கு முன் மறைகுறியாக்க வெளிப்புற கருவிகளைப் பயன்படுத்தலாம்.
7. மாற்றத்தின் போது பாக்கெட்டுகளில் புதிய லேயர்களைச் சேர்க்க வழி உள்ளதா?
8. ஆம், Scapy போன்ற செயல்பாடுகளைப் பயன்படுத்தி அடுக்குகளைச் சேர்க்க உங்களை அனுமதிக்கிறது packet = Ether() / IP() / TCP(), உங்கள் மாற்றங்களுடன் ஒரு புதிய அடுக்கை நீங்கள் வரையறுக்கலாம்.
9. பாக்கெட்டுகளை மாற்றிய பின் நேர முத்திரை துல்லியத்தை உறுதி செய்வது எப்படி?
10. பைத்தானைப் பயன்படுத்தவும் time நேர முத்திரைகளை கைமுறையாக புதுப்பிக்க அல்லது மாற்றங்களின் போது தொடர்புடைய பாக்கெட் ஓட்டங்களுடன் அவற்றை ஒத்திசைக்க தொகுதி.
11. பாக்கெட் தரவை மாற்றும் போது அளவு கட்டுப்பாடுகள் உள்ளதா?
12. ஆம், பெரிய பாக்கெட்டுகளுக்கான துண்டு துண்டாக நீங்கள் வெளிப்படையாகக் கையாளாத வரை, Scapy க்கு ஏற்கனவே இருக்கும் MTU க்குள் மாற்றங்கள் பொருந்த வேண்டும்.
13. ஸ்கேபியைப் பயன்படுத்தி நிகழ்நேரத்தில் பாக்கெட்டுகளை மாற்ற முடியுமா?
14. Scapy ஆனது நிகழ்நேரத்தில் பாக்கெட்டுகளை உருவாக்கி உட்செலுத்த முடியும் என்றாலும், `.pcap` கோப்பு மாற்றங்கள் பொதுவாக ஆஃப்லைனில் நிகழ்கின்றன.
15. `.pcap` கோப்புகளில் செய்யப்பட்ட மாற்றங்களைச் சரிபார்க்க சிறந்த வழி எது?
16. வயர்ஷார்க் போன்ற பாக்கெட் பகுப்பாய்வு கருவி மூலம் மாற்றியமைக்கப்பட்ட கோப்பை இயக்கவும் அல்லது Scapy இன் உள்ளமைக்கப்பட்ட சரிபார்ப்பு கட்டளைகளைப் பயன்படுத்தவும் ls().
17. அசல் பாக்கெட்டுகளின் ஓட்டத்தை எவ்வாறு பாதுகாப்பது?
18. அசல் வரிசை எண்கள் மற்றும் நேர முத்திரைகளைப் பராமரிப்பதன் மூலம் மாற்றங்களின் போது பாக்கெட்டுகளின் வரிசை மற்றும் நேரத்தைப் பாதுகாக்கவும்.
19. HTTP அல்லாத போக்குவரத்தை மாற்றியமைப்பதை Scapy ஆதரிக்கிறதா?
20. ஆம், Scapy பரந்த அளவிலான நெறிமுறைகளை ஆதரிக்கிறது, மேலும் DNS, TCP மற்றும் UDP உட்பட எந்த வகையிலும் நீங்கள் மாற்றலாம்.
21. மாற்றியமைக்கப்பட்ட பாக்கெட்டுகளை `.pcap` கோப்பில் எழுதும்போது பிழைகளை எவ்வாறு தவிர்க்கலாம்?
22. பயன்படுத்தவும் wrpcap() ஒவ்வொரு பாக்கெட்டின் ஒருமைப்பாட்டையும் கவனமாக சரிபார்த்த பிறகு, ஒரு சுமூகமான எழுதும் செயல்முறையை உறுதிசெய்யவும்.

பாக்கெட் மாற்றங்கள் குறித்த இறுதி எண்ணங்கள்

போன்ற கருவிகளுடன் பணிபுரிதல் ஸ்கேபி `.pcap` கோப்புகளை மாற்றுவதற்கு ஒப்பிடமுடியாத நெகிழ்வுத்தன்மையை வழங்குகிறது, ஆனால் பாக்கெட் ஒருமைப்பாட்டைப் பராமரிக்க விவரங்களுக்கு கவனம் செலுத்துவது அவசியம். நீளம் மற்றும் செக்சம்கள் போன்ற புலங்களைச் சரிசெய்வது, மாற்றங்களுக்குப் பிறகு நெட்வொர்க் செயல்படுவதையும் பிழையின்றி இருப்பதையும் உறுதி செய்கிறது.

Scapy மூலம், HTTP தலைப்புகளை மாற்றுவது போன்ற சிக்கலான பணிகளும் கவனமாகக் கையாளப்படும்போது நிர்வகிக்கப்படும். நெட்வொர்க் பகுப்பாய்வு அல்லது நெறிமுறை சோதனை என எதுவாக இருந்தாலும், இந்த நுட்பங்களில் தேர்ச்சி பெறுவது டெவலப்பர்கள் நிஜ உலக சிக்கல்களை திறமையாகவும் நம்பிக்கையுடனும் சமாளிக்க உதவுகிறது. 🚀