├── ebfuscator.bin ├── output ├── errors.h ├── errors.c └── ebfuscated.c ├── errors ├── linux │ ├── errors.h │ └── errors.c └── windows │ ├── errors.h │ └── errors.c ├── examples └── crackme_test.c └── README.md /ebfuscator.bin: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/d00rt/ebfuscator/HEAD/ebfuscator.bin -------------------------------------------------------------------------------- /output/errors.h: -------------------------------------------------------------------------------- 1 | void generate_error_1(void); 2 | void generate_error_2(void); 3 | void generate_error_3(void); 4 | void generate_error_10(void); 5 | void generate_error_12(void); 6 | void generate_error_13(void); 7 | void generate_error_14(void); 8 | void generate_error_17(void); 9 | void generate_error_20(void); 10 | void generate_error_21(void); 11 | void generate_error_22(void); 12 | void generate_error_24(void); 13 | void generate_error_30(void); 14 | -------------------------------------------------------------------------------- /errors/linux/errors.h: -------------------------------------------------------------------------------- 1 | void generate_error_1(void); 2 | void generate_error_2(void); 3 | void generate_error_3(void); 4 | void generate_error_10(void); 5 | void generate_error_12(void); 6 | void generate_error_13(void); 7 | void generate_error_14(void); 8 | void generate_error_17(void); 9 | void generate_error_20(void); 10 | void generate_error_21(void); 11 | void generate_error_22(void); 12 | void generate_error_24(void); 13 | void generate_error_30(void); 14 | -------------------------------------------------------------------------------- /errors/windows/errors.h: -------------------------------------------------------------------------------- 1 | #define CHECK_ERROR_CODE(TARGET) { \ 2 | DWORD last_error = GetLastError(); \ 3 | if ( last_error == (TARGET) ) { \ 4 | printf("[+] SUCESS ON ERROR: %d\n", (int)(TARGET)); \ 5 | } \ 6 | else { \ 7 | printf("[!] ERROR %d DOESNT MATCH WITH LAST ERROR %d\n", (int)(TARGET), (int)last_error); \ 8 | } \ 9 | } 10 | 11 | void generate_error_1(void); 12 | void generate_error_2(void); 13 | void generate_error_3(void); 14 | void generate_error_5(void); 15 | void generate_error_6(void); 16 | void generate_error_18(void); 17 | void generate_error_32(void); 18 | void generate_error_126(void); 19 | -------------------------------------------------------------------------------- /examples/crackme_test.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | 5 | int 6 | check_input(void) 7 | { 8 | char input[101] = { 0 }; 9 | char passwd[11] = "password123"; 10 | printf("Enter a value: "); 11 | fgets(input, 50, stdin); 12 | 13 | if (strncmp(input, passwd, strnlen(passwd, 11)) == 0) 14 | { 15 | return 1; 16 | } 17 | return 0; 18 | } 19 | 20 | int 21 | main(int argc, char *argv[]) 22 | { 23 | if (check_input() == 1) 24 | { 25 | char * valid_pass = "Well done!"; 26 | printf("%s\n", valid_pass); 27 | } else 28 | { 29 | char * invalid_pass = "Try again!"; 30 | printf("%s\n", invalid_pass); 31 | } 32 | 33 | return 0; 34 | } 35 | -------------------------------------------------------------------------------- /output/errors.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | 15 | #include "error.h" 16 | 17 | void 18 | generate_error_1() 19 | { 20 | chmod ("/etc/shadow", S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH); 21 | } 22 | 23 | void 24 | generate_error_2() 25 | { 26 | fopen("nonexist.txt", "rb"); 27 | } 28 | 29 | void 30 | generate_error_3() 31 | { 32 | kill(-9999, 0); 33 | } 34 | 35 | void 36 | generate_error_10() 37 | { 38 | int childStatus; 39 | waitpid(0x29B, &childStatus, WNOHANG); 40 | } 41 | 42 | void 43 | generate_error_12() 44 | { 45 | int tb = -1; 46 | (int *) malloc(tb); 47 | } 48 | 49 | void 50 | generate_error_13() 51 | { 52 | fopen ("/etc/shadow", "wb"); 53 | } 54 | 55 | void 56 | generate_error_14() 57 | { 58 | char *argv[] = { "/bin/kill"}; 59 | char *envp[] = {}; 60 | execve(argv[0], &argv[0], envp); 61 | } 62 | 63 | void 64 | generate_error_17() 65 | { 66 | mkdir("/etc", S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH); 67 | } 68 | 69 | void 70 | generate_error_20() 71 | { 72 | opendir("/bin/ls"); 73 | } 74 | 75 | void 76 | generate_error_21() 77 | { 78 | fopen ("/bin", "wb"); 79 | } 80 | 81 | void 82 | generate_error_22() 83 | { 84 | select(-1, 0, 0, 0, 0); 85 | } 86 | 87 | void 88 | generate_error_24() 89 | { 90 | while (open("/bin/ls", O_RDONLY) != -1){}; 91 | } 92 | 93 | void 94 | generate_error_30() 95 | { 96 | /* 97 | * We should check to make sure this fs is always on linux and always read-only 98 | * other approach would be to create a tmp FS only readable 99 | */ 100 | access("/sys/fs/cgroup", W_OK); 101 | } 102 | -------------------------------------------------------------------------------- /errors/linux/errors.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | 15 | #include "error.h" 16 | 17 | void 18 | generate_error_1() 19 | { 20 | chmod ("/etc/shadow", S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH); 21 | } 22 | 23 | void 24 | generate_error_2() 25 | { 26 | fopen("nonexist.txt", "rb"); 27 | } 28 | 29 | void 30 | generate_error_3() 31 | { 32 | kill(-9999, 0); 33 | } 34 | 35 | void 36 | generate_error_10() 37 | { 38 | int childStatus; 39 | waitpid(0x29B, &childStatus, WNOHANG); 40 | } 41 | 42 | void 43 | generate_error_12() 44 | { 45 | int tb = -1; 46 | (int *) malloc(tb); 47 | } 48 | 49 | void 50 | generate_error_13() 51 | { 52 | fopen ("/etc/shadow", "wb"); 53 | } 54 | 55 | void 56 | generate_error_14() 57 | { 58 | char *argv[] = { "/bin/kill"}; 59 | char *envp[] = {}; 60 | execve(argv[0], &argv[0], envp); 61 | } 62 | 63 | void 64 | generate_error_17() 65 | { 66 | mkdir("/etc", S_IRWXU|S_IRGRP|S_IXGRP|S_IROTH); 67 | } 68 | 69 | void 70 | generate_error_20() 71 | { 72 | opendir("/bin/ls"); 73 | } 74 | 75 | void 76 | generate_error_21() 77 | { 78 | fopen ("/bin", "wb"); 79 | } 80 | 81 | void 82 | generate_error_22() 83 | { 84 | select(-1, 0, 0, 0, 0); 85 | } 86 | 87 | void 88 | generate_error_24() 89 | { 90 | while (open("/bin/ls", O_RDONLY) != -1){}; 91 | } 92 | 93 | void 94 | generate_error_30() 95 | { 96 | /* 97 | * We should check to make sure this fs is always on linux and always read-only 98 | * other approach would be to create a tmp FS only readable 99 | */ 100 | access("/sys/fs/cgroup", W_OK); 101 | } 102 | -------------------------------------------------------------------------------- /errors/windows/errors.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | 7 | #include "errors.h" 8 | 9 | void 10 | generate_error_1(void) 11 | { 12 | //ERROR_INVALID_FUNCTION 13 | SetLastError(1); 14 | // HANDLE hFile; 15 | // 16 | // hFile = CreateFile( 17 | // "\\\\.\\NetBT", 18 | // GENERIC_READ | GENERIC_WRITE, 0, NULL, 19 | // OPEN_EXISTING, 0, NULL 20 | // ); 21 | // 22 | //CHECK_ERROR_CODE(1); 23 | // 24 | // if (hFile != INVALID_HANDLE_VALUE) 25 | // { 26 | // CloseHandle(hFile); 27 | // return; 28 | // } 29 | } 30 | 31 | void 32 | generate_error_2(void) 33 | { 34 | //ERROR_FILE_NOT_FOUND 35 | CreateFile( 36 | "ERROR_SHELLCODE_WINDOWS_BY_D00RT", 37 | GENERIC_READ | GENERIC_WRITE, 0, NULL, 38 | OPEN_EXISTING, 0, NULL 39 | ); 40 | } 41 | 42 | void 43 | generate_error_3(void) 44 | { 45 | //ERROR_PATH_NOT_FOUND 46 | CreateFile( 47 | "C:\\ERROR\\SHELLCODE\\WINDOWS\\BY\\D00RT", 48 | GENERIC_READ | GENERIC_WRITE, 0, NULL, 49 | OPEN_EXISTING, 0, NULL 50 | ); 51 | } 52 | 53 | void 54 | generate_error_5(void) 55 | { 56 | //ERROR_ACCESS_DENIED 57 | CreateFile( 58 | "C:\\Windows\\System32\\user32.dll", 59 | GENERIC_READ | GENERIC_WRITE, 0, NULL, 60 | OPEN_EXISTING, 0, NULL 61 | ); 62 | } 63 | 64 | void 65 | generate_error_6(void) 66 | { 67 | //ERROR_INVALID_HANDLE 68 | DWORD lpNumberOfBytesWritten; 69 | WriteFile((HANDLE)0xFFFFFFFF, NULL, 0, &lpNumberOfBytesWritten, NULL); 70 | } 71 | 72 | void 73 | generate_error_18(void) 74 | { 75 | //ERROR_NO_MORE_FILES 76 | WIN32_FIND_DATA ffd; 77 | HANDLE hFind = INVALID_HANDLE_VALUE; 78 | LPSTR szPath, szFPath; 79 | szPath = _getcwd(NULL, MAX_PATH - 1); 80 | 81 | size_t path_len = strlen(szPath); 82 | szFPath = calloc(path_len + 2 + 1, 1); 83 | 84 | memcpy(szFPath, szPath, path_len); 85 | memcpy(szFPath + path_len, TEXT("\\*"), 2); 86 | szFPath[path_len + 2] = 0; 87 | 88 | hFind = FindFirstFileA((LPCSTR)szFPath, &ffd); 89 | do 90 | { 91 | } 92 | while (FindNextFileA(hFind, &ffd) != 0); 93 | free(szFPath); 94 | } 95 | 96 | void 97 | generate_error_24(void) 98 | { 99 | //ERROR_BAD_LENGTH 100 | HANDLE hSnap; 101 | PROCESSENTRY32 pe; 102 | 103 | hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0); 104 | 105 | Process32First(hSnap, &pe); 106 | //CHECK_ERROR_CODE(24); 107 | } 108 | 109 | void 110 | generate_error_32(void) 111 | { 112 | //ERROR_TOO_MANY_OPEN_FILES 113 | CreateFile( 114 | "C:\\Windows\\System32\\rundll32.exe", 115 | GENERIC_READ, 0, NULL, 116 | OPEN_EXISTING, 0, NULL 117 | ); 118 | CreateFile( 119 | "C:\\Windows\\System32\\rundll32.exe", 120 | GENERIC_READ, 0, NULL, 121 | OPEN_EXISTING, 0, NULL 122 | ); 123 | } 124 | 125 | void 126 | generate_error_126(void) 127 | { 128 | LoadLibrary("C:\\D00RT.DLL"); 129 | } 130 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Ebfuscator 2 | Ebfuscator is the first tool that allows you to obfuscate strings using the ebfuscation technique. 3 | 4 | Ebfuscator takes a C source file, the target platform (Windows, Linux) and a list of variables in the source you want to obfuscate. It applies a transformation based on Ebfuscation technique and produces a C source obfuscated file. 5 | 6 | This tool is a proof of concept so there are many features that are not yet implemented and it has its limitations. For more information read the Limitations section. 7 | 8 | ## Ebfuscation: Abusing system errors for binary obfuscation 9 | Ebfuscation, is a technique which can be used to implement different transformations such as Literals encoding, Control Flow Flattening and Virtualization. This technique is based on System's errors. To understand better how this technique works please read the article I wrote [here](https://www.d00rt.eus/2020/04/ebfuscation-abusing-system-errors-for.html) where I explain in detail the technique. 10 | 11 | # Usage 12 | 13 | Ebfuscator must be run from the project path, since it depends on the files located into {CURRENT_PATH}/errors/* 14 | 15 | First you need to ebfuscate your source program 16 | 17 | **Linux:** 18 | 19 | `./ebfuscator.bin --platform [platform] --source [source] --var [variables] ...` 20 | 21 | 22 | If success the folder **./output/** is created where you can find your C source code obfuscated (ebfuscated.c) and both errors.c and erros.h files where you can find the need code to generate errors for the target platform you chose. 23 | 24 | So now you only need to compile the sources for your target platform. In case of linux you can do 25 | 26 | `gcc -o my_program ./output/ebfuscated.c ./output/errors.c -lm` 27 | 28 | Enjoy! 29 | 30 | ## Example 31 | 32 | The following example uses the source program ./examples/crackme_test.c and it can be ebfuscated for both **Linux** and **Windows** 33 | 34 | 1) ebfuscate the variable **passwd** for **windows** platform. 35 | 36 | `./ebfuscator.bin --platform windows --source ./examples/crackme_test.c --var passwd` 37 | 38 | 2) ebfuscate the variables **passwd**, **invalid_pass** and **valid_pass** for **linux** platform. 39 | 40 | `./ebfuscator.bin --platform linux --source ./examples/crackme_test.c --var passwd valid_pass invalid_pass` 41 | 42 | 43 | 3) ebfuscate the variables **invalid_pass** and **valid_pass** for **windows** platform. 44 | 45 | `./ebfuscator.bin --platform windows --source ./examples/crackme_test.c --var valid_pass --var invalid_pass` 46 | 47 | # Limitations 48 | - **Analyzer:** The main idea of this project was not to have a powerful analyzer, rather the analyzer is very dumb. So in order for your variables to be found by the analyzer they have to be declared in compliance with the following requirements: 49 | - Declaration and initialization of the string/bytearray must be done in the same line. 50 | - The declaration must match the following regex **r#"([\s\t]*)char\s*\*?\s*{variable}\s*(\[[0-9]*\])?\s*=\s*(".*")\s*;"#**. Here some valid examples: 51 | - `char * valid = "test";` 52 | - `char valid[] = "test";` 53 | - `char valid[5] = "test\0";` 54 | - `char *shellcode = "\xDE\xAD\xBE\xEF";` 55 | 56 | - **Platform:** At this moment the tool only supports **Windows** and **Linux** based operating systems. 57 | - **Errors:** There are only a few errors implemented for each platform, this causes a lot of overhead when generating the obfuscated program. This overhead could be as well a feature but it's preferible to have the way to generate an error for a given value instead of combine different errors to get it. 58 | 59 | # Upcoming 60 | - Ebfuscator code release. 61 | - Stealthy mode to retrieve the errors. Instead of use GetLastError() or errno, read errors from TIB. 62 | - Implementation of more errors, for both Windows and Linux (Pull Request are allowed :D) 63 | -------------------------------------------------------------------------------- /output/ebfuscated.c: -------------------------------------------------------------------------------- 1 | #include "errors.h" 2 | #include 3 | extern int errno; 4 | 5 | #include 6 | #include 7 | #include 8 | 9 | int 10 | check_input(void) 11 | { 12 | char input[101] = { 0 }; 13 | char passwd[12]; 14 | /* GENERATE BYTE 112 (0x70) */ 15 | int var2_0; 16 | generate_error_2(); 17 | var2_0 = errno; 18 | int var2_1; 19 | generate_error_2(); 20 | var2_1 = errno; 21 | int var2_aux = var2_1 * var2_0; 22 | int var2_3; 23 | generate_error_2(); 24 | var2_3 = errno; 25 | int var4_aux = var2_3 * var2_aux; 26 | int var2_5; 27 | generate_error_2(); 28 | var2_5 = errno; 29 | int var6_aux = var2_5 * var4_aux; 30 | int var3_7; 31 | generate_error_3(); 32 | var3_7 = errno; 33 | int var3_8; 34 | generate_error_3(); 35 | var3_8 = errno; 36 | int var9_aux = var3_8 + var3_7; 37 | int var1_10; 38 | generate_error_1(); 39 | var1_10 = errno; 40 | int var11_aux = var1_10 + var9_aux; 41 | int var12_aux = var11_aux * var6_aux; 42 | passwd[0] = var12_aux; 43 | /* GENERATE BYTE 97 (0x61) */ 44 | int var2_13; 45 | generate_error_2(); 46 | var2_13 = errno; 47 | int var2_14; 48 | generate_error_2(); 49 | var2_14 = errno; 50 | int var15_aux = var2_14 * var2_13; 51 | int var2_16; 52 | generate_error_2(); 53 | var2_16 = errno; 54 | int var17_aux = var2_16 * var15_aux; 55 | int var2_18; 56 | generate_error_2(); 57 | var2_18 = errno; 58 | int var19_aux = var2_18 * var17_aux; 59 | int var3_20; 60 | generate_error_3(); 61 | var3_20 = errno; 62 | int var21_aux = var3_20 * var19_aux; 63 | int var2_22; 64 | generate_error_2(); 65 | var2_22 = errno; 66 | int var2_23; 67 | generate_error_2(); 68 | var2_23 = errno; 69 | int var24_aux = var2_23 * var2_22; 70 | int var2_25; 71 | generate_error_2(); 72 | var2_25 = errno; 73 | int var26_aux = var2_25 * var24_aux; 74 | int var2_27; 75 | generate_error_2(); 76 | var2_27 = errno; 77 | int var28_aux = var2_27 * var26_aux; 78 | int var3_29; 79 | generate_error_3(); 80 | var3_29 = errno; 81 | int var30_aux = var3_29 * var28_aux; 82 | int var31_aux = var30_aux + var21_aux; 83 | int var1_32; 84 | generate_error_1(); 85 | var1_32 = errno; 86 | int var33_aux = var1_32 + var31_aux; 87 | passwd[1] = var33_aux; 88 | /* GENERATE BYTE 115 (0x73) */ 89 | int var2_34; 90 | generate_error_2(); 91 | var2_34 = errno; 92 | int var2_35; 93 | generate_error_2(); 94 | var2_35 = errno; 95 | int var36_aux = var2_35 + var2_34; 96 | int var1_37; 97 | generate_error_1(); 98 | var1_37 = errno; 99 | int var38_aux = var1_37 + var36_aux; 100 | int var2_39; 101 | generate_error_2(); 102 | var2_39 = errno; 103 | int var2_40; 104 | generate_error_2(); 105 | var2_40 = errno; 106 | int var41_aux = var2_40 + var2_39; 107 | int var1_42; 108 | generate_error_1(); 109 | var1_42 = errno; 110 | int var43_aux = var1_42 + var41_aux; 111 | int var2_44; 112 | generate_error_2(); 113 | var2_44 = errno; 114 | int var2_45; 115 | generate_error_2(); 116 | var2_45 = errno; 117 | int var46_aux = var2_45 + var2_44; 118 | int var1_47; 119 | generate_error_1(); 120 | var1_47 = errno; 121 | int var48_aux = var1_47 + var46_aux; 122 | int var49_aux = var48_aux + var43_aux; 123 | int var1_50; 124 | generate_error_1(); 125 | var1_50 = errno; 126 | int var51_aux = var1_50 + var49_aux; 127 | int var2_52; 128 | generate_error_2(); 129 | var2_52 = errno; 130 | int var2_53; 131 | generate_error_2(); 132 | var2_53 = errno; 133 | int var54_aux = var2_53 + var2_52; 134 | int var1_55; 135 | generate_error_1(); 136 | var1_55 = errno; 137 | int var56_aux = var1_55 + var54_aux; 138 | int var2_57; 139 | generate_error_2(); 140 | var2_57 = errno; 141 | int var2_58; 142 | generate_error_2(); 143 | var2_58 = errno; 144 | int var59_aux = var2_58 + var2_57; 145 | int var1_60; 146 | generate_error_1(); 147 | var1_60 = errno; 148 | int var61_aux = var1_60 + var59_aux; 149 | int var62_aux = var61_aux + var56_aux; 150 | int var1_63; 151 | generate_error_1(); 152 | var1_63 = errno; 153 | int var64_aux = var1_63 + var62_aux; 154 | int var65_aux = var64_aux + var51_aux; 155 | int var1_66; 156 | generate_error_1(); 157 | var1_66 = errno; 158 | int var67_aux = var1_66 + var65_aux; 159 | int var68_aux = var67_aux * var38_aux; 160 | passwd[2] = var68_aux; 161 | /* GENERATE BYTE 115 (0x73) */ 162 | int var2_69; 163 | generate_error_2(); 164 | var2_69 = errno; 165 | int var2_70; 166 | generate_error_2(); 167 | var2_70 = errno; 168 | int var71_aux = var2_70 + var2_69; 169 | int var1_72; 170 | generate_error_1(); 171 | var1_72 = errno; 172 | int var73_aux = var1_72 + var71_aux; 173 | int var2_74; 174 | generate_error_2(); 175 | var2_74 = errno; 176 | int var2_75; 177 | generate_error_2(); 178 | var2_75 = errno; 179 | int var76_aux = var2_75 + var2_74; 180 | int var1_77; 181 | generate_error_1(); 182 | var1_77 = errno; 183 | int var78_aux = var1_77 + var76_aux; 184 | int var2_79; 185 | generate_error_2(); 186 | var2_79 = errno; 187 | int var2_80; 188 | generate_error_2(); 189 | var2_80 = errno; 190 | int var81_aux = var2_80 + var2_79; 191 | int var1_82; 192 | generate_error_1(); 193 | var1_82 = errno; 194 | int var83_aux = var1_82 + var81_aux; 195 | int var84_aux = var83_aux + var78_aux; 196 | int var1_85; 197 | generate_error_1(); 198 | var1_85 = errno; 199 | int var86_aux = var1_85 + var84_aux; 200 | int var2_87; 201 | generate_error_2(); 202 | var2_87 = errno; 203 | int var2_88; 204 | generate_error_2(); 205 | var2_88 = errno; 206 | int var89_aux = var2_88 + var2_87; 207 | int var1_90; 208 | generate_error_1(); 209 | var1_90 = errno; 210 | int var91_aux = var1_90 + var89_aux; 211 | int var2_92; 212 | generate_error_2(); 213 | var2_92 = errno; 214 | int var2_93; 215 | generate_error_2(); 216 | var2_93 = errno; 217 | int var94_aux = var2_93 + var2_92; 218 | int var1_95; 219 | generate_error_1(); 220 | var1_95 = errno; 221 | int var96_aux = var1_95 + var94_aux; 222 | int var97_aux = var96_aux + var91_aux; 223 | int var1_98; 224 | generate_error_1(); 225 | var1_98 = errno; 226 | int var99_aux = var1_98 + var97_aux; 227 | int var100_aux = var99_aux + var86_aux; 228 | int var1_101; 229 | generate_error_1(); 230 | var1_101 = errno; 231 | int var102_aux = var1_101 + var100_aux; 232 | int var103_aux = var102_aux * var73_aux; 233 | passwd[3] = var103_aux; 234 | /* GENERATE BYTE 119 (0x77) */ 235 | int var3_104; 236 | generate_error_3(); 237 | var3_104 = errno; 238 | int var3_105; 239 | generate_error_3(); 240 | var3_105 = errno; 241 | int var106_aux = var3_105 + var3_104; 242 | int var1_107; 243 | generate_error_1(); 244 | var1_107 = errno; 245 | int var108_aux = var1_107 + var106_aux; 246 | int var17_109; 247 | generate_error_17(); 248 | var17_109 = errno; 249 | int var110_aux = var17_109 * var108_aux; 250 | passwd[4] = var110_aux; 251 | /* GENERATE BYTE 111 (0x6F) */ 252 | int var3_111; 253 | generate_error_3(); 254 | var3_111 = errno; 255 | int var2_112; 256 | generate_error_2(); 257 | var2_112 = errno; 258 | int var3_113; 259 | generate_error_3(); 260 | var3_113 = errno; 261 | int var114_aux = var3_113 * var2_112; 262 | int var3_115; 263 | generate_error_3(); 264 | var3_115 = errno; 265 | int var116_aux = var3_115 * var114_aux; 266 | int var2_117; 267 | generate_error_2(); 268 | var2_117 = errno; 269 | int var3_118; 270 | generate_error_3(); 271 | var3_118 = errno; 272 | int var119_aux = var3_118 * var2_117; 273 | int var3_120; 274 | generate_error_3(); 275 | var3_120 = errno; 276 | int var121_aux = var3_120 * var119_aux; 277 | int var122_aux = var121_aux + var116_aux; 278 | int var1_123; 279 | generate_error_1(); 280 | var1_123 = errno; 281 | int var124_aux = var1_123 + var122_aux; 282 | int var125_aux = var124_aux * var3_111; 283 | passwd[5] = var125_aux; 284 | /* GENERATE BYTE 114 (0x72) */ 285 | int var2_126; 286 | generate_error_2(); 287 | var2_126 = errno; 288 | int var3_127; 289 | generate_error_3(); 290 | var3_127 = errno; 291 | int var128_aux = var3_127 * var2_126; 292 | int var3_129; 293 | generate_error_3(); 294 | var3_129 = errno; 295 | int var3_130; 296 | generate_error_3(); 297 | var3_130 = errno; 298 | int var131_aux = var3_130 * var3_129; 299 | int var3_132; 300 | generate_error_3(); 301 | var3_132 = errno; 302 | int var3_133; 303 | generate_error_3(); 304 | var3_133 = errno; 305 | int var134_aux = var3_133 * var3_132; 306 | int var135_aux = var134_aux + var131_aux; 307 | int var1_136; 308 | generate_error_1(); 309 | var1_136 = errno; 310 | int var137_aux = var1_136 + var135_aux; 311 | int var138_aux = var137_aux * var128_aux; 312 | passwd[6] = var138_aux; 313 | /* GENERATE BYTE 100 (0x64) */ 314 | int var2_139; 315 | generate_error_2(); 316 | var2_139 = errno; 317 | int var2_140; 318 | generate_error_2(); 319 | var2_140 = errno; 320 | int var141_aux = var2_140 * var2_139; 321 | int var2_142; 322 | generate_error_2(); 323 | var2_142 = errno; 324 | int var2_143; 325 | generate_error_2(); 326 | var2_143 = errno; 327 | int var144_aux = var2_143 + var2_142; 328 | int var1_145; 329 | generate_error_1(); 330 | var1_145 = errno; 331 | int var146_aux = var1_145 + var144_aux; 332 | int var147_aux = var146_aux * var141_aux; 333 | int var2_148; 334 | generate_error_2(); 335 | var2_148 = errno; 336 | int var2_149; 337 | generate_error_2(); 338 | var2_149 = errno; 339 | int var150_aux = var2_149 + var2_148; 340 | int var1_151; 341 | generate_error_1(); 342 | var1_151 = errno; 343 | int var152_aux = var1_151 + var150_aux; 344 | int var153_aux = var152_aux * var147_aux; 345 | passwd[7] = var153_aux; 346 | /* GENERATE BYTE 49 (0x31) */ 347 | int var3_154; 348 | generate_error_3(); 349 | var3_154 = errno; 350 | int var3_155; 351 | generate_error_3(); 352 | var3_155 = errno; 353 | int var156_aux = var3_155 + var3_154; 354 | int var1_157; 355 | generate_error_1(); 356 | var1_157 = errno; 357 | int var158_aux = var1_157 + var156_aux; 358 | int var3_159; 359 | generate_error_3(); 360 | var3_159 = errno; 361 | int var3_160; 362 | generate_error_3(); 363 | var3_160 = errno; 364 | int var161_aux = var3_160 + var3_159; 365 | int var1_162; 366 | generate_error_1(); 367 | var1_162 = errno; 368 | int var163_aux = var1_162 + var161_aux; 369 | int var164_aux = var163_aux * var158_aux; 370 | passwd[8] = var164_aux; 371 | /* GENERATE BYTE 50 (0x32) */ 372 | int var2_165; 373 | generate_error_2(); 374 | var2_165 = errno; 375 | int var2_166; 376 | generate_error_2(); 377 | var2_166 = errno; 378 | int var2_167; 379 | generate_error_2(); 380 | var2_167 = errno; 381 | int var168_aux = var2_167 + var2_166; 382 | int var1_169; 383 | generate_error_1(); 384 | var1_169 = errno; 385 | int var170_aux = var1_169 + var168_aux; 386 | int var171_aux = var170_aux * var2_165; 387 | int var2_172; 388 | generate_error_2(); 389 | var2_172 = errno; 390 | int var2_173; 391 | generate_error_2(); 392 | var2_173 = errno; 393 | int var174_aux = var2_173 + var2_172; 394 | int var1_175; 395 | generate_error_1(); 396 | var1_175 = errno; 397 | int var176_aux = var1_175 + var174_aux; 398 | int var177_aux = var176_aux * var171_aux; 399 | passwd[9] = var177_aux; 400 | /* GENERATE BYTE 51 (0x33) */ 401 | int var3_178; 402 | generate_error_3(); 403 | var3_178 = errno; 404 | int var17_179; 405 | generate_error_17(); 406 | var17_179 = errno; 407 | int var180_aux = var17_179 * var3_178; 408 | passwd[10] = var180_aux; 409 | passwd[11] = 0; 410 | printf("Enter a value: "); 411 | fgets(input, 50, stdin); 412 | 413 | if (strncmp(input, passwd, strnlen(passwd, 11)) == 0) 414 | { 415 | return 1; 416 | } 417 | return 0; 418 | } 419 | 420 | int 421 | main(int argc, char *argv[]) 422 | { 423 | if (check_input() == 1) 424 | { 425 | char valid_pass[11]; 426 | /* GENERATE BYTE 87 (0x57) */ 427 | int var3_181; 428 | generate_error_3(); 429 | var3_181 = errno; 430 | int var14_182; 431 | generate_error_14(); 432 | var14_182 = errno; 433 | int var14_183; 434 | generate_error_14(); 435 | var14_183 = errno; 436 | int var184_aux = var14_183 + var14_182; 437 | int var1_185; 438 | generate_error_1(); 439 | var1_185 = errno; 440 | int var186_aux = var1_185 + var184_aux; 441 | int var187_aux = var186_aux * var3_181; 442 | valid_pass[0] = var187_aux; 443 | /* GENERATE BYTE 101 (0x65) */ 444 | int var2_188; 445 | generate_error_2(); 446 | var2_188 = errno; 447 | int var2_189; 448 | generate_error_2(); 449 | var2_189 = errno; 450 | int var2_190; 451 | generate_error_2(); 452 | var2_190 = errno; 453 | int var191_aux = var2_190 + var2_189; 454 | int var1_192; 455 | generate_error_1(); 456 | var1_192 = errno; 457 | int var193_aux = var1_192 + var191_aux; 458 | int var194_aux = var193_aux * var2_188; 459 | int var2_195; 460 | generate_error_2(); 461 | var2_195 = errno; 462 | int var2_196; 463 | generate_error_2(); 464 | var2_196 = errno; 465 | int var197_aux = var2_196 + var2_195; 466 | int var1_198; 467 | generate_error_1(); 468 | var1_198 = errno; 469 | int var199_aux = var1_198 + var197_aux; 470 | int var200_aux = var199_aux * var194_aux; 471 | int var2_201; 472 | generate_error_2(); 473 | var2_201 = errno; 474 | int var2_202; 475 | generate_error_2(); 476 | var2_202 = errno; 477 | int var2_203; 478 | generate_error_2(); 479 | var2_203 = errno; 480 | int var204_aux = var2_203 + var2_202; 481 | int var1_205; 482 | generate_error_1(); 483 | var1_205 = errno; 484 | int var206_aux = var1_205 + var204_aux; 485 | int var207_aux = var206_aux * var2_201; 486 | int var2_208; 487 | generate_error_2(); 488 | var2_208 = errno; 489 | int var2_209; 490 | generate_error_2(); 491 | var2_209 = errno; 492 | int var210_aux = var2_209 + var2_208; 493 | int var1_211; 494 | generate_error_1(); 495 | var1_211 = errno; 496 | int var212_aux = var1_211 + var210_aux; 497 | int var213_aux = var212_aux * var207_aux; 498 | int var214_aux = var213_aux + var200_aux; 499 | int var1_215; 500 | generate_error_1(); 501 | var1_215 = errno; 502 | int var216_aux = var1_215 + var214_aux; 503 | valid_pass[1] = var216_aux; 504 | /* GENERATE BYTE 108 (0x6C) */ 505 | int var2_217; 506 | generate_error_2(); 507 | var2_217 = errno; 508 | int var2_218; 509 | generate_error_2(); 510 | var2_218 = errno; 511 | int var219_aux = var2_218 * var2_217; 512 | int var3_220; 513 | generate_error_3(); 514 | var3_220 = errno; 515 | int var221_aux = var3_220 * var219_aux; 516 | int var3_222; 517 | generate_error_3(); 518 | var3_222 = errno; 519 | int var223_aux = var3_222 * var221_aux; 520 | int var3_224; 521 | generate_error_3(); 522 | var3_224 = errno; 523 | int var225_aux = var3_224 * var223_aux; 524 | valid_pass[2] = var225_aux; 525 | /* GENERATE BYTE 108 (0x6C) */ 526 | int var2_226; 527 | generate_error_2(); 528 | var2_226 = errno; 529 | int var2_227; 530 | generate_error_2(); 531 | var2_227 = errno; 532 | int var228_aux = var2_227 * var2_226; 533 | int var3_229; 534 | generate_error_3(); 535 | var3_229 = errno; 536 | int var230_aux = var3_229 * var228_aux; 537 | int var3_231; 538 | generate_error_3(); 539 | var3_231 = errno; 540 | int var232_aux = var3_231 * var230_aux; 541 | int var3_233; 542 | generate_error_3(); 543 | var3_233 = errno; 544 | int var234_aux = var3_233 * var232_aux; 545 | valid_pass[3] = var234_aux; 546 | /* GENERATE BYTE 32 (0x20) */ 547 | int var2_235; 548 | generate_error_2(); 549 | var2_235 = errno; 550 | int var2_236; 551 | generate_error_2(); 552 | var2_236 = errno; 553 | int var237_aux = var2_236 * var2_235; 554 | int var2_238; 555 | generate_error_2(); 556 | var2_238 = errno; 557 | int var239_aux = var2_238 * var237_aux; 558 | int var2_240; 559 | generate_error_2(); 560 | var2_240 = errno; 561 | int var241_aux = var2_240 * var239_aux; 562 | int var2_242; 563 | generate_error_2(); 564 | var2_242 = errno; 565 | int var243_aux = var2_242 * var241_aux; 566 | valid_pass[4] = var243_aux; 567 | /* GENERATE BYTE 100 (0x64) */ 568 | int var2_244; 569 | generate_error_2(); 570 | var2_244 = errno; 571 | int var2_245; 572 | generate_error_2(); 573 | var2_245 = errno; 574 | int var246_aux = var2_245 * var2_244; 575 | int var2_247; 576 | generate_error_2(); 577 | var2_247 = errno; 578 | int var2_248; 579 | generate_error_2(); 580 | var2_248 = errno; 581 | int var249_aux = var2_248 + var2_247; 582 | int var1_250; 583 | generate_error_1(); 584 | var1_250 = errno; 585 | int var251_aux = var1_250 + var249_aux; 586 | int var252_aux = var251_aux * var246_aux; 587 | int var2_253; 588 | generate_error_2(); 589 | var2_253 = errno; 590 | int var2_254; 591 | generate_error_2(); 592 | var2_254 = errno; 593 | int var255_aux = var2_254 + var2_253; 594 | int var1_256; 595 | generate_error_1(); 596 | var1_256 = errno; 597 | int var257_aux = var1_256 + var255_aux; 598 | int var258_aux = var257_aux * var252_aux; 599 | valid_pass[5] = var258_aux; 600 | /* GENERATE BYTE 111 (0x6F) */ 601 | int var3_259; 602 | generate_error_3(); 603 | var3_259 = errno; 604 | int var2_260; 605 | generate_error_2(); 606 | var2_260 = errno; 607 | int var3_261; 608 | generate_error_3(); 609 | var3_261 = errno; 610 | int var262_aux = var3_261 * var2_260; 611 | int var3_263; 612 | generate_error_3(); 613 | var3_263 = errno; 614 | int var264_aux = var3_263 * var262_aux; 615 | int var2_265; 616 | generate_error_2(); 617 | var2_265 = errno; 618 | int var3_266; 619 | generate_error_3(); 620 | var3_266 = errno; 621 | int var267_aux = var3_266 * var2_265; 622 | int var3_268; 623 | generate_error_3(); 624 | var3_268 = errno; 625 | int var269_aux = var3_268 * var267_aux; 626 | int var270_aux = var269_aux + var264_aux; 627 | int var1_271; 628 | generate_error_1(); 629 | var1_271 = errno; 630 | int var272_aux = var1_271 + var270_aux; 631 | int var273_aux = var272_aux * var3_259; 632 | valid_pass[6] = var273_aux; 633 | /* GENERATE BYTE 110 (0x6E) */ 634 | int var2_274; 635 | generate_error_2(); 636 | var2_274 = errno; 637 | int var2_275; 638 | generate_error_2(); 639 | var2_275 = errno; 640 | int var2_276; 641 | generate_error_2(); 642 | var2_276 = errno; 643 | int var277_aux = var2_276 + var2_275; 644 | int var1_278; 645 | generate_error_1(); 646 | var1_278 = errno; 647 | int var279_aux = var1_278 + var277_aux; 648 | int var280_aux = var279_aux * var2_274; 649 | int var2_281; 650 | generate_error_2(); 651 | var2_281 = errno; 652 | int var2_282; 653 | generate_error_2(); 654 | var2_282 = errno; 655 | int var283_aux = var2_282 + var2_281; 656 | int var1_284; 657 | generate_error_1(); 658 | var1_284 = errno; 659 | int var285_aux = var1_284 + var283_aux; 660 | int var2_286; 661 | generate_error_2(); 662 | var2_286 = errno; 663 | int var2_287; 664 | generate_error_2(); 665 | var2_287 = errno; 666 | int var288_aux = var2_287 + var2_286; 667 | int var1_289; 668 | generate_error_1(); 669 | var1_289 = errno; 670 | int var290_aux = var1_289 + var288_aux; 671 | int var291_aux = var290_aux + var285_aux; 672 | int var1_292; 673 | generate_error_1(); 674 | var1_292 = errno; 675 | int var293_aux = var1_292 + var291_aux; 676 | int var294_aux = var293_aux * var280_aux; 677 | valid_pass[7] = var294_aux; 678 | /* GENERATE BYTE 101 (0x65) */ 679 | int var2_295; 680 | generate_error_2(); 681 | var2_295 = errno; 682 | int var2_296; 683 | generate_error_2(); 684 | var2_296 = errno; 685 | int var2_297; 686 | generate_error_2(); 687 | var2_297 = errno; 688 | int var298_aux = var2_297 + var2_296; 689 | int var1_299; 690 | generate_error_1(); 691 | var1_299 = errno; 692 | int var300_aux = var1_299 + var298_aux; 693 | int var301_aux = var300_aux * var2_295; 694 | int var2_302; 695 | generate_error_2(); 696 | var2_302 = errno; 697 | int var2_303; 698 | generate_error_2(); 699 | var2_303 = errno; 700 | int var304_aux = var2_303 + var2_302; 701 | int var1_305; 702 | generate_error_1(); 703 | var1_305 = errno; 704 | int var306_aux = var1_305 + var304_aux; 705 | int var307_aux = var306_aux * var301_aux; 706 | int var2_308; 707 | generate_error_2(); 708 | var2_308 = errno; 709 | int var2_309; 710 | generate_error_2(); 711 | var2_309 = errno; 712 | int var2_310; 713 | generate_error_2(); 714 | var2_310 = errno; 715 | int var311_aux = var2_310 + var2_309; 716 | int var1_312; 717 | generate_error_1(); 718 | var1_312 = errno; 719 | int var313_aux = var1_312 + var311_aux; 720 | int var314_aux = var313_aux * var2_308; 721 | int var2_315; 722 | generate_error_2(); 723 | var2_315 = errno; 724 | int var2_316; 725 | generate_error_2(); 726 | var2_316 = errno; 727 | int var317_aux = var2_316 + var2_315; 728 | int var1_318; 729 | generate_error_1(); 730 | var1_318 = errno; 731 | int var319_aux = var1_318 + var317_aux; 732 | int var320_aux = var319_aux * var314_aux; 733 | int var321_aux = var320_aux + var307_aux; 734 | int var1_322; 735 | generate_error_1(); 736 | var1_322 = errno; 737 | int var323_aux = var1_322 + var321_aux; 738 | valid_pass[8] = var323_aux; 739 | /* GENERATE BYTE 33 (0x21) */ 740 | int var3_324; 741 | generate_error_3(); 742 | var3_324 = errno; 743 | int var2_325; 744 | generate_error_2(); 745 | var2_325 = errno; 746 | int var2_326; 747 | generate_error_2(); 748 | var2_326 = errno; 749 | int var327_aux = var2_326 + var2_325; 750 | int var1_328; 751 | generate_error_1(); 752 | var1_328 = errno; 753 | int var329_aux = var1_328 + var327_aux; 754 | int var2_330; 755 | generate_error_2(); 756 | var2_330 = errno; 757 | int var2_331; 758 | generate_error_2(); 759 | var2_331 = errno; 760 | int var332_aux = var2_331 + var2_330; 761 | int var1_333; 762 | generate_error_1(); 763 | var1_333 = errno; 764 | int var334_aux = var1_333 + var332_aux; 765 | int var335_aux = var334_aux + var329_aux; 766 | int var1_336; 767 | generate_error_1(); 768 | var1_336 = errno; 769 | int var337_aux = var1_336 + var335_aux; 770 | int var338_aux = var337_aux * var3_324; 771 | valid_pass[9] = var338_aux; 772 | valid_pass[10] = 0; 773 | printf("%s\n", valid_pass); 774 | } else 775 | { 776 | char invalid_pass[11]; 777 | /* GENERATE BYTE 84 (0x54) */ 778 | int var2_339; 779 | generate_error_2(); 780 | var2_339 = errno; 781 | int var2_340; 782 | generate_error_2(); 783 | var2_340 = errno; 784 | int var341_aux = var2_340 * var2_339; 785 | int var3_342; 786 | generate_error_3(); 787 | var3_342 = errno; 788 | int var343_aux = var3_342 * var341_aux; 789 | int var3_344; 790 | generate_error_3(); 791 | var3_344 = errno; 792 | int var3_345; 793 | generate_error_3(); 794 | var3_345 = errno; 795 | int var346_aux = var3_345 + var3_344; 796 | int var1_347; 797 | generate_error_1(); 798 | var1_347 = errno; 799 | int var348_aux = var1_347 + var346_aux; 800 | int var349_aux = var348_aux * var343_aux; 801 | invalid_pass[0] = var349_aux; 802 | /* GENERATE BYTE 114 (0x72) */ 803 | int var2_350; 804 | generate_error_2(); 805 | var2_350 = errno; 806 | int var3_351; 807 | generate_error_3(); 808 | var3_351 = errno; 809 | int var352_aux = var3_351 * var2_350; 810 | int var3_353; 811 | generate_error_3(); 812 | var3_353 = errno; 813 | int var3_354; 814 | generate_error_3(); 815 | var3_354 = errno; 816 | int var355_aux = var3_354 * var3_353; 817 | int var3_356; 818 | generate_error_3(); 819 | var3_356 = errno; 820 | int var3_357; 821 | generate_error_3(); 822 | var3_357 = errno; 823 | int var358_aux = var3_357 * var3_356; 824 | int var359_aux = var358_aux + var355_aux; 825 | int var1_360; 826 | generate_error_1(); 827 | var1_360 = errno; 828 | int var361_aux = var1_360 + var359_aux; 829 | int var362_aux = var361_aux * var352_aux; 830 | invalid_pass[1] = var362_aux; 831 | /* GENERATE BYTE 121 (0x79) */ 832 | int var2_363; 833 | generate_error_2(); 834 | var2_363 = errno; 835 | int var2_364; 836 | generate_error_2(); 837 | var2_364 = errno; 838 | int var365_aux = var2_364 + var2_363; 839 | int var1_366; 840 | generate_error_1(); 841 | var1_366 = errno; 842 | int var367_aux = var1_366 + var365_aux; 843 | int var2_368; 844 | generate_error_2(); 845 | var2_368 = errno; 846 | int var2_369; 847 | generate_error_2(); 848 | var2_369 = errno; 849 | int var370_aux = var2_369 + var2_368; 850 | int var1_371; 851 | generate_error_1(); 852 | var1_371 = errno; 853 | int var372_aux = var1_371 + var370_aux; 854 | int var373_aux = var372_aux + var367_aux; 855 | int var1_374; 856 | generate_error_1(); 857 | var1_374 = errno; 858 | int var375_aux = var1_374 + var373_aux; 859 | int var2_376; 860 | generate_error_2(); 861 | var2_376 = errno; 862 | int var2_377; 863 | generate_error_2(); 864 | var2_377 = errno; 865 | int var378_aux = var2_377 + var2_376; 866 | int var1_379; 867 | generate_error_1(); 868 | var1_379 = errno; 869 | int var380_aux = var1_379 + var378_aux; 870 | int var2_381; 871 | generate_error_2(); 872 | var2_381 = errno; 873 | int var2_382; 874 | generate_error_2(); 875 | var2_382 = errno; 876 | int var383_aux = var2_382 + var2_381; 877 | int var1_384; 878 | generate_error_1(); 879 | var1_384 = errno; 880 | int var385_aux = var1_384 + var383_aux; 881 | int var386_aux = var385_aux + var380_aux; 882 | int var1_387; 883 | generate_error_1(); 884 | var1_387 = errno; 885 | int var388_aux = var1_387 + var386_aux; 886 | int var389_aux = var388_aux * var375_aux; 887 | invalid_pass[2] = var389_aux; 888 | /* GENERATE BYTE 32 (0x20) */ 889 | int var2_390; 890 | generate_error_2(); 891 | var2_390 = errno; 892 | int var2_391; 893 | generate_error_2(); 894 | var2_391 = errno; 895 | int var392_aux = var2_391 * var2_390; 896 | int var2_393; 897 | generate_error_2(); 898 | var2_393 = errno; 899 | int var394_aux = var2_393 * var392_aux; 900 | int var2_395; 901 | generate_error_2(); 902 | var2_395 = errno; 903 | int var396_aux = var2_395 * var394_aux; 904 | int var2_397; 905 | generate_error_2(); 906 | var2_397 = errno; 907 | int var398_aux = var2_397 * var396_aux; 908 | invalid_pass[3] = var398_aux; 909 | /* GENERATE BYTE 97 (0x61) */ 910 | int var2_399; 911 | generate_error_2(); 912 | var2_399 = errno; 913 | int var2_400; 914 | generate_error_2(); 915 | var2_400 = errno; 916 | int var401_aux = var2_400 * var2_399; 917 | int var2_402; 918 | generate_error_2(); 919 | var2_402 = errno; 920 | int var403_aux = var2_402 * var401_aux; 921 | int var2_404; 922 | generate_error_2(); 923 | var2_404 = errno; 924 | int var405_aux = var2_404 * var403_aux; 925 | int var3_406; 926 | generate_error_3(); 927 | var3_406 = errno; 928 | int var407_aux = var3_406 * var405_aux; 929 | int var2_408; 930 | generate_error_2(); 931 | var2_408 = errno; 932 | int var2_409; 933 | generate_error_2(); 934 | var2_409 = errno; 935 | int var410_aux = var2_409 * var2_408; 936 | int var2_411; 937 | generate_error_2(); 938 | var2_411 = errno; 939 | int var412_aux = var2_411 * var410_aux; 940 | int var2_413; 941 | generate_error_2(); 942 | var2_413 = errno; 943 | int var414_aux = var2_413 * var412_aux; 944 | int var3_415; 945 | generate_error_3(); 946 | var3_415 = errno; 947 | int var416_aux = var3_415 * var414_aux; 948 | int var417_aux = var416_aux + var407_aux; 949 | int var1_418; 950 | generate_error_1(); 951 | var1_418 = errno; 952 | int var419_aux = var1_418 + var417_aux; 953 | invalid_pass[4] = var419_aux; 954 | /* GENERATE BYTE 103 (0x67) */ 955 | int var3_420; 956 | generate_error_3(); 957 | var3_420 = errno; 958 | int var17_421; 959 | generate_error_17(); 960 | var17_421 = errno; 961 | int var422_aux = var17_421 * var3_420; 962 | int var3_423; 963 | generate_error_3(); 964 | var3_423 = errno; 965 | int var17_424; 966 | generate_error_17(); 967 | var17_424 = errno; 968 | int var425_aux = var17_424 * var3_423; 969 | int var426_aux = var425_aux + var422_aux; 970 | int var1_427; 971 | generate_error_1(); 972 | var1_427 = errno; 973 | int var428_aux = var1_427 + var426_aux; 974 | invalid_pass[5] = var428_aux; 975 | /* GENERATE BYTE 97 (0x61) */ 976 | int var2_429; 977 | generate_error_2(); 978 | var2_429 = errno; 979 | int var2_430; 980 | generate_error_2(); 981 | var2_430 = errno; 982 | int var431_aux = var2_430 * var2_429; 983 | int var2_432; 984 | generate_error_2(); 985 | var2_432 = errno; 986 | int var433_aux = var2_432 * var431_aux; 987 | int var2_434; 988 | generate_error_2(); 989 | var2_434 = errno; 990 | int var435_aux = var2_434 * var433_aux; 991 | int var3_436; 992 | generate_error_3(); 993 | var3_436 = errno; 994 | int var437_aux = var3_436 * var435_aux; 995 | int var2_438; 996 | generate_error_2(); 997 | var2_438 = errno; 998 | int var2_439; 999 | generate_error_2(); 1000 | var2_439 = errno; 1001 | int var440_aux = var2_439 * var2_438; 1002 | int var2_441; 1003 | generate_error_2(); 1004 | var2_441 = errno; 1005 | int var442_aux = var2_441 * var440_aux; 1006 | int var2_443; 1007 | generate_error_2(); 1008 | var2_443 = errno; 1009 | int var444_aux = var2_443 * var442_aux; 1010 | int var3_445; 1011 | generate_error_3(); 1012 | var3_445 = errno; 1013 | int var446_aux = var3_445 * var444_aux; 1014 | int var447_aux = var446_aux + var437_aux; 1015 | int var1_448; 1016 | generate_error_1(); 1017 | var1_448 = errno; 1018 | int var449_aux = var1_448 + var447_aux; 1019 | invalid_pass[6] = var449_aux; 1020 | /* GENERATE BYTE 105 (0x69) */ 1021 | int var3_450; 1022 | generate_error_3(); 1023 | var3_450 = errno; 1024 | int var2_451; 1025 | generate_error_2(); 1026 | var2_451 = errno; 1027 | int var2_452; 1028 | generate_error_2(); 1029 | var2_452 = errno; 1030 | int var453_aux = var2_452 + var2_451; 1031 | int var1_454; 1032 | generate_error_1(); 1033 | var1_454 = errno; 1034 | int var455_aux = var1_454 + var453_aux; 1035 | int var456_aux = var455_aux * var3_450; 1036 | int var3_457; 1037 | generate_error_3(); 1038 | var3_457 = errno; 1039 | int var3_458; 1040 | generate_error_3(); 1041 | var3_458 = errno; 1042 | int var459_aux = var3_458 + var3_457; 1043 | int var1_460; 1044 | generate_error_1(); 1045 | var1_460 = errno; 1046 | int var461_aux = var1_460 + var459_aux; 1047 | int var462_aux = var461_aux * var456_aux; 1048 | invalid_pass[7] = var462_aux; 1049 | /* GENERATE BYTE 110 (0x6E) */ 1050 | int var2_463; 1051 | generate_error_2(); 1052 | var2_463 = errno; 1053 | int var2_464; 1054 | generate_error_2(); 1055 | var2_464 = errno; 1056 | int var2_465; 1057 | generate_error_2(); 1058 | var2_465 = errno; 1059 | int var466_aux = var2_465 + var2_464; 1060 | int var1_467; 1061 | generate_error_1(); 1062 | var1_467 = errno; 1063 | int var468_aux = var1_467 + var466_aux; 1064 | int var469_aux = var468_aux * var2_463; 1065 | int var2_470; 1066 | generate_error_2(); 1067 | var2_470 = errno; 1068 | int var2_471; 1069 | generate_error_2(); 1070 | var2_471 = errno; 1071 | int var472_aux = var2_471 + var2_470; 1072 | int var1_473; 1073 | generate_error_1(); 1074 | var1_473 = errno; 1075 | int var474_aux = var1_473 + var472_aux; 1076 | int var2_475; 1077 | generate_error_2(); 1078 | var2_475 = errno; 1079 | int var2_476; 1080 | generate_error_2(); 1081 | var2_476 = errno; 1082 | int var477_aux = var2_476 + var2_475; 1083 | int var1_478; 1084 | generate_error_1(); 1085 | var1_478 = errno; 1086 | int var479_aux = var1_478 + var477_aux; 1087 | int var480_aux = var479_aux + var474_aux; 1088 | int var1_481; 1089 | generate_error_1(); 1090 | var1_481 = errno; 1091 | int var482_aux = var1_481 + var480_aux; 1092 | int var483_aux = var482_aux * var469_aux; 1093 | invalid_pass[8] = var483_aux; 1094 | /* GENERATE BYTE 33 (0x21) */ 1095 | int var3_484; 1096 | generate_error_3(); 1097 | var3_484 = errno; 1098 | int var2_485; 1099 | generate_error_2(); 1100 | var2_485 = errno; 1101 | int var2_486; 1102 | generate_error_2(); 1103 | var2_486 = errno; 1104 | int var487_aux = var2_486 + var2_485; 1105 | int var1_488; 1106 | generate_error_1(); 1107 | var1_488 = errno; 1108 | int var489_aux = var1_488 + var487_aux; 1109 | int var2_490; 1110 | generate_error_2(); 1111 | var2_490 = errno; 1112 | int var2_491; 1113 | generate_error_2(); 1114 | var2_491 = errno; 1115 | int var492_aux = var2_491 + var2_490; 1116 | int var1_493; 1117 | generate_error_1(); 1118 | var1_493 = errno; 1119 | int var494_aux = var1_493 + var492_aux; 1120 | int var495_aux = var494_aux + var489_aux; 1121 | int var1_496; 1122 | generate_error_1(); 1123 | var1_496 = errno; 1124 | int var497_aux = var1_496 + var495_aux; 1125 | int var498_aux = var497_aux * var3_484; 1126 | invalid_pass[9] = var498_aux; 1127 | invalid_pass[10] = 0; 1128 | printf("%s\n", invalid_pass); 1129 | } 1130 | 1131 | return 0; 1132 | } 1133 | --------------------------------------------------------------------------------