Trying to remove EPS bounds and do strict matching with tight bounds from signature...
[pingpong.git] / parser / parse_packet_frequency.py
1 #!/usr/bin/python
2
3 """
4 Script that takes a file (output by wireshark/tshark, in JSON format) and analyze
5 the traffic frequency of a certain device at a certain time.
6 """
7
8 import sys
9 import json
10 import numpy as np
11 from collections import defaultdict
12 from dateutil import parser
13 from datetime import datetime
14 from decimal import *
15
16 JSON_KEY_SOURCE = "_source"
17 JSON_KEY_LAYERS = "layers"
18
19 JSON_KEY_ETH = "eth"
20 JSON_KEY_ETH_DST = "eth.dst"
21 JSON_KEY_ETH_SRC = "eth.src"
22 JSON_KEY_FRAME = "frame"
23 JSON_KEY_FRAME_TIME = "frame.time"
24 JSON_KEY_FRAME_LEN = "frame.len"
25 TABLE_HEADER_X = "Timestamp (hh:mm:ss)"
26 TABLE_HEADER_Y = "Packet frequency"
27 INCOMING_APPENDIX = "_incoming"
28 OUTGOING_APPENDIX = "_outgoing"
29 FILE_APPENDIX = ".dat"
30
31 # Use this constant as a flag
32 WINDOW_SIZE = 5
33 USE_MOVING_AVERAGE = False
34 USE_BINNING = True
35 # Range = 6, i.e. 3 to left and 3 to right (in seconds)
36 #TOTAL_RANGE = 60 # TOTAL_RANGE = 2 x RANGE
37 #RANGE = 30
38 TOTAL_RANGE = 20 # TOTAL_RANGE = 2 x RANGE
39 RANGE = 10
40
41 def moving_average(array, window=3):
42     """ Calculate moving average
43         Args:
44             array: array of numbers
45             window: window of moving average (default = 3)
46         Adapted from: 
47             https://stackoverflow.com/questions/14313510/how-to-calculate-moving-average-using-numpy
48     """
49     # Check if window > len(array)
50     if window > len(array):
51         window = len(array)
52     # Calculate cumulative sum of each array element
53     retarr = np.cumsum(array, dtype=float)
54     # Adjust cumulative sum of each array element
55     #   based on window size
56     retarr[window:] = retarr[window:] - retarr[:-window]
57     # Pad the first array elements with zeroes
58     retarr[:window - 1] = np.zeros(window - 1)
59     # Calculate moving average starting from the element
60     #   at window size, e.g. element 4 for window=5
61     retarr[window - 1:] = retarr[window - 1:] / window
62     return retarr
63
64 def hms_to_seconds(t):
65     """ Calculate hms to seconds
66         Args:
67             t = time in hh:mm:ss string
68         Adapted from:
69             https://stackoverflow.com/questions/10742296/python-time-conversion-hms-to-seconds
70     """
71     h, m, s = [int(i) for i in t.split(':')]
72     return 3600*h + 60*m + s
73     
74 def seconds_to_hms(t):
75     """ Calculate seconds to hms
76         Args:
77             t = time in seconds
78         Adapted from:
79             https://stackoverflow.com/questions/10742296/python-time-conversion-hms-to-seconds
80     """
81     h = t / 3600
82     m = (t - (h * 3600)) / 60
83     s = t - (h * 3600) - (m * 60)
84     hh = str(h)
85     if len(hh) is 1:
86         hh = "0" + hh
87     mm = str(m)
88     if len(mm) is 1:
89         mm = "0" + mm
90     ss = str(s) 
91     if len(ss) is 1:
92         ss = "0" + ss
93     return hh + ":" + mm + ":" + ss
94     
95 def include_timestamps_zero_packets(timelen):
96     """ Include every second that has zero packets (no packets/transmission)
97         Args:
98             timelen = dictionary that maps timestamps to packet length
99     """
100     sortedkeylist = []
101     for key in sorted(timelen):
102         sortedkeylist.append(key)
103     first = sortedkeylist[0]
104     last = sortedkeylist[len(sortedkeylist)-1]
105     # Calculate the number of seconds between first and last packets
106     first_seconds = hms_to_seconds(first)
107     last_seconds = hms_to_seconds(last)
108     seconds = last_seconds - first_seconds
109     # Start counting and filling in timestamps with zero packets
110     counter = 0
111     while counter < seconds:
112         timestamp = seconds_to_hms(first_seconds + counter)
113         if timestamp not in timelen:
114             timelen[timestamp] = 0
115         counter += 1
116     return timelen
117     
118
119 def save_to_file(tblheader, dictionary, filenameout):
120     """ Show summary of statistics of PCAP file
121         Args:
122             tblheader: header for the saved table
123             dictionary: dictionary to be saved
124             filename_out: file name to save
125     """
126     # Appending, not overwriting!
127     f = open(filenameout, 'a')
128     # Write the table header
129     f.write("# " + tblheader + "\n")
130     f.write("# " + TABLE_HEADER_X + " " + TABLE_HEADER_Y + "\n")
131     # Write "0 0" if dictionary is empty
132     if not dictionary:
133         f.write("0 0")
134         f.close()
135         print "Writing zeroes to file: ", filenameout
136         return
137
138     if USE_MOVING_AVERAGE:
139         # Use moving average if this flag is true
140         sortedarr = []
141         for key in sorted(dictionary):
142             sortedarr.append(dictionary[key])
143         valarr = moving_average(sortedarr, WINDOW_SIZE)
144         #print vallist
145         # Iterate over dictionary and write (key, value) pairs
146         ind = 0
147         for key in sorted(dictionary):
148             # Space separated
149             f.write(str(key) + " " + str(valarr[ind]) + "\n")
150             ind += 1
151
152     elif USE_BINNING:
153         sortedlist = []
154         # Iterate over dictionary and write (key, value) pairs
155         ind = 0
156         first = 0
157         last = 0
158         for key in sorted(dictionary):
159             sortedlist.append(key)
160             print "Key: ", key, " - Value: ", dictionary[key], " - Ind: ", ind
161             ind += 1
162         first = hms_to_seconds(sortedlist[0])
163         #print "First: ", key
164         last = hms_to_seconds(sortedlist[ind-1])
165         #print "Last: ", key
166         resultdict = dict()
167         # Put new binning keys
168         time_ind = first
169         ind = 0
170         while time_ind < last:
171             # Initialize with the first key in the list
172             curr_key = sortedlist[ind]
173             curr_key_secs = hms_to_seconds(curr_key)
174             # Initialize with 0 first
175             resultdict[time_ind] = 0
176             # Check if this is still within RANGE - bin the value if it is
177             while time_ind - RANGE <= curr_key_secs and curr_key_secs <= time_ind + RANGE:
178                 resultdict[time_ind] += dictionary[curr_key]
179                 print "Time index: ", seconds_to_hms(time_ind), " Value: ", resultdict[time_ind]
180                 ind += 1
181                 if ind > len(dictionary)-1:
182                     break
183                 # Initialize with the key in the list
184                 curr_key = sortedlist[ind]
185                 curr_key_secs = hms_to_seconds(curr_key)
186             # Increment time index
187             time_ind += TOTAL_RANGE
188         # Now write to file after binning
189         for key in sorted(resultdict):
190             # Space separated
191             f.write(seconds_to_hms(key) + " " + str(resultdict[key]) + "\n")
192             #print seconds_to_hms(key) + " " + str(resultdict[key])
193
194     else:
195         # Iterate over dictionary and write (key, value) pairs
196         for key in sorted(dictionary):
197             # Space separated
198             f.write(str(key) + " " + str(dictionary[key]) + "\n")
199     f.close()
200     print "Writing output to file: ", filenameout
201
202
203 def main():
204     """ Main function
205     """
206     if len(sys.argv) < 5:
207         print "Usage: python", sys.argv[0], "<input_file> <output_file> <device_name> <mac_address>"
208         return
209     # Parse the file for the specified MAC address
210     print "====================================================================="
211     print "Analyzing file: ", sys.argv[1]
212     timelen_incoming = parse_json(sys.argv[1], sys.argv[4], True)
213     if len(timelen_incoming) > 0:
214         timelen_incoming = include_timestamps_zero_packets(timelen_incoming)
215         print "==> Printing incoming traffic ..."
216         save_to_file(sys.argv[3] + INCOMING_APPENDIX, timelen_incoming, sys.argv[2] + INCOMING_APPENDIX + FILE_APPENDIX)
217     else:
218         print "No incoming traffic to this MAC address!"
219     print "====================================================================="
220     timelen_outgoing = parse_json(sys.argv[1], sys.argv[4], False)
221     if len(timelen_outgoing) > 0:
222         timelen_outgoing = include_timestamps_zero_packets(timelen_outgoing)
223         print "==> Printing outgoing traffic ..."
224         save_to_file(sys.argv[3] + OUTGOING_APPENDIX, timelen_outgoing, sys.argv[2] + OUTGOING_APPENDIX + FILE_APPENDIX)
225     else:
226         print "No outgoing traffic from this MAC address!"
227     print "====================================================================="
228     #for time in time_freq.keys():
229     #for key in sorted(time_freq):
230     #    print key, " => ", time_freq[key]
231     #print "====================================================================="
232
233
234 # Convert JSON file containing DNS traffic to a map in which a hostname points to its set of associated IPs.
235 def parse_json(filepath, macaddress, incomingoutgoing):
236     """ Show summary of statistics of PCAP file
237         Args:
238             filepath: path of the read file
239             macaddress: MAC address of a device to analyze
240             incomingoutgoing: boolean to define whether we collect incoming or outgoing traffic
241                               True = incoming, False = outgoing
242     """
243     # Maps timestamps to lengths of packets
244     timelen = dict()
245     with open(filepath) as jf:
246         # Read JSON.
247         # data becomes reference to root JSON object (or in our case json array)
248         data = json.load(jf)
249         # Loop through json objects in data
250         # Each entry is a pcap entry (request/response (packet) and associated metadata)
251         for p in data:
252             # p is a JSON object, not an index
253             layers = p[JSON_KEY_SOURCE][JSON_KEY_LAYERS]
254             # Get timestamp
255             frame = layers.get(JSON_KEY_FRAME, None)
256             datetime = frame.get(JSON_KEY_FRAME_TIME, None)
257             # Get frame length
258             length = frame.get(JSON_KEY_FRAME_LEN, None)
259             # Get into the Ethernet address part
260             eth = layers.get(JSON_KEY_ETH, None)
261             # Skip any non DNS traffic
262             if eth is None:
263                 print "[ WARNING: Packet has no ethernet address! ]"
264                 continue
265             # Get source and destination MAC addresses
266             src = eth.get(JSON_KEY_ETH_SRC, None)
267             dst = eth.get(JSON_KEY_ETH_DST, None)
268             # Get just the time part
269             datetimeobj = parser.parse(datetime)
270             # Remove the microsecond part
271             timestr = str(datetimeobj.time())[:8]
272             #print str(timestr) + " - src:" + str(src) + " - dest:" + str(dst) + " - length: ", length
273             # Get and count the traffic for the specified MAC address
274             if incomingoutgoing:           
275                 if dst == macaddress:
276                     # Check if timestamp already exists in the map
277                     # If yes, then just increment the frequency value...
278                     if timestr in timelen:
279                         timelen[timestr] = timelen[timestr] + int(length)
280                     else: # If not, then put the value one there
281                         timelen[timestr] = int(length)
282             else:
283                 if src == macaddress:
284                     # Check if timestamp already exists in the map
285                     # If yes, then just increment the frequency value...
286                     if timestr in timelen:
287                         timelen[timestr] = timelen[timestr] + int(length)
288                     else: # If not, then put the value one there
289                         timelen[timestr] = int(length)
290
291     return timelen
292
293
294 if __name__ == '__main__':
295     main()
296