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)
