#ifndef UNICODE

#define UNICODE

#endif

#ifndef _WIN32_WINNT

#define _WIN32_WINNT 0x0600

#endif

#ifndef WIN32_LEAN_AND_MEAN

#define WIN32_LEAN_AND_MEAN

#endif

#include <auth.hpp>

#include <strsafe.h>

#include <windows.h>

#include <string>

#include <stdio.h>

#include <iostream>

#include <shellapi.h>

#include <sstream>

#include <iomanip>

#include <xorstr.hpp>

#include <fstream>

#include <http.h>

#include <stdlib.h>

#include <atlstr.h>

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

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

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

#include <cstdio>

#include <iostream>

#include <memory>

#include <stdexcept>

#include <string>

#include <array>

#include <functional>

#include <vector>

#include <bitset>

#include <psapi.h>

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

#include <thread>

#include "hmac_sha256.h"

#include <cctype>

#include <algorithm>

#include "Security.hpp"

#define SHA256_HASH_SIZE 32

static std::string hexDecode(const std::string& hex);

std::string get_str_between_two_str(const std::string& s, const std::string& start_delim, const std::string& stop_delim);

std::string checksum();

void modify();

void error(std::string message);

std::string signature;

void KeyAuth::api::init()

{

CreateThread(0, 0, (LPTHREAD_START_ROUTINE)modify, 0, 0, 0);

if (ownerid.length() != 10 || secret.length() != 64)

{

MessageBoxA(0, XorStr("Application Not Setup Correctly. Please Watch Video Linked in main.cpp").c_str(), NULL, MB_ICONERROR);

exit(0);

}

UUID uuid = { 0 };

std::string guid;

::UuidCreate(&uuid);

RPC_CSTR szUuid = NULL;

if (::UuidToStringA(&uuid, &szUuid) == RPC_S_OK)

{

guid = (char*)szUuid;

::RpcStringFreeA(&szUuid);

}

std::string sentKey;

sentKey = guid.substr(0, 16);

enckey = sentKey + XorStr("-") + secret;

std::string hash = checksum();

auto data =

XorStr("type=init") +

XorStr("&ver=") + version +

XorStr("&hash=") + hash +

XorStr("&enckey=") + sentKey +

XorStr("&name=") + name +

XorStr("&ownerid=") + ownerid;

auto response = req(data, url);

if (response == XorStr("KeyAuth_Invalid")) {

MessageBoxA(0, XorStr("Application not found. Please copy strings directly from dashboard.").c_str(), NULL, MB_ICONERROR);

exit(0);

}

auto json = response_decoder.parse(response);

std::string message = json[(XorStr("message"))];

// from https://github.com/h5p9sl/hmac_sha256

std::stringstream ss_result;

// Allocate memory for the HMAC

std::vector<uint8_t> out(SHA256_HASH_SIZE);

// Call hmac-sha256 function

hmac_sha256(secret.data(), secret.size(), response.data(), response.size(),

out.data(), out.size());

// Convert `out` to string with std::hex

for (uint8_t x : out) {

ss_result << std::hex << std::setfill('0') << std::setw(2) << (int)x;

}

if (ss_result.str().c_str() != signature) { // check response authenticity, if not authentic program crashes

error("Signature checksum failed. Request was tampered with or session ended most likely. & echo: & echo Message: " + message);

}

load_response_data(json);

if (json[(XorStr("success"))])

{

sessionid = json[(XorStr("sessionid"))];

load_app_data(json[(XorStr("appinfo"))]);

}

else if (json[(XorStr("message"))] == XorStr("invalidver"))

{

std::string dl = json[(XorStr("download"))];

if (dl == "")

{

MessageBoxA(0, XorStr("Version in the loader does match the one on the dashboard, and the download link on dashboard is blank.\n\nTo fix this, either fix the loader so it matches the version on the dashboard. Or if you intended for it to have different versions, update the download link on dashboard so it will auto-update correctly.").c_str(), NULL, MB_ICONERROR);

}

else

{

ShellExecuteA(0, XorStr("open").c_str(), dl.c_str(), 0, 0, SW_SHOWNORMAL);

}

exit(0);

}

}

size_t write_callback(void* contents, size_t size, size_t nmemb, void* userp) {

((std::string*)userp)->append((char*)contents, size * nmemb);

return size * nmemb;

}

static size_t header_callback(char* buffer, size_t size, size_t nitems, void* userdata)

}

void KeyAuth::api::login(std::string username, std::string password)

{

std::string hwid = utils::get_hwid();

auto data =

XorStr("type=login") +

XorStr("&username=") + username +

XorStr("&pass=") + password +

XorStr("&hwid=") + hwid +

XorStr("&sessionid=") + sessionid +

XorStr("&name=") + name +

XorStr("&ownerid=") + ownerid;

auto response = req(data, url);

auto json = response_decoder.parse(response);

std::string message = json[(XorStr("message"))];

// from https://github.com/h5p9sl/hmac_sha256

std::stringstream ss_result;

// Allocate memory for the HMAC

std::vector<uint8_t> out(SHA256_HASH_SIZE);

// Call hmac-sha256 function

hmac_sha256(enckey.data(), enckey.size(), response.data(), response.size(),

out.data(), out.size());

// Convert `out` to string with std::hex

for (uint8_t x : out) {

ss_result << std::hex << std::setfill('0') << std::setw(2) << (int)x;

}

if (ss_result.str() != signature) { // check response authenticity, if not authentic program crashes

error("Signature checksum failed. Request was tampered with or session ended most likely. & echo: & echo Message: " + message);

}

load_response_data(json);

if (json[(XorStr("success"))])

load_user_data(json[(XorStr("info"))]);

}

void KeyAuth::api::chatget(std::string channel)

{

auto data =

XorStr("type=chatget") +

XorStr("&channel=") + channel +

XorStr("&sessionid=") + sessionid +

XorStr("&name=") + name +

XorStr("&ownerid=") + ownerid;

auto response = req(data, url);

auto json = response_decoder.parse(response);

load_channel_data(json);

}

bool KeyAuth::api::chatsend(std::string message, std::string channel)

{

auto data =

XorStr("type=chatsend") +

XorStr("&message=") + message +

XorStr("&channel=") + channel +

XorStr("&sessionid=") + sessionid +

XorStr("&name=") + name +

XorStr("&ownerid=") + ownerid;

auto response = req(data, url);

auto json = response_decoder.parse(response);

load_response_data(json);

return json[("success")];

}

void KeyAuth::api::changeusername(std::string newusername)

{

auto data =

XorStr("type=changeUsername") +

XorStr("&newUsername=") + newusername +

XorStr("&sessionid=") + sessionid +

XorStr("&name=") + name +

XorStr("&ownerid=") + ownerid;

auto response = req(data, url);

auto json = response_decoder.parse(response);

std::string message = json[(XorStr("message"))];

// from https://github.com/h5p9sl/hmac_sha256

std::stringstream ss_result;

// Allocate memory for the HMAC

std::vector<uint8_t> out(SHA256_HASH_SIZE);

// Call hmac-sha256 function

hmac_sha256(enckey.data(), enckey.size(), response.data(), response.size(),

out.data(), out.size());

// Convert `out` to string with std::hex

for (uint8_t x : out) {

ss_result << std::hex << std::setfill('0') << std::setw(2) << (int)x;

}

if (ss_result.str() != signature) { // check response authenticity, if not authentic program crashes

error("Signature checksum failed. Request was tampered with or session ended most likely. & echo: & echo Message: " + message);

}

load_response_data(json);

}

void KeyAuth::api::web_login()

{

// from https://perpetualprogrammers.wordpress.com/2016/05/22/the-http-server-api/

// Initialize the API.

ULONG result = 0;

HTTPAPI_VERSION version = HTTPAPI_VERSION_2;

result = HttpInitialize(version, HTTP_INITIALIZE_SERVER, 0);

// Create server session.

HTTP_SERVER_SESSION_ID serverSessionId;

result = HttpCreateServerSession(version, &serverSessionId, 0);

// Create URL group.

HTTP_URL_GROUP_ID groupId;

result = HttpCreateUrlGroup(serverSessionId, &groupId, 0);

// Create request queue.

HANDLE requestQueueHandle;

result = HttpCreateRequestQueue(version, NULL, NULL, 0, &requestQueueHandle);

// Attach request queue to URL group.

HTTP_BINDING_INFO info;

info.Flags.Present = 1;

info.RequestQueueHandle = requestQueueHandle;

result = HttpSetUrlGroupProperty(groupId, HttpServerBindingProperty, &info, sizeof(info));

// Add URLs to URL group.

PCWSTR url = L"http://localhost:1337/handshake";

result = HttpAddUrlToUrlGroup(groupId, url, 0, 0);

// Announce that it is running.

// wprintf(L"Listening. Please submit requests to: %s\n", url);

// req to: http://localhost:1337/handshake?user=mak&token=2f3e9eccc22ee583cf7bad86c751d865

bool going = true;

while (going == true)

{

// Wait for a request.

HTTP_REQUEST_ID requestId = 0;

HTTP_SET_NULL_ID(&requestId);

int bufferSize = 4096;

int requestSize = sizeof(HTTP_REQUEST) + bufferSize;

BYTE* buffer = new BYTE[requestSize];

PHTTP_REQUEST pRequest = (PHTTP_REQUEST)buffer;

RtlZeroMemory(buffer, requestSize);

ULONG bytesReturned;

result = HttpReceiveHttpRequest(

requestQueueHandle,

requestId,

HTTP_RECEIVE_REQUEST_FLAG_COPY_BODY,

pRequest,

requestSize,

&bytesReturned,

NULL

);

// Display some information about the request.

// wprintf(L"Full URL: %ws\n", pRequest->CookedUrl.pFullUrl);

// wprintf(L" Path: %ws\n", pRequest->CookedUrl.pAbsPath);

// wprintf(L" Query: %ws\n", pRequest->CookedUrl.pQueryString);

std::wstring ws(pRequest->CookedUrl.pQueryString);

std::string myVarS = std::string(ws.begin(), ws.end());

std::string user = get_str_between_two_str(myVarS, "?user=", "&");

std::string token = get_str_between_two_str(myVarS, "&token=", "");

// std::cout << get_str_between_two_str(CW2A(pRequest->CookedUrl.pQueryString), "?", "&") << std::endl;

// break if preflight request from browser

if (pRequest->Verb == HttpVerbOPTIONS)

{

// Respond to the request.

HTTP_RESPONSE response;

RtlZeroMemory(&response, sizeof(response));

response.StatusCode = 200;

response.pReason = static_cast<PCSTR>(XorStr("OK").c_str());

response.ReasonLength = (USHORT)strlen(response.pReason);

response.Headers.KnownHeaders[HttpHeaderServer].pRawValue = XorStr("Apache/2.4.48 nginx/1.12.2").c_str(); // confuse anyone looking at server header

response.Headers.KnownHeaders[HttpHeaderServer].RawValueLength = 24;

response.Headers.KnownHeaders[HttpHeaderVia].pRawValue = XorStr("hugzho's big brain").c_str();

response.Headers.KnownHeaders[HttpHeaderVia].RawValueLength = 18;

response.Headers.KnownHeaders[HttpHeaderRetryAfter].pRawValue = XorStr("never lmao").c_str();

response.Headers.KnownHeaders[HttpHeaderRetryAfter].RawValueLength = 10;

response.Headers.KnownHeaders[HttpHeaderLocation].pRawValue = XorStr("your kernel ;)").c_str();

response.Headers.KnownHeaders[HttpHeaderLocation].RawValueLength = 14;

// https://social.msdn.microsoft.com/Forums/vstudio/en-US/6d468747-2221-4f4a-9156-f98f355a9c08/using-httph-to-set-up-an-https-server-that-is-queried-by-a-client-that-uses-cross-origin-requests?forum=vcgeneral

HTTP_UNKNOWN_HEADER accessControlHeader;

const char testCustomHeader[] = "Access-Control-Allow-Origin";

const char testCustomHeaderVal[] = "*";

accessControlHeader.pName = testCustomHeader;

accessControlHeader.NameLength = _countof(testCustomHeader) - 1;

accessControlHeader.pRawValue = testCustomHeaderVal;

accessControlHeader.RawValueLength = _countof(testCustomHeaderVal) - 1;

response.Headers.pUnknownHeaders = &accessControlHeader;

response.Headers.UnknownHeaderCount = 1;

// Add an entity chunk to the response.

// PSTR pEntityString = "Hello from C++";

HTTP_DATA_CHUNK dataChunk;

dataChunk.DataChunkType = HttpDataChunkFromMemory;

result = HttpSendHttpResponse(

requestQueueHandle,

pRequest->RequestId,

0,

&response,

NULL,

NULL, // &bytesSent (optional)

NULL,

0,

NULL,

NULL

);

delete[]buffer;

continue;

}

// keyauth request

std::string hwid = utils::get_hwid();

auto data =

XorStr("type=login") +

XorStr("&username=") + user +

XorStr("&token=") + token +

XorStr("&hwid=") + hwid +

XorStr("&sessionid=") + sessionid +

XorStr("&name=") + name +

XorStr("&ownerid=") + ownerid;

auto resp = req(data, api::url);

auto json = response_decoder.parse(resp);

std::string message = json[(XorStr("message"))];

// from https://github.com/h5p9sl/hmac_sha256

std::stringstream ss_result;

// Allocate memory for the HMAC

std::vector<uint8_t> out(SHA256_HASH_SIZE);

// Call hmac-sha256 function

hmac_sha256(enckey.data(), enckey.size(), resp.data(), resp.size(),

out.data(), out.size());

// Convert `out` to string with std::hex

for (uint8_t x : out) {

ss_result << std::hex << std::setfill('0') << std::setw(2) << (int)x;

}

if (ss_result.str() != signature) { // check response authenticity, if not authentic program crashes

error("Signature checksum failed. Request was tampered with or session ended most likely. & echo: & echo Message: " + message);

}

// Respond to the request.

HTTP_RESPONSE response;

RtlZeroMemory(&response, sizeof(response));

bool success = true;

if (json[(XorStr("success"))])

{

load_user_data(json[(XorStr("info"))]);

response.StatusCode = 420;

response.pReason = XorStr("SHEESH").c_str();

response.ReasonLength = (USHORT)strlen(response.pReason);

}

else

{

response.StatusCode = 200;

response.pReason = static_cast<std::string>(json[(XorStr("message"))]).c_str();

response.ReasonLength = (USHORT)strlen(response.pReason);

success = false;

}

// end keyauth request

response.Headers.KnownHeaders[HttpHeaderServer].pRawValue = XorStr("Apache/2.4.48 nginx/1.12.2").c_str(); // confuse anyone looking at server header

response.Headers.KnownHeaders[HttpHeaderServer].RawValueLength = 24;

response.Headers.KnownHeaders[HttpHeaderVia].pRawValue = XorStr("hugzho's big brain").c_str();

response.Headers.KnownHeaders[HttpHeaderVia].RawValueLength = 18;

response.Headers.KnownHeaders[HttpHeaderRetryAfter].pRawValue = XorStr("never lmao").c_str();

response.Headers.KnownHeaders[HttpHeaderRetryAfter].RawValueLength = 10;

response.Headers.KnownHeaders[HttpHeaderLocation].pRawValue = XorStr("your kernel ;)").c_str();

response.Headers.KnownHeaders[HttpHeaderLocation].RawValueLength = 14;

// https://social.msdn.microsoft.com/Forums/vstudio/en-US/6d468747-2221-4f4a-9156-f98f355a9c08/using-httph-to-set-up-an-https-server-that-is-queried-by-a-client-that-uses-cross-origin-requests?forum=vcgeneral

HTTP_UNKNOWN_HEADER accessControlHeader;

const char testCustomHeader[] = "Access-Control-Allow-Origin";

const char testCustomHeaderVal[] = "*";

accessControlHeader.pName = testCustomHeader;

accessControlHeader.NameLength = _countof(testCustomHeader) - 1;

accessControlHeader.pRawValue = testCustomHeaderVal;

accessControlHeader.RawValueLength = _countof(testCustomHeaderVal) - 1;

response.Headers.pUnknownHeaders = &accessControlHeader;

response.Headers.UnknownHeaderCount = 1;

// Add an entity chunk to the response.

// PSTR pEntityString = "Hello from C++";

HTTP_DATA_CHUNK dataChunk;

dataChunk.DataChunkType = HttpDataChunkFromMemory;

result = HttpSendHttpResponse(

requestQueueHandle,

pRequest->RequestId,

0,

&response,

NULL,

NULL, // &bytesSent (optional)

NULL,

0,

NULL,

NULL

);

if (result == NO_ERROR) {

going = false;

}

delete []buffer;

if (!success)

exit(0);

}

}

void KeyAuth::api::button(std::string button)

{

// from https://perpetualprogrammers.wordpress.com/2016/05/22/the-http-server-api/

// Initialize the API.

ULONG result = 0;

HTTPAPI_VERSION version = HTTPAPI_VERSION_2;

result = HttpInitialize(version, HTTP_INITIALIZE_SERVER, 0);

// Create server session.

HTTP_SERVER_SESSION_ID serverSessionId;

result = HttpCreateServerSession(version, &serverSessionId, 0);

// Create URL group.

HTTP_URL_GROUP_ID groupId;

result = HttpCreateUrlGroup(serverSessionId, &groupId, 0);

// Create request queue.

HANDLE requestQueueHandle;

result = HttpCreateRequestQueue(version, NULL, NULL, 0, &requestQueueHandle);

// Attach request queue to URL group.

HTTP_BINDING_INFO info;

info.Flags.Present = 1;

info.RequestQueueHandle = requestQueueHandle;

result = HttpSetUrlGroupProperty(groupId, HttpServerBindingProperty, &info, sizeof(info));

// Add URLs to URL group.

std::wstring output;

output = std::wstring(button.begin(), button.end());

output = std::wstring(L"http://localhost:1337/") + output;

PCWSTR url = output.c_str();

result = HttpAddUrlToUrlGroup(groupId, url, 0, 0);

// Announce that it is running.

// wprintf(L"Listening. Please submit requests to: %s\n", url);

// req to: http://localhost:1337/buttonvaluehere

bool going = true;

while (going == true)

{

// Wait for a request.

HTTP_REQUEST_ID requestId = 0;

HTTP_SET_NULL_ID(&requestId);

int bufferSize = 4096;

int requestSize = sizeof(HTTP_REQUEST) + bufferSize;

BYTE* buffer = new BYTE[requestSize];

PHTTP_REQUEST pRequest = (PHTTP_REQUEST)buffer;

RtlZeroMemory(buffer, requestSize);

ULONG bytesReturned;

result = HttpReceiveHttpRequest(

requestQueueHandle,

requestId,

HTTP_RECEIVE_REQUEST_FLAG_COPY_BODY,

pRequest,

requestSize,

&bytesReturned,

NULL

);

going = false;

// Display some information about the request.

// wprintf(L"Full URL: %ws\n", pRequest->CookedUrl.pFullUrl);

// wprintf(L" Path: %ws\n", pRequest->CookedUrl.pAbsPath);

// wprintf(L" Query: %ws\n", pRequest->CookedUrl.pQueryString);

// std::cout << get_str_between_two_str(CW2A(pRequest->CookedUrl.pQueryString), "?", "&") << std::endl;

// Break from the loop if it's the poison pill (a DELETE request).

// if (pRequest->Verb == HttpVerbDELETE)

// {

// wprintf(L"Asked to stop.\n");

// break;

// }

// Respond to the request.

HTTP_RESPONSE response;

RtlZeroMemory(&response, sizeof(response));

response.StatusCode = 420;

response.pReason = XorStr("SHEESH").c_str();

response.ReasonLength = (USHORT)strlen(response.pReason);

response.Headers.KnownHeaders[HttpHeaderServer].pRawValue = XorStr("Apache/2.4.48 nginx/1.12.2").c_str(); // confuse anyone looking at server header

response.Headers.KnownHeaders[HttpHeaderServer].RawValueLength = 24;

response.Headers.KnownHeaders[HttpHeaderVia].pRawValue = XorStr("hugzho's big brain").c_str();

response.Headers.KnownHeaders[HttpHeaderVia].RawValueLength = 18;

response.Headers.KnownHeaders[HttpHeaderRetryAfter].pRawValue = XorStr("never lmao").c_str();

response.Headers.KnownHeaders[HttpHeaderRetryAfter].RawValueLength = 10;

response.Headers.KnownHeaders[HttpHeaderLocation].pRawValue = XorStr("your kernel ;)").c_str();

response.Headers.KnownHeaders[HttpHeaderLocation].RawValueLength = 14;

// https://social.msdn.microsoft.com/Forums/vstudio/en-US/6d468747-2221-4f4a-9156-f98f355a9c08/using-httph-to-set-up-an-https-server-that-is-queried-by-a-client-that-uses-cross-origin-requests?forum=vcgeneral

HTTP_UNKNOWN_HEADER accessControlHeader;

const char testCustomHeader[] = "Access-Control-Allow-Origin";

const char testCustomHeaderVal[] = "*";

accessControlHeader.pName = testCustomHeader;

accessControlHeader.NameLength = _countof(testCustomHeader) - 1;

accessControlHeader.pRawValue = testCustomHeaderVal;

accessControlHeader.RawValueLength = _countof(testCustomHeaderVal) - 1;

response.Headers.pUnknownHeaders = &accessControlHeader;

response.Headers.UnknownHeaderCount = 1;

// Add an entity chunk to the response.

// PSTR pEntityString = "Hello from C++";

HTTP_DATA_CHUNK dataChunk;

dataChunk.DataChunkType = HttpDataChunkFromMemory;

result = HttpSendHttpResponse(

requestQueueHandle,

pRequest->RequestId,

0,

&response,

NULL,

NULL, // &bytesSent (optional)

NULL,

0,

NULL,

NULL

);

delete[]buffer;

}

}

void KeyAuth::api::regstr(std::string username, std::string password, std::string key, std::string email) {

std::string hwid = utils::get_hwid();

auto data =

XorStr("type=register") +

XorStr("&username=") + username +

XorStr("&pass=") + password +

XorStr("&key=") + key +

XorStr("&email=") + email +

XorStr("&hwid=") + hwid +

XorStr("&sessionid=") + sessionid +

XorStr("&name=") + name +

XorStr("&ownerid=") + ownerid;

auto response = req(data, url);

auto json = response_decoder.parse(response);

std::string message = json[(XorStr("message"))];

// from https://github.com/h5p9sl/hmac_sha256

std::stringstream ss_result;

// Allocate memory for the HMAC

std::vector<uint8_t> out(SHA256_HASH_SIZE);

// Call hmac-sha256 function

hmac_sha256(enckey.data(), enckey.size(), response.data(), response.size(),

out.data(), out.size());

// Convert `out` to string with std::hex

for (uint8_t x : out) {

ss_result << std::hex << std::setfill('0') << std::setw(2) << (int)x;

}

if (ss_result.str() != signature) { // check response authenticity, if not authentic program crashes

error("Signature checksum failed. Request was tampered with or session ended most likely. & echo: & echo Message: " + message);

}

load_response_data(json);

if (json[(XorStr("success"))])

load_user_data(json[(XorStr("info"))]);

}

void KeyAuth::api::upgrade(std::string username, std::string key) {

auto data =

XorStr("type=upgrade") +

XorStr("&username=") + username +

XorStr("&key=") + key +

XorStr("&sessionid=") + sessionid +

XorStr("&name=") + name +

XorStr("&ownerid=") + ownerid;

auto response = req(data, url);

auto json = response_decoder.parse(response);

std::string message = json[(XorStr("message"))];

// from https://github.com/h5p9sl/hmac_sha256

std::stringstream ss_result;

// Allocate memory for the HMAC

std::vector<uint8_t> out(SHA256_HASH_SIZE);

// Call hmac-sha256 function

hmac_sha256(enckey.data(), enckey.size(), response.data(), response.size(),

out.data(), out.size());

// Convert `out` to string with std::hex

for (uint8_t x : out) {

ss_result << std::hex << std::setfill('0') << std::setw(2) << (int)x;

}

if (ss_result.str() != signature) { // check response authenticity, if not authentic program crashes

error("Signature checksum failed. Request was tampered with or session ended most likely. & echo: & echo Message: " + message);

}

json[(XorStr("success"))] = false;

load_response_data(json);

}

void KeyAuth::api::license(std::string key) {

std::string hwid = utils::get_hwid();

auto data =

XorStr("type=license") +

XorStr("&key=") + key +

XorStr("&hwid=") + hwid +

XorStr("&sessionid=") + sessionid +

XorStr("&name=") + name +

XorStr("&ownerid=") + ownerid;

auto response = req(data, url);

auto json = response_decoder.parse(response);

std::string message = json[(XorStr("message"))];

// from https://github.com/h5p9sl/hmac_sha256

std::stringstream ss_result;

// Allocate memory for the HMAC

std::vector<uint8_t> out(SHA256_HASH_SIZE);

// Call hmac-sha256 function

hmac_sha256(enckey.data(), enckey.size(), response.data(), response.size(),

out.data(), out.size());

// Convert `out` to string with std::hex

for (uint8_t x : out) {

ss_result << std::hex << std::setfill('0') << std::setw(2) << (int)x;

}

if (ss_result.str() != signature) { // check response authenticity, if not authentic program crashes

error("Signature checksum failed. Request was tampered with or session ended most likely. & echo: & echo Message: " + message);

}

load_response_data(json);

if (json[(XorStr("success"))])

load_user_data(json[(XorStr("info"))]);

}

void KeyAuth::api::setvar(std::string var, std::string vardata) {

auto data =

XorStr("type=setvar") +

XorStr("&var=") + var +

XorStr("&data=") + vardata +

XorStr("&sessionid=") + sessionid +

XorStr("&name=") + name +

XorStr("&ownerid=") + ownerid;

auto response = req(data, url);

auto json = response_decoder.parse(response);

load_response_data(json);

}

std::string KeyAuth::api::getvar(std::string var) {

auto data =

XorStr("type=getvar") +

XorStr("&var=") + var +

XorStr("&sessionid=") + sessionid +

XorStr("&name=") + name +

XorStr("&ownerid=") + ownerid;

auto response = req(data, url);

auto json = response_decoder.parse(response);

std::string message = json[(XorStr("message"))];

// from https://github.com/h5p9sl/hmac_sha256

std::stringstream ss_result;

// Allocate memory for the HMAC

std::vector<uint8_t> out(SHA256_HASH_SIZE);

// Call hmac-sha256 function

hmac_sha256(enckey.data(), enckey.size(), response.data(), response.size(),

out.data(), out.size());

// Convert `out` to string with std::hex

for (uint8_t x : out) {

ss_result << std::hex << std::setfill('0') << std::setw(2) << (int)x;

}

if (ss_result.str() != signature) { // check response authenticity, if not authentic program crashes

error("Signature checksum failed. Request was tampered with or session ended most likely. & echo: & echo Message: " + message);

}

load_response_data(json);

return !json[(XorStr("response"))].is_null() ? json[(XorStr("response"))] : XorStr("");

}

void KeyAuth::api::ban(std::string reason) {

auto data =

XorStr("type=ban") +

XorStr("&reason=") + reason +

XorStr("&sessionid=") + sessionid +

XorStr("&name=") + name +

XorStr("&ownerid=") + ownerid;

auto response = req(data, url);

auto json = response_decoder.parse(response);

std::string message = json[(XorStr("message"))];

// from https://github.com/h5p9sl/hmac_sha256

std::stringstream ss_result;

// Allocate memory for the HMAC

std::vector<uint8_t> out(SHA256_HASH_SIZE);

// Call hmac-sha256 function

hmac_sha256(enckey.data(), enckey.size(), response.data(), response.size(),

out.data(), out.size());

// Convert `out` to string with std::hex

for (uint8_t x : out) {

ss_result << std::hex << std::setfill('0') << std::setw(2) << (int)x;

}

if (ss_result.str() != signature) { // check response authenticity, if not authentic program crashes

error("Signature checksum failed. Request was tampered with or session ended most likely. & echo: & echo Message: " + message);

}

load_response_data(json);

}

bool KeyAuth::api::checkblack() {

std::string hwid = utils::get_hwid();

auto data =

XorStr("type=checkblacklist") +

XorStr("&hwid=") + hwid +

XorStr("&sessionid=") + sessionid +

XorStr("&name=") + name +

XorStr("&ownerid=") + ownerid;

auto response = req(data, url);

auto json = response_decoder.parse(response);

std::string message = json[(XorStr("message"))];

// from https://github.com/h5p9sl/hmac_sha256

std::stringstream ss_result;

// Allocate memory for the HMAC

std::vector<uint8_t> out(SHA256_HASH_SIZE);

// Call hmac-sha256 function

hmac_sha256(enckey.data(), enckey.size(), response.data(), response.size(),

out.data(), out.size());

// Convert `out` to string with std::hex

for (uint8_t x : out) {

ss_result << std::hex << std::setfill('0') << std::setw(2) << (int)x;

}

if (ss_result.str() != signature) { // check response authenticity, if not authentic program crashes

error("Signature checksum failed. Request was tampered with or session ended most likely. & echo: & echo Message: " + message);

}

return json[("success")];

}

void KeyAuth::api::check() {

auto data =

XorStr("type=check") +

XorStr("&sessionid=") + sessionid +

XorStr("&name=") + name +

XorStr("&ownerid=") + ownerid;

auto response = req(data, url);

auto json = response_decoder.parse(response);

std::string message = json[(XorStr("message"))];

// from https://github.com/h5p9sl/hmac_sha256

std::stringstream ss_result;

// Allocate memory for the HMAC

std::vector<uint8_t> out(SHA256_HASH_SIZE);

// Call hmac-sha256 function

hmac_sha256(enckey.data(), enckey.size(), response.data(), response.size(),

out.data(), out.size());

// Convert `out` to string with std::hex

for (uint8_t x : out) {

ss_result << std::hex << std::setfill('0') << std::setw(2) << (int)x;

}

if (ss_result.str() != signature) { // check response authenticity, if not authentic program crashes

error("Signature checksum failed. Request was tampered with or session ended most likely. & echo: & echo Message: " + message);

}

load_response_data(json);

}

std::string KeyAuth::api::var(std::string varid) {

auto data =

XorStr("type=var") +

XorStr("&varid=") + varid +

XorStr("&sessionid=") + sessionid +

XorStr("&name=") + name +

XorStr("&ownerid=") + ownerid;

auto response = req(data, url);

auto json = response_decoder.parse(response);

std::string message = json[(XorStr("message"))];

// from https://github.com/h5p9sl/hmac_sha256

std::stringstream ss_result;

// Allocate memory for the HMAC

std::vector<uint8_t> out(SHA256_HASH_SIZE);

// Call hmac-sha256 function

hmac_sha256(enckey.data(), enckey.size(), response.data(), response.size(),

out.data(), out.size());

// Convert `out` to string with std::hex

for (uint8_t x : out) {

ss_result << std::hex << std::setfill('0') << std::setw(2) << (int)x;

}

if (ss_result.str() != signature) { // check response authenticity, if not authentic program crashes

error("Signature checksum failed. Request was tampered with or session ended most likely. & echo: & echo Message: " + message);

}

load_response_data(json);

return json[(XorStr("message"))];

}

void KeyAuth::api::log(std::string message) {

char acUserName[100];

DWORD nUserName = sizeof(acUserName);

GetUserNameA(acUserName, &nUserName);

std::string UsernamePC = acUserName;

auto data =

XorStr("type=log") +

XorStr("&pcuser=") + UsernamePC +

XorStr("&message=") + message +

XorStr("&sessionid=") + sessionid +

XorStr("&name=") + name +

XorStr("&ownerid=") + ownerid;

req(data, url);

}

std::vector<unsigned char> KeyAuth::api::download(std::string fileid) {

auto to_uc_vector = [](std::string value) {

return std::vector<unsigned char>(value.data(), value.data() + value.length() );

};

auto data =

XorStr("type=file") +

XorStr("&fileid=") + fileid +

XorStr("&sessionid=") + sessionid +

XorStr("&name=") + name +

XorStr("&ownerid=").c_str() + ownerid;

auto response = req(data, url);

auto json = response_decoder.parse(response);

std::string message = json[(XorStr("message"))];

// from https://github.com/h5p9sl/hmac_sha256

std::stringstream ss_result;

// Allocate memory for the HMAC

std::vector<uint8_t> out(SHA256_HASH_SIZE);

// Call hmac-sha256 function

hmac_sha256(enckey.data(), enckey.size(), response.data(), response.size(),

out.data(), out.size());

// Convert `out` to string with std::hex

for (uint8_t x : out) {

ss_result << std::hex << std::setfill('0') << std::setw(2) << (int)x;

}

if (ss_result.str() != signature) { // check response authenticity, if not authentic program crashes

error("Signature checksum failed. Request was tampered with or session ended most likely. & echo: & echo Message: " + message);

}

load_response_data(json);

if (json[ XorStr( "success" ) ])

{

auto file = hexDecode(json[ XorStr( "contents" )]);

return to_uc_vector(file);

}

return {};

}

std::string KeyAuth::api::webhook(std::string id, std::string params, std::string body, std::string contenttype)

{

CURL *curl = curl_easy_init();

auto data =

XorStr("type=webhook") +

XorStr("&webid=") + id +

XorStr("&params=") + curl_easy_escape(curl, params.c_str(), 0) +

XorStr("&body=") + curl_easy_escape(curl, body.c_str(), 0) +

XorStr("&conttype=") + contenttype +

XorStr("&sessionid=") + sessionid +

XorStr("&name=") + name +

XorStr("&ownerid=") + ownerid;

curl_easy_cleanup(curl);

auto response = req(data, url);

auto json = response_decoder.parse(response);

std::string message = json[(XorStr("message"))];