added comments
[goodfet] / client / experiments.py
1 import sys;
2 import binascii;
3 import array;
4 import csv, time, argparse;
5 import datetime
6 import os
7 from random import randrange
8 import random
9 from GoodFETMCPCAN import GoodFETMCPCAN;
10 from GoodFETMCPCANCommunication import GoodFETMCPCANCommunication
11 from intelhex import IntelHex;
12 import Queue
13 import math
14
15 tT = time
16
17
18 class experiments(GoodFETMCPCANCommunication):
19     """ 
20     This class provides methods for reverse-engineering the protocols on the CAN bus network
21     via the GOODTHOPTER10 board, U{http://goodfet.sourceforge.net/hardware/goodthopter10/}    
22     
23     """
24     
25     def __init__(self, data_location = "../../contrib/ThayerData/"):
26         """ 
27         Constructor
28         @type data_location: string
29         @param data_location: path to the folder where data will be stored
30         """
31         GoodFETMCPCANCommunication.__init__(self, data_location)
32         #super(experiments,self).__init(self)
33         self.freq = 500;
34         
35     
36     def filterStdSweep(self, freq, low, high, time = 5):
37         """
38         This method will sweep through the range of standard ids given from low to high.
39         This will actively filter for 6 ids at a time and sniff for the given amount of
40         time in seconds. If at least one message is read in then it will go individually
41         through the 6 ids and sniff only for that id for the given amount of time.
42         This does not save any sniffed packets.
43         
44         @type  freq: number
45         @param freq: The frequency at which the bus is communicating
46         @type   low: integer
47         @param  low: The low end of the id sweep
48         @type  high: integer 
49         @param high: The high end of the id sweep
50         @type  time: number
51         @param time: Sniff time for each trial. Default is 5 seconds
52         
53         @rtype: list of numbers
54         @return: A list of all IDs found during the sweep.
55         """
56         msgIDs = []
57         self.client.serInit()
58         self.client.MCPsetup()
59         for i in range(low, high+1, 6):
60             print "sniffing id: %d, %d, %d, %d, %d, %d" % (i,i+1,i+2,i+3,i+4,i+5)
61             comment= "sweepFilter: "
62             #comment = "sweepFilter_%d_%d_%d_%d_%d_%d" % (i,i+1,i+2,i+3,i+4,i+5)
63             description = "Running a sweep filer for all the possible standard IDs. This run filters for: %d, %d, %d, %d, %d, %d" % (i,i+1,i+2,i+3,i+4,i+5)
64             count = self.sniff(freq=freq, duration = time, description = description,comment = comment, standardid = [i, i+1, i+2, i+3, i+4, i+5])
65             if( count != 0):
66                 for j in range(i,i+5):
67                     comment = "sweepFilter: "
68                     #comment = "sweepFilter: %d" % (j)
69                     description = "Running a sweep filer for all the possible standard IDs. This run filters for: %d " % j
70                     count = self.sniff(freq=freq, duration = time, description = description,comment = comment, standardid = [j, j, j, j])
71                     if( count != 0):
72                         msgIDs.append(j)
73         return msgIDs
74     
75     
76     def sweepRandom(self, freq, number = 5, time = 5):
77         """
78         This method will choose random values to listen out of all the possible standard ids up to
79         the given number. It will sniff for the given amount of time on each set of ids on the given 
80         frequency. Sniffs in groups of 6 but when at least one message is read in it will go through all
81         six individually before continuing. This does not save any sniffed packets.
82         
83         @type  freq: number
84         @param freq: The frequency at which the bus is communicating
85         @type  number: integer
86         @param number: High end of the possible ids. This will define a range from 0 to number that the ids will be chosen from
87         @type  time: number
88         @param time: Sniff time for each trial. Default is 5 seconds
89         
90         @rtype: list of numbers, list of numbers 
91         @return: A list of all IDs found during the sweep and a list of all the IDs that were listened for throughout the test
92         """
93         msgIDs = [] #standard IDs that we have observed during run
94         ids = [] #standard IDs that have been tried
95         self.client.serInit()
96         self.client.MCPsetup()
97         for i in range(0,number+1,6):
98             idsTemp = []
99             comment = "sweepFilter: "
100             for j in range(0,6,1):
101                 id = randrange(2047)
102                 #comment += "_%d" % id
103                 idsTemp.append(id)
104                 ids.append(id)
105             #print comment
106             description = "Running a sweep filer for all the possible standard IDs. This runs the following : " + comment
107             count = self.sniff(freq=freq, duration=time, description=description, comment = comment, standardid = idsTemp)
108             if( count != 0):
109                 for element in idsTemp:
110                     #comment = "sweepFilter: %d" % (element)
111                     comment="sweepFilter: "
112                     description = "Running a sweep filer for all the possible standard IDs. This run filters for: %d " % element
113                     count = self.sniff(freq=freq, duration = time, description = description,comment = comment, standardid = [element, element, element])
114                     if( count != 0):
115                         msgIDs.append(j)
116         return msgIDs, ids
117     
118     
119     def rtrSweep(self,freq,lowID,highID, attempts = 1,duration = 1, verbose = True):
120         """
121         This method will sweep through the range of ids given by lowID to highID and
122         send a remote transmissions request (RTR) to each id and then listen for a response. 
123         The RTR will be repeated in the given number of attempts and will sniff for the given duration
124         continuing to the next id.
125         
126         Any messages that are sniffed will be saved to a csv file. The filename will be stored in the DATA_LOCATION folder
127         with a filename that is the date (YYYYMMDD)_rtr.csv. If the file already exists it will append to the end of the file
128         The format will follow that of L{GoodFETMCPCANCommunication.sniff} in that the columns will be as follows:
129             1. timestamp:     as floating point number
130             2. error boolean: 1 if there was an error detected of packet formatting (not exhaustive check). 0 otherwise
131             3. comment tag:   comment about experiments as String
132             4. duration:      Length of overall sniff
133             5. filtering:     1 if there was filtering. 0 otherwise
134             6. db0:           Integer
135             
136                 ---
137             7. db7:           Integer
138         
139         @type  freq: number
140         @param freq: The frequency at which the bus is communicating
141         @type   lowID: integer
142         @param  lowID: The low end of the id sweep
143         @type  highID: integer 
144         @param highID: The high end of the id sweep
145         @type attempts: integer
146         @param attempts: The number of times a RTR will be repeated for a given standard id
147         @type  duration: integer
148         @param duration: The length of time that it will listen to the bus after sending an RTR
149         @type verbose:  boolean
150         @param verbose: When true, messages will be printed out to the terminal
151         
152         @rtype: None
153         @return: Does not return anything
154         """
155         #set up file for writing
156         now = datetime.datetime.now()
157         datestr = now.strftime("%Y%m%d")
158         path = self.DATA_LOCATION+datestr+"_rtr.csv"
159         filename = path
160         outfile = open(filename,'a');
161         dataWriter = csv.writer(outfile,delimiter=',');
162         dataWriter.writerow(['# Time     Error        Bytes 1-13']);
163         dataWriter.writerow(['#' + "rtr sweep from %d to %d"%(lowID,highID)])
164         if( verbose):
165             print "started"
166         #self.client.serInit()
167         #self.spitSetup(freq)
168         
169         #for each id
170         for i in range(lowID,highID+1, 1):
171             self.client.serInit()
172             self.spitSetup(freq) #reset the chip to try and avoid serial timeouts
173             #set filters
174             standardid = [i, i, i, i]
175             self.addFilter(standardid, verbose = True)
176             
177             #### split SID into different areas
178             SIDlow = (standardid[0] & 0x07) << 5;  # get SID bits 2:0, rotate them to bits 7:5
179             SIDhigh = (standardid[0] >> 3) & 0xFF; # get SID bits 10:3, rotate them to bits 7:0
180             #create RTR packet
181             packet = [SIDhigh, SIDlow, 0x00,0x00,0x40]
182             dataWriter.writerow(["#requested id %d"%i])
183             #self.client.poke8(0x2C,0x00);  #clear the CANINTF register; we care about bits 0 and 1 (RXnIF flags) which indicate a message is being held 
184             #clear buffer
185             packet1 = self.client.rxpacket();
186             packet2 = self.client.rxpacket();
187             #send in rtr request
188             self.client.txpacket(packet)
189             ## listen for 2 packets. one should be the rtr we requested the other should be
190             ## a new packet response
191             starttime = tT.time()
192             while ((time.time() - starttime) < duration): #listen for the given duration time period
193                 packet = self.client.rxpacket()
194                 if( packet == None):
195                     continue
196                 # we have sniffed a packet, save it
197                 row = []
198                 row.append("%f"%time.time()) #timestamp
199                 row.append(0) #error flag (not checkign)
200                 row.append("rtrRequest_%d"%i) #comment
201                 row.append(duration) #sniff time
202                 row.append(1) # filtering boolean
203                 for byte in packet:
204                     row.append("%02x"%ord(byte));
205                 dataWriter.writerow(row)
206                 print self.client.packet2parsedstr(packet)
207             trial= 2;
208             # for each trial repeat
209             while( trial <= attempts):
210                 print "trial: ", trial
211                 self.client.MCPrts(TXB0=True);
212                 starttime = time.time()
213                 # this time we will sniff for the given amount of time to see if there is a
214                 # time till the packets come in
215                 while( (time.time()-starttime) < duration):
216                     packet=self.client.rxpacket();
217                     if( packet == None):
218                         continue
219                     row = []
220                     row.append("%f"%time.time()) #timestamp
221                     row.append(0) #error flag (not checking)
222                     row.append("rtrRequest_%d"%i) #comment
223                     row.append(duration) #sniff time
224                     row.append(1) # filtering boolean
225                     for byte in packet:
226                         row.append("%02x"%ord(byte));
227                     dataWriter.writerow(row)
228                     print self.client.packet2parsedstr(packet)
229                 trial += 1
230         print "sweep complete"
231         outfile.close()
232         
233     # This method will do generation based fuzzing on the id given in standard id
234     # dbLimits is a dictionary of the databytes
235     # dbLimits['db0'] = [low, High]
236     # ..
237     # dbLimits['db7'] = [low, High]
238     # where low is the low end of values for the fuzz, high is the high end value
239     # period is the time between sending packets in milliseconds, writesPerFuzz is the times the 
240     # same fuzzed packet will be injecetez. Fuzzes is the number of different packets to be injected
241     def generationFuzzer(self,freq, standardIDs, dbLimits, period, writesPerFuzz, Fuzzes):
242         """
243         This method will perform generation based fuzzing on the bus. The method will inject
244         properly formatted, randomly generated messages at a given period for a I{writesPerFuzz} 
245         number of times. The packets that are injected into the bus will all be saved in the following path
246         DATALOCATION/InjectedData/(today's date (YYYYMMDD))_GenerationFuzzedPackets.csv. An example filename would be 20130222_GenerationFuzzedPackets.csv
247         Where DATALOCATION is provided when the class is initiated. The data will be saved as integers.
248         Each row will be formatted in the following form::
249                      row = [time of injection, standardID, 8, db0, db1, db2, db3, db4, db5, db6, db7]
250         
251         @type  freq: number
252         @param freq: The frequency at which the bus is communicating
253         @type standardIDs: list of integers
254         @param standardIDs: List of standard IDs the user wishes to fuzz on. An ID will randomly be chosen
255                             with every new random packet generated. If only 1 ID is input in the list then it will
256                             only fuzz on that one ID.
257         @type  dbLimits: dictionary
258         @param dbLimits: This is a dictionary that holds the limits of each bytes values. Each value in the dictionary will be a list 
259                          containing the lowest possible value for the byte and the highest possible value. The form is shown below::
260                             
261                             dbLimits['db0'] = [low, high]
262                             dbLimits['db1'] = [low, high]
263                             ...
264                             dbLimits['db7'] = [low, high] 
265         
266         @type period: number
267         @param period: The time gap between packet inejctions given in milliseconds
268         @type writesPerFuzz: integer
269         @param writesPerFuzz: This will be the number of times that each randomly generated packet will be injected onto the bus
270                               before a new packet is generated
271         @type Fuzzes: integer
272         @param Fuzzes: The number of packets to be generated and injected onto bus
273         
274         @rtype: None
275         @return: This method does not return anything
276                          
277         """
278         #print "Fuzzing on standard ID: %d" %standardId
279         self.client.serInit()
280         self.spitSetup(freq)
281         packet = [0,0,0x00,0x00,0x08,0,0,0,0,0,0,0,0] #empty packet template
282     
283
284         #get folder information (based on today's date)
285         now = datetime.datetime.now()
286         datestr = now.strftime("%Y%m%d")
287         path = self.DATA_LOCATION+"InjectedData/"+datestr+"_GenerationFuzzedPackets.csv"
288         filename = path
289         outfile = open(filename,'a');
290         dataWriter = csv.writer(outfile,delimiter=',');
291         #dataWriter.writerow(['# Time     Error        Bytes 1-13']);
292         #dataWriter.writerow(['#' + description])
293             
294         numIds = len(standardIDs)
295         fuzzNumber = 0; #: counts the number of packets we have generated
296         while( fuzzNumber < Fuzzes):
297             id_new = standardIDs[random.randint(0,numIds-1)]
298             print id_new
299             #### split SID into different regs
300             SIDhigh = (id_new >> 3) & 0xFF; # get SID bits 10:3, rotate them to bits 7:0
301             SIDlow = (id_new & 0x07) << 5;  # get SID bits 2:0, rotate them to bits 7:5
302             packet[0] = SIDhigh
303             packet[1] = SIDlow
304             
305             #generate a fuzzed packet
306             for i in range(0,8): # for each data byte, fuzz it
307                 idx = "db%d"%i
308                 limits = dbLimits[idx]
309                 value = random.randint(limits[0],limits[1]) #generate pseudo-random integer value
310                 packet[i+5] = value
311             print packet
312             #put a rough time stamp on the data and get all the data bytes    
313             row = [tT.time(), id_new,8] # could make this 8 a variable 
314             msg = "Injecting: "
315             for i in range(5,13):
316                 row.append(packet[i])
317                 msg += " %d"%packet[i]
318             #print msg
319             dataWriter.writerow(row)
320             self.client.txpacket(packet)
321             tT.sleep(period/1000)
322             
323             #inject the packet the given number of times. 
324             for i in range(1,writesPerFuzz):
325                 self.client.MCPrts(TXB0=True)
326                 tT.sleep(period/1000)
327             fuzzNumber += 1
328         print "Fuzzing Complete"   
329         outfile.close()
330             
331     def generalFuzz(self,freq, Fuzzes, period, writesPerFuzz):
332         """
333         The method will inject properly formatted, randomly generated messages at a given period for a I{writesPerFuzz} 
334         number of times. A new random standard id will be chosen with each newly generated packet. IDs will be chosen from the full
335         range of potential ids ranging from 0 to 4095. The packets that are injected into the bus will all be saved in the following path
336         DATALOCATION/InjectedData/(today's date (YYYYMMDD))_GenerationFuzzedPackets.csv. An example filename would be 20130222_GenerationFuzzedPackets.csv
337         Where DATALOCATION is provided when the class is initiated. The data will be saved as integers.
338         Each row will be formatted in the following form::
339                      row = [time of injection, standardID, 8, db0, db1, db2, db3, db4, db5, db6, db7]
340         
341         @type  freq: number
342         @param freq: The frequency at which the bus is communicating
343         @type period: number
344         @param period: The time gap between packet inejctions given in milliseconds
345         @type writesPerFuzz: integer
346         @param writesPerFuzz: This will be the number of times that each randomly generated packet will be injected onto the bus
347                               before a new packet is generated
348         @type Fuzzes: integer
349         @param Fuzzes: The number of packets to be generated and injected onto bus
350         
351         @rtype: None
352         @return: This method does not return anything
353                          
354         """
355         #print "Fuzzing on standard ID: %d" %standardId
356         self.client.serInit()
357         self.spitSetup(freq)
358         packet = [0,0,0x00,0x00,0x08,0,0,0,0,0,0,0,0] #empty template
359         
360         #get folder information (based on today's date)
361         now = datetime.datetime.now()
362         datestr = now.strftime("%Y%m%d")
363         path = self.DATA_LOCATION+"InjectedData/"+datestr+"_GenerationFuzzedPackets.csv"
364         filename = path
365         outfile = open(filename,'a');
366         dataWriter = csv.writer(outfile,delimiter=',');
367         #dataWriter.writerow(['# Time     Error        Bytes 1-13']);
368         #dataWriter.writerow(['#' + description])
369             
370         fuzzNumber = 0; #: counts the number of packets we have generated
371         while( fuzzNumber < Fuzzes):
372             #generate new random standard id in the full range of possible values
373             id_new = random.randint(0,4095) 
374             #print id_new
375             #### split SID into different regs
376             SIDhigh = (id_new >> 3) & 0xFF; # get SID bits 10:3, rotate them to bits 7:0
377             SIDlow = (id_new & 0x07) << 5;  # get SID bits 2:0, rotate them to bits 7:5
378             packet[0] = SIDhigh
379             packet[1] = SIDlow
380             
381             #generate a fuzzed packet
382             for i in range(0,8): # for each data byte, fuzz it
383                 idx = "db%d"%i
384                 
385                 value = random.randint(0, 255) #generate pseudo-random integer value
386                 packet[i+5] = value
387             #print packet
388             #put a rough time stamp on the data and get all the data bytes    
389             row = [time.time(), id_new,8] 
390             """@todo: allow for varied packet lengths"""
391             msg = "Injecting: "
392             for i in range(5,13):
393                 row.append(packet[i])
394                 msg += " %d"%packet[i]
395             #print msg
396             dataWriter.writerow(row)
397             self.client.txpacket(packet)
398             time.sleep(period/1000)
399             
400             #inject the packet the given number of times. 
401             for i in range(1,writesPerFuzz):
402                 self.client.MCPrts(TXB0=True)
403                 time.sleep(period/1000)
404             fuzzNumber += 1
405         print "Fuzzing Complete"   
406         outfile.close()
407     
408     # assumes 8 byte packets
409     def packetRespond(self,freq, time, repeats, period,  responseID, respondPacket,listenID, listenPacket = None):
410         """
411         This method will allow the user to listen for a specific packet and then respond with a given message.
412         If no listening packet is included then the method will only listen for the id and respond with the specified
413         packet when it receives a message from that id. This process will continue for the given amount of time (in seconds). 
414         and with each message received that matches the listenPacket and ID the transmit message will be sent the I{repeats} number
415         of times at the specified I{period}. This message assumes a packet length of 8 for both messages, although the listenPacket can be None
416         
417         @type freq: number
418         @param freq: Frequency of the CAN bus
419         @type time: number
420         @param time: Length of time to perform the packet listen/response in seconds.
421         @type repeats: Integer
422         @param repeats: The number of times the response packet will be injected onto the bus after the listening 
423                         criteria has been met.
424         @type period: number
425         @param period: The time interval between messages being injected onto the CAN bus. This will be specified in milliseconds
426         @type responseID: Integer
427         @param responseID: The standard ID of the message that we want to inject
428         @type respondPacket: List of integers
429         @param respondPacket: The data we wish to inject into the bus. In the format where respondPacket[0] = databyte 0 ... respondPacket[7] = databyte 7
430                               This assumes a packet length of 8.
431         @type listenID: Integer
432         @param listenID: The standard ID of the messages that we are listening for. When we read the correct message from this ID off of the bus, the method will
433                          begin re-injecting the responsePacket on the responseID
434         @type listenPacket: List of Integers
435         @param listenPacket: The data we wish to listen for before we inject packets. This will be a list of the databytes, stored as integers such that
436                              listenPacket[0] = data byte 0, ..., listenPacket[7] = databyte 7. This assumes a packet length of 8. This input can be None and this
437                              will lead to the program only listening for the standardID and injecting the response as soon as any message from that ID is given
438         """
439         
440         
441         self.client.serInit()
442         self.spitSetup(freq)
443         
444         #formulate response packet
445         SIDhigh = (responseID >> 3) & 0xFF; # get SID bits 10:3, rotate them to bits 7:0
446         SIDlow = (responseID & 0x07) << 5;  # get SID bits 2:0, rotate them to bits 7:5
447         #resPacket[0] = SIDhigh
448         #resPacket[1] = SIDlow
449         resPacket = [SIDhigh, SIDlow, 0x00,0x00, # pad out EID regs
450                   0x08, # bit 6 must be set to 0 for data frame (1 for RTR) 
451                   # lower nibble is DLC                   
452                  respondPacket[0],respondPacket[1],respondPacket[2],respondPacket[3],respondPacket[4],respondPacket[5],respondPacket[6],respondPacket[7]]
453         #load packet/send once
454         """@todo: make this only load the data onto the chip and not send """
455         self.client.txpacket(resPacket) 
456         self.addFilter([listenID,listenID,listenID,listenID, listenID, listenID]) #listen only for this packet
457         startTime = tT.time()
458         packet = None
459         while( (tT.time() - startTime) < time):
460             packet = self.client.rxpacket()
461             if( packet != None):
462                 print "packet read in, responding now"
463                 # assume the ids already match since we are filtering for the id
464                 
465                 #compare packet received to desired packet
466                 if( listenPacket == None): # no packets given, just want the id
467                     for i in range(0,repeats):
468                         self.client.MCPrts(TXB0=True)
469                         tT.sleep(period/1000)
470                 else: #compare packets
471                     sid =  ord(packet[0])<<3 | ord(packet[1])>>5
472                     print "standard id of packet recieved: ", sid #standard ID
473                     msg = ""
474                     for i in range(0,8):
475                         idx = 5 + i
476                         byteIn = ord(packet[idx])
477                         msg += " %d" %byteIn
478                         compareIn = listenPacket[i]
479                         print byteIn, compareIn
480                         if( byteIn != compareIn):
481                             packet == None
482                             print "packet did not match"
483                             break
484                     print msg
485                     if( packet != None ):
486                         self.client.MCPrts(TXB0=True)
487                         tT.sleep(period/1000)
488         print "Response Listening Terminated."
489                 
490         
491 #    def generationFuzzRandomID(self, freq, standardIDs, dbLimits, period, writesPerFuzz, Fuzzes):
492 #        print "Fuzzing on standard ID: %d" %standardId
493 #        self.client.serInit()
494 #        self.spitSetup(freq)
495 #        packetTemp = [0,0,0,0,0,0,0,0]
496 #        #form a basic packet
497 #        
498 #        #### split SID into different regs
499 #        SIDlow = (standardId & 0x07) << 5;  # get SID bits 2:0, rotate them to bits 7:5
500 #        SIDhigh = (standardId >> 3) & 0xFF; # get SID bits 10:3, rotate them to bits 7:0
501 #        
502 #        packet = [SIDhigh, SIDlow, 0x00,0x00, # pad out EID regs
503 #                  0x08, # bit 6 must be set to 0 for data frame (1 for RTR) 
504 #                  # lower nibble is DLC                   
505 #                 packetTemp[0],packetTemp[1],packetTemp[2],packetTemp[3],packetTemp[4],packetTemp[5],packetTemp[6],packetTemp[7]]
506 #        
507 #        
508 #        #get folder information (based on today's date)
509 #        now = datetime.datetime.now()
510 #        datestr = now.strftime("%Y%m%d")
511 #        path = self.DATA_LOCATION+"InjectedData/"+datestr+"_GenerationFuzzedPackets.csv"
512 #        filename = path
513 #        outfile = open(filename,'a');
514 #        dataWriter = csv.writer(outfile,delimiter=',');
515 #        #dataWriter.writerow(['# Time     Error        Bytes 1-13']);
516 #        #dataWriter.writerow(['#' + description])
517 #            
518 #        numIds = len(standardIDs)
519 #        fuzzNumber = 0;
520 #        while( fuzzNumber < Fuzzes):
521 #            id_new = standsardIDs[random.randint(0,numIds-1)]
522 #            #### split SID into different regs
523 #            SIDlow = (id_new & 0x07) << 5;  # get SID bits 2:0, rotate them to bits 7:5
524 #            SIDhigh = (id_new >> 3) & 0xFF; # get SID bits 10:3, rotate them to bits 7:0
525 #            packet[0] = SIDhigh
526 #            packet[1] = SIDlow
527 #            
528 #            #generate a fuzzed packet
529 #            for i in range(0,8): # for each databyte, fuzz it
530 #                idx = "db%d"%i
531 #                limits = dbLimits[idx]
532 #                value = random.randint(limits[0],limits[1]) #generate pseudo-random integer value
533 #                packet[i+5] = value
534 #            
535 #            #put a rough time stamp on the data and get all the data bytes    
536 #            row = [time.time(), standardId,8]
537 #            msg = "Injecting: "
538 #            for i in range(5,13):
539 #                row.append(packet[i])
540 #                msg += " %d"%packet[i]
541 #            #print msg
542 #            dataWriter.writerow(row)
543 #            self.client.txpacket(packet)
544 #            #inject the packet repeatily 
545 #            for i in range(1,writesPerFuzz):
546 #                self.client.MCPrts(TXB0=True)
547 #                time.sleep(period/1000)
548 #            fuzzNumber += 1
549 #        print "Fuzzing Complete"   
550 #        outfile.close()