def test_cwd(self): """Tests the FTP CWD command""" sessions = {} options = { 'enabled': 'True', 'port': 0, 'banner': 'Test Banner', 'protocol_specific_data': { 'max_attempts': 3, 'banner': 'test banner', 'syst_type': 'Test Type' }, 'users': { 'test': 'test' } } cap = hive_ftp.ftp(sessions, options, self.work_dir) srv = StreamServer(('0.0.0.0', 0), cap.handle_session) srv.start() bee_info = { 'enabled': True, 'timing': 'regular', 'username': '******', 'password': '******', 'port': srv.server_port, 'server': '127.0.0.1' } beesessions = {} BaitSession.client_id = 'f51171df-c8f6-4af4-86c0-f4e163cf69e8' current_bee = bee_ftp.ftp(beesessions, bee_info) current_bee.connect() current_bee.login(bee_info['username'], bee_info['password']) self.assertEquals('/', current_bee.state['current_dir']) current_bee.list() current_bee.cwd(current_bee.state['dir_list'][0]) self.assertNotEquals('/', current_bee.state['current_dir']) srv.stop()
def __init__(self, ip=None, port=None, request_handler=None): self.ip = ip self.port = port self.last_connection_id = 1 # Connection id incrementer self.log = logging.getLogger("ConnServer") self.port_opened = None if config.tor != "disabled": self.tor_manager = TorManager(self.ip, self.port) else: self.tor_manager = None self.connections = [] # Connections self.whitelist = ("127.0.0.1", ) # No flood protection on this ips self.ip_incoming = { } # Incoming connections from ip in the last minute to avoid connection flood self.broken_ssl_peer_ids = {} # Peerids of broken ssl connections self.ips = {} # Connection by ip self.has_internet = True # Internet outage detection self.running = True self.thread_checker = gevent.spawn(self.checkConnections) self.bytes_recv = 0 self.bytes_sent = 0 # Bittorrent style peerid self.peer_id = "-ZN0%s-%s" % (config.version.replace( ".", ""), CryptHash.random(12, "base64")) # Check msgpack version if msgpack.version[0] == 0 and msgpack.version[1] < 4: self.log.error( "Error: Unsupported msgpack version: %s (<0.4.0), please run `sudo apt-get install python-pip; sudo pip install msgpack-python --upgrade`" % str(msgpack.version)) sys.exit(0) if port: # Listen server on a port self.pool = Pool(1000) # do not accept more than 1000 connections self.stream_server = StreamServer((ip.replace("*", ""), port), self.handleIncomingConnection, spawn=self.pool, backlog=500) if request_handler: self.handleRequest = request_handler
def start_server(port): assert type(port) == int try: pool = Pool(256) server = StreamServer(('0.0.0.0', port), CacheProxy(Cache(cache_dir, **args)), spawn=pool) server.serve_forever() except Exception as e: print(e) server.close() del pool del server finally: server.close() del pool del server print("Closed Server")
def start(self): # Add the default hosts. for ip in self.config['CODEFIRE_WEB_IPS']: if (ip): self.__server_table[ip] = None # Initialize the control server control_listener = StreamServer( (self.config['NODE_PRIVATE_IP'], int(self.config['CONTROL_PORT'])), self.__control_handler) # Create and start all the Greenlets gevent.joinall([ gevent.spawn(self.__update_netload), gevent.spawn(self.__heartbeat_handler), gevent.spawn(control_listener.start), gevent.spawn(self.__heartbeat_dispatcher), ])
def test_login(self): """ Tries to login using the username/password as test/test. """ sessions = {} options = {'enabled': 'True', 'port': 0, 'users': {'test': 'test'}} cap = http.http(sessions, options, self.work_dir) srv = StreamServer(('0.0.0.0', 0), cap.handle_session) srv.start() client = httplib.HTTPConnection('127.0.0.1', srv.server_port) client.putrequest('GET', '/') client.putheader('Authorization', 'Basic ' + base64.b64encode('test:test')) client.endheaders() response = client.getresponse() self.assertEqual(response.status, 200) srv.stop()
def start(): MyMaster.set_worker_kwargs(pre_malloc_size=1024, client_send_interval=10) # pre_malloc_size: is not None, each worker will malloc some memory, # used for struct.pack_into method, this can avoid malloc memory in each sendall call. # default is None # client_send_interval: used for Limit the transmission rate. # if value is None, means no limits. # you should call self.check_interval() method in worker when you needs # default is None master = MyMaster(MyWorker, WorkersContainerDictType, dump_status_interval=600) # dump_status_interval: interval of log out how many clients have connected. secends master.start() s = StreamServer(('0.0.0.0', 8000), master.handle) s.serve_forever()
def __init__(self, host='127.0.0.1', port=31337, max_clients=1024, path='data', **storage_config): self._host = host self._port = port self._max_clients = max_clients self._pool = Pool(max_clients) self._server = StreamServer((self._host, self._port), self.connection_handler, spawn=self._pool) self._commands = self.get_commands() self._protocol = ProtocolHandler() self.storage = Storage(path, **storage_config)
def run(self): u"""启动RPC服务""" if not self.handler: raise ServerLoadError("Methods not exits.") logger.info( "Starting server at %s:%s" % (self.url.host, str(self.url.port)) ) self.handle_signal() server = StreamServer( (self.url.host, self.url.port), self.handler, spawn=self.limit ) self.register() server.serve_forever()
def serve(self): """Start a fixed number of worker threads and put client into a queue""" self.server = StreamServer(('', self.port), self.serveClient) # Temporary patch for gevent 0.13.x # Remove pre_start when we are fully on gevent 1.0 if gevent.version_info[0] == 0: self.server.pre_start() else: self.server.init_socket() print('Starting %s workers' % self.numWorkers) for i in range(self.numWorkers - 1): # Current process also serves p = Process(target=self.serve_forever) self.workers.append(p) p.start() self.serve_forever()
def daemons_greenlet(context): @monitored def handle(socket, address): sock_file = socket.makefile(mode='rwb') while True: req, daemon_info = pickle.load(sock_file) if req == b'RPC_SERVER': # if the remote end says 'server', we are client :) rpc_client_manager(daemon_info, context, sock_file) break elif req == b'RPC_CLIENT': # if the remote end says 'client', we are server :) rpc_server_manager(daemon_info, context, sock_file) break server = StreamServer(('0.0.0.0', conf.hub_port), handle) server.start() # wait for end or exception handle.catch_issues()
def test_login(self): """Testing different login combinations""" login_sequences = [ # invalid login, invalid password (('USER wakkwakk', '+OK User accepted'), ('PASS wakkwakk', '-ERR Authentication failed.')), # PASS without user ( ('PASS bond', '-ERR No username given.'), ), # Try to run a TRANSACITON state command in AUTHORIZATION state ( ('RETR', '-ERR Unknown command'), ), ] options = { 'port': 110, 'protocol_specific_data': { 'max_attempts': 3 }, 'users': { 'james': 'bond' } } sut = Pop3(options) server = StreamServer(('127.0.0.1', 0), sut.handle_session) server.start() for sequence in login_sequences: client = gevent.socket.create_connection( ('127.0.0.1', server.server_port)) fileobj = client.makefile() # skip banner fileobj.readline() for pair in sequence: client.sendall(pair[0] + "\r\n") response = fileobj.readline().rstrip() self.assertEqual(response, pair[1]) server.stop()
def workers_connector(): """ Connects and reconnects to other workers. """ while 1: try: for worker in xrange( state.worker + 1, WORKERS ): # Avoids racing when two workers connect each other at the same time. if worker in state.socks_by_workers: continue host, port_for_workers, _ = config['workers'][worker].split( ':') family = AF_UNIX if host == config['host'] else AF_INET addr = os.path.join(config['unix_sock_dir'], 'w{}'.format( worker)) if family == AF_UNIX else (host, port_for_workers) sock = socket.socket(family=family) try: sock.connect(addr) except Exception as e: log.debug('w{}: failed to connect to w{} at {}, error: {}'. format(state.worker, worker, addr, e)) sock.close() continue state.socks_by_workers[worker] = sock log.debug('w{}: connected to w{} at {}'.format( state.worker, worker, addr)) sock.sendall(config['workers'][state.worker] + '\n') spawn(on_worker_connected, sock, worker=worker) if len(state.socks_by_workers ) == WORKERS - 1 and not state.server_for_clients: state.server_for_clients = StreamServer( get_listener(config['port_for_clients']), on_client_connected) state.server_for_clients.start() except Exception: crit(also=dict(worker=state.worker)) time.sleep(config['block_seconds'])
def run(self): servers = [] ssl_args = {} for s in self.sockets: s.setblocking(1) pool = Pool(self.worker_connections) # TODO(benjamin): process handler hfun = partial(self.handler, s) server = StreamServer(s, handle=hfun, spawn=pool, **ssl_args) server.start() servers.append(server) while self.alive: self.notify() gevent.sleep(1.0) try: # Stop accepting requests for server in servers: server.close() # Handle current requests until graceful_timeout ts = time.time() while time.time() - ts <= self.config.GRACEFUL_TIMEOUT: accepting = 0 for server in servers: if server.pool.free_count() != server.pool.size: accepting += 1 # if no server is accepting a connection, we can exit if not accepting: return self.notify() gevent.sleep(1.0) # Force kill all active the handlers self.logger.warning("Worker graceful timeout (pid:%s)" % self.pid) [server.stop(timeout=1) for server in servers] except: pass
def main(args): serverqueue = gevent.queue.Queue() gevent.spawn(handleserver, serverqueue) def handleclient(socket, address): ipbytes = socket.recv(6) socket.close() if (len(ipbytes) == 6): listtype = 'whitelist' if ipbytes[0] == ord('w') else 'blacklist' action = 'add' if ipbytes[1] == ord('a') else 'remove' serverqueue.put((listtype, action, (ipbytes[2], ipbytes[3], ipbytes[4], ipbytes[5]))) server = StreamServer(('127.0.0.1', 9801), handleclient) try: server.serve_forever() except KeyboardInterrupt: removeallrules()
def test_connection(self): """ Tests if the capability is up, and sending HTTP 401 (Unauthorized) headers. """ sessions = {} # Use uncommon port so that you can run the test even if the Honeypot # is running. options = {'enabled': 'True', 'port': 0, 'users': {'test': 'test'}} cap = http.http(sessions, options, self.work_dir) srv = StreamServer(('0.0.0.0', 0), cap.handle_session) srv.start() client = httplib.HTTPConnection('127.0.0.1', srv.server_port) client.request('GET', '/') response = client.getresponse() self.assertEqual(response.status, 401) srv.stop()
def test_invalid_login(self): """Tests if telnet server responds correctly to a invalid login attempt.""" # curses dependency in the telnetserver need a STDOUT with file descriptor. sys.stdout = tempfile.TemporaryFile() # initialize capability and start tcp server options = { 'enabled': 'True', 'port': 2503, 'protocol_specific_data': { 'max_attempts': 3 }, 'users': { 'test': 'test' } } cap = telnet.Telnet(options, self.work_dir) server = StreamServer(('0.0.0.0', 2503), cap.handle_session) server.start() client = telnetlib.Telnet('localhost', 2503) # set this to 1 if having problems with this test client.set_debuglevel(0) # this disables all command negotiation. client.set_option_negotiation_callback(self.cb) #Expect username as first output reply = client.read_until('Username: '******'Username: '******'someuser' + '\r\n') reply = client.read_until('Password: '******'Password: '******'somepass' + '\r\n') reply = client.read_until('Invalid username/password\r\nUsername: '******'Invalid username/password\r\nUsername: ')) server.stop()
def __init__(self, host="127.0.0.1", port=4567, max_client=64): self._pool = Pool(max_client) self._server = StreamServer( (host, port), self.connect_handler, spawn=self._pool ) self._protocol = ProtocolHandler() self._kv = {} # Full redis command set is too large: https://redis.io/commands # Here just implement CRUD # Redis command example: https://redis.io/topics/protocol self.command_map = { "GET": self._get, #R "SET": self._set, #U & C "DELETE": self._delete, #D "MGET": self._mget, #batch get "MSET": self._mset, #batch set }
def startup(self): """ start the rpc server """ # if not self.handler: # raise ServerLoadError('Methods not exits.') self.handle_signal() pair = self.opts.address.url.split(":") server = StreamServer((pair[0], int(pair[1])), self.handle, backlog=self.opts.backlog, spawn=self.opts.max_conn_size) self.register() server.serve_forever() self.srv = server
def main(): print('Running on Python %s' % sys.version) config = configparser.ConfigParser() with open(INI_PATH) as f: config.read_file(f) ports = Ports(int(config['shared']['port_offset'])) try: wine64env = os.environ.copy() wine64env['WINEPREFIX'] = '/home/tribes/.wine64' udp_proxy_proc1 = sp.Popen('udpproxy.exe %d' % ports['gameserver1'], env=wine64env) udp_proxy_proc2 = sp.Popen('udpproxy.exe %d' % ports['gameserver2'], env=wine64env) except OSError as e: print( 'Failed to run udpproxy.exe. Run download_udpproxy.py to download it\n' 'or build it yourself using the Visual Studio solution in the udpproxy\n' 'subdirectory and place it in the taserver directory.\n', file=sys.stderr) return server_queue = gevent.queue.Queue() firewall = Firewall(ports) gevent_spawn('firewall.run', firewall.run, server_queue) def handle_client(socket, address): msg = TcpMessageReader(socket).receive() command = json.loads(msg.decode('utf8')) server_queue.put(command) server = StreamServer(('127.0.0.1', ports['firewall']), handle_client) try: server.serve_forever() except KeyboardInterrupt: firewall.remove_all_rules() udp_proxy_proc1.terminate() udp_proxy_proc2.terminate()
def main(): server = StreamServer(("127.0.0.1", 0), recvall) server.start() length = 50 * 0x100000 data = "x" * length spent_total = 0 N = 10 conn = socket.create_connection((server.server_host, server.server_port)) for i in range(N): start = time.time() conn.sendall(data) spent = time.time() - start print "%.2f MB/s" % (length / spent / 0x100000) spent_total += spent print "~ %.2f MB/s" % (length * N / spent_total / 0x100000) server.stop()
def test_login(self): """Testing different login combinations""" options = {'enabled': 'True', 'port': 0, 'banner': 'Test Banner', 'users': {'test': 'test'}, 'protocol_specific_data': {'max_attempts': 3, 'banner': 'test banner', 'syst_type': 'Test Type'}} ftp_capability = ftp.ftp(options) srv = StreamServer(('0.0.0.0', 0), ftp_capability.handle_session) srv.start() ftp_client = FTP() ftp_client.connect('127.0.0.1', srv.server_port, 1) # expect perm exception try: ftp_client.login('james', 'bond') response = ftp_client.getresp() # NOQA except ftplib.error_perm: pass srv.stop()
def _create(tag, address, func, max): ''' 创建一个tcp连接 :param address: 连接地址 :param func: 函数 :param max: 最大值 :return: ''' instance = StreamServer(address, func) instance.max_accept = max # 最大的连接数 instance.max_delay = 0.1 instance.start() TcpServerManager._servers[tag] = { "address": address, "max": max, "instance": instance, "status": True # 状态 } return True
def start_gevent(module, handler_class, my_process, addr, max_conn=1000, max_process=1): from gevent.pool import Pool from gevent.server import StreamServer from gevent.socket import wait_write, socket module.handler = handler_class() global service service = module pool = Pool(max_conn) server = StreamServer(addr, handle, spawn=pool) server.reuse_addr = 1 server.start() def server_start(): # do_trans_all_logger() log.info('server started addr=%s:%d pid=%d', addr[0], addr[1], os.getpid()) server.serve_forever() def _start_process(index): server_name = 'process%02d' % index process = multiprocessing.Process(target=server_start, name=server_name) process.start() return process # 创建工作进程 processes = [_start_process(index) for index in range(0, max_process)] for item in processes: my_process.append(item) #proc_process = processes # 等待所有的子进程结束 map(lambda p: p.join(), processes)
def bb_api(conn={}): xonn = { 'host': 'localhost', 'port': 7902, 'modname': 'alanapi', 'appname': 'cgi_api', 'npool': 100 } xonn.update(conn) #locals().update(xonn) global appfnc appfnc = import_from(xonn['modname'], xonn['appname']) # creates a new server server = StreamServer((xonn['host'], xonn['port']), handle, spawn=Pool(xonn['npool'])) # start accepting new connections server.start() server.serve_forever()
def listen_to_channel(port): # Returns a queue we can read from print 'Preparing server on %d...' % port q = Queue() def _handle(socket, address): while True: try: msglength, = struct.unpack('<I', goodrecv(socket, 4)) line = goodrecv(socket, msglength) except AssertionError: print 'Receive Failed!' return obj = decode(line) sender, payload = obj # TODO: authenticate sender using TLS certificate q.put((sender, payload)) server = StreamServer(('127.0.0.1', port), _handle) server.start() return q
def test_proxy_with_decoder(self): self.test_input = 'Hiya, this is a test'.encode('utf-8') mock_service = StreamServer(('127.0.0.1', 0), self.echo_server) gevent.spawn(mock_service.start) gevent.sleep(1) proxy = Proxy( 'proxy', '127.0.0.1', mock_service.server_port, decoder='conpot.protocols.misc.ascii_decoder.AsciiDecoder') server = proxy.get_server('127.0.0.1', 0) gevent.spawn(server.start) gevent.sleep(1) s = socket() s.connect(('127.0.0.1', server.server_port)) s.sendall(self.test_input) received = s.recv(len(self.test_input)) self.assertEqual(self.test_input, received) mock_service.stop(1)
def start(self, check_connections=True): self.running = True if check_connections: self.thread_checker = gevent.spawn(self.checkConnections) CryptConnection.manager.loadCerts() if config.tor != "disable": self.tor_manager.start() if not self.port: self.log.info("No port found, not binding") return False self.log.debug("Binding to: %s:%s, (msgpack: %s), supported crypt: %s" % ( self.ip, self.port, ".".join(map(str, msgpack.version)), CryptConnection.manager.crypt_supported )) try: self.stream_server = StreamServer( (self.ip, self.port), self.handleIncomingConnection, spawn=self.pool, backlog=100 ) except Exception, err: self.log.info("StreamServer create error: %s" % Debug.formatException(err))
def __init__(self, ip=config.fileserver_ip, port=config.fileserver_port, ip_type=config.fileserver_ip_type): self.site_manager = SiteManager.site_manager self.portchecker = PeerPortchecker.PeerPortchecker(self) self.log = logging.getLogger("FileServer") self.ip_type = ip_type self.ip_external_list = [] self.supported_ip_types = ["ipv4"] # Outgoing ip_type support if helper.getIpType(ip) == "ipv6" or self.isIpv6Supported(): self.supported_ip_types.append("ipv6") if ip_type == "ipv6" or (ip_type == "dual" and "ipv6" in self.supported_ip_types): ip = ip.replace("*", "::") else: ip = ip.replace("*", "0.0.0.0") if config.tor == "always": port = config.tor_hs_port config.fileserver_port = port elif port == 0: # Use random port port_range_from, port_range_to = map(int, config.fileserver_port_range.split("-")) port = self.getRandomPort(ip, port_range_from, port_range_to) config.fileserver_port = port if not port: raise Exception("Can't find bindable port") if not config.tor == "always": config.saveValue("fileserver_port", port) # Save random port value for next restart ConnectionServer.__init__(self, ip, port, self.handleRequest) self.log.debug("Supported IP types: %s" % self.supported_ip_types) if ip_type == "dual" and ip == "::": # Also bind to ipv4 addres in dual mode try: self.log.debug("Binding proxy to %s:%s" % ("::", self.port)) self.stream_server_proxy = StreamServer( ("0.0.0.0", self.port), self.handleIncomingConnection, spawn=self.pool, backlog=100 ) except Exception, err: self.log.info("StreamServer proxy create error: %s" % Debug.formatException(err))
def __init__(self, port=None, backend=None, backend_parameters=None, ssl_cert_path=None, ssl_key_path=None): self.port = port if self.port is None: self.port = DEFAULT_PORT if backend_parameters is None: backend_parameters = {} Backend = backends.get(backend) if Backend is None: raise ConfigurationException("The '%s' backend isn't supported" % backend) self.backend = Backend(**backend_parameters) if ssl_cert_path is None or ssl_key_path is None: raise ConfigurationException( "An SSL cert and key must be provided") self.pool = Pool(MAX_CONNECTIONS) log.debug("Starting server with SSL cert '%s' and key '%s'" % (ssl_cert_path, ssl_key_path)) self.server = StreamServer(('', self.port), self.handle_message, certfile=ssl_cert_path, keyfile=ssl_key_path, spawn=self.pool) log.info("%s serving on port %s" % (__fullversion__, self.port)) try: self.server.serve_forever() except KeyboardInterrupt: log.info("Stopping server...") self.server.stop() log.info("Server stopped")
def test_proxy_with_decoder(self): self.test_input = "Hiya, this is a test".encode("utf-8") mock_service = StreamServer(("127.0.0.1", 0), self.echo_server) gevent.spawn(mock_service.start) gevent.sleep(1) proxy = Proxy( "proxy", "127.0.0.1", mock_service.server_port, decoder="conpot.protocols.misc.ascii_decoder.AsciiDecoder", ) server = proxy.get_server("127.0.0.1", 0) gevent.spawn(server.start) gevent.sleep(1) s = socket() s.connect(("127.0.0.1", server.server_port)) s.sendall(self.test_input) received = s.recv(len(self.test_input)) self.assertEqual(self.test_input, received) mock_service.stop(1)