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
