def generate_function_name(random_prev_length=3, random_end_length=3, max_word=5, prev_probability=10, auto_add_prev_probability=80): name = "" if random.randint(0, 100) < prev_probability: name += function_prev_words[random.randint( 0, function_prev_words_lenth - 1)] elif random_prev_length > 0 and random.randint( 0, 100) < auto_add_prev_probability: name += RandomGenerater.generate_string_first_lower( random_prev_length, random_prev_length) word_count = random.randint(1, max_word) indexs = range(function_main_words_lenth) for i in range(word_count): indx = random.randint(0, function_main_words_lenth - 1 - i) name += function_main_words[indexs[indx]] indexs[indx] = indexs[-1 - i] if random_end_length > 0: name += RandomGenerater.generate_string_first_upper( random_end_length, random_end_length) return name[0].lower() + name[1:]
def create_project(self, project_name, crypt_key, xcode_project_path, origin_xcode_project_name, xcode_project_name, target_name=None, display_name=None, xxtea_key=None, xxtea_sign=None): project_data = {} project_data["name"] = project_name project_data["resource_path"] = project_name project_data["project_path"] = project_name project_data["crypt"] = ConfigCreator.create_crypt_info(crypt_key) project_data["xcode_project_path"] = xcode_project_path project_data["origin_xcode_project_name"] = origin_xcode_project_name project_data["xcode_project_name"] = xcode_project_name if target_name: project_data["target_name"] = target_name if display_name: project_data["display_name"] = display_name if xxtea_key: project_data["xxtea_key"] = xxtea_key if xxtea_sign: project_data["xxtea_sign"] = xxtea_sign project_data["gen_cpp_dir"] = RandomGenerater.generate_string(6, 12) project_data["gen_objc_dir"] = RandomGenerater.generate_string(6, 12) return project_data
def generate_class(tpl_folder_path, field_count, method_count, max_parameter, method_return_probability, class_name=None): # gen fields fields = None if field_count > 0: fields = [] for i in range(field_count): fields.append(ObjcGenerator.generate_field(tpl_folder_path)) if not class_name: class_name = RandomGenerater.generate_string() class_name = class_name[0].upper() + class_name[1:] objc_class = ObjcClass(class_name, fields, None, tpl_folder_path) # gen methods methods = None if method_count > 0: methods = [] for i in range(method_count): method = ObjcGenerator.generate_function( tpl_folder_path, max_parameter, method_return_probability) method.objc_class = objc_class methods.append(method) objc_class.methods = methods return objc_class
def generate_file(self, out_folder_path, class_index): class_name = RandomGenerater.generate_string_first_upper(8, 16) head_file_name = os.path.join(out_folder_path, class_name + ".h") source_file_name = os.path.join(out_folder_path, class_name + self.source_file_ext) self.generated_files.append(head_file_name) self.generated_files.append(source_file_name) self.generated_head_files.append(class_name + ".h") field_count = gc_utils.get_range_count("field_count", self.generate_config, 3) method_count = gc_utils.get_range_count("method_count", self.generate_config, 5) parameter_count = gc_utils.get_range_count("parameter_count", self.generate_config, 3) return_probability = gc_utils.get_range_count("return_probability", self.generate_config, 5) generator = ObjcFile({ "head_file": head_file_name, "source_file": source_file_name, "tpl_folder": self.tpl_folder_path, "class_name": class_name, "field_count": field_count, "method_count": method_count, "parameter_count": parameter_count, "return_probability": return_probability, "call_others": self.generate_config["call_others"], "search_path": self.generate_config["search_path"] }) generator.prepare() generator.generate_code() return generator.get_class_execute_chain(class_index)
def save_mapping_data(self, out_mapping_file, crypt, save_json=True, save_plist=True): if not out_mapping_file: out_mapping_file = os.path.join( self.out_res_path, RandomGenerater.generate_words(1, 2)) if crypt: map_data = {} for k, v in self.map.items(): k = PathCrypt.path_md5(k, crypt) map_data[k] = v else: map_data = self.map if save_json: fp = open(out_mapping_file + ".json", "w+") json.dump(map_data, fp) fp.close() if save_plist: plist_file_path = out_mapping_file + ".plist" print("save to %s" % plist_file_path) plistlib.writePlist(map_data, plist_file_path)
def generate_file(self,min_size,max_size): file_size=random.randint(min_size,max_size) file_name=RandomGenerater.generate_words_first_lower(2,3,"_") file_ext="."+ResourceGarbage.generate_ext_name() fp = open(os.path.join(self.out_folder_path,file_name+file_ext), "w+") fp.write(ResourceGarbage.generate_content(file_size)) fp.close()
def __init__(self, max_level, min_dir_counts, max_dir_counts, ignore_root=False): # dir deep self.max_level = max_level self.min_dir_counts = min_dir_counts if isinstance(min_dir_counts, list) else [min_dir_counts] self.max_dir_counts = max_dir_counts if isinstance(max_dir_counts, list) else [max_dir_counts] self.have_sub_dir_probability = 60 self.root_dir = DirInfo(True, "" if ignore_root else RandomGenerater.generate_words(1, 1)) self.dirs = []
def __init__(self, have_children, name=None): self.name = name if name is not None else RandomGenerater.generate_words(1, 3) self.level = 0 self.parent = None self.have_children = have_children if have_children: self.children = [] else: self.children = None
def prepare_config(self, out_folder_path): if "namespace" in self.generate_config: if not self.generate_config["namespace"]: self.generate_config[ "namespace"] = RandomGenerater.generate_string(5, 8).lower() return super(CppGarbageCode, self).prepare_config(out_folder_path)
def generate_rule_name(random_prev_length=3, random_end_length=3, max_word=5, prev_probability=10): name = RandomGenerater.generate_string_first_upper( random_prev_length, random_prev_length) if random.randint(0, 100) < prev_probability: name += name_prev_words[random.randint(0, name_prev_words_lenth - 1)] word_count = random.randint(1, max_word) for _ in range(word_count): name += name_main_words[random.randint(0, name_main_words_lenth - 1)] name += RandomGenerater.generate_string_first_upper( random_end_length, random_end_length) return name
def _gen_inject_code(self): """ 获取注入代码。 目前实现二种代码,后面可以加入多种。 :return: """ p = random.randrange(0, 10) # now use two code type if p > 4: num = [] for _ in range(0, 3): num.append(RandomGenerater.generate_int()) tpl_data = { "num": num, "var_name": RandomGenerater.generate_string() } code_declare = TemplateManager.get_data( os.path.join(self.tpl_folder_path, "one_int_declare.cpp"), [tpl_data]) code = TemplateManager.get_data( os.path.join(self.tpl_folder_path, "one_int.cpp"), [tpl_data]) return code_declare, code else: num = [] for _ in range(0, 6): num.append(RandomGenerater.generate_float()) num.sort() tpl_data = { "num": num, "var_name": RandomGenerater.generate_string() } code_declare = TemplateManager.get_data( os.path.join(self.tpl_folder_path, "one_float_declare.cpp"), [tpl_data]) code = TemplateManager.get_data( os.path.join(self.tpl_folder_path, "one_float.cpp"), [tpl_data]) return code_declare, code
def parse_file(self, src_file, relative_path): out_dir = random.choice(self.dirs) out_file_name = RandomGenerater.generate_words(1, 2) if self.keep_ext: out_file_name += os.path.splitext(src_file)[1] out_relative_path = out_dir + "/" + out_file_name out_path = os.path.join(self.out_res_path, out_relative_path) # copy to out_dir if self.remove_source: os.rename(src_file, out_path) else: shutil.copyfile(src_file, out_path) self.map[relative_path] = out_relative_path
def prepare_config(self, out_folder_path): gen_file_count = gc_utils.get_range_count("generate_file_count", self.generate_config, 6) if "group_name" not in self.generate_config: self.generate_config[ "group_name"] = RandomGenerater.generate_string(6, 10) if "call_others" not in self.generate_config: self.generate_config["call_others"] = True if "search_path" not in self.generate_config: self.generate_config["search_path"] = out_folder_path if "namespace" in self.generate_config: if not self.generate_config["namespace"]: self.generate_config[ "namespace"] = RandomGenerater.generate_string(5, 8).lower() return gen_file_count
def prepare(self): # check class name if not self.class_name: self.class_name = RandomGenerater.generate_string(8, 32) self.class_name = self.class_name[0].upper() + self.class_name[1:] cpp_class = CppGenerator.generate_class( self.tpl_folder_path, self.config["field_count"], self.config["method_count"], self.config["parameter_count"], self.config["return_probability"], self.class_name) if "call_others" in self.config and self.config["call_others"]: for i in range(len(cpp_class.methods) - 1): cpp_class.methods[i].call(cpp_class.methods[i + 1]) self.c_class = cpp_class
def inject(self, functions, cpp_class, percent=1, code_times=6): """ 把调用类的方法和属性的代码插入源函数的代码之间 :param functions: :param cpp_class: :return: """ inst_name = RandomGenerater.generate_string() var_declare = cpp_class.get_stack_instance_def(inst_name) for function_info in functions: if function_info.root_statement: code_count = int( len( gc_utils.get_children_array_from_cursor( function_info.root_statement)) * percent * code_times) if code_count < 1: code_count = 1 codes = cpp_class.get_call_codes(inst_name, code_count) self._inject_function_more(function_info, var_declare, codes, percent)
def generate_function(tpl_folder_path, max_parameter_count=0, return_probability=30, method_name=None): if not method_name: method_name = ObjcGenerator.generate_function_name(0, 2, 3, 50) parameters = [] if max_parameter_count > 0: parameter_count = random.randint(0, max_parameter_count) for i in range(parameter_count): parameter = ObjcGenerator.generate_parameter() if i > 0: parameter.prev = ObjcGenerator.get_random_parameter_prev( ) + parameter.name parameters.append(parameter) if random.randint(0, 100) <= return_probability: return_type = CType(RandomGenerater.generate_objc_type()) else: return_type = CType(None) return ObjcMethod(method_name, parameters, return_type, tpl_folder_path)
def generate_ext_name(use_rule_ext_probability=70): if random.randint(1,100)<use_rule_ext_probability: return file_exts[random.randint(0,file_exts_length-1)] else: return RandomGenerater.generate_string(2,3).lower()
def generate_parameter(param_name=None, param_type=None): if not param_name: param_name = ObjcGenerator.generate_function_name(0, 0) if not param_type: param_type = CType(RandomGenerater.generate_objc_type()) return CParameter(param_name, param_type)
def generate_field(tpl_folder_path, field_name=None, field_type=None): if not field_name: field_name = ObjcGenerator.generate_field_name(2, 3) if not field_type: field_type = CType(RandomGenerater.generate_objc_type()) return CField(field_name, field_type, tpl_folder_path)
def random_value_stringify(self): return RandomGenerater.generate_value_stringify(self.name)
def main(): work_path = os.getcwd() repack_project_path = os.path.dirname(os.path.realpath(__file__)) parser = ArgumentParser() parser.add_argument('-p', '--project', dest='project', help="xcode project file path") parser.add_argument('-s', '--scheme', dest='scheme', help="xcode scheme") parser.add_argument('-m', '--mode', dest='mode', help="build mod archive or ipa") parser.add_argument('-o', '--out', dest='out', help="out put path") parser.add_argument('steps', nargs='*', help="steps to run") args = parser.parse_args() xcode_project_file_path = args.project if not os.path.isabs(xcode_project_file_path): xcode_project_file_path = os.path.join(work_path, xcode_project_file_path) # 分析cocos路径 pos = xcode_project_file_path.find("frameworks") if pos > -1: src_project = xcode_project_file_path[:pos - 1] xcode_project_path = os.path.dirname(xcode_project_file_path[pos:]) else: raise Exception("not a cocos project") print("matrix:%s,xcode root:%s" % (src_project, xcode_project_path)) origin_xcode_project_name = os.path.basename(xcode_project_file_path) project_name = os.path.splitext(origin_xcode_project_name)[0] xcode_project_name = project_name + ".xcodeproj" # 生成配置 crypt_key = RandomGenerater.generate_string(6, 10) config_creator = ConfigCreator() project_data = config_creator.create_project(project_name, crypt_key, xcode_project_path, origin_xcode_project_name, xcode_project_name) project_data["build_scheme"] = args.scheme if "out" in args and args.out: out_path = args.out if not os.path.isabs(out_path): out_path = os.path.join(work_path, out_path) project_data["archive_file_path_name"] = os.path.join(out_path, project_name) project_data["app_file_path_name"] = os.path.join(out_path, project_name + ".ipa") else: project_data["archive_file_path_name"] = project_name project_data["app_file_path_name"] = project_name + ".ipa" # 打包的其它目录 resource_dir = os.path.join(repack_project_path, "../resources") out_dir = os.path.join(repack_project_path, "../tempprojects") data_dir = os.path.join(repack_project_path, "data") # 配置保存成json project_config_path = os.path.join(resource_dir, project_name) if not os.path.exists(project_config_path): os.makedirs(project_config_path) config_file = os.path.join(resource_dir, project_name, "project.json") config_creator.save_project(project_data, config_file) # 读取操作步骤 step_config_file = os.path.join(repack_project_path, "../steps.json") fp = open(step_config_file) step_config = json.load(fp) fp.close() # 进行打包 repack.repack_project(src_project, out_dir, resource_dir, data_dir, project_data, step_config["steps"], None, args.steps, None, 1)
def generate_call_file_for_files(self, out_folder_path, call_generate_codes): """ 使用一个文件引用生成的文件 :param out_folder_path: :param generate_config: :param call_generate_codes: :return: """ # generate call generated code prevent delete by link optimization exec_once_tpl = Template(file=os.path.join(self.tpl_folder_path, "exec_code_once.tpl"), searchList=[{ "code": "".join(call_generate_codes), "prefix": RandomGenerater.generate_string() }]) exec_once = str(exec_once_tpl) if "generate_executor" in self.generate_config and self.generate_config[ "generate_executor"]: print("generate a executor") else: print("insert into execute file") include_heads = "\n" for head_file in self.generated_head_files: include_heads += "#include \"%s\"\n" % head_file auto_all_name = RandomGenerater.generate_string(20, 30) auto_all_function = RandomGenerater.generate_string(20, 30) auto_all_head_file = os.path.join(out_folder_path, auto_all_name + ".h") auto_all_source_file = os.path.join( out_folder_path, auto_all_name + self.source_file_ext) self.generated_files.append(auto_all_head_file) self.generated_files.append(auto_all_source_file) auto_all_head_tpl = Template(file=os.path.join(self.tpl_folder_path, "auto_all_head.tpl"), searchList=[{ "name": auto_all_name, "headers": include_heads, "auto_all_function": auto_all_function }]) auto_all_source_tpl = Template(file=os.path.join( self.tpl_folder_path, "auto_all_source.tpl"), searchList=[{ "name": auto_all_name, "code": exec_once, "auto_all_function": auto_all_function }]) fp = open(auto_all_head_file, "w+") fp.write(str(auto_all_head_tpl)) fp.close() fp = open(auto_all_source_file, "w+") fp.write(str(auto_all_source_tpl)) fp.close() return auto_all_name, auto_all_function