टीसीपी स्ट्रीम रीप्ले टूल

Question

मैं परीक्षण के लिए एक टीसीपी धारा के एक तरफ रिकॉर्डिंग और दोबारा चलाने के लिए एक उपकरण की तलाश में हूं। मैं ऐसे टूल देखता हूं जो फ़ायरवॉल का परीक्षण करने के लिए संपूर्ण टीसीपी स्ट्रीम (सर्वर और क्लाइंट दोनों) रिकॉर्ड करते हैं, लेकिन जो मैं खोज रहा हूं वह एक ऐसा टूल है जो क्लाइंट द्वारा प्रस्तुत ट्रैफ़िक रिकॉर्ड करेगा (समय की जानकारी के साथ) और फिर पुनः सबमिट करें यह परीक्षण के लिए सर्वर के लिए।

Answer 1

टीसीपी रीट्रान्समिशन, अनुक्रम संख्या, SACK को संभालने के तरीके के कारण और इसे विंडो करने से आप कल्पना करने की तुलना में एक और कठिन कार्य हो सकते हैं।

आम तौर पर लोग पैकेट रीप्ले के लिए tcpreplay का उपयोग करते हैं; हालांकि, यह doesn't support synchronizing TCP sequence numbers है। जब से तुम (और इस seq नंबरिंग के तुल्यकालन की आवश्यकता है) एक द्विदिश टीसीपी धारा, की आवश्यकता है निम्न विकल्पों में से एक का उपयोग करें:

1. यह एक बहुत ही इंटरैक्टिव ग्राहक/सर्वर प्रोटोकॉल है, तो आप scapy इस्तेमाल कर सकते हैं अपनी स्ट्रीम की टीसीपी सामग्री, समय और अंतःक्रियाशीलता के लिए पार्स को बाहर निकालने के लिए। इसके बाद इस जानकारी का उपयोग करें, अपने सर्वर पर एक नया टीसीपी सॉकेट खोलें और उस डेटा को नए टीसीपी सॉकेट में deserialize करें। scapy के साथ मूल स्ट्रीम को पार्स करना मुश्किल हो सकता है, यदि आप टीसीपी रीट्रांसमिशन और विंडोिंग गतिशीलता में भाग लेते हैं। बाइट्स को एक नए टीसीपी सॉकेट में लिखने के लिए अनुक्रम संख्या से निपटने की आवश्यकता नहीं होगी ... ओएस इसका ख्याल रखेगा।

2. यह एक सरल धारा है और आप समय के बिना कर सकता है (या समय जानकारी डालने के लिए मैन्युअल रूप से चाहते हैं), आप wireshark का उपयोग scapy साथ पार्स करने के बारे में चिंता किए बिना एक टीसीपी भाप से कच्चे बाइट्स प्राप्त करने के लिए कर सकते हैं। कच्चे बाइट्स के बाद, इन बाइट्स को एक नई टीसीपी सॉकेट में लिखें (आवश्यकतानुसार अंतःक्रियाशीलता के लिए लेखांकन)। बाइट्स को एक नए टीसीपी सॉकेट में लिखने के लिए अनुक्रम संख्या से निपटने की आवश्यकता नहीं होगी ... ओएस इसका ख्याल रखेगा।

3. यदि आपकी स्ट्रीम सख्ती से टेक्स्ट (लेकिन एचटीएमएल या एक्सएमएल नहीं) कमांड है, जैसे कि टेलनेट सत्र, Expect-जैसा समाधान उपर्युक्त पार्सिंग से आसान हो सकता है। इस समाधान में, आप अपने कोड से सीधे एक टीसीपी सॉकेट नहीं खोलेंगे, spawn एक टेलनेट (या जो कुछ भी) सत्र की उम्मीद करते हुए send/expect के साथ टेक्स्ट कमांड को दोबारा चलाएं। आपकी उम्मीद पुस्तकालय/अंतर्निहित ओएस सीईसी नंबरिंग का ख्याल रखेगा।

4. यदि आप एक वेब सेवा का परीक्षण कर रहे हैं, तो मुझे संदेह है कि वास्तविक वेब क्लाइंट को Selenium या Splinter के साथ लिंक के माध्यम से क्लिक करना अनुकरण करना बहुत आसान होगा। आपकी http लाइब्रेरी/अंतर्निहित ओएस नई स्ट्रीम में सीईसी नंबरिंग का ख्याल रखेगी।

Answer 2

जो के रूप में आवश्यक सभी SYN/एसीके अनुक्रम संख्या के संशोधन के साथ या तो ग्राहक या एक पर कब्जा कर लिया टीसीपी सत्र के सर्वर साइड को पुनः चलाने का वादा किया WirePlay code.google.com/p/wireplay या github.com/abhisek/wireplay पर एक नजर डालें।

मुझे नहीं पता कि कोई बाइनरी बिल्ड उपलब्ध है या नहीं, आपको इसे स्वयं संकलित करने की आवश्यकता होगी।

नोट मैंने अभी तक यह कोशिश नहीं की है, लेकिन मैं इसे देख रहा हूं।

Answer 3

हां, ऐसे उपकरण को लागू करना एक कठिन काम है। मैंने दो साल पहले इस तरह के उपकरण को लागू करना शुरू किया था और उपकरण अब परिपक्व है। इसे आज़माएं और शायद आप पाएंगे कि यह वह टूल है जिसे आप ढूंढ रहे हैं।

https://github.com/wangbin579/tcpcopy

Answer 4

मैं कुछ इसी तरह तो मैं थोड़ा के लिए Scapy के साथ काम किया था और एक समाधान है कि मेरे लिए काम किया के साथ आया था। मेरा लक्ष्य एक कैप्चर की गई पॅक फ़ाइल के क्लाइंट हिस्से को फिर से चलाने के लिए था। मुझे सर्वर से प्रतिक्रिया प्राप्त करने में दिलचस्पी थी - समय के साथ जरूरी नहीं। नीचे मेरा डरावना समाधान है - यह किसी भी तरह से परीक्षण या पूर्ण नहीं है, लेकिन यह वही किया जो मैं चाहता था। उम्मीद है कि यह एक अच्छा उदाहरण है कि स्कैपी का उपयोग करके एक टीसीपी स्ट्रीम को फिर से चलाने के लिए कैसे।

from scapy.all import * 
import sys 

#NOTE - This script assumes that there is only 1 TCP stream in the PCAP file and that 
# you wish to replay the role of the client 

#acks 
ACK = 0x10 
#client closing the connection 
RSTACK = 0x14 

def replay(infile, inface): 
    recvSeqNum = 0 
    first = True 
    targetIp = None 
    #send will put the correct src ip and mac in 
    #this assumes that the client portion of the stream is being replayed 
    for p in rdpcap(infile): 
     if 'IP' in p and 'TCP' in p: 
      ip = p[IP] 
      eth = p[Ether] 
      tcp = p[TCP] 
      if targetIp == None: 
       #figure out the target ip we're interested in 
       targetIp = ip.dst 
       print(targetIp) 
      elif ip.dst != targetIp: 
       # don't replay a packet that isn't to our target ip 
       continue 
      # delete checksums so that they are recalculated 
      del ip.chksum 
      del tcp.chksum 
      if tcp.flags == ACK or tcp.flags == RSTACK: 
       tcp.ack = recvSeqNum+1 
       if first or tcp.flags == RSTACK: 
        # don't expect a response from these 
        sendp(p, iface=inface) 
        first=False 
        continue 

      rcv = srp1(p, iface=inface) 
      recvSeqNum = rcv[TCP].seq 

def printUsage(prog): 
    print("%s <pcapPath> <interface>" % prog) 

if __name__ == "__main__": 
    if 3 != len(sys.argv): 
     printUsage(sys.argv[0]) 
     exit(1) 
    replay(sys.argv[1], sys.argv[2]) 

Answer 5

पूर्ण टीसीपी क्लाइंट/सर्वर संचार का एक पैकेट कैप्चर रिकॉर्ड करें। फिर, आप वास्तविक सर्वर पर संचार के क्लाइंट साइड को फिर से चलाने के लिए tcpliveplay का उपयोग कर सकते हैं। tcpliveplay नए अनुक्रम संख्या, आईपी पते, मैक पते, आदि उत्पन्न करेगा, तो संचार ठीक से बह जाएगा।