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_")