#ifndef UNICODE

#define UNICODE

#endif

#ifndef _WIN32_WINNT

#define _WIN32_WINNT 0x0600

#endif

#ifndef WIN32_LEAN_AND_MEAN

#define WIN32_LEAN_AND_MEAN

#endif

#define _CRT_SECURE_NO_WARNINGS

#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>

#include <ctime>

#include <filesystem>

#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);

bool constantTimeStringCompare(const char* str1, const char* str2, size_t length);

void checkInit();

std::string checksum();

void debugInfo(std::string data, std::string url, std::string response);

void modify();

void error(std::string message);

std::string signature;

bool initalized;

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();

CURL* curl = curl_easy_init();

auto data =

XorStr("type=init") +

XorStr("&ver=") + version +

XorStr("&hash=") + hash +

XorStr("&enckey=") + sentKey +

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

XorStr("&ownerid=") + ownerid;

curl_easy_cleanup(curl);

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 (!constantTimeStringCompare(ss_result.str().c_str(), signature.c_str(), sizeof(signature).c_str())) { // 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"))])

{

if (json[(XorStr("newSession"))]) {

Sleep(100);

}

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

initalized = true;

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)

{

checkInit();

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 (!constantTimeStringCompare(ss_result.str().c_str(), signature.c_str(), sizeof(signature).c_str())) { // 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)

{

checkInit();

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)

{

checkInit();

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)

{

checkInit();

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 (!constantTimeStringCompare(ss_result.str().c_str(), signature.c_str(), sizeof(signature).c_str())) { // 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()

{

checkInit();

// 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);

if (result == ERROR_INVALID_PARAMETER) {

MessageBoxA(NULL, "The Flags parameter contains an unsupported value.", "Error", MB_ICONEXCLAMATION);

exit(0);

}

if (result != NO_ERROR) {

MessageBoxA(NULL, "System error for Initialize", "Error", MB_ICONEXCLAMATION);

exit(0);

}

// Create server session.

HTTP_SERVER_SESSION_ID serverSessionId;

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

if (result == ERROR_REVISION_MISMATCH) {

MessageBoxA(NULL, "Version for session invalid", "Error", MB_ICONEXCLAMATION);

exit(0);

}

if (result == ERROR_INVALID_PARAMETER) {

MessageBoxA(NULL, "pServerSessionId parameter is null", "Error", MB_ICONEXCLAMATION);

exit(0);

}

if (result != NO_ERROR) {

MessageBoxA(NULL, "System error for HttpCreateServerSession", "Error", MB_ICONEXCLAMATION);

exit(0);

}

// Create URL group.

HTTP_URL_GROUP_ID groupId;

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

if (result == ERROR_INVALID_PARAMETER) {

MessageBoxA(NULL, "Url group create parameter error", "Error", MB_ICONEXCLAMATION);

exit(0);

}

if (result != NO_ERROR) {

MessageBoxA(NULL, "System error for HttpCreateUrlGroup", "Error", MB_ICONEXCLAMATION);

exit(0);

}

// Create request queue.

HANDLE requestQueueHandle;

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

if (result == ERROR_REVISION_MISMATCH) {

MessageBoxA(NULL, "Wrong version", "Error", MB_ICONEXCLAMATION);

exit(0);

}

if (result == ERROR_INVALID_PARAMETER) {

MessageBoxA(NULL, "Byte length exceeded", "Error", MB_ICONEXCLAMATION);

exit(0);

}

if (result == ERROR_ALREADY_EXISTS) {

MessageBoxA(NULL, "pName already used", "Error", MB_ICONEXCLAMATION);

exit(0);

}

if (result == ERROR_ACCESS_DENIED) {

MessageBoxA(NULL, "queue access denied", "Error", MB_ICONEXCLAMATION);

exit(0);

}

if (result == ERROR_DLL_INIT_FAILED) {

MessageBoxA(NULL, "Initialize not called", "Error", MB_ICONEXCLAMATION);

exit(0);

}

if (result != NO_ERROR) {

MessageBoxA(NULL, "System error for HttpCreateRequestQueue", "Error", MB_ICONEXCLAMATION);

exit(0);

}

// Attach request queue to URL group.

HTTP_BINDING_INFO info;

info.Flags.Present = 1;

info.RequestQueueHandle = requestQueueHandle;

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

if (result == ERROR_INVALID_PARAMETER) {

MessageBoxA(NULL, XorStr("Invalid parameter").c_str(), "Error", MB_ICONEXCLAMATION);

exit(0);

}

if (result != NO_ERROR) {

MessageBoxA(NULL, XorStr("System error for HttpSetUrlGroupProperty").c_str(), "Error", MB_ICONEXCLAMATION);

exit(0);

}

// Add URLs to URL group.

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

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

if (result == ERROR_ACCESS_DENIED) {

MessageBoxA(NULL, XorStr("No permissions to run web server").c_str(), "Error", MB_ICONEXCLAMATION);

exit(0);

}

if (result == ERROR_ALREADY_EXISTS) {

MessageBoxA(NULL, XorStr("You are running this program already").c_str(), "Error", MB_ICONEXCLAMATION);

exit(0);

}

if (result == ERROR_INVALID_PARAMETER) {

MessageBoxA(NULL, XorStr("ERROR_INVALID_PARAMETER for HttpAddUrlToUrlGroup").c_str(), "Error", MB_ICONEXCLAMATION);

exit(0);

}

if (result == ERROR_SHARING_VIOLATION) {

MessageBoxA(NULL, XorStr("Another program is using the webserver. Close Razer Chroma mouse software if you use that. Try to restart computer.").c_str(), "Error", MB_ICONEXCLAMATION);

exit(0);

}

if (result != NO_ERROR) {

MessageBoxA(NULL, XorStr("System error for HttpAddUrlToUrlGroup").c_str(), "Error", MB_ICONEXCLAMATION);

exit(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);

// 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 (!constantTimeStringCompare(ss_result.str().c_str(), signature.c_str(), sizeof(signature).c_str())) { // 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

// 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)

{

checkInit();

// 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);

// 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) {

checkInit();

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 (!constantTimeStringCompare(ss_result.str().c_str(), signature.c_str(), sizeof(signature).c_str())) { // 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) {

checkInit();

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 (!constantTimeStringCompare(ss_result.str().c_str(), signature.c_str(), sizeof(signature).c_str())) { // 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) {

checkInit();

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 (!constantTimeStringCompare(ss_result.str().c_str(), signature.c_str(), sizeof(signature).c_str())) { // 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) {

checkInit();

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) {

checkInit();

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 (!constantTimeStringCompare(ss_result.str().c_str(), signature.c_str(), sizeof(signature).c_str())) { // 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) {

checkInit();

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 (!constantTimeStringCompare(ss_result.str().c_str(), signature.c_str(), sizeof(signature).c_str())) { // 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() {

checkInit();

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 (!constantTimeStringCompare(ss_result.str().c_str(), signature.c_str(), sizeof(signature).c_str())) { // 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() {

checkInit();

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 (!constantTimeStringCompare(ss_result.str().c_str(), signature.c_str(), sizeof(signature).c_str())) { // 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) {

checkInit();

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"))];