def setUp(self):
self.password = '******'
app.ensure_admin_password(True, password=self.password)
app.app.config['WTF_CSRF_ENABLED'] = False
self.work_dir = tempfile.mkdtemp()
beeswarm.shared.zmq_context = zmq.Context()
fd, self.db_file = tempfile.mkstemp()
os.close(fd)
connection_string = 'sqlite:///{0}'.format(self.db_file)
os.remove(self.db_file)
database.setup_db(connection_string)
self.config_actor = ConfigActor(
os.path.join(os.path.dirname(__file__), 'beeswarmcfg.json.test'),
self.work_dir)
self.config_actor.start()
# seed database with test data
session = database.get_session()
session.add_all([Client(), Honeypot()])
session.commit()
# startup session database
self.database_actor = DatabaseActor(999, delay_seconds=2)
self.database_actor.start()
self.app = app.app.test_client()
app.connect_sockets()
def setUp(self):
app.app.config["WTF_CSRF_ENABLED"] = False
self.work_dir = tempfile.mkdtemp()
self.config_actor = ConfigActor(os.path.join(os.path.dirname(__file__), "beeswarmcfg.json.test"), self.work_dir)
self.config_actor.start()
self.app = app.app.test_client()
self.authenticator = Authenticator()
database.setup_db("sqlite://")
session = database.get_session()
# dummy entities
self.authenticator.add_user("test", "test", 0)
self.client_id = str(uuid.uuid4())
self.client_password = str(uuid.uuid4())
self.authenticator.add_user(self.client_id, self.client_password, 2)
self.honeypot_id = str(uuid.uuid4())
self.honeypot_password = str(uuid.uuid4())
self.authenticator.add_user(self.honeypot_id, self.honeypot_password, 1)
session.add_all(
[
Client(id=self.client_id, configuration="test_client_config"),
Honeypot(id=self.honeypot_id, configuration="test_honeypot_config"),
]
)
session.commit()
def setUp(self):
beeswarm.shared.zmq_context = zmq.Context()
fd, self.db_file = tempfile.mkstemp()
os.close(fd)
connection_string = 'sqlite:///{0}'.format(self.db_file)
os.remove(self.db_file)
database_setup.setup_db(connection_string)
def setUp(self):
self.password = '******'
app.ensure_admin_password(True, password=self.password)
app.app.config['WTF_CSRF_ENABLED'] = False
self.work_dir = tempfile.mkdtemp()
beeswarm.shared.zmq_context = zmq.Context()
fd, self.db_file = tempfile.mkstemp()
os.close(fd)
connection_string = 'sqlite:///{0}'.format(self.db_file)
os.remove(self.db_file)
database.setup_db(connection_string)
self.config_actor = ConfigActor(os.path.join(os.path.dirname(__file__), 'beeswarmcfg.json.test'), self.work_dir)
self.config_actor.start()
# seed database with test data
session = database.get_session()
session.add_all([Client(), Honeypot()])
session.commit()
# startup session database
self.database_actor = DatabaseActor(999, delay_seconds=2)
self.database_actor.start()
self.app = app.app.test_client()
app.connect_sockets()
def setUp(self):
beeswarm.shared.zmq_context = zmq.Context()
fd, self.db_file = tempfile.mkstemp()
os.close(fd)
connection_string = 'sqlite:///{0}'.format(self.db_file)
os.remove(self.db_file)
database_setup.setup_db(connection_string)
def setUp(self):
app.app.config['WTF_CSRF_ENABLED'] = False
self.work_dir = tempfile.mkdtemp()
self.config_actor = ConfigActor(
os.path.join(os.path.dirname(__file__), 'beeswarmcfg.json.test'),
self.work_dir)
self.config_actor.start()
self.app = app.app.test_client()
self.authenticator = Authenticator()
database.setup_db('sqlite://')
session = database.get_session()
# dummy entities
self.authenticator.add_user('test', 'test', 0)
self.client_id = str(uuid.uuid4())
self.client_password = str(uuid.uuid4())
self.authenticator.add_user(self.client_id, self.client_password, 2)
self.honeypot_id = str(uuid.uuid4())
self.honeypot_password = str(uuid.uuid4())
self.authenticator.add_user(self.honeypot_id, self.honeypot_password,
1)
session.add_all([
Client(id=self.client_id, configuration='test_client_config'),
Honeypot(id=self.honeypot_id, configuration='test_honeypot_config')
])
session.commit()
def __init__(self, work_dir, config, **kwargs):
"""
Main class for the Web-Interface. It takes care of setting up
the database, managing the users, etc.
:param work_dir: The working directory (usually the current working directory).
:param config_arg: Beeswarm configuration dictionary, None if not configuration was supplied.
"""
customize = kwargs['customize']
reset_password = kwargs['reset_password']
if 'clear_db' in kwargs:
clear_sessions = kwargs['clear_db']
else:
clear_sessions = True
self.work_dir = work_dir
self.config_file = 'beeswarmcfg.json'
if config is None:
Server.prepare_environment(work_dir, customize)
with open(os.path.join(work_dir, self.config_file),
'r') as config_file:
self.config = json.load(config_file, object_hook=asciify)
else:
self.config = config
# list of all self-running (actor) objects that receive or send
# messages on one or more zmq queues
self.actors = []
gevent.spawn(self.message_proxy, work_dir)
config_actor = ConfigActor(self.config_file, work_dir)
config_actor.start()
self.actors.append(config_actor)
database_setup.setup_db(
os.path.join(self.config['sql']['connection_string']))
persistanceActor = SessionPersister(clear_sessions)
persistanceActor.start()
self.actors.append(persistanceActor)
gevent.sleep()
self.workers = {}
self.greenlets = []
self.started = False
from beeswarm.server.webapp import app
self.app = app.app
self.app.config['CERT_PATH'] = self.config['ssl']['certpath']
self.authenticator = Authenticator()
self.authenticator.ensure_default_user(reset_password)
def __init__(self, work_dir, config, **kwargs):
"""
Main class for the Web-Interface. It takes care of setting up
the database, managing the users, etc.
:param work_dir: The working directory (usually the current working directory).
:param config_arg: Beeswarm configuration dictionary, None if not configuration was supplied.
"""
customize = kwargs['customize']
reset_password = kwargs['reset_password']
if 'clear_db' in kwargs:
clear_sessions = kwargs['clear_db']
else:
clear_sessions = True
self.work_dir = work_dir
self.config_file = 'beeswarmcfg.json'
if config is None:
Server.prepare_environment(work_dir, customize)
with open(os.path.join(work_dir, self.config_file), 'r') as config_file:
self.config = json.load(config_file, object_hook=asciify)
else:
self.config = config
# list of all self-running (actor) objects that receive or send
# messages on one or more zmq queues
self.actors = []
gevent.spawn(self.message_proxy, work_dir)
config_actor = ConfigActor(self.config_file, work_dir)
config_actor.start()
self.actors.append(config_actor)
database_setup.setup_db(os.path.join(self.config['sql']['connection_string']))
persistanceActor = SessionPersister(clear_sessions)
persistanceActor.start()
self.actors.append(persistanceActor)
gevent.sleep()
self.workers = {}
self.greenlets = []
self.started = False
from beeswarm.server.webapp import app
self.app = app.app
self.app.config['CERT_PATH'] = self.config['ssl']['certpath']
self.authenticator = Authenticator()
self.authenticator.ensure_default_user(reset_password)
def __init__(self, work_dir, config, curses_screen=None, **kwargs):
"""
Main class for the Web-Interface. It takes care of setting up
the database, managing the users, etc.
:param work_dir: The working directory (usually the current working directory).
:param config_arg: Beeswarm configuration dictionary, None if not configuration was supplied.
:param curses_screen: This parameter is to maintain a similar interface for
all the modes. It is ignored for the Server.
"""
customize = kwargs['customize']
if config is None:
Server.prepare_environment(work_dir, customize)
with open(os.path.join(work_dir, 'beeswarmcfg.json'), 'r') as config_file:
config = json.load(config_file, object_hook=asciify)
self.work_dir = work_dir
self.config = config
self.config_file = 'beeswarmcfg.json'
self.actors = []
config_actor = ConfigActor('beeswarmcfg.json', work_dir)
config_actor.start()
self.actors.append(config_actor)
self.workers = {}
self.greenlets = []
self.started = False
database_setup.setup_db(os.path.join(self.config['sql']['connection_string']))
self.app = app.app
self.app.config['CERT_PATH'] = self.config['ssl']['certpath']
self.app.config['SERVER_CONFIG'] = 'beeswarmcfg.json'
self.authenticator = Authenticator()
self.authenticator.ensure_default_user()
gevent.spawn(self.message_proxy, work_dir)
persistanceWorker = PersistanceWorker()
gevent.spawn(persistanceWorker.start)
gevent.sleep()
source_port=random.randint(1024, 65535),
destination_ip='4.3.2.1',
destination_port='1111')
session.protocol, session.destination_port = random.choice(protocols)
session.honeypot = random.choice(honeypots)
session.classification = db_session.query(Classification).filter(
Classification.type == 'credentials_reuse').one()
username = ''.join(random.choice(string.lowercase) for x in range(8))
password = ''.join(random.choice(string.lowercase) for x in range(8))
authentication = Authentication(id=str(uuid.uuid4()),
username=username,
password=password)
session.authentication.append(authentication)
authentications.append(authentication)
sessions.append(session)
db_session.add_all(authentications)
db_session.add_all(sessions)
db_session.add_all(honeypots)
db_session.add_all(client)
db_session.commit()
if __name__ == '__main__':
database_setup.setup_db('sqlite:///beeswarm_sqlite.db')
fill_dummy_data()
def __init__(self, work_dir, config, **kwargs):
"""
Main class for the Web-Interface. It takes care of setting up
the database, managing the users, etc.
:param work_dir: The working directory (usually the current working directory).
:param config_arg: Beeswarm configuration dictionary, None if not configuration was supplied.
"""
customize = kwargs['customize']
reset_password = kwargs['reset_password']
if 'clear_db' in kwargs:
clear_sessions = kwargs['clear_db']
else:
clear_sessions = True
if 'server_hostname' in kwargs:
server_hostname = kwargs['server_hostname']
else:
server_hostname = None
max_sessions = kwargs['max_sessions']
start_webui = kwargs['start_webui']
self.work_dir = work_dir
self.config_file = os.path.join(work_dir, 'beeswarmcfg.json')
if config is None:
self.prepare_environment(work_dir,
customize,
server_hostname=server_hostname)
with open(os.path.join(work_dir, self.config_file),
'r') as config_file:
self.config = json.load(config_file, object_hook=asciify)
else:
self.config = config
# list of all self-running (actor) objects that receive or send
# messages on one or more zmq queues
self.actors = []
self.greenlets = []
proxy_greenlet = gevent.spawn(self.message_proxy, work_dir)
self.greenlets.append(proxy_greenlet)
config_actor = ConfigActor(self.config_file, work_dir)
config_actor.start()
self.actors.append(config_actor)
self.greenlets.append(config_actor)
# make path in sqlite connection string absolute
connection_string = self.config['sql']['connection_string']
if connection_string.startswith('sqlite:///'):
_, relative_path = os.path.split(connection_string)
connection_string = 'sqlite:///{0}'.format(
os.path.join(self.work_dir, relative_path))
database_setup.setup_db(connection_string)
database_actor = DatabaseActor(max_sessions, clear_sessions)
database_actor.start()
self.actors.append(database_actor)
self.greenlets.append(database_actor)
for g in self.greenlets:
g.link_exception(self.on_exception)
gevent.sleep()
self.started = False
if start_webui:
from beeswarm.server.webapp import app
self.app = app.app
self.app.config['CERT_PATH'] = self.config['ssl']['certpath']
app.ensure_admin_password(reset_password)
else:
self.app = None
def __init__(self, work_dir, config, **kwargs):
"""
Main class for the Web-Interface. It takes care of setting up
the database, managing the users, etc.
:param work_dir: The working directory (usually the current working directory).
:param config_arg: Beeswarm configuration dictionary, None if not configuration was supplied.
"""
customize = kwargs['customize']
reset_password = kwargs['reset_password']
if 'clear_db' in kwargs:
clear_sessions = kwargs['clear_db']
else:
clear_sessions = True
if 'server_hostname' in kwargs:
server_hostname = kwargs['server_hostname']
else:
server_hostname = None
max_sessions = kwargs['max_sessions']
start_webui = kwargs['start_webui']
self.work_dir = work_dir
self.config_file = os.path.join(work_dir, 'beeswarmcfg.json')
if config is None:
self.prepare_environment(work_dir, customize, server_hostname=server_hostname)
with open(os.path.join(work_dir, self.config_file), 'r') as config_file:
self.config = json.load(config_file, object_hook=asciify)
else:
self.config = config
# list of all self-running (actor) objects that receive or send
# messages on one or more zmq queues
self.actors = []
self.greenlets = []
proxy_greenlet = gevent.spawn(self.message_proxy, work_dir)
self.greenlets.append(proxy_greenlet)
config_actor = ConfigActor(self.config_file, work_dir)
config_actor.start()
self.actors.append(config_actor)
self.greenlets.append(config_actor)
# make path in sqlite connection string absolute
connection_string = self.config['sql']['connection_string']
if connection_string.startswith('sqlite:///'):
_, relative_path = os.path.split(connection_string)
connection_string = 'sqlite:///{0}'.format(os.path.join(self.work_dir, relative_path))
database_setup.setup_db(connection_string)
database_actor = DatabaseActor(max_sessions, clear_sessions)
database_actor.start()
self.actors.append(database_actor)
self.greenlets.append(database_actor)
for g in self.greenlets:
g.link_exception(self.on_exception)
gevent.sleep()
self.started = False
if start_webui:
from beeswarm.server.webapp import app
self.app = app.app
self.app.config['CERT_PATH'] = self.config['ssl']['certpath']
app.ensure_admin_password(reset_password)
else:
self.app = None
while len(sessions) < 200:
session = Session(id=str(uuid.uuid4()), timestamp=datetime.now(),
source_ip=random.choice(source_ips), source_port=random.randint(1024, 65535),
destination_ip='4.3.2.1', destination_port='1111')
session.protocol, session.destination_port = random.choice(protocols)
session.honeypot = random.choice(honeypots)
session.classification = db_session.query(Classification).filter(
Classification.type == 'credentials_reuse').one()
username = ''.join(random.choice(string.lowercase) for x in range(8))
password = ''.join(random.choice(string.lowercase) for x in range(8))
authentication = Authentication(id=str(uuid.uuid4()), username=username, password=password)
session.authentication.append(authentication)
authentications.append(authentication)
sessions.append(session)
db_session.add_all(authentications)
db_session.add_all(sessions)
db_session.add_all(honeypots)
db_session.add_all(client)
db_session.commit()
if __name__ == '__main__':
database_setup.setup_db('sqlite:///beeswarm_sqlite.db')
fill_dummy_data()
