Python Reporter.write_passive方法代码示例

# 需要导入模块: from reporter import Reporter [as 别名]
# 或者: from reporter.Reporter import write_passive [as 别名]
class Scanner():
    logging.basicConfig(format='%(asctime)s %(levelname)-8s %(message)s')
    logger = logging.getLogger("Garmr-Scanner")
    logger.setLevel(logging.DEBUG)

    def __init__(self):
        self.resolve_target = True
        self.force_passives = False
        self._disabled_tests_ = []
        self._passive_tests_ = []
        self._active_tests_ = []
        self._finished_active_tests_ = []
        self._targets_ = []
        self._protos_ = ["http", "https"]
        Scanner.logger.debug("Scanner initialized.")
        self.reporter = Reporter()
        self.modules = []

    def do_passive_scan(self, passiveclass, is_ssl, response):
        if passiveclass.secure_only and not is_ssl:
            Scanner.logger.debug("\t\t[%s] Skip Test invalid for http scheme" % passiveclass)
            passive_result = PassiveTest().result("Skip", "This check is only applicable to SSL requests.", None)
            start = datetime.now()
            passive_result['start'] = start
            passive_result['end'] = start
            passive_result["duration"] = 0
        else:
            start = datetime.now()
            passive = passiveclass()
            passive_result = passive.analyze(response)
            end = datetime.now()
            td = end - start
            passive_result['start'] = start
            passive_result['end'] = end
            passive_result['duration'] = float((td.microseconds + (td.seconds + td.days * 24 * 3600) * 10**6)) / 10**6
            Scanner.logger.info("\t\t[%s] %s %s" % (passiveclass, passive_result['state'], passive_result['message']))
        return passive_result

    def do_active_scan(self, testclass, is_ssl, target):
        ''' instantiate the class and run it against the specified target, if applicable '''
        if (testclass.secure_only and not is_ssl):
            Scanner.logger.info("\t[Skip] [%s] (reason: secure_only)" % testclass)
            result = ActiveTest().result("Skip", "This check is only applicable to SSL requests", None)
            result['start'] = datetime.now()
            result['end'] = result['start']
            result['duration'] = 0
            return result
        elif (testclass.insecure_only and is_ssl):
            Scanner.logger.info("\t[Skip] [%s] (reason: insecure_only)" % testclass)
            result = ActiveTest().result("Skip", "This check is only applicable to SSL requests", None)
            result['start'] = datetime.now()
            result['end'] = result['start']
            result['duration'] = 0
            return result
        elif str(testclass).split('.')[-1] in self._disabled_tests_:
            Scanner.logger.info("\t[Skip] [%s] (reason: disabled)" % testclass)
            result = ActiveTest().result("Skip", "This check was marked as disabled.", None)
            result['start'] = datetime.now()
            result['end'] = result['start']
            result['duration'] = 0
            return result
        start = datetime.now()
        test = testclass() # from now on we have an instance of the class
        if "pred" in getargspec(test.do_test).args:
            # Check if class accepts this parameter. avoids rewriting.
            predecessor_key = "%s.%s" % (getmodule(self._finished_active_tests_[-1]).__name__, self._finished_active_tests_[-1].__name__)
            predecessor_results = self.results[predecessor_key]
            result, response = test.execute(target, predecessor=predecessor_results)
        else:
            result, response = test.execute(target)
        end = datetime.now()
        td = end - start
        result['response'] = response
        result['start'] = start
        result['end'] = end
        result['duration'] = float((td.microseconds + (td.seconds + td.days * 24 * 3600) * 10**6)) / 10**6
        Scanner.logger.info("\t[%s] %s %s" % (testclass, result['state'], result['message']))
        self.reporter.write_active(testclass, result)
        if (result['state'] == "Error"):
            Scanner.logger.error(result['data'])
        if response != None and test.run_passives:
            result['passive'] = {}
            self.reporter.start_passives()
            for passive_testclass in self._passive_tests_:
		passive_testclass_key = "%s.%s" % (getmodule(passive_testclass).__name__, passive_testclass.__name__)
                result["passive"][passive_testclass_key] = self.do_passive_scan(passive_testclass, is_ssl, response)
                self.reporter.write_passive(passive_testclass, result["passive"][passive_testclass_key])
            self.reporter.end_passives()
        return result

    def scan_target(self, target):
        ''' iterate over registered tests and deligate for scan '''
        self.reporter.write_target(target)
        Scanner.logger.info("[%s] scanning:" % target)
        url = urlparse(target)
        is_ssl = url.scheme == "https"
        self.results = {}
        self.reporter.start_actives()
        self.active_tests_stack = self._active_tests_
        while len(self.active_tests_stack) > 0:
#.........这里部分代码省略.........