def start(argv):
"""
Analyze users options and run the malware string analyzer.
:param argv: Users options.
:type: List
:returns: True if msa success, False otherwise.
:rtype: Boolean
"""
opts = getopts(argv)
if opts == []:
exit_error()
selected_opts = {"path": None, "vt": None}
for opt, arg in opts:
if opt in ("-h", "--help"):
exit_error()
elif opt in ("-p", "--path"):
selected_opts["path"] = arg
elif opt in ("-v", "--vt"):
selected_opts["vt"] = arg
if selected_opts["path"] is None:
exit_error()
core = Core(selected_opts["path"], selected_opts["vt"])
if core.load_strings():
core.run()
else:
exit_error()
def UpPwn(argv):
opts = Opts(argv)
opts.initialize_options()
parsed_opts = opts.parse()
core = Core(parsed_opts)
core.run()
core.stop()
def __init__(self):
self.io = IO()
self.core = Core()
banner = self.io.readBanner()
args = self.io.getArguments()
salt = args.salt
if salt == None:
salt = DEFAULT_SALT
saltyBanner = self.core.addSalt(banner, salt)
print(saltyBanner)
def configure_pipeline(conffile):
from lib import inputs
from lib import outputs
LOG.info("Creating the pipeline")
with open(conffile) as f_in:
conf = yaml.load(f_in)
# Parse inputs
LOG.debug("Inputs:")
ins = []
outs = []
for i in conf["inputs"]:
LOG.debug("- %s (%s)", i["class"], i["name"])
new_in = inputs.Input.select(i["class"], i["name"],
i.get("options",
{}), conf["core"]["inbound"])
ins.append(new_in)
LOG.debug("Outputs:")
for o in conf.get("outputs", []):
LOG.debug("- %s (%s)", o["class"], o["name"])
new_out = outputs.Output.select(o["class"], o["name"],
o.get("options", {}),
conf["core"]["outbound"])
outs.append(new_out)
core = [Core(conf["core"]["inbound"], conf["core"]["outbound"])]
if conf.get("reactor", None) is not None:
# Import the Reactor only when used
from lib.reactor import Reactor
core.append(Reactor(conf["reactor"], conf["core"]["outbound"]))
if conf.get("db", None) is not None:
# Import DB here (hence also SQLAlchemy) only when needed
from lib.db import DB
core.append(DB(conf["db"], conf["core"]["outbound"]))
return (core, ins, outs)
def test_send(self, connection):
Core('10.0.0.3', 9998, False).send('foo')
connection.assert_called_with(ANY, '10.0.0.3', 9998)
def test_request(self, connection):
Core('10.0.0.2', 9999, False).request('foo')
connection.assert_called_with(ANY, '10.0.0.2', 9999)
VERSION = "0.3"
import sys
try:
import settings
except ImportError as e:
print("Error: unable to load 'settings.py': %s" % e)
sys.exit(1)
from lib.context import Context
from lib.core import Core
from lib.webserver import Webserver
from lib.log import get_logger
import logging
if __name__ == '__main__':
get_logger().event("main", "started")
logging.info(
"Yelena, version {version} starting ...".format(version=VERSION))
context = Context()
core = Core(context=context)
webserver = Webserver(core=core, context=context)
webserver.start()
core.start()
def create_app():
app = Flask(__name__)
Bootstrap(app)
nav = Nav()
nav.register_element(
'top',
Navbar(
View('Overview', 'overview'),
Subgroup('Groups', View('List Groups', 'list_group'),
View('Add Group', 'add_group')),
Subgroup('Servers', View('List Servers', 'list_server'),
View('Add Server', 'add_server')),
View('Ban', 'index'),
View('Users', 'index'),
))
nav.init_app(app)
# init varnish
varnish = Varnish()
# remove this please
core = Core('192.168.99.100', 'varnishmon', 'root', '123.')
# function for make response to charts
def makeResponse(r):
response = make_response(r)
response.content_type = 'application/json'
return response
# index content
@app.route('/')
def index():
return "ok"
@app.route('/overview', methods=['GET', 'POST'])
def overview():
if request.method == 'GET':
response = core.listGroup()
servers = core.listServer(1)
return render_template('overview.html',
groups=response,
servers=servers,
group_id=1)
else:
response = core.listGroup()
return redirect('/overview/' + request.form['group_id'])
@app.route('/overview/<group_id>', methods=['GET'])
def overview_select(group_id):
group_list = core.listGroup()
servers = core.listServer(group_id)
return render_template('overview.html',
groups=group_list,
servers=servers,
group_id=int(group_id))
@app.route('/add_group', methods=['GET', 'POST'])
def add_group():
if request.method == 'GET':
return render_template('addGroup.html')
else:
response = core.addGroup(request.form['name'])
return response
@app.route('/list_group')
def list_group():
response = core.listGroup()
return render_template('listGroup.html', groups=response)
@app.route('/add_server', methods=['GET', 'POST'])
def add_server():
if request.method == 'GET':
response = core.listGroup()
return render_template('addServer.html', groups=response)
else:
response = core.addServer(request.form['name'], request.form['ip'],
request.form['port'],
request.form['password'],
request.form['group'])
return response
@app.route('/list_server')
def list_server():
response = core.listServer()
return render_template('listServer.html', servers=response)
@app.route('/registered')
def registered():
return render_template('registeRed.html')
#
# response for charts data
#
@app.route('/live/hit/<group_id>')
def hit(group_id):
response = core.listServer(group_id)
v = varnish.only_hit_or_miss('hit', servers=response)
return makeResponse(v)
@app.route('/live/miss/<group_id>')
def miss(group_id):
response = core.listServer(group_id)
v = varnish.only_hit_or_miss('miss', servers=response)
return makeResponse(v)
@app.route('/live/client_req/<group_id>')
def client_req(group_id):
response = core.listServer(group_id)
v = varnish.client_req(servers=response)
return makeResponse(v)
@app.route('/live/health/<group_id>')
def health(group_id):
response = core.listServer(group_id)
v = varnish.health(servers=response)
return makeResponse(v)
return app
