def pause(self): """ ThreadPool pause :raise KeyboardInterrupt :return: None """ self.is_started = False tpl.info(key='stop_threads', threads=len(self.__workers)) try: while 0 < threading.active_count(): for worker in threading.enumerate(): if threading.current_thread().__class__.__name__ != '_MainThread': worker.pause() time.sleep(2) char = tpl.prompt(key='option_prompt') if char.lower() == 'e': raise KeyboardInterrupt elif char.lower() == 'c': self.resume() break else: continue except (SystemExit, KeyboardInterrupt): raise KeyboardInterrupt
def _add_urls(self, urllist): """ Add recieved urllist to threadpool :param dict urllist: read from dictionary :raise KeyboardInterrupt :return: None """ try: for url in urllist: if False is self.__is_ignored(url): self.__pool.add(self.__http_request, url) else: self.__catch_report_data('ignored', url) tpl.warning(key='ignored_item', current='{0:0{l}d}'.format( 0, l=len(str(abs( self.__reader.total_lines)))), total=self.__reader.total_lines, item=helper.parse_url(url).path) self.__pool.join() except (SystemExit, KeyboardInterrupt): raise KeyboardInterrupt
def banner(): """ Load application banner :raise PackageError :return: str """ try: banner = CoreConfig.get('banner').format( tpl.line('Directories: {0}'.format( Package.__directories_count()), color='blue'), tpl.line('Subdomains: {0}'.format( Package.__subdomains_count()), color='blue'), tpl.line('Browsers: {0}'.format(Package.__browsers_count()), color='blue'), tpl.line('Proxies: {0}'.format(Package.__proxies_count()), color='blue'), tpl.line(Package.__license(), color='blue')) return banner except (FileSystemError, CoreSystemError, PackageError) as error: raise PackageError(error)
def scan(self): """ Scanner :raise BrowserError :return: None """ self.__debug.debug_user_agents() self.__debug.debug_list(total_lines=self.__pool.total_items_size) try: # beginning scan process if True is self.__config.is_random_list: self.__reader.randomize_list(target=self.__config.scan, output='tmplist') tpl.info(key='scanning', host=self.__config.host) self.__start_request_provider() if True is self.__pool.is_started: self.__reader.get_lines(params={ 'host': self.__config.host, 'port': self.__config.port, 'scheme': self.__config.scheme }, loader=getattr(self, '_add_urls'.format())) except (ProxyRequestError, HttpRequestError, HttpsRequestError, ReaderError) as error: raise BrowserError(error)
def test_line_log_exception(self): """ Tpl.line_log() exception test """ undefined = 'undefined' with self.assertRaises(TplError) as context: Tpl.line_log(key=undefined) self.assertTrue(undefined in str(context.exception)) self.assertTrue(TplError == context.expected)
def terminate(cls, msg): """ Terminate thread :param str msg: output message :return: None """ tpl.error(msg) process.kill()
def debug_response(self, response_header): """ Debug response :param dict response_header: response header :return: bool """ tpl.debug(key='response_header_dbg', dbg=helper.to_json(response_header)) return True
def debug_load_sniffer_plugin(self, description): """ Debug load sniffers plugin :param str description: plugin description :return: bool """ tpl.debug(key='load_sniffer_plugin', description=description) return True
def resume(self): """ Resume threadpool :return: None """ if False is self.is_started: tpl.info(key='resume_threads') for worker in self.__workers: worker.resume() self.is_started = True
def debug_connection_pool(self, keymsg, pool): """ Debug connection pool message :param str keymsg: tpl key :param object pool: pool object :return: bool """ tpl.debug(key=keymsg) if pool: tpl.debug(str(pool)) return True
def __init__(self, Config): """ Debug constructor :param Config: Config """ self.__catched = False self.__clear = False self.__cfg = Config self.__level = self.__cfg.debug if 0 < self.__level: tpl.debug(key='debug', level=self.__cfg.debug, method=self.__cfg.method)
def debug_user_agents(self): """ Debug info for user agent :return: bool """ if 0 < self.__level: if True is self.__cfg.is_random_user_agent: tpl.debug(key='random_browser') else: tpl.debug(key='browser', browser=self.__cfg.user_agent) return True
def __init__(self, Config, total_lines): """ Filter constructor :param Config: Config :param int total_lines: num lines in list """ if Config.threads > Config.DEFAULT_MAX_THREADS or Config.threads > total_lines: max_threads = total_lines if Config.DEFAULT_MAX_THREADS > total_lines else Config.DEFAULT_MAX_THREADS tpl.warning(key='thread_limit', threads=Config.threads, max=max_threads) Config.set_threads(max_threads)
def ping(self): """ Check remote host for available :raise: BrowserError :return: None """ try: tpl.info(key='checking_connect', host=self.__config.host, port=self.__config.port) socket.ping(self.__config.host, self.__config.port, self.__config.DEFAULT_SOCKET_TIMEOUT) tpl.info(key='online', host=self.__config.host, port=self.__config.port, ip=socket.get_ip_address(self.__config.host)) except SocketError as error: raise BrowserError(error)
def debug_request(self, request_header, url, method): """ Debug request :param dict request_header: request header :param str url: request url :param str method: request method :return: bool """ request_header.update({'Request URI': url}) request_header.update({'Request Method': method}) tpl.debug(key='request_header_dbg', dbg=helper.to_json(request_header)) return True
def update(): """ Check for update :raise PackageError :return: str """ try: if False is sys().is_windows: status = process.execute(CoreConfig.get('command').get('cvsupdate')) upd_status = tpl.line(status, color='green') msg = CoreConfig.get('update').format(status=upd_status) else: msg = CoreConfig.get('update').format(status=tpl.line(key='upd_win_stat')) return msg except (AttributeError, CoreSystemError) as error: raise PackageError(error)
def update(): """ Check for update :raise PackageError :return: str """ try: if False is sys().is_windows: status = process.execute(Config.params.get('cvsupdate')) upd_status = tpl.line(status, color='green') msg = Config.params.get('update').format(status=upd_status) else: msg = Config.params.get('update').format(status=tpl.line(key='upd_win_stat')) return msg except (AttributeError, CoreSystemError) as error: raise PackageError(error)
def __current_version(): """ Get current application version :raise PackageError :return: str """ try: local = Package.local_version() remote = Package.__remote_version() if True is helper.is_less(local, remote): current_version = tpl.line(local, color='red') else: current_version = tpl.line(local, color='green') return current_version except (FileSystemError, CoreSystemError, PackageError) as error: raise PackageError(error)
def debug_request_uri(self, status, request_uri, **kwargs): """ Debug request_uri :param str status: response status :param str request_uri: http request uri :param mixed kwargs: :return: bool """ percentage = tpl.line( msg=helper.percent(kwargs.get('items_size', 0), kwargs.get('total_size', 1)), color='cyan') total_len = len(str(abs(kwargs.get('total_size', 1)))) if self.__cfg.DEFAULT_SCAN is self.__cfg.scan: urlpath = helper.parse_url(request_uri).path else: urlpath = request_uri if status in ['success', 'file', 'indexof', 'certificat', 'auth']: request_uri = tpl.line(key=status, color='green', url=urlpath) elif status in ['bad', 'forbidden']: request_uri = tpl.line(key='forbidden', color='yellow', url=urlpath) elif status in ['redirect']: request_uri = tpl.line(key='redirect', color='blue', url=urlpath, rurl=kwargs.get('redirect_uri')) self.__clear = True if self.__catched else False if status in ['success', 'file', 'bad', 'forbidden', 'redirect', 'indexof', 'certificat', 'auth']: sys.writels("", flush=True) tpl.info(key='get_item', clear=self.__clear, percent=percentage, current='{0:0{l}d}'.format(kwargs.get('items_size', 0), l=total_len), total=kwargs.get('total_size', 1), item=request_uri, size=kwargs.get('content_size') ) self.__catched = True else: tpl.line_log(key='get_item', percent=percentage, current='{0:0{l}d}'.format(kwargs.get('items_size', 0), l=total_len), total=kwargs.get('total_size', 1), item=request_uri, size=kwargs.get('content_size'), ) self.__catched = False if kwargs.get('items_size', 0) is kwargs.get('total_size', 1): sys.writels("", flush=True) return True
def debug_list(self, total_lines): """ Debug scan list :param int total_lines: list lines :return: bool """ if 0 < self.__level: if True is self.__cfg.is_random_list: tpl.debug(key='randomizing') if self.__cfg.DEFAULT_SCAN is self.__cfg.scan: if None is self.__cfg.extensions: tpl.debug(key='directories', total=total_lines) else: tpl.debug(key='ext_filter', total=total_lines, ext=', '.join(self.__cfg.extensions)) else: tpl.debug(key='subdomains', total=total_lines) tpl.debug(key='create_queue', threads=self.__cfg.threads) return True
def banner(): """ Load application banner :raise PackageError :return: str """ try: banner = CoreConfig.get('banner').format( tpl.line('Directories: {0}'.format(Package.__directories_count()), color='blue'), tpl.line('Subdomains: {0}'.format(Package.__subdomains_count()), color='blue'), tpl.line('Browsers: {0}'.format(Package.__browsers_count()), color='blue'), tpl.line('Proxies: {0}'.format(Package.__proxies_count()), color='blue'), tpl.line(Package.__license(), color='blue')) return banner except (FileSystemError, CoreSystemError, PackageError) as error: raise PackageError(error)
def _add_urls(self, urllist): """ Add received urllist to threadpool :param dict urllist: read from dictionary :raise KeyboardInterrupt :return: None """ try: for url in urllist: if False is self.__is_ignored(url): self.__pool.add(self.__http_request, url) else: self.__catch_report_data('ignored', url) tpl.warning( key='ignored_item', current='{0:0{l}d}'.format(0, l=len(str(abs(self.__reader.total_lines)))), total=self.__reader.total_lines, item=helper.parse_url(url).path ) self.__pool.join() except (SystemExit, KeyboardInterrupt): raise KeyboardInterrupt
def scan(self): """ Scanner :raise BrowserError :return: None """ self.__debug.debug_user_agents() self.__debug.debug_list(total_lines=self.__pool.total_items_size) try: # beginning scan process if True is self.__config.is_random_list: if self.__config.scan == self.__config.DEFAULT_SCAN: if True is self.__config.is_extension_filter: setattr(self.__config, 'scan', 'extensionlist') elif True is self.__config.is_ignore_extension_filter: setattr(self.__config, 'scan', 'ignore_extensionlist') self.__reader.randomize_list(target=self.__config.scan, output='tmplist') tpl.info(key='scanning', host=self.__config.host) self.__start_request_provider() if True is self.__pool.is_started: self.__reader.get_lines( params={ 'host': self.__config.host, 'port': self.__config.port, 'scheme': self.__config.scheme }, loader=getattr(self, '_add_urls'.format()) ) except (ProxyRequestError, HttpRequestError, HttpsRequestError, ReaderError) as error: raise BrowserError(error)
def debug_proxy_pool(self): """ Debug proxy pool message :return: bool """ if True is self.__cfg.is_external_torlist: tpl.debug(key='proxy_pool_external_start') elif True is self.__cfg.is_standalone_proxy: tpl.debug(key='proxy_pool_standalone', server=self.__cfg.proxy) elif True is self.__cfg.is_internal_torlist: tpl.debug(key='proxy_pool_internal_start') return True
def prompt_answer(self): ans = Tpl.prompt(msg='fake') return ans
def test_message(self): """ Tpl.message() test """ with patch('sys.stdout', new=StringIO()) as fakeOutput: Tpl.message('test_message') self.assertTrue('test_message' in fakeOutput.getvalue().strip())
def test_line_log(self): """ Tpl.line_log() test """ with patch('sys.stdout', new=StringIO()) as fakeOutput: Tpl.line_log('test_line_log') self.assertTrue('test_line_log' in fakeOutput.getvalue().strip())
def test_line_with_key(self): """ Tpl.line() test with key """ expected = Tpl.line(key='report', plugin='testplugin', dest='testdst') self.assertTrue('testplugin' in expected) self.assertTrue('testdst' in expected)
def test_line(self): """ Tpl.line() test """ expected = Tpl.line('test') self.assertTrue('test' in expected)
def test_cancel(self): """ Tpl.cancel() test """ with self.assertRaises(SystemExit) as context: Tpl.cancel(key='abort') self.assertTrue(SystemExit == context.expected)
def test_error(self): """ Tpl.error() test """ with patch('sys.stderr', new=StringIO()) as fakeOutput: Tpl.error('test_error') self.assertTrue('' in fakeOutput.getvalue().strip())
def debug_list(self, total_lines): """ Debug scan list :param int total_lines: list lines :return: bool """ if 0 < self.__level: if True is self.__cfg.is_random_list: tpl.debug(key='randomizing') if self.__cfg.DEFAULT_SCAN is self.__cfg.scan: if True is self.__cfg.is_extension_filter: tpl.debug(key='ext_filter', total=total_lines, ext=', '.join(self.__cfg.extensions)) elif True is self.__cfg.is_ignore_extension_filter: tpl.debug(key='ext_ignore_filter', total=total_lines, ext=', '.join(self.__cfg.ignore_extensions)) else: tpl.debug(key='directories', total=total_lines) else: tpl.debug(key='subdomains', total=total_lines) tpl.debug(key='create_queue', threads=self.__cfg.threads) return True