Пример #1
0
 def send(self, msg, node, timeout=None):
     '''Send some msg to dest node (Node), and if timeout is specified then return a success (True)
     or failure (False) within that timeout. Otherwise, the function may return immediately.'''
     try:
         start = time.time()
         if node.type == socket.SOCK_DGRAM and timeout is not None:  # no ack required for tcp
             msg['ack'] = True  # require a NetworkAck
         data = dht.int2bin(self.node.guid) + str(
             msg)  # TODO: this assumes guid is same for all transports.
         if _debug and msg.name[:4] != 'Hash':
             print self.name, 'sending %d bytes %s=>%s: %r' % (
                 len(data), self.node.hostport, node.hostport, msg)
         if node.type == socket.SOCK_DGRAM:
             self.udp.sendto(data, (node.ip, node.port))
         else:
             if node in self.tcpc:
                 sock = self.tcpc[node]
             else:
                 sock = socket.socket(type=socket.SOCK_STREAM)
                 sock.setblocking(0)
                 try:
                     if _debug: print 'connecting to %s' % (node.hostport, )
                     sock.connect((node.ip, node.port))
                 except (socket.timeout, socket.error):
                     yield multitask.sleep(2.0)
                     ret = select.select((), (sock, ), (), 0)
                     if len(ret[1]) == 0:
                         if _debug:
                             print 'connection timedout to %s' % (
                                 node.hostport, )
                         raise multitask.Timeout, 'Cannot connect to the destination'
                 self.tcpc[node] = sock
                 multitask.sleep()
                 multitask.add(self.tcphandler(sock, (node.ip, node.port)))
             data = struct.pack('!H',
                                len(data)) + data  # put a length first.
             sock.send(data)
         if msg.ack:
             hash = H(
                 data
             )  # hash property to associate the ack to the data request.
             ack = yield self.get(
                 lambda x: x.name == 'Ack:Indication' and x.hash == hash,
                 timeout=(timeout - (time.time() - start)))
             if _debug: 'received ack %r' % (ack)
             if ack is None: raise StopIteration(False)  # no ack received
         raise StopIteration(True)
     except (multitask.Timeout, socket.error):
         raise StopIteration(False)  # timeout in sendto or get
Пример #2
0
 def _registerUA(self):
     ''' Creates the requests to Register the use, Authenticates if neccesary and returns success/failed.'''
     if self.reg_state == None:
         self.app.status.append('Register Generator Initiated')
     try:
         if self.reg_refresh and self._ua.gen:
             yield multitask.sleep(
                 self.register_interval -
                 min(self.register_interval * 0.05,
                     5))  # refresh about 5 seconds before expiry
         self._ua.sendRequest(self._createRegister())
         while True:
             response = (yield self._ua.queue.get())
             if response.CSeq.method == 'REGISTER':
                 if response.is2xx:  # success
                     if self.reg_refresh:
                         if response.Expires:
                             self.register_interval = int(
                                 response.Expires.value)
                         if self.register_interval > 0:
                             self._ua.gen = self._register(
                             )  # generator for refresh
                             multitask.add(self._ua.gen)
                     raise StopIteration(('success', None))
                 elif response.isfinal:  # failed
                     raise StopIteration(('failed', str(response.response) +
                                          ' ' + response.responsetext))
     except GeneratorExit:
         raise StopIteration(('failed', 'Generator closed'))
Пример #3
0
	def mainController(self):
		logger.info("ntsga: start fuzzing controller")
		while True:
			if self.status: # Print app status
				print self.status.pop(0)
			# If not register needed or already registered => fuzz
			if not self.options.register or (self.options.register and self.user.reg_state==self.user.REGISTERED):
				while True:
					# If not crash_detect => fuzz,  else => set setCrashDetect
					if not self.options.crash_detect or (self.options.crash_detect and self.user.crash_det_state==self.user.CRASH_SET):
						self.user.add_fuzzerGen()
						while True:
							yield multitask.sleep(1)
							if not self.user.state == self.user.FUZZING:
								self.printResults()
								self.stop()
								raise StopIteration()
							yield
					else:
						# crash detection active
						self.user.add_setCrashDetectGen()	
						if self.user.crash_det_state==self.user.CRASH_ERROR:
							self.printResults()
							self.stop()
							raise StopIteration()
					yield
			# If register needed and could not register = > stop app
			elif not (self.user.reg_result=='success' or self.user.reg_result==None):
				print 'Could not register user.'
				self.stop()
				raise StopIteration()
			yield
Пример #4
0
 def run(self):
     try:
         import multitask
         yield multitask.sleep(self.delay / 1000.0)
         if self.running: self.app.timedout(self)
     except:
         pass  # probably stopped before timeout
Пример #5
0
 def reader(self, stream):
     '''A generator to periodically read the file and dispatch them to the stream.'''
     if _debug: print 'reader started'
     try:
         while True:
             bytes = self.fp.read(11)
             if len(bytes) == 0:
                 response = Command(name='onStatus', id=stream.id, args=[dict(level='status',code='NetStream.Play.Stop', description='File ended', details=None)])
                 stream.send(response.toMessage())
                 break
             type, len0, len1, ts0, ts1, ts2, sid0, sid1 = struct.unpack('>BBHBHBBH', bytes)
             length = (len0 << 16) | len1; ts = (ts0 << 16) | (ts1 & 0x0ffff) | (ts2 << 24)
             body = self.fp.read(length); ptagsize, = struct.unpack('>I', self.fp.read(4))
             if ptagsize != (length+11): 
                 if _debug: print 'invalid previous tag-size found:', ptagsize, '!=', (length+11),'ignored.'
             if type == Message.AUDIO: self.tsa, ts = ts, ts - max(self.tsa, self.tsv)
             else: self.tsv, ts = ts, ts - max(self.tsa, self.tsv)
             # if _debug: print 'ts=', ts
             if ts < 0: ts = 0
             if ts > 0: yield multitask.sleep(ts / 1000.0)
             if stream is None or stream.client is None: break # if it is closed
             hdr = Header(0, ts if ts < 0xffffff else 0xffffff, length, type, stream.id)
             if ts >= 0xffffff: hdr.extendedtime = ts
             msg = Message(hdr, body)
             # if _debug: print 'sending length=', length, 'hdr=', hdr
             stream.send(msg)
     except StopIteration: pass
     except: 
         if _debug: print 'closing the reader', (sys and sys.exc_info() or None)
         traceback.print_exc()
         if self.fp is not None: self.fp.close(); self.fp = None
Пример #6
0
def _testServer():
    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM, 0)
    sock.bind(('0.0.0.0', 0)) # should use any port for testing
    multitask.add(server(sock))
    sockaddr = getlocaladdr(sock)
    multitask.add(_testDiscoverBehavior([sockaddr, defaultServers[0]]))
    yield multitask.sleep(5)
    sock.close()
Пример #7
0
def _testTcpRequest():
    try:
        sock1 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock1.bind(('0.0.0.0', 0)) # should use any port for testing
        multitask.add(server(sock1))
        sockaddr = getlocaladdr(sock1)
        
        sock2 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock2.bind(('0.0.0.0', 0))
        yield multitask.sleep(2) # wait for server to be started.
        response, external = (yield request(sock2, sockaddr))
        print 'external=', external
        sock1.close()
        yield multitask.sleep(6)
        print '_testTcpRequest() exiting'
    except (ValueError, multitask.Timeout), E:
        print 'exception - ValueError or Timeout', E
Пример #8
0
def _testRelay():
    try:
        sock1 = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        sock1.bind(('0.0.0.0', 0))
        multitask.add(server(sock1))
        sockaddr = getlocaladdr(sock1)
        
        sock2 = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        sock2.bind(('0.0.0.0', 0))
        yield multitask.sleep(2)
        response, mapped = request(sock2, sockaddr, method=Message.ALLOCATE)
        print 'mapped=', mapped
        sock1.close()
        sock2.close()
        yield multitask.sleep(6)
    except:
        print 'exception', sys.exc_info(), traceback.print_exc(file=sys.stdout)    
Пример #9
0
	def _spoofing(self):
		# Msg to spoof generator ---------
		def _createSpoofMessage():
			if self.spoof_msg_file:
				with open (self.spoof_msg_file, "r") as file_txt:
					file_txt=file_txt.read()
				m = rfc3261_IPv6.Message()
				try:
					m = m._parse(file_txt.rstrip()+'\r\n\r\n\r\n')
				except ValueError, E: pass # TODO: send 400 response to non-ACK request
			else:
				m = self._ua.createRequest(self.spoof_method)
				if self.spoof_srcURI:
					m.From.value.uri = self.spoof_srcURI
				if m.method == "INVITE":
					if self.app.options.registrar_ip != self.app.options.to.uri.host:
						SourceFakeAddr = self.app.options.registrar_ip
					else:
						SourceFakeAddr = str(self.app.options.to.uri.host).split('.')
						SourceFakeAddr[3] = str(random.randint(0,254))
						SourceFakeAddr = ".".join(SourceFakeAddr)
					if not self.spoof_srcURI:
						m.From.value.uri.user = m.From.value.displayName =  str(random.randint(0,999))
						m.From.value.uri.host = SourceFakeAddr
				m.Contact = rfc3261_IPv6.Header(str(self._stack.uri), 'Contact')
				m.Contact.value.uri.user = self.localParty.uri.user
				m.Expires = rfc3261_IPv6.Header(str(self.app.options.register_interval), 'Expires')
			return m
		# Stop listener if not necessary in spoof mode
		if self.listenerOff: self._listenerGen.close()
		try:
			spoof_message = self.spoofMsg(_createSpoofMessage())
			if not self.listenerOff:
				self._ua.sendRequest(spoof_message)
				while True:
					response = (yield self._ua.queue.get())
					if response.CSeq.method == 'REGISTER':
						if response.is2xx:   # success
							if self.reg_refresh:
								if response.Expires: self.register_interval = int(response.Expires.value)
								if self.register_interval > 0:								
									self._ua.gen = self._register() # generator for refresh
									multitask.add(self._ua.gen)
							raise StopIteration(('success', None))
						elif response.isfinal: # failed
							raise StopIteration(('failed', str(response.response) + ' ' + response.responsetext))
			else:
				self.send(str(spoof_message),self.remoteParty.uri.hostPort,None)				
			yield multitask.sleep(1)
			self.app.stop()
			yield
			raise StopIteration()
		except GeneratorExit:
			raise StopIteration(('failed', 'Generator closed'))
		self.app.stop()
		yield
		raise StopIteration()
Пример #10
0
def main(username, password, targetname):
    user = rfc3921.User(server='gmail.com', username=username, password=password)
    result, error = yield user.login()
    
    yield multitask.sleep(1)
    user.roster.presence = rfc3921.Presence(show=None, status='Online')

    history = user.chat(targetname + '@gmail.com')

    multitask.add(recv(history))
    multitask.add(send(history, user))
Пример #11
0
 def send(self, msg, node, timeout=None):
     '''Send some msg to dest node (Node), and if timeout is specified then return a success (True)
     or failure (False) within that timeout. Otherwise, the function may return immediately.'''
     try:
         start = time.time()
         if node.type==socket.SOCK_DGRAM and timeout is not None: # no ack required for tcp 
             msg['ack'] = True # require a NetworkAck
         data = dht.int2bin(self.node.guid) + str(msg) # TODO: this assumes guid is same for all transports.
         if _debug and msg.name[:4] != 'Hash': print self.name, 'sending %d bytes %s=>%s: %r'%(len(data), self.node.hostport, node.hostport, msg)
         if node.type == socket.SOCK_DGRAM:
             self.udp.sendto(data, (node.ip, node.port))
         else:
             if node in self.tcpc:
                 sock = self.tcpc[node]
             else:
                 sock = socket.socket(type=socket.SOCK_STREAM)
                 sock.setblocking(0)
                 try:
                     if _debug: print 'connecting to %s'%(node.hostport,)
                     sock.connect((node.ip, node.port))
                 except (socket.timeout, socket.error):
                     yield multitask.sleep(2.0)
                     ret = select.select((), (sock,), (), 0)
                     if len(ret[1]) == 0:
                         if _debug: print 'connection timedout to %s'%(node.hostport,)
                         raise multitask.Timeout, 'Cannot connect to the destination'
                 self.tcpc[node] = sock
                 multitask.sleep()
                 multitask.add(self.tcphandler(sock, (node.ip, node.port)))
             data = struct.pack('!H', len(data)) + data # put a length first.
             sock.send(data)
         if msg.ack:
             hash = H(data)    # hash property to associate the ack to the data request.
             ack = yield self.get(lambda x: x.name=='Ack:Indication' and x.hash==hash, timeout=(timeout - (time.time() - start)))
             if _debug: 'received ack %r'%(ack)
             if ack is None: raise StopIteration(False) # no ack received
         raise StopIteration(True)
     except (multitask.Timeout, socket.error):
         raise StopIteration(False) # timeout in sendto or get
Пример #12
0
    def write(self):
        '''Writes messages to stream'''
        while True:
            while self.writeQueue.empty(): (yield multitask.sleep(0.01))
            message = self.writeQueue.get() # TODO this should be used using multitask.Queue and remove previous wait.
            if _debug: print 'response', message
            if message is None: 
                try: self.stream.close()  # just in case TCP socket is not closed, close it.
                except: pass
                break
            
            # get the header stored for the stream
            if self.lastWriteHeaders.has_key(message.streamId):
                header = self.lastWriteHeaders[message.streamId]
            else:
                if self.nextChannelId < Protocol.MIN_CHANNEL_ID: self.nextChannelId = Protocol.MIN_CHANNEL_ID
                header, self.nextChannelId = Header(self.nextChannelId), self.nextChannelId + 1
                self.lastWriteHeaders[message.streamId] = header
            # special header for protocol messages
            if message.type < Message.AUDIO:
                header = Header(Protocol.PROTOCOL_CHANNEL_ID)
                    
            # now figure out the header data bytes
            if header.streamId != message.streamId or header.time == 0:
                header.streamId, header.type, header.size, header.time = message.streamId, message.type, message.size, message.time
                control = Header.FULL
            elif header.size != message.size or header.type != message.type:
                header.type, header.size, header.time = message.type, message.size, message.time
                control = Header.MESSAGE
            elif header.time != message.time:
                # if _debug: print '------- time changed'
                header.time = message.time
                control = Header.TIME
            else:
                control = Header.SEPARATOR

            assert message.size == len(message.data)

            data = ''
            while len(message.data) > 0:
                data += header.toBytes(control) # gather header bytes
                count = min(self.writeChunkSize, len(message.data))
                data += message.data[:count]
                message.data = message.data[count:]
                control = Header.SEPARATOR # incomplete message continuation
            try:
                yield self.stream.write(data)
            except ConnectionClosed:
                yield self.connectionClosed()
            except:
                print traceback.print_exc()
Пример #13
0
def testPresence(): # TODO: rename this with prefix _ to enable testing
    # TODO: change the following to your account and password
    u1 = User(server='gmail.com', username='******', password='******')
    result, error = yield u1.login()
    
    yield multitask.sleep(1)
    u1.roster.presence = Presence(show='dnd', status='Online')

    h1 = u1.chat('*****@*****.**')
    yield h1.send(Message(body='Hello How are you?'))

    count = 5
    for i in xrange(5):
        try:
            msg = yield h1.recv(timeout=120)
            print msg
            print '%s: %s'%(msg.frm, msg.body.cdata)
            yield h1.send(Message(body='You said "%s"'%(msg.body.cdata)))
        except Exception, e:
            print str(type(e)), e
            break
Пример #14
0
	def _registerUA(self):
		''' Creates the requests to Register the use, Authenticates if neccesary and returns success/failed.'''
		if self.reg_state == None:
			self.app.status.append('Register Generator Initiated')
		try:
			if self.reg_refresh and self._ua.gen:
				yield multitask.sleep(self.register_interval - min(self.register_interval*0.05, 5)) # refresh about 5 seconds before expiry
			self._ua.sendRequest(self._createRegister())
			while True:
				response = (yield self._ua.queue.get())
				if response.CSeq.method == 'REGISTER':
					if response.is2xx:   # success
						if self.reg_refresh:
							if response.Expires: self.register_interval = int(response.Expires.value)
							if self.register_interval > 0:								
								self._ua.gen = self._register() # generator for refresh
								multitask.add(self._ua.gen)
						raise StopIteration(('success', None))
					elif response.isfinal: # failed
						raise StopIteration(('failed', str(response.response) + ' ' + response.responsetext))
		except GeneratorExit:
			raise StopIteration(('failed', 'Generator closed'))
Пример #15
0
 def mainController(self):
     logger.info("ntsga: start fuzzing controller")
     while True:
         if self.status:  # Print app status
             print self.status.pop(0)
         # If not register needed or already registered => fuzz
         if not self.options.register or (self.options.register
                                          and self.user.reg_state
                                          == self.user.REGISTERED):
             while True:
                 # If not crash_detect => fuzz,  else => set setCrashDetect
                 if not self.options.crash_detect or (
                         self.options.crash_detect and
                         self.user.crash_det_state == self.user.CRASH_SET):
                     self.user.add_fuzzerGen()
                     while True:
                         yield multitask.sleep(1)
                         if not self.user.state == self.user.FUZZING:
                             self.printResults()
                             self.stop()
                             raise StopIteration()
                         yield
                 else:
                     # crash detection active
                     self.user.add_setCrashDetectGen()
                     if self.user.crash_det_state == self.user.CRASH_ERROR:
                         self.printResults()
                         self.stop()
                         raise StopIteration()
                 yield
         # If register needed and could not register = > stop app
         elif not (self.user.reg_result == 'success'
                   or self.user.reg_result == None):
             print 'Could not register user.'
             self.stop()
             raise StopIteration()
         yield
Пример #16
0
def testClose():
    yield multitask.sleep(25)
    exit()
Пример #17
0
 def run(self):
     try:
         import multitask
         yield multitask.sleep(self.delay / 1000.0)
         if self.running: self.app.timedout(self)
     except: pass # probably stopped before timeout
Пример #18
0
def _testClose(): yield multitask.sleep(2); exit()

if __name__ == '__main__':
Пример #19
0
    def _fuzzing(self):
        # Msg to Fuzz generator ---------
        fuzzers = {
            'InviteCommonFuzzer': 'INVITE_COMMON',
            'InviteStructureFuzzer': 'INVITE_STRUCTURE',
            'InviteRequestLineFuzzer': 'INVITE_REQUEST_LINE',
            'InviteOtherFuzzer': 'INVITE_OTHER',
            'CANCELFuzzer': 'CANCEL',
            'REGISTERFuzzer': 'REGISTER',
            'SUBSCRIBEFuzzer': 'SUBSCRIBE',
            'NOTIFYFuzzer': 'NOTIFY',
            'ACKFuzzer': 'ACK'
        }

        def fuzzingCtrl(fuzz_index):
            if self.state == self.FUZZING:
                import datetime

                def log_perc_completed(i, partials, total=self.mutations):
                    partials = map(int, (partials.split(',')))
                    for partial in partials:
                        if i == (partial * total / 100):
                            logger.info(
                                str((datetime.datetime.now() -
                                     self.start_fuzz_time).total_seconds() *
                                    1000) + ' msec' + ':		' +
                                str(int((total * partial / 100) // 1)) + '/' +
                                str(total) + ' (' + str(int((partial) // 1)) +
                                '%) messages sent')

                if not self.start_fuzz_time:
                    self.start_fuzz_time = datetime.datetime.now()
                if self.crash_detect:
                    log_perc_completed(
                        fuzz_index, '1,2,4,8,10,20,30,40,50,60,70,80,90,100')
                else:
                    log_perc_completed(fuzz_index, '25,50,75,100')

        def _createMutableMessage():
            # Msg to Fuzz generator ---------
            if not self.fuzzer == 'All':
                mutable_msg = s_get(fuzzers.get(self.fuzzer))
            else:
                mutable_msg = s_get(fuzzers.get('INVITE_COMMON'))
            return mutable_msg

        def _createFuzzerMsgGen(mutable_msg):
            def replaceDefaults(rendered_msg):
                from random import Random
                import string
                # branch
                self.curr_invite_branch = ''.join(Random().sample(
                    string.ascii_lowercase + string.digits, 32))
                rendered_msg = rendered_msg.replace('somebranchvalue',
                                                    self.curr_invite_branch)
                rendered_msg = rendered_msg.replace('somefromtagvalue',
                                                    self.curr_invite_branch)
                rendered_msg = rendered_msg.replace('somecallidvalue',
                                                    self.curr_invite_branch)
                # This stuff is new in this function and should be moved elsewhere
                # Works fine here for now though
                rendered_msg = rendered_msg.replace('TARGET_USER',
                                                    self.remoteParty.uri.user)
                rendered_msg = rendered_msg.replace('HOST',
                                                    self.remoteParty.uri.host)
                rendered_msg = rendered_msg.replace('USER',
                                                    self.localParty.uri.user)
                rendered_msg = rendered_msg.replace('LOCAL_IP',
                                                    self.localParty.uri.host)
                rendered_msg = rendered_msg.replace('192.168.96.69',
                                                    self.localParty.uri.host)
                rendered_msg = rendered_msg.replace('192.168.99.99',
                                                    self.localParty.uri.host)
                rendered_msg = rendered_msg.replace(
                    'PORT', str(self.localParty.uri.port))
                rendered_msg = rendered_msg.replace(':password', '')
                return rendered_msg

            if not self.fuzzer == 'All':
                for i in range(min(self.mutations, self.fuzz_max_msgs)):
                    mutable_msg.mutate()
                    m = replaceDefaults(mutable_msg.render())
                    yield (m)
            else:
                msg_counter = 0
                for item in fuzzers:
                    mutable_msg = s_get(fuzzers.get(item))
                    for i in range(mutable_msg.num_mutations()):
                        msg_counter += 1
                        if msg_counter < min(self.mutations,
                                             self.fuzz_max_msgs):
                            mutable_msg.mutate()
                            m = replaceDefaults(mutable_msg.render())
                            yield (m)

        # Stop listener if no crash detection is been used
        if self.listenerOff: self._listenerGen.close()
        # Dest Address
        addr = self.remoteTarget.uri
        if addr and isinstance(addr, rfc2396_IPv6.URI):
            if not addr.host: raise ValueError, 'No host in destination uri'
            addr = (addr.host, addr.port or self.transport.type == 'tls'
                    and self.transport.secure and 5061 or 5060)
        mutable_msg = _createMutableMessage()
        # Msg generator
        if not self.fuzzer == 'All':
            self.mutations = mutable_msg.num_mutations()
        else:
            self.mutations = 0
            for item in fuzzers:
                self.mutations += s_get(fuzzers.get(item)).num_mutations()
        Fuzz_Generator = _createFuzzerMsgGen(mutable_msg)
        if self.audit_file_name:
            self.audit_file_name = open(self.audit_file_name, 'w')
        print "Fuzzing %s messages to %s" % (self.mutations, addr)
        try:
            if self.sock:
                if self.sock.type == socket.SOCK_STREAM:
                    pass
                elif self.sock.type == socket.SOCK_DGRAM:
                    while True:
                        try:
                            data = str(Fuzz_Generator.next())
                            if len(data) > 9216:
                                data = data[:9216]
                            try:
                                # SEND FUZZ MSG
                                self.sock.sendto(data, addr)
                                # Index
                                self.fuzz_index += 1
                                fuzzingCtrl(self.fuzz_index)
                                if self.audit_file_name:
                                    self.audit_file_name.write(
                                        "Index " + str(self.fuzz_index) +
                                        "\n--\n" + data + "\n--\n\n")
                                self.crash_fuzz = self.WAIT_CRSH_CHK
                                # if crash detect => wait until crash detection is completed
                                #print '1. Fuzz sent'
                                while (self.crash_detect
                                       and self.crash_fuzz != self.WAIT_FUZZ):
                                    yield multitask.sleep(1)
                            except socket.error:
                                logger.debug('socket error in sendto')
                        except StopIteration:
                            self.state = self.FUZZING_COMPETED
                            raise StopIteration()
                        yield
                else:
                    logger.debug('invalid socket type', self.sock.type)
        except AttributeError:
            pass
Пример #20
0
	def _fuzzing(self):
		# Msg to Fuzz generator ---------
		fuzzers = {'InviteCommonFuzzer': 'INVITE_COMMON', 'InviteStructureFuzzer': 'INVITE_STRUCTURE', 'InviteRequestLineFuzzer': 'INVITE_REQUEST_LINE','InviteOtherFuzzer': 'INVITE_OTHER', 'CANCELFuzzer': 'CANCEL', 'REGISTERFuzzer': 'REGISTER','SUBSCRIBEFuzzer': 'SUBSCRIBE', 'NOTIFYFuzzer': 'NOTIFY', 'ACKFuzzer': 'ACK'}

		def fuzzingCtrl(fuzz_index):
			if self.state == self.FUZZING:
				import datetime
				def log_perc_completed(i, partials, total=self.mutations):
					partials = map(int,(partials.split(',')))
					for partial in partials:
						if i == (partial*total/100):
							logger.info(str((datetime.datetime.now()-self.start_fuzz_time).total_seconds()*1000)+' msec'+':		'+str(int((total*partial/100)//1))+'/'+str(total)+' ('+str(int((partial)//1))+'%) messages sent')
				if not self.start_fuzz_time:
					self.start_fuzz_time = datetime.datetime.now()
				if self.crash_detect:
					log_perc_completed(fuzz_index,'1,2,4,8,10,20,30,40,50,60,70,80,90,100')
				else:
					log_perc_completed(fuzz_index,'25,50,75,100')
				
		def _createMutableMessage():
			# Msg to Fuzz generator ---------
			if not self.fuzzer == 'All':
				mutable_msg = s_get(fuzzers.get(self.fuzzer))
			else:
				mutable_msg = s_get(fuzzers.get('INVITE_COMMON'))
			return mutable_msg
			
		def _createFuzzerMsgGen(mutable_msg):
			def replaceDefaults(rendered_msg):
				from random import Random
				import string
				# branch
				self.curr_invite_branch = ''.join(Random().sample(string.ascii_lowercase+string.digits, 32))
				rendered_msg = rendered_msg.replace('somebranchvalue', self.curr_invite_branch)
				rendered_msg = rendered_msg.replace('somefromtagvalue', self.curr_invite_branch)
				rendered_msg = rendered_msg.replace('somecallidvalue', self.curr_invite_branch)
				# This stuff is new in this function and should be moved elsewhere
				# Works fine here for now though
				rendered_msg = rendered_msg.replace('TARGET_USER', self.remoteParty.uri.user)
				rendered_msg = rendered_msg.replace('HOST', self.remoteParty.uri.host)
				rendered_msg = rendered_msg.replace('USER', self.localParty.uri.user)
				rendered_msg = rendered_msg.replace('LOCAL_IP', self.localParty.uri.host)
				rendered_msg = rendered_msg.replace('192.168.96.69', self.localParty.uri.host)
				rendered_msg = rendered_msg.replace('192.168.99.99', self.localParty.uri.host)        
				rendered_msg = rendered_msg.replace('PORT', str(self.localParty.uri.port))
				rendered_msg = rendered_msg.replace(':password', '')
				return rendered_msg
				
			if not self.fuzzer == 'All':
				for i in range(min(self.mutations, self.fuzz_max_msgs)):
					mutable_msg.mutate()
					m = replaceDefaults(mutable_msg.render())
					yield (m)
			else:
				msg_counter = 0
				for item in fuzzers:
					mutable_msg = s_get(fuzzers.get(item))
					for i in range(mutable_msg.num_mutations()):
						msg_counter += 1
						if msg_counter < min(self.mutations, self.fuzz_max_msgs):
							mutable_msg.mutate()
							m = replaceDefaults(mutable_msg.render())
							yield (m)
		
		# Stop listener if no crash detection is been used
		if self.listenerOff: self._listenerGen.close()
		# Dest Address
		addr = self.remoteTarget.uri
		if addr and isinstance(addr, rfc2396_IPv6.URI):
			if not addr.host: raise ValueError, 'No host in destination uri'
			addr = (addr.host, addr.port or self.transport.type == 'tls' and self.transport.secure and 5061 or 5060)
		mutable_msg = _createMutableMessage()
		# Msg generator
		if not self.fuzzer == 'All':
			self.mutations = mutable_msg.num_mutations()
		else:
			self.mutations = 0
			for item in fuzzers:
				self.mutations += s_get(fuzzers.get(item)).num_mutations()
		Fuzz_Generator = _createFuzzerMsgGen(mutable_msg)
		if self.audit_file_name:
			self.audit_file_name = open(self.audit_file_name, 'w')
		print "Fuzzing %s messages to %s" % (self.mutations, addr)
		try:
			if self.sock:
				if self.sock.type == socket.SOCK_STREAM:
					pass
				elif self.sock.type == socket.SOCK_DGRAM:
					while True:
						try:
							data = str(Fuzz_Generator.next())
							if len(data) > 9216:
								data = data[:9216]
							try:
								# SEND FUZZ MSG
								self.sock.sendto(data, addr)
								# Index
								self.fuzz_index += 1
								fuzzingCtrl(self.fuzz_index)
								if self.audit_file_name:
									self.audit_file_name.write("Index "+str(self.fuzz_index)+"\n--\n"+data+"\n--\n\n")
								self.crash_fuzz=self.WAIT_CRSH_CHK
								# if crash detect => wait until crash detection is completed
								#print '1. Fuzz sent'
								while (self.crash_detect and self.crash_fuzz!=self.WAIT_FUZZ):
									yield multitask.sleep(1)
							except socket.error:
								logger.debug('socket error in sendto' )
						except StopIteration:
							self.state = self.FUZZING_COMPETED
							raise StopIteration()
						yield
				else:
					logger.debug('invalid socket type', self.sock.type)
		except AttributeError: pass
Пример #21
0
 def _taskCheck(self):
     inv = t_com.max_multitask_inv
     while True:
         yield multitask.sleep(inv)
Пример #22
0
                self.syncResult()
            except httplib.HTTPException:
                #            app.connection.set_text("Connection Error")
                pass
            except socket.gaierror:
                #            app.connection.set_text("OffLine")
                pass
            except peewee.DoesNotExist:
                #            app.connection.set_text("Updated...")
                pass
            except Exception, e:
                #            app.connection.set_text("Ignore - Result Error")
                print e
            try:
                self.syncOddTable()
            except httplib.HTTPException:
                #            app.connection.set_text("Connection Error")
                pass
            except socket.gaierror:
                #            app.connection.set_text("OffLine")
                pass
            except peewee.DoesNotExist:
                #            app.connection.set_text("Updated...")
                pass
            except Exception, e:
                #            app.connection.set_text("Ignore - Odd Error")
                print e

    #        self.syncTicketTable()
            yield sleep(20)
Пример #23
0
         try:
             self.syncResult()
         except httplib.HTTPException:
 #            app.connection.set_text("Connection Error")
             pass
         except socket.gaierror:
 #            app.connection.set_text("OffLine")
             pass
         except peewee.DoesNotExist:
 #            app.connection.set_text("Updated...")
             pass
         except Exception,e:
 #            app.connection.set_text("Ignore - Result Error")
             print e
         try:
             self.syncOddTable()
         except httplib.HTTPException:
 #            app.connection.set_text("Connection Error")
             pass
         except socket.gaierror:
 #            app.connection.set_text("OffLine")
             pass
         except peewee.DoesNotExist:
 #            app.connection.set_text("Updated...")
             pass
         except Exception,e:
 #            app.connection.set_text("Ignore - Odd Error")
             print e
 #        self.syncTicketTable()
         yield sleep(20)
Пример #24
0
def _testClose():
    yield multitask.sleep(2)
    exit()
Пример #25
0
def testClose(): yield multitask.sleep(25); exit()

if __name__ == '__main__':
Пример #26
0
 def printT():
     while True:
         print '+++'
         yield multitask.sleep(3)
Пример #27
0
 def printT2():
     while True:
         print '---'
         yield multitask.sleep(0.2)