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 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 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 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 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 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 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 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 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 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 __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 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_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 prompt_answer(self):
ans = Tpl.prompt(msg='fake')
return ans
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 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_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
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)
