import json import time import uuid from datetime import datetime import numpy as np import requests from model.operation_dependency_graph import OperationDependencyGraph from validator.validator_huawei import validate from .huawei_converter import HuaWeiConverter from .runtime_dictionary import RuntimeDictionary class APIFuzzer: def __init__(self, apis=[], specification={}, odg: OperationDependencyGraph = OperationDependencyGraph(), time_budget=10): self.runtime_dict = RuntimeDictionary() self.apis = apis self.base_path = specification.get("basePath", "") self.server_address = "https://10.162.187.212:32018" self.protocol = "HTTPS" self.sequences = odg.generate_sequence() self.specification = specification self.start_time = time.time() # for test case limit time self.time_limit = 2000 self.end_time = self.start_time + time_budget self.seed_id = uuid.uuid4().__str__() self.sequence_id = uuid.uuid4().__str__() self.iteration_id = 0 self.request_count = 0 self.response_count = 0 self.violations = set() self.error_sequence = [] self.pending_request = {} self.pending_sequence = {} self.pending_add_sequence = set() self.pending_remove_sequence = set() self.pending_test_sequence_to_remove = set() self.status_code_status = {} self.time_budget = 300 self.send_msg_count = 0 self.receive_msg_count = 0 self.success_sequence_count = 0 self.success_apis = set() self.error_apis = set() self.total_apis = set() self.success_sequence = set() self.begin = time.time() self.success_sequence_output = [] self.api_curve = [{ "time": 0, 'count': 0 }] def send_testcase(self, seq): request_api = "http://apitestgenexe.cd-cloud-test.gamma-y.dragon.tools.huawei.com/v1/request_flow" resp = requests.post(request_api, json=seq) # mandatory check for service assert resp.status_code == 200 def run(self): init_listener() # Collect All API for api in self.apis: for method in api.methods: self.total_apis.add(method) huawei_converter = HuaWeiConverter(self.runtime_dict) self.begin = time.time() begin = self.begin time_budget = self.time_budget while time.time() - begin < time_budget: for sequence in self.sequences: seq = huawei_converter.convert_sequence(self, sequence) self.send_testcase(seq) self.request_count += len(seq["sceneApis"]) sequence_id = seq["sequenceID"] self.pending_request[sequence_id] = seq self.pending_sequence[sequence_id] = sequence self.send_msg_count += 1 # self.process_response() self.iteration_id += 1 # remove test sequence self.sequences = self.sequences.difference(self.pending_test_sequence_to_remove) self.pending_test_sequence_to_remove = set() # remove sequences self.sequences = self.sequences.difference(self.pending_remove_sequence) self.success_sequence = self.success_sequence.union(self.pending_remove_sequence) self.pending_remove_sequence = set() # add sequences self.sequences = self.sequences.union(self.pending_add_sequence) self.pending_add_sequence = set() # analyze dependency to add self.analyze_dependency_to_add() break print('current seq') for seq in self.sequences: print(seq.to_str()) # print('\n runtime dictionary') # for signature in self.runtime_dict.signature_to_value.keys(): # print(signature) # FIXME: consuming current response while self.response_count != self.request_count: self.process_response() break self.write_result() terminate_listener() def write_result(self): with open('errors.json', 'w') as data: json.dump({"result": self.error_sequence}, data) with open('success_resource_merging.json', 'w') as data: json.dump({"result": self.success_sequence_output}, data) with open('runtime.json', 'w') as data: json.dump({ 'keys': list(self.runtime_dict.signature_to_value.keys()) }, data) def analyze_dependency_to_add(self): res = set() if len(self.sequences) > len(self.apis): return success_sequences = list(self.success_sequence) np.random.shuffle(success_sequences) for sequence in self.sequences: if len(sequence) > 1: continue request_nominal_parameters = sequence.get_request_parameter_by_index(0) response_nominal_runtime_parameters = self.runtime_dict.signature_to_value.keys() matched_methods = {} request_parameter_to_methods = {} method_recorded_response = {} method_to_request = {} for request_parameter in request_nominal_parameters: chunked_token = request_parameter.lower().split('.')[-1] for response in response_nominal_runtime_parameters: method_name, response_parameter = response.split('-') chunked_response_token = response_parameter.lower().split('.')[-1] if chunked_token != chunked_response_token: continue matched_parameters = matched_methods.get(method_name, set()) matched_parameters.add(response_parameter) matched_methods[method_name] = matched_parameters request_parameter_to_meth = request_parameter_to_methods.get(request_parameter, set()) request_parameter_to_meth.add(method_name) request_parameter_to_methods[request_parameter] = request_parameter_to_meth method_to_response = method_recorded_response.get(method_name, set()) method_to_response.add(response_parameter) method_to_req = method_to_request.get(method_name, set()) method_to_req.add((request_parameter, response_parameter)) method_to_request[method_name] = method_to_req # for success_sequence in self.success_sequence: # if np.random.random() < 0.5: # break # if not success_sequence.has_method(method_name): # continue # new_seq = success_sequence.slice_by_method_name(method_name) # new_seq.add_def(len(new_seq) - 1, response_parameter) # new_seq.add_method(sequence.requests[0]) # new_seq.add_ref(len(new_seq) - 1, request_parameter, response_parameter) # res.add(new_seq) # print('add ref in sequence', sequence.requests[0].method_name, "to", method_name, # f'via {response_parameter} -> {request_parameter}', "new sequence", # len(new_seq)) for method in method_recorded_response: matched_seq = None for success_seq in success_sequences: if success_seq.has_method(method): matched_seq = success_seq break if matched_seq: request_parameters = method_to_request[method] response_parameters = method_recorded_response[method] new_seq = success_seq.slice_by_method_name(method) for response_parameter in response_parameters: new_seq.add_def(len(new_seq) - 1, response_parameter) new_seq.add_method(sequence.requests[0]) for req, res in request_parameters: new_seq.add_ref(len(new_seq) - 1, req, res) res.add(new_seq) print('add ref in sequence', sequence.requests[0].method_name, "to", method, f'via {request_parameters}', "new sequence", len(new_seq)) # print('request_parameter_to_methods') # print(request_parameter_to_methods) # print('matched_methods') # print(matched_methods) # time.sleep(20) self.sequences = self.sequences.union(res) def process_response(self): while len(ResponseReader.message_queue) > 0: ResponseReader.lock.acquire() resp = ResponseReader.message_queue.pop() response_sequence_id = resp["sequenceID"] if not self.pending_request.__contains__(response_sequence_id): print('mix request', response_sequence_id) continue violations = validate(resp, self.apis) has_error = False # FIXME: temp: check 500 for response in resp["result"]: status_code = str(response["statusCode"]) self.runtime_dict.parse(response) if int(status_code) > 499 and int(status_code) < 600 and not has_error: self.error_sequence.append({ "sequence": self.pending_request[response_sequence_id], "response": resp }) has_error = True result_count = self.status_code_status.get(str(status_code), 0) self.status_code_status[status_code] = result_count + 1 # analyze sequence self.analysis_sequence(resp['result'], self.pending_sequence[response_sequence_id]) # traverse violation for violation in violations: signature = violation.signature() self.violations.add(signature) # try to get success and error api status is_all_success = True for response in resp["result"]: status_code = response["statusCode"] if status_code > 299: is_all_success = False if status_code > 199 and status_code < 300: if not self.success_apis.__contains__(response['apiName']): self.api_curve.append({ "time": time.time() - self.begin, 'count': len(self.success_apis) + 1 }) self.success_apis.add(response["apiName"]) if status_code == 0: print(resp) time.sleep(10) if status_code > 499 and status_code < 600: self.error_apis.add(response['apiName']) if is_all_success: self.success_sequence_count += 1 self.success_sequence_output.append({ "sequence": self.pending_request[response_sequence_id], "response": resp }) self.receive_msg_count += 1 self.response_count += len(resp["result"]) del self.pending_request[response_sequence_id] del self.pending_sequence[response_sequence_id] self.overall_status() ResponseReader.lock.release() def has_success_api(self, responses): for resp in responses: status_code = resp["statusCode"] if status_code < 300 and status_code > 199: return True return False def chunk_responses(self, responses): success_sequence = [] fail_sequence = [] current_fail_sequence = [] current_success_sequence = [] # handle whole error status if not self.has_success_api(responses): for i in range(len(responses)): fail_sequence.append([i]) return success_sequence, fail_sequence for index in range(len(responses)): status_code = responses[index]["statusCode"] if status_code < 300 and status_code > 199: current_success_sequence.append(index) if len(current_fail_sequence) > 0: fail_sequence.append(current_fail_sequence) current_fail_sequence = [] else: current_fail_sequence.append(index) if len(current_success_sequence) > 0: success_sequence.append(current_success_sequence) current_success_sequence = [] if len(current_success_sequence) > 0: success_sequence.append(current_success_sequence) else: fail_sequence.append(current_fail_sequence) return success_sequence, fail_sequence def analysis_sequence(self, responses, test_sequence): success_converted_sequences = [] failed_converted_sequences = [] success_sequences, fail_sequences = self.chunk_responses(responses) # convert sequence for seq in success_sequences: success_converted_sequences.append(test_sequence.sub_sequence(seq)) for seq in fail_sequences: failed_converted_sequences.append(test_sequence.sub_sequence(seq)) self.pending_add_sequence = self.pending_add_sequence.union(failed_converted_sequences) self.pending_remove_sequence = self.pending_remove_sequence.union(success_converted_sequences) self.pending_test_sequence_to_remove.add(test_sequence) def overall_status(self): status_stat = "" elapsed = time.time() - self.begin for status_code in self.status_code_status.keys(): status_stat += f'{status_code}:{self.status_code_status[status_code]},' \ f'{float(self.status_code_status[status_code]) / self.response_count} ' print( f'{datetime.now().strftime("%Y/%m/%d %H:%M:%S")}, Fuzzing Time: {elapsed}s, Send Msg Count: {self.send_msg_count}, ' f'Receive Msg Count: {self.receive_msg_count}, Success Response Sequence Count: {self.success_sequence_count}, ' f'Success Sequence Rate: {float(self.success_sequence_count) / self.receive_msg_count}, ' f'Success API: {float(len(self.success_apis)) / len(self.total_apis)}' f' ({len(self.success_apis)}/{len(self.total_apis)}),' f'Error API: {float(len(self.error_apis)) / len(self.total_apis)}' f' ({len(self.error_apis)}/{len(self.total_apis)}),' f' Tested Error and Success Unique API: {float(len(set.union(self.success_apis, self.error_apis))) / len(self.total_apis)}' f' ({len(set.union(self.success_apis, self.error_apis))}/{len(self.total_apis)}),' f' Request Count: {self.request_count}, ' f'Response Count: {self.response_count}, Response / Request: {float(self.response_count) / self.request_count}, ' f'Request(QPS): {float(self.request_count) / elapsed}, Response(QPS):' f' {float(self.response_count) / elapsed}, Violation Count: {len(self.violations)}' f' Remain Sequence Count: {len(self.sequences)}' f' Success Sequence: {len(self.success_sequence)}') print('success') print(self.success_apis) print('errors') print(self.error_apis) print(self.api_curve) print(self.runtime_dict.signature_to_value.keys()) print(status_stat)