├── Images ├── After.jpg ├── Before.png └── Output.jpg ├── README.md ├── SegmentEncryption.sln └── SegmentEncryption ├── SED.h ├── SegmentEncryption.cpp ├── SegmentEncryption.vcxproj ├── SegmentEncryption.vcxproj.filters └── SegmentEncryption.vcxproj.user /Images/After.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/C5Hackr/Segment-Encryption/b363a2f71da32b16793758ffe98a69a56172be01/Images/After.jpg -------------------------------------------------------------------------------- /Images/Before.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/C5Hackr/Segment-Encryption/b363a2f71da32b16793758ffe98a69a56172be01/Images/Before.png -------------------------------------------------------------------------------- /Images/Output.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/C5Hackr/Segment-Encryption/b363a2f71da32b16793758ffe98a69a56172be01/Images/Output.jpg -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Segment-Encryption (SED) 2 | 3 | Segment-Encryption-Decryption (SED) is a project I made during a all nighter for fun as a proof of concept for evading modern AntiVirus memory scanners by encrypting a function during runtime, then decrypting it when the function needs to be executed, then re-encrypting the function once the function has finished executing. 4 | 5 | ## Quick Note 6 | Starring the repo helps a lot! 7 | 8 | ## Screenshots 9 | 10 | **Before:** 11 | ![image](https://raw.githubusercontent.com/C5Hackr/Segment-Encryption/main/Images/Before.png) 12 | **After:** 13 | ![image](https://raw.githubusercontent.com/C5Hackr/Segment-Encryption/main/Images/After.jpg) 14 | **Output (Execution):** 15 | ![image](https://raw.githubusercontent.com/C5Hackr/Segment-Encryption/main/Images/Output.jpg) 16 | 17 | ## Disclaimer 18 | This project was made for educational purposes only. I am not responsible if you choose to use this illegally/maliciously. 19 | -------------------------------------------------------------------------------- /SegmentEncryption.sln: -------------------------------------------------------------------------------- 1 |  2 | Microsoft Visual Studio Solution File, Format Version 12.00 3 | # Visual Studio Version 17 4 | VisualStudioVersion = 17.9.34728.123 5 | MinimumVisualStudioVersion = 10.0.40219.1 6 | Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "SegmentEncryption", "SegmentEncryption\SegmentEncryption.vcxproj", "{97D023AF-2DC5-49E1-B6AE-37897269534C}" 7 | EndProject 8 | Global 9 | GlobalSection(SolutionConfigurationPlatforms) = preSolution 10 | Debug|x64 = Debug|x64 11 | Debug|x86 = Debug|x86 12 | Release|x64 = Release|x64 13 | Release|x86 = Release|x86 14 | EndGlobalSection 15 | GlobalSection(ProjectConfigurationPlatforms) = postSolution 16 | {97D023AF-2DC5-49E1-B6AE-37897269534C}.Debug|x64.ActiveCfg = Debug|x64 17 | {97D023AF-2DC5-49E1-B6AE-37897269534C}.Debug|x64.Build.0 = Debug|x64 18 | {97D023AF-2DC5-49E1-B6AE-37897269534C}.Debug|x86.ActiveCfg = Debug|Win32 19 | {97D023AF-2DC5-49E1-B6AE-37897269534C}.Debug|x86.Build.0 = Debug|Win32 20 | {97D023AF-2DC5-49E1-B6AE-37897269534C}.Release|x64.ActiveCfg = Release|x64 21 | {97D023AF-2DC5-49E1-B6AE-37897269534C}.Release|x64.Build.0 = Release|x64 22 | {97D023AF-2DC5-49E1-B6AE-37897269534C}.Release|x86.ActiveCfg = Release|Win32 23 | {97D023AF-2DC5-49E1-B6AE-37897269534C}.Release|x86.Build.0 = Release|Win32 24 | EndGlobalSection 25 | GlobalSection(SolutionProperties) = preSolution 26 | HideSolutionNode = FALSE 27 | EndGlobalSection 28 | GlobalSection(ExtensibilityGlobals) = postSolution 29 | SolutionGuid = {194DFD2E-205C-4915-8ED1-9DB87B956093} 30 | EndGlobalSection 31 | EndGlobal 32 | -------------------------------------------------------------------------------- /SegmentEncryption/SED.h: -------------------------------------------------------------------------------- 1 | #include 2 | 3 | #define USE_XOR_ENCRYPTION TRUE 4 | 5 | #if USE_XOR_ENCRYPTION 6 | unsigned char xor_key[] = "YwAYwAonvsgHUbnoYwAonvsgHUbnnvsgHUbn"; 7 | size_t xor_key_size = NULL; 8 | #endif 9 | 10 | typedef struct { 11 | uintptr_t FunctionAddress; 12 | uintptr_t ReturnAddress; 13 | __int64 functionSize; 14 | char* originalInstructions; 15 | BOOL IsJMPReturn; 16 | } EncryptedFunctionList; 17 | 18 | EncryptedFunctionList* EncryptedFunctions = NULL; 19 | size_t num_EncryptedFunctions = 0; 20 | 21 | BOOL EncryptHandlerInitialized = FALSE; 22 | 23 | #define CALL_FUNCTION_SAFE(ptr, args) ((void*(*)(va_list))(ptr))(args) 24 | 25 | #pragma optimize("", off) 26 | __declspec(dllexport) void* EndSED(void* returnValue) 27 | { 28 | return returnValue; 29 | } 30 | #pragma optimize("", on) 31 | 32 | #if USE_XOR_ENCRYPTION 33 | void xor_encrypt(unsigned char* data, size_t data_len, unsigned char* key, size_t key_len) 34 | { 35 | for (size_t i = 0; i < data_len; i++) 36 | { 37 | data[i] ^= key[i % key_len]; 38 | } 39 | } 40 | 41 | void xor_decrypt(unsigned char* data, size_t data_len, unsigned char* key, size_t key_len) 42 | { 43 | for (size_t i = 0; i < data_len; i++) 44 | { 45 | data[i] ^= key[i % key_len]; 46 | } 47 | } 48 | #endif 49 | 50 | __declspec(noinline) void EncryptCodeSection(LPVOID address, char* originalInstructions, int SIZE_OF_FUNCTION) 51 | { 52 | memcpy(originalInstructions, address, SIZE_OF_FUNCTION); 53 | #if USE_XOR_ENCRYPTION 54 | xor_encrypt((unsigned char*)originalInstructions, SIZE_OF_FUNCTION, xor_key, xor_key_size); 55 | #endif 56 | DWORD oldProtect; 57 | VirtualProtect(address, SIZE_OF_FUNCTION, PAGE_EXECUTE_READWRITE, &oldProtect); 58 | for (int i = 0; i < SIZE_OF_FUNCTION; i++) 59 | { 60 | #if _WIN64 61 | * ((char*)((uintptr_t)address + i)) = 0x1F; 62 | #else 63 | * ((char*)((uintptr_t)address + i)) = 0xFE; 64 | #endif 65 | } 66 | VirtualProtect(address, SIZE_OF_FUNCTION, oldProtect, &oldProtect); 67 | } 68 | 69 | __declspec(noinline) BOOL SetBreakpoint(LPVOID address) 70 | { 71 | DWORD oldProtect; 72 | VirtualProtect(address, sizeof(char), PAGE_EXECUTE_READWRITE, &oldProtect); 73 | *((char*)address) = 0xCC; 74 | VirtualProtect(address, sizeof(char), oldProtect, &oldProtect); 75 | return TRUE; 76 | } 77 | 78 | __declspec(noinline) LONG WINAPI VEHDecryptionHandler(PEXCEPTION_POINTERS exceptions) 79 | { 80 | if (exceptions->ExceptionRecord->ExceptionCode == EXCEPTION_ILLEGAL_INSTRUCTION) 81 | { 82 | for (size_t i = 0; i < num_EncryptedFunctions; i++) 83 | { 84 | if ((uintptr_t)((uintptr_t)exceptions->ExceptionRecord->ExceptionAddress) == (uintptr_t)EncryptedFunctions[i].FunctionAddress) 85 | { 86 | DWORD oldProtect; 87 | VirtualProtect((LPVOID)EncryptedFunctions[i].FunctionAddress, EncryptedFunctions[i].functionSize, PAGE_EXECUTE_READWRITE, &oldProtect); 88 | #if USE_XOR_ENCRYPTION 89 | xor_decrypt((unsigned char*)EncryptedFunctions[i].originalInstructions, EncryptedFunctions[i].functionSize, xor_key, xor_key_size); 90 | #endif 91 | memcpy((LPVOID)EncryptedFunctions[i].FunctionAddress, EncryptedFunctions[i].originalInstructions, EncryptedFunctions[i].functionSize); 92 | VirtualProtect((LPVOID)EncryptedFunctions[i].FunctionAddress, EncryptedFunctions[i].functionSize, oldProtect, &oldProtect); 93 | SetBreakpoint((LPVOID)EncryptedFunctions[i].ReturnAddress); 94 | return EXCEPTION_CONTINUE_EXECUTION; 95 | } 96 | } 97 | return EXCEPTION_CONTINUE_SEARCH; 98 | } 99 | else if (exceptions->ExceptionRecord->ExceptionCode == EXCEPTION_BREAKPOINT) 100 | { 101 | for (size_t i = 0; i < num_EncryptedFunctions; i++) 102 | { 103 | if ((uintptr_t)((uintptr_t)exceptions->ExceptionRecord->ExceptionAddress) == (uintptr_t)EncryptedFunctions[i].ReturnAddress) 104 | { 105 | DWORD oldProtect; 106 | VirtualProtect(exceptions->ExceptionRecord->ExceptionAddress, EncryptedFunctions[i].functionSize, PAGE_EXECUTE_READWRITE, &oldProtect); 107 | if (EncryptedFunctions[i].IsJMPReturn) 108 | { 109 | *((char*)exceptions->ExceptionRecord->ExceptionAddress) = 0xE9; 110 | } 111 | else 112 | { 113 | *((char*)exceptions->ExceptionRecord->ExceptionAddress) = 0xE8; 114 | } 115 | VirtualProtect(exceptions->ExceptionRecord->ExceptionAddress, EncryptedFunctions[i].functionSize, oldProtect, &oldProtect); 116 | EncryptCodeSection((LPVOID)EncryptedFunctions[i].FunctionAddress, EncryptedFunctions[i].originalInstructions, EncryptedFunctions[i].functionSize); 117 | return EXCEPTION_CONTINUE_EXECUTION; 118 | } 119 | } 120 | return EXCEPTION_CONTINUE_SEARCH; 121 | } 122 | else 123 | { 124 | return EXCEPTION_CONTINUE_SEARCH; 125 | } 126 | } 127 | 128 | CRITICAL_SECTION cs; 129 | 130 | __declspec(noinline) void EncryptFunction(uintptr_t functionPointer) 131 | { 132 | if (!EncryptHandlerInitialized) 133 | { 134 | InitializeCriticalSection(&cs); 135 | xor_key_size = strlen((char*)xor_key); 136 | EncryptHandlerInitialized = TRUE; 137 | AddVectoredExceptionHandler(1, &VEHDecryptionHandler); 138 | } 139 | num_EncryptedFunctions++; 140 | EncryptedFunctions = (EncryptedFunctionList*)realloc(EncryptedFunctions, num_EncryptedFunctions * sizeof(EncryptedFunctionList)); 141 | EncryptedFunctionList* currentHookInfo = &EncryptedFunctions[num_EncryptedFunctions - 1]; 142 | int SIZE_OF_FUNCTION = 0; 143 | unsigned char* current_address = (unsigned char*)((void*)functionPointer); 144 | while (TRUE) 145 | { 146 | BYTE* ptr = (BYTE*)current_address; 147 | if (ptr[0] == 0xE9 && *((DWORD*)(current_address + 1)) == ((DWORD)EndSED - ((DWORD)current_address + 5))) 148 | { 149 | currentHookInfo->IsJMPReturn = TRUE; 150 | currentHookInfo->ReturnAddress = (uintptr_t)current_address; 151 | break; 152 | } 153 | else if (ptr[0] == 0xE8 && *((DWORD*)(current_address + 1)) == ((DWORD)EndSED - ((DWORD)current_address + 5))) 154 | { 155 | currentHookInfo->IsJMPReturn = FALSE; 156 | currentHookInfo->ReturnAddress = (uintptr_t)current_address; 157 | break; 158 | } 159 | current_address++; 160 | SIZE_OF_FUNCTION++; 161 | } 162 | currentHookInfo->FunctionAddress = functionPointer; 163 | currentHookInfo->functionSize = SIZE_OF_FUNCTION; 164 | currentHookInfo->originalInstructions = (char*)malloc(SIZE_OF_FUNCTION * sizeof(char)); 165 | memcpy(currentHookInfo->originalInstructions, (void*)functionPointer, SIZE_OF_FUNCTION); 166 | EncryptCodeSection((LPVOID)functionPointer, currentHookInfo->originalInstructions, SIZE_OF_FUNCTION); 167 | } 168 | 169 | __declspec(noinline) void* CallFunction(void* ptr, ...) 170 | { 171 | EnterCriticalSection(&cs); 172 | va_list args; 173 | va_start(args, ptr); 174 | void* returnValue = CALL_FUNCTION_SAFE(ptr, args); 175 | va_end(args); 176 | LeaveCriticalSection(&cs); 177 | return returnValue; 178 | } 179 | -------------------------------------------------------------------------------- /SegmentEncryption/SegmentEncryption.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include "SED.h" 5 | 6 | #pragma region Math Stuff 7 | int factorial(int n) { 8 | if (n == 0 || n == 1) { 9 | return 1; 10 | } 11 | else { 12 | return n * factorial(n - 1); 13 | } 14 | } 15 | int fibonacci(int n) { 16 | if (n <= 1) { 17 | return n; 18 | } 19 | else { 20 | return fibonacci(n - 1) + fibonacci(n - 2); 21 | } 22 | } 23 | void printArray(int arr[], int size) { 24 | int i; 25 | for (i = 0; i < size; i++) { 26 | printf("%d ", arr[i]); 27 | } 28 | } 29 | void modifyArray(int arr[], int size) { 30 | int i; 31 | for (i = 0; i < size; i++) { 32 | arr[i] *= 2; 33 | } 34 | } 35 | 36 | #define SQUARE(x) ((x) * (x)) 37 | #define MAX(a, b) ((a) > (b) ? (a) : (b)) 38 | 39 | // Structure definition 40 | struct Person { 41 | char name[50]; 42 | int age; 43 | }; 44 | 45 | int gcd(int a, int b) { 46 | if (b == 0) 47 | return a; 48 | else 49 | return gcd(b, a % b); 50 | } 51 | void swap(int* xp, int* yp) { 52 | int temp = *xp; 53 | *xp = *yp; 54 | *yp = temp; 55 | } 56 | void bubbleSort(int arr[], int n) { 57 | for (int i = 0; i < n - 1; i++) { 58 | for (int j = 0; j < n - i - 1; j++) { 59 | if (arr[j] > arr[j + 1]) { 60 | swap(&arr[j], &arr[j + 1]); 61 | } 62 | } 63 | } 64 | } 65 | #pragma endregion 66 | 67 | __declspec(noinline) void* testCCode(void* DummyArgument, int numberArgument) 68 | { 69 | // Arg test 70 | printf("Arg 1 is: %d | Function will return %d + 1\n", numberArgument, numberArgument); 71 | 72 | // Arithmetic operations 73 | int a = 5, b = 3; 74 | int result = a + b * 2 - 1; 75 | 76 | // Logical operations 77 | int x = 10, y = 20; 78 | int logical_result = (x > y) && (x != 0); 79 | 80 | // Control structures 81 | if (a > b) { 82 | printf("a is greater than b\n"); 83 | } 84 | else { 85 | printf("b is greater than or equal to a\n"); 86 | } 87 | 88 | // Pointers and arrays 89 | int arr[5] = { 1, 2, 3, 4, 5 }; 90 | int* ptr = arr; 91 | printf("First element of array: %d\n", *ptr); 92 | printf("Third element of array: %d\n", *(ptr + 2)); 93 | 94 | // Loops 95 | printf("Array elements: "); 96 | printArray(arr, 5); 97 | printf("\n"); 98 | 99 | // Function call 100 | int factorial_result = factorial(5); 101 | printf("Factorial of 5: %d\n", factorial_result); 102 | 103 | // Fibonacci sequence 104 | printf("Fibonacci sequence up to 10: "); 105 | int i; 106 | for (i = 0; i < 10; i++) { 107 | printf("%d ", fibonacci(i)); 108 | } 109 | printf("\n"); 110 | 111 | // Dynamic memory allocation 112 | int* dynamic_array = (int*)malloc(3 * sizeof(int)); 113 | dynamic_array[0] = 10; 114 | dynamic_array[1] = 20; 115 | dynamic_array[2] = 30; 116 | printf("Dynamic array elements: "); 117 | printArray(dynamic_array, 3); 118 | free(dynamic_array); 119 | 120 | // Bitwise operations 121 | int num1 = 10, num2 = 5; 122 | printf("Bitwise AND: %d\n", num1 & num2); 123 | printf("Bitwise OR: %d\n", num1 | num2); 124 | printf("Bitwise XOR: %d\n", num1 ^ num2); 125 | 126 | // Sizeof operator 127 | printf("Size of int: %lu bytes\n", sizeof(int)); 128 | 129 | 130 | return EndSED((void*)(numberArgument + 1)); 131 | } 132 | 133 | __declspec(noinline) void* testCCode2(void* DummyArgument, const char* stringArg, int numberArg) 134 | { 135 | // Arg test 136 | printf("Arg 1 is: %s\n", stringArg); 137 | printf("Arg 2 is: %d\n", numberArg); 138 | 139 | // String manipulation 140 | char str1[20] = "Hello"; 141 | char str2[20] = "World"; 142 | char str3[40]; 143 | 144 | // String concatenation 145 | strcpy(str3, str1); 146 | strcat(str3, " "); 147 | strcat(str3, str2); 148 | printf("Concatenated string: %s\n", str3); 149 | 150 | // String length 151 | printf("Length of str1: %lu\n", strlen(str1)); 152 | 153 | // String comparison 154 | printf("Comparison of str1 and str2: %d\n", strcmp(str1, str2)); 155 | 156 | // Structures 157 | struct Person person1; 158 | strcpy(person1.name, "John Doe"); 159 | person1.age = 30; 160 | 161 | struct Person person2 = { "Jane Doe", 25 }; 162 | 163 | printf("Person 1: %s, %d\n", person1.name, person1.age); 164 | printf("Person 2: %s, %d\n", person2.name, person2.age); 165 | 166 | // Dynamic memory 167 | int* arr = (int*)malloc(5 * sizeof(int)); 168 | if (arr == NULL) { 169 | printf("Memory allocation failed!\n"); 170 | return 0; 171 | } 172 | for (int i = 0; i < 5; i++) { 173 | arr[i] = i + 1; 174 | } 175 | printf("Dynamic array elements: "); 176 | for (int i = 0; i < 5; i++) { 177 | printf("%d ", arr[i]); 178 | } 179 | printf("\n"); 180 | free(arr); 181 | 182 | // Macros 183 | int num = 4; 184 | int max_val = MAX(10, 20); 185 | printf("Square of %d: %d\n", num, SQUARE(num)); 186 | printf("Max of 10 and 20: %d\n", max_val); 187 | 188 | // Recursive functions 189 | int gcd_result = gcd(48, 18); 190 | printf("GCD of 48 and 18: %d\n", gcd_result); 191 | 192 | // Sorting algorithms 193 | int sortArr[] = { 64, 34, 25, 12, 22, 11, 90 }; 194 | int n = sizeof(sortArr) / sizeof(sortArr[0]); 195 | bubbleSort(sortArr, n); 196 | printf("Sorted array: "); 197 | for (int i = 0; i < n; i++) { 198 | printf("%d ", sortArr[i]); 199 | } 200 | printf("\n"); 201 | 202 | return EndSED((void*)(0)); 203 | } 204 | 205 | /* 206 | __declspec(noinline) void* DemoFunction(void* DummyArgument) //Function type must be a void*, and must have the __declspec(noinline) attribute and the "void* DummyArgument" as the first argument (this argument is never used but is required to have). 207 | { 208 | printf("[ourfunction] - hello world!\n"); 209 | return EndSED((void*)(0)); //Function must end with "return EndSED((void*)(returnValueHere))". 210 | } 211 | */ 212 | 213 | int main() //Project must be in Release mode, x64 and x86 are both supported. 214 | { 215 | printf("Encrypting code section (Execution will pause once encryption is finished for inspection in x64dbg)...\n"); 216 | EncryptFunction((uintptr_t)testCCode); //Encrypt function "testCCode". 217 | EncryptFunction((uintptr_t)testCCode2); //Encrypt function "testCCode2". 218 | system("pause"); 219 | printf("[START!]\n"); 220 | printf("[======================testCCode========================]\n"); 221 | int returnValue = (int)CallFunction(testCCode, 15); //Call encrypted function "testCCode" with 1 param. 222 | printf("testCCode return value is: %d\n", returnValue); 223 | printf("[======================testCCode2=======================]\n"); 224 | CallFunction(testCCode2, "abcd", 123); //Call encrypted function "testCCode2" with 2 params. 225 | printf("[END!]\n"); 226 | system("pause"); 227 | exit(0); 228 | } 229 | -------------------------------------------------------------------------------- /SegmentEncryption/SegmentEncryption.vcxproj: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | Debug 6 | Win32 7 | 8 | 9 | Release 10 | Win32 11 | 12 | 13 | Debug 14 | x64 15 | 16 | 17 | Release 18 | x64 19 | 20 | 21 | 22 | 17.0 23 | Win32Proj 24 | {97d023af-2dc5-49e1-b6ae-37897269534c} 25 | SegmentEncryption 26 | 10.0 27 | 28 | 29 | 30 | Application 31 | true 32 | v143 33 | Unicode 34 | 35 | 36 | Application 37 | false 38 | v143 39 | true 40 | Unicode 41 | 42 | 43 | Application 44 | true 45 | v143 46 | Unicode 47 | 48 | 49 | Application 50 | false 51 | v143 52 | true 53 | Unicode 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 73 | 74 | 75 | Level3 76 | true 77 | WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) 78 | true 79 | 80 | 81 | Console 82 | true 83 | 84 | 85 | 86 | 87 | Level3 88 | true 89 | true 90 | true 91 | WIN32;NDEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions) 92 | true 93 | 94 | 95 | Console 96 | true 97 | true 98 | true 99 | 100 | 101 | 102 | 103 | Level3 104 | true 105 | _DEBUG;_CONSOLE;%(PreprocessorDefinitions) 106 | true 107 | 108 | 109 | Console 110 | true 111 | 112 | 113 | 114 | 115 | Level3 116 | true 117 | true 118 | true 119 | NDEBUG;_CONSOLE;_CRT_SECURE_NO_WARNINGS;%(PreprocessorDefinitions) 120 | true 121 | 122 | 123 | Console 124 | true 125 | true 126 | true 127 | 128 | 129 | 130 | 131 | 132 | 133 | 134 | 135 | 136 | 137 | 138 | -------------------------------------------------------------------------------- /SegmentEncryption/SegmentEncryption.vcxproj.filters: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | 5 | {4FC737F1-C7A5-4376-A066-2A32D752A2FF} 6 | cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx 7 | 8 | 9 | {93995380-89BD-4b04-88EB-625FBE52EBFB} 10 | h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd 11 | 12 | 13 | {67DA6AB6-F800-4c08-8B7A-83BB121AAD01} 14 | rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms 15 | 16 | 17 | 18 | 19 | Source Files 20 | 21 | 22 | 23 | 24 | Header Files 25 | 26 | 27 | -------------------------------------------------------------------------------- /SegmentEncryption/SegmentEncryption.vcxproj.user: -------------------------------------------------------------------------------- 1 |  2 | 3 | 4 | --------------------------------------------------------------------------------