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 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 __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 UpPwn(argv):
opts = Opts(argv)
opts.initialize_options()
parsed_opts = opts.parse()
core = Core(parsed_opts)
core.run()
core.stop()
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()
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 __init__(self, api_version=Core.Api.RPC_LITERAL_UNBRANDED):
self.api_client = Suds(api_version)
self.api_translator = Translator(self)
self.api_core = Core(self)
self.register_helpers()
class PureResponseClient(object):
version = '1.2.7'
api_client = None
api_account_level = None
api_core = None
api_translator = None
encoding_exceptions = [Core.Entity.ID,
Core.Message.ID,
Core.List.ID,
Core.Api.USERNAME,
Core.Api.PASSWORD]
class AccountLevel:
LITE = 10
PRO = 20
EXPERT = 40
def __init__(self, api_version=Core.Api.RPC_LITERAL_UNBRANDED):
self.api_client = Suds(api_version)
self.api_translator = Translator(self)
self.api_core = Core(self)
self.register_helpers()
def authenticate(self, api_username=None, api_password=None, api_account_level=AccountLevel.LITE):
"""
Authenticates a username and password against the PureResponse API,
must be done before making all other API calls.
------------------------------------------------
@param api_username - username of account from which to make api calls
@param api_password - password of that same account
@param [api_account_level] - your api account level indicates how many custom
fields you are allowed to use in contact lists
if you indicate a level higher than that of your
account a pyresponse.Core.StoreErrors will be raised
when your actual limit is met
going over the limit indicated by this parameter will
raise a pyresponse.Translator.AccountLevelError in
those same cases
pyresponse.AccountLevel.LITE offers 10 custom fields
pyresponse.AccountLevel.PRO offers 20 custom fields
pyresponse.AccountLevel.EXPERT offers 40 custom fields
@return - bean id for a context bean in pureresponse, will be
used to identify the API session
"""
self.api_account_level = api_account_level
if (not api_username) or (not api_password):
message = ('Invalid authentication details: api_username=%s, api_password=%s' %
(api_username, api_password))
raise Core.AuthenticationException(message)
return self.api_core.authenticate(api_username, api_password)
def invalidate(self):
"""
Clears authentication credentials, makes a logout call
to PureResponse. Follow-on calls will fail before calling
as a result of lacking an api context id (Core.context_id).
------------------------------------------------
"""
self.api_core.invalidate()
def register_helpers(self):
"""
Gives access to classes and methods from ./lib/helpers.py and
./lib/core.py from pyresponse.py, making the code a litle easier
to maintain. Separates public facing interfaces from those mainly
intended for internal use.
------------------------------------------------
"""
for key, value in Helpers.__dict__.iteritems():
if callable(value):
setattr(self, key, types.MethodType(value, self))
for key, value in Core.__dict__.iteritems():
if isinstance(value, (type, types.ClassType)):
setattr(self, key, value)
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
def __init__(self):
cmd.Cmd.__init__(self)
Core.__init__(self)
self.prompt = "[*]探测装置->"
self.name = "sniff"
self.start_status = False
from lib.core import Core
Core.split("./test/test.png", "./test/split", 1, "splited_")
