def __init__(self,
name=str,
host=str,
port=int,
max_retries=10,
timeout=None,
logger=None,
pb2_module=None) -> None:
"""
Class creates the protobuf payload with the marriage of Fuzzed data.
:param name: name of the class
:param host: target host
:param port: target port
:param max_retries: maximum retries of connection
:param timeout: timeout
:param logger: kitty logger
"""
super(ProtobufTarget, self).__init__(name, logger)
self.host = host
self.port = port
if (host is None) or (port is None):
raise ValueError('Host and port may not be None')
self.timeout = timeout
self.socket = None
self.max_retries = max_retries
self.pb2_module = pb2_module
self.set_expect_response(False)
self.config = ConfigParser()
self.verbosity = self.config.get_generic_verbosity()
self.logger.setLevel(self.verbosity)
self.module_path = self.config.get_module_path()
self._uuid = GenerateUUID.generate_uuid()
self.frmwrk_utils = FrameworkUtils()
def __init__(self,
name,
host,
port,
max_retries=10,
timeout=None,
logger=None) -> object:
"""
:param name: name of the target
:param host: host ip (to send data to) currently unused
:param port: port to send to
:param max_retries: maximum connection retries (default: 10)
:param timeout: socket timeout (default: None)
:param logger: logger for the object (default: None)
"""
super(HttpTarget, self).__init__(name, logger)
self.host = host
self.port = port
if (host is None) or (port is None):
raise ValueError('host and port may not be None')
self.timeout = timeout
self.socket = None
self.max_retries = max_retries
self.config = ConfigParser()
self.use_tls = self.config.get_tls()
self.target_host = self.config.get_target_host_name()
self.report = Report('report')
self._uuid = GenerateUUID.generate_uuid()
def __init__(self, name, host, port, timeout=None, logger=None):
"""
:param name: name of the target
:param host: host ip (to send data to) currently unused
:param port: port to send to
:param timeout: socket timeout (default: None)
:param logger: logger for the object (default: None)
"""
super(DnsTarget, self).__init__(name, logger)
self.host = host
self.port = port
if (host is None) or (port is None):
raise ValueError('Host and port may not be None!')
self.timeout = timeout
self.socket = None
self.bind_host = None
self.bind_port = None
self.expect_response = False
self.config = ConfigParser()
self.dns_a_record_status = self.config.get_dns_a_record_status()
self.dns_ns_record_status = self.config.get_dns_ns_record_status()
self.dns_txt_record_status = self.config.get_dns_txt_record_status()
self.verbosity = self.config.get_generic_verbosity()
self.logger.setLevel(self.verbosity)
self._uuid = GenerateUUID.generate_uuid()
self.question_length = None
def __init__(self, name='FrameworkUtils', logger=None):
"""
Constructor of utils
:type name of the object: object
"""
super(FrameworkUtils, self).__init__(name, logger)
self.logger = FuzzObject.get_logger()
self._uuid = GenerateUUID.generate_uuid()
def test_08_archive_locally(self):
dir_exists = False
self.framework_utils.archive_locally()
self._uuid = GenerateUUID.generate_uuid()
dir_ = str(self._uuid) + '-log'
if os.path.exists(os.getcwd() + '/' + dir_):
dir_exists = True
self.assertTrue(dir_exists, True)
def test_05_rename_log_file(self):
self._uuid = GenerateUUID.generate_uuid()
self.framework_utils.rename_log_file()
file_name = glob.glob(os.getcwd() + '/kittylogs/' +
'*.log')[0].split('/')[-1:]
expected_file_name = str(
self._uuid) + '-kitty_' + time.strftime("%Y%m%d-%H%M%S") + '.log'
shutil.rmtree(os.getcwd() + '/kittylogs/', ignore_errors=True)
self.assertAlmostEqual(file_name[0], expected_file_name)
def __init__(self, name='HttpRunner', logger=None) -> object:
"""
HttpRunner constructor
:param name: the name of the class
:param logger: logger from the framework
"""
super(HttpRunner, self).__init__(name, logger)
self.config = ConfigParser()
self.target_host = self.config.get_target_host_name()
self.target_port = self.config.get_target_port()
self.http_get = self.config.get_http_get_method()
self.http_post_put = self.config.get_http_post_put_method()
self.http_post_update = self.config.get_http_post_update_method()
self.http_delete = self.config.get_http_delete_method()
self.http_fuzz_protocol = self.config.get_http_fuzz_protocol()
self.http_path = self.config.get_http_path()
self.http_content_type = self.config.get_http_content_type()
self.http_payload = self.config.get_http_payload()
self.gen_uuid = GenerateUUID.generate_uuid()
def __init__(self, name='CreateReport', logger=None):
super(CreateReport, self).__init__(name, logger)
self._uuid = GenerateUUID.generate_uuid()
self.files_to_report = None
def __init__(self, name='PutArchiveToS3', logger=None):
super(PutArchiveToS3, self).__init__(name, logger)
self._uuid = GenerateUUID.generate_uuid()
self.region = 'eu-central-1'
self.s3_resource = boto3.resource('s3')
self.s3_connection = self.s3_resource.meta.client
class FuzzObject:
"""
Basic class to define specific logging independently from Kitty
for the fuzzer_framework
"""
_logger = None
_uuid = GenerateUUID.generate_uuid()
log_file_name = './fuzzer_logs/%s-frmwrk_%s.log' % (str(_uuid), time.strftime("%Y%m%d-%H%M%S"),)
@classmethod
def get_logger(cls) -> object:
"""
:return: the class logger
"""
if FuzzObject._logger is None:
logger = logging.getLogger('fuzzer')
logger.setLevel(logging.INFO)
consolehandler = logging.StreamHandler()
console_format = logging.Formatter('[%(levelname)-1s] [%(asctime)s] [%(filename)s:%(lineno)s] '
'[%(funcName)s] %(message)s')
consolehandler.setFormatter(console_format)
logger.addHandler(consolehandler)
if not os.path.exists('./fuzzer_logs/'):
os.mkdir('./fuzzer_logs')
filehandler = logging.FileHandler(FuzzObject.log_file_name)
file_format = console_format
filehandler.setFormatter(file_format)
logger.addHandler(filehandler)
FuzzObject._logger = logger
return FuzzObject._logger
@classmethod
def get_log_file_name(cls) -> object:
"""
Get the logger file name.
:return: object
"""
return FuzzObject.get_log_file_name()
@classmethod
def set_verbosity(cls, verbosity):
"""
:param verbosity: the level of the verbosity DEBUG, INFO
:rtype: object
"""
# TODO extend point 02: implement WARNING, CRITICAL
if verbosity > 0:
logger = FuzzObject.get_logger()
levels = [logging.DEBUG]
verbosity = min(verbosity, len(levels)) - 1
logger.setLevel(levels[verbosity])
def __init__(self, name, logger=None):
"""
:type logger: object
"""
self.name = name
if logger:
self.logger = logger
else:
self.logger = FuzzObject.get_logger()
def get_description(self):
"""
:rtype: str
:return: the description of the object. by default only prints the object type.
"""
return type(self).__name__
def get_name(self):
"""
:rtype: str
:return: object's name
"""
return self.name