import datetime import json import logging import uuid import numpy as np from model.sequence import Sequence from .request_builder import build_request from .runtime_dictionary import RuntimeDictionary from .normal_test_data_generator import RandomDataGenerator from utils.PayloadDataGenerator import PayloadDataGenerator from .util import resolve_json_value from model.reference_definition import ReferenceDefinition import requests import re logging.basicConfig(format='%(levelname)s:%(message)s', level=logging.INFO) class NpEncoder(json.JSONEncoder): def default(self, obj): if isinstance(obj, np.integer): return int(obj) elif isinstance(obj, np.floating): return float(obj) elif isinstance(obj, np.ndarray): return obj.tolist() else: return super(NpEncoder, self).default(obj) class RequestBodyType: JSON = "1" TEXT = "2" class ContentType: XFORM = "1" JSON = "2" class VariableGetterType: ALL = 1 KEY_VALUE = 2 JSON = 3 REG_EXPRESSION = 4 TEXT = 5 class mutationSequenceConverter: def __init__(self, runtime_dictionary: RuntimeDictionary): self.ref_prefix = "%{APIGen#" self.ref_suffix = "}" self.runtime_dictionary = runtime_dictionary self.seq_to_check = "post get" def get_date_time(self): now = datetime.datetime.now() date_time = now.strftime("%Y-%m-%d %H:%M:%S") return date_time def generate_random_parameter(self, index, method, sequence, ref_values): values = [] ref_dict = sequence.ref_vars.get(index, ReferenceDefinition([])) for param_name in method.request_parameters: parameter = method.request_parameters[param_name] generator = RandomDataGenerator(parameter, self.runtime_dictionary, ref_dict, ref_values, method) generated_value = generator.generate() values.append((parameter, generated_value)) url, params, data, headers, files, form_data = build_request(method, values) return url, params, data, headers, files, form_data def generate_mutation_parameter(self, index, method, sequence, ref_values): values = [] ref_dict = sequence.ref_vars.get(index, ReferenceDefinition([])) for param_name in method.request_parameters: parameter = method.request_parameters[param_name] generator = PayloadDataGenerator(parameter, self.runtime_dictionary, ref_dict, ref_values) generated_value = generator.generate() values.append((parameter, generated_value)) url, params, data, headers, files, form_data = build_request(method, values) return url, params, data, headers, files, form_data def extract_value(self, response): status_code = response["statusCode"] resolved_value = {} if status_code < 200 or status_code > 300: return resolved_value content = response["content"] if content is None or len(content) == 0: return resolved_value content = json.loads(content) resolve_json_value("", content, resolved_value) return resolved_value def check_header_validity(self, header): """Verifies that header value is a string which doesn't contain leading whitespace or return characters. This prevents unintended header injection. :param header: tuple, in the format (name, value). """ name, value = header # Moved outside of function to avoid recompile every call _CLEAN_HEADER_REGEX_BYTE = re.compile(b'^\\S[^\\r\\n]*$|^$') _CLEAN_HEADER_REGEX_STR = re.compile(r'^\S[^\r\n]*$|^$') if isinstance(value, bytes): pat = _CLEAN_HEADER_REGEX_BYTE else: pat = _CLEAN_HEADER_REGEX_STR try: if not pat.match(value): raise Exception("Invalid return character or leading space in header: %s" % name) except TypeError: raise Exception("Value for header {%s: %s} must be of type str or " "bytes, not %s" % (name, value, type(value))) def do_request(self, session, url, method, params, data, headers, files, form_data, pre_defined_headers): response = { "content": "", "apiName": method.method_name, "request": { "url": url, "method": method.method_type, "params": params, "data": data, "headers": headers, "files": files } } executed_method = getattr(session, method.method_type) try: for ind, key in enumerate(headers): self.check_header_validity((key, headers[key])) except Exception as ex: print(ex) headers = {} # add pre defined headers for k in pre_defined_headers.keys(): headers[k] = pre_defined_headers[k] # do request try: raw_response = executed_method(url, params=params, data=form_data, json=data, headers=headers, files=files, allow_redirects=False, timeout=3) except requests.exceptions.ReadTimeout as err: print(err) response["statusCode"] = 524 response["content"] = "Timeout Error" response["resolved_value"] = "None" except Exception as e: # probably an encoding error return None else: response["statusCode"] = raw_response.status_code response["content"] = raw_response.text try: resolved_value = self.extract_value(response) except: # returned value format not correct resolved_value = {} response["resolved_value"] = resolved_value return response def execute_request(self, fuzzer, session, method, url, params, data, headers, files, form_data, pre_defined_headers): request_url = fuzzer.server_address + url result = self.do_request(session, request_url, method, params, data, headers, files, form_data, pre_defined_headers) return result def execute_sequence(self, fuzzer, sequence: Sequence, mutation_index): result = [] session = requests.session() last_call_response = {} for i, method in enumerate(sequence.requests): if mutation_index == i: url, params, data, headers, files, form_data = self.generate_mutation_parameter(i, method, sequence, last_call_response) else: url, params, data, headers, files, form_data = self.generate_random_parameter(i, method, sequence, last_call_response) resp = self.execute_request(fuzzer, session, method, url, params, data, headers, files, form_data, fuzzer.pre_defined_headers) result.append(resp) last_call_response = resp["resolved_value"] return result def enumerate_sequence(self, fuzzer, sequence: Sequence, mutation_index): ''' The general idea of this function is to enumerate through all the possible fuzz-strings, instead of the random generation approach used in the previous methods. ''' result = [] session = requests.session() last_call_response = {} for i, method in enumerate(sequence.requests): if mutation_index == i: url, params, data, headers, files, form_data = self.generate_mutation_parameter(i, method, sequence, last_call_response) else: url, params, data, headers, files, form_data = self.generate_random_parameter(i, method, sequence, last_call_response) resp = self.execute_request(fuzzer, session, method, url, params, data, headers, files, form_data, fuzzer.pre_defined_headers) result.append(resp) last_call_response = resp["resolved_value"] return result