using System;

using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link].X509Certificates;
using [Link];
using [Link];
using Cryptographic;
using [Link];

namespace KeyAuth
{
public class api
{
[DllImport("[Link]", SetLastError = true)]
private static extern bool TerminateProcess(IntPtr hProcess, uint
uExitCode);

[DllImport("[Link]", SetLastError = true)]

private static extern IntPtr GetCurrentProcess();

// Import the required Atom Table functions from [Link]

[DllImport("[Link]", SetLastError = true, CharSet = [Link])]
private static extern ushort GlobalAddAtom(string lpString);

[DllImport("[Link]", SetLastError = true, CharSet = [Link])]

private static extern ushort GlobalFindAtom(string lpString);

public string name, ownerid, version, path, seed;

/// <summary>
/// Set up your application credentials in order to use keyauth
/// </summary>
/// <param name="name">Application Name</param>
/// <param name="ownerid">Your OwnerID, found in your account
settings.</param>
/// <param name="version">Application Version, if version doesnt match it
will open the download link you set up in your application settings and close the
app, if empty the app will close</param>
public api(string name, string ownerid, string version, string path = null)
{
if ([Link] != 10)
{
[Link]("[Link]
[Link]("[Link]
[Link](2000);
error("Application not setup correctly. Please watch the YouTube
video for setup.");
TerminateProcess(GetCurrentProcess(), 1);
}

[Link] = name;
 [Link] = ownerid;

[Link] = version;

[Link] = path;
}

#region structures
[DataContract]
private class response_structure
{
[DataMember]
public bool success { get; set; }

[DataMember]
public bool newSession { get; set; }

[DataMember]
public string sessionid { get; set; }

[DataMember]
public string contents { get; set; }

[DataMember]
public string response { get; set; }

[DataMember]
public string message { get; set; }

[DataMember]
public string ownerid { get; set; }

[DataMember]
public string download { get; set; }

[DataMember(IsRequired = false, EmitDefaultValue = false)]

public user_data_structure info { get; set; }

[DataMember(IsRequired = false, EmitDefaultValue = false)]

public app_data_structure appinfo { get; set; }

[DataMember]
public List<msg> messages { get; set; }

[DataMember]
public List<users> users { get; set; }

[DataMember(Name = "2fa", IsRequired = false, EmitDefaultValue =

false)] // Ensure mapping to "2fa"
public TwoFactorData twoFactor { get; set; } // Add a property for the
2FA data
}

public class msg

{
public string message { get; set; }
public string author { get; set; }
public string timestamp { get; set; }
}
 public class users
{
public string credential { get; set; }
}

[DataContract]
private class user_data_structure
{
[DataMember]
public string username { get; set; }

[DataMember]
public string ip { get; set; }
[DataMember]
public string hwid { get; set; }
[DataMember]
public string createdate { get; set; }
[DataMember]
public string lastlogin { get; set; }
[DataMember]
public List<Data> subscriptions { get; set; } // array of subscriptions
(basically multiple user ranks for user with individual expiry dates
}

[DataContract]
private class app_data_structure
{
[DataMember]
public string numUsers { get; set; }
[DataMember]
public string numOnlineUsers { get; set; }
[DataMember]
public string numKeys { get; set; }
[DataMember]
public string version { get; set; }
[DataMember]
public string customerPanelLink { get; set; }
[DataMember]
public string downloadLink { get; set; }
}
#endregion
private static string sessionid, enckey;
bool initialized;
/// <summary>
/// Initializes the connection with keyauth in order to use any of the
functions
/// </summary>
public void init()
{
Random random = new Random();

// Generate a random length for the string (let's assume between 5 and
50 characters)
int length = [Link](5, 51); // Min length: 5, Max length: 50

StringBuilder sb = new StringBuilder(length);

// Define the range of printable ASCII characters (32-126)

 for (int i = 0; i < length; i++)
{
// Generate a random printable ASCII character
char randomChar = (char)[Link](32, 127); // ASCII 32 to 126
[Link](randomChar);
}

seed = [Link]();
checkAtom();

var values_to_upload = new NameValueCollection

{
["type"] = "init",
["ver"] = version,
["hash"] =
checksum([Link]().[Link]),
["name"] = name,
["ownerid"] = ownerid
};

if ()
{
values_to_upload.Add("token", [Link](path));
values_to_upload.Add("thash", TokenHash(path));
}

var response = req(values_to_upload);

if (response == "KeyAuth_Invalid")
{
error("Application not found");
TerminateProcess(GetCurrentProcess(), 1);
}

var json =
response_decoder.string_to_generic<response_structure>(response);
if ([Link] == ownerid)
{
load_response_struct(json);
if ([Link])
{
sessionid = [Link];
initialized = true;
}
else if ([Link] == "invalidver")
{
app_data.downloadLink = [Link];
}
}
else
{
TerminateProcess(GetCurrentProcess(), 1);
}
}

void checkAtom()
{
Thread atomCheckThread = new Thread(() =>
{
 while (true)
{
[Link](60000); // give people 1 minute to login

ushort foundAtom = GlobalFindAtom(seed);

if (foundAtom == 0)
{
TerminateProcess(GetCurrentProcess(), 1);
}
}
});

[Link] = true; // Ensure the thread does not

block program exit
[Link]();
}

public static string TokenHash(string tokenPath)

{
using (var sha256 = [Link]())
{
using (var s = [Link](tokenPath))
{
byte[] bytes = [Link](s);
return [Link](bytes).Replace("-",
[Link]);
}
}
}
/// <summary>
/// Checks if Keyauth is been Initalized
/// </summary>
public void CheckInit()
{
if (!initialized)
{
error("You must run the function [Link](); first");
TerminateProcess(GetCurrentProcess(), 1);
}
}

/// <summary>
/// Converts Unix time to Days,Months,Hours
///</summary>
/// <param name="subscription">Subscription Number</param>
/// <param name="Type">You can choose between Days,Hours,Months </param>
public string expirydaysleft(string Type,int subscription)
{
CheckInit();

[Link] dtDateTime = new DateTime(1970, 1, 1, 0, 0, 0, 0,

[Link]);
dtDateTime =
[Link]([Link](user_data.subscriptions[subscription].expiry)).ToL
ocalTime();
TimeSpan difference = dtDateTime - [Link];
switch ([Link]())
{
case "months":
 return [Link]([Link] / 30);
case "days":
return [Link]([Link]);
case "hours":
return [Link]([Link]);
}
return null;

/// <summary>
/// Registers the user using a license and gives the user a subscription
that matches their license level
/// </summary>
/// <param name="username">Username</param>
/// <param name="pass">Password</param>
/// <param name="key">License key</param>
public void register(string username, string pass, string key, string email
= "")
{
CheckInit();

string hwid = [Link]().[Link];

var values_to_upload = new NameValueCollection

{
["type"] = "register",
["username"] = username,
["pass"] = pass,
["key"] = key,
["email"] = email,
["hwid"] = hwid,
["sessionid"] = sessionid,
["name"] = name,
["ownerid"] = ownerid
};

var response = req(values_to_upload);

var json =
response_decoder.string_to_generic<response_structure>(response);
if ([Link] == ownerid)
{
GlobalAddAtom(seed);
GlobalAddAtom(ownerid);

load_response_struct(json);
if ([Link])
load_user_data([Link]);
}
else
{
TerminateProcess(GetCurrentProcess(), 1);
}
}
/// <summary>
/// Allow users to enter their account information and recieve an email to
reset their password.
/// </summary>
 /// <param name="username">Username</param>
/// <param name="email">Email address</param>
public void forgot(string username, string email)
{
CheckInit();

var values_to_upload = new NameValueCollection

{
["type"] = "forgot",
["username"] = username,
["email"] = email,
["sessionid"] = sessionid,
["name"] = name,
["ownerid"] = ownerid
};

var response = req(values_to_upload);

var json =
response_decoder.string_to_generic<response_structure>(response);
load_response_struct(json);
}
/// <summary>
/// Authenticates the user using their username and password
/// </summary>
/// <param name="username">Username</param>
/// <param name="pass">Password</param>
public void login(string username, string pass, string code = null)
{
CheckInit();

string hwid = [Link]().[Link];

var values_to_upload = new NameValueCollection

{
["type"] = "login",
["username"] = username,
["pass"] = pass,
["hwid"] = hwid,
["sessionid"] = sessionid,
["name"] = name,
["ownerid"] = ownerid,
["code"] = code ?? [Link]
};

var response = req(values_to_upload);

var json =
response_decoder.string_to_generic<response_structure>(response);
if ([Link] == ownerid)
{
GlobalAddAtom(seed);
GlobalAddAtom(ownerid);

load_response_struct(json);
if ([Link])
load_user_data([Link]);
}
else
 {
TerminateProcess(GetCurrentProcess(), 1);
}
}

public void logout()

{
CheckInit();

var values_to_upload = new NameValueCollection

{
["type"] = "logout",
["sessionid"] = sessionid,
["name"] = name,
["ownerid"] = ownerid
};

var response = req(values_to_upload);

var json =
response_decoder.string_to_generic<response_structure>(response);
if ([Link] == ownerid)
{
load_response_struct(json);
}
else
{
TerminateProcess(GetCurrentProcess(), 1);
}
}

public void web_login()

{
CheckInit();

string hwid = [Link]().[Link];

string datastore, datastore2, outputten;

start:

HttpListener listener = new HttpListener();

outputten = "handshake";
outputten = "[Link] + outputten + "/";

[Link](outputten);

[Link]();

HttpListenerContext context = [Link]();

HttpListenerRequest request = [Link];
HttpListenerResponse responsepp = [Link];

[Link]("Access-Control-Allow-Methods", "GET, POST");

[Link]("Access-Control-Allow-Origin", "*");
[Link]("Via", "hugzho's big brain");
[Link]("Location", "your kernel ;)");
[Link]("Retry-After", "never lmao");
 [Link]("Server", "\r\n\r\n");

if ([Link] == "OPTIONS")
{
[Link] = (int)[Link];
[Link](1); // without this, the response doesn't return to
the website, and the web buttons can't be shown
[Link]();
goto start;
}

[Link] = [Link];
[Link] = true;
[Link] = true;

string data = [Link];

datastore2 = [Link]("/handshake?user=", "");

datastore2 = [Link]("&token=", " ");

datastore = datastore2;

string user = [Link]()[0];

string token = [Link](' ')[1];

var values_to_upload = new NameValueCollection

{
["type"] = "login",
["username"] = user,
["token"] = token,
["hwid"] = hwid,
["sessionid"] = sessionid,
["name"] = name,
["ownerid"] = ownerid
};

var response = req(values_to_upload);

var json =
response_decoder.string_to_generic<response_structure>(response);
bool success = true;
if ([Link] == ownerid)
{
GlobalAddAtom(seed);
GlobalAddAtom(ownerid);

load_response_struct(json);

if ([Link])
{
load_user_data([Link]);

[Link] = 420;
[Link] = "SHEESH";
}
else
{
[Link]([Link]);
[Link] = (int)[Link];
 [Link] = [Link];
success = false;
}
}
else
{
TerminateProcess(GetCurrentProcess(), 1);
}

byte[] buffer = [Link]("Complete");

responsepp.ContentLength64 = [Link];
Stream output = [Link];
[Link](buffer, 0, [Link]);
[Link](1); // without this, the response doesn't return to the
website, and the web buttons can't be shown
[Link]();

if (!success)
TerminateProcess(GetCurrentProcess(), 1);

/// <summary>
/// Use Buttons from KeyAuth Customer Panel
/// </summary>
/// <param name="button">Button Name</param>

public void button(string button)

{
CheckInit();

HttpListener listener = new HttpListener();

string output;

output = button;
output = "[Link] + output + "/";

[Link](output);

[Link]();

HttpListenerContext context = [Link]();

HttpListenerRequest request = [Link];
HttpListenerResponse responsepp = [Link];

[Link]("Access-Control-Allow-Methods", "GET, POST");

[Link]("Access-Control-Allow-Origin", "*");
[Link]("Via", "hugzho's big brain");
[Link]("Location", "your kernel ;)");
[Link]("Retry-After", "never lmao");
[Link]("Server", "\r\n\r\n");

[Link] = 420;
[Link] = "SHEESH";

[Link] = [Link];
[Link] = true;
 [Link] = true;

[Link]();
}

/// <summary>
/// Gives the user a subscription that has the same level as the key
/// </summary>
/// <param name="username">Username of the user thats going to get
upgraded</param>
/// <param name="key">License with the same level as the subscription you
want to give the user</param>
public void upgrade(string username, string key)
{
CheckInit();

var values_to_upload = new NameValueCollection

{
["type"] = "upgrade",
["username"] = username,
["key"] = key,
["sessionid"] = sessionid,
["name"] = name,
["ownerid"] = ownerid
};

var response = req(values_to_upload);

var json =
response_decoder.string_to_generic<response_structure>(response);
if ([Link] == ownerid)
{
[Link] = false;
load_response_struct(json);
}
else
{
TerminateProcess(GetCurrentProcess(), 1);
}
}

/// <summary>
/// Authenticate without using usernames and passwords
/// </summary>
/// <param name="key">Licence used to login with</param>
public void license(string key, string code = null)
{
CheckInit();

string hwid = [Link]().[Link];

var values_to_upload = new NameValueCollection

{
["type"] = "license",
["key"] = key,
["hwid"] = hwid,
["sessionid"] = sessionid,
["name"] = name,
["ownerid"] = ownerid,
 ["code"] = code ?? [Link]
};

var response = req(values_to_upload);

var json =
response_decoder.string_to_generic<response_structure>(response);

if ([Link] == ownerid)
{
GlobalAddAtom(seed);
GlobalAddAtom(ownerid);

load_response_struct(json);
if ([Link])
load_user_data([Link]);
}
else
{
TerminateProcess(GetCurrentProcess(), 1);
}
}
/// <summary>
/// Checks if the current session is validated or not
/// </summary>
public void check()
{
CheckInit();

var values_to_upload = new NameValueCollection

{
["type"] = "check",
["sessionid"] = sessionid,
["name"] = name,
["ownerid"] = ownerid
};

var response = req(values_to_upload);

var json =
response_decoder.string_to_generic<response_structure>(response);
if ([Link] == ownerid)
{
load_response_struct(json);
}
else
{
TerminateProcess(GetCurrentProcess(), 1);
}
}
/// <summary>
/// Disable two factor authentication (2fa)
/// </summary>
public void disable2fa(string code)
{
CheckInit();

var values_to_upload = new NameValueCollection

{
 ["type"] = "2fadisable",
["sessionid"] = sessionid,
["name"] = name,
["ownerid"] = ownerid,
["code"] = code
};

var response = req(values_to_upload);

var json =
response_decoder.string_to_generic<response_structure>(response);
load_response_struct(json);

[Link]([Link]);
}
/// <summary>
/// Enable two factor authentication (2fa)
/// </summary>
public void enable2fa(string code = null)
{
CheckInit();

var values_to_upload = new NameValueCollection

{
["type"] = "2faenable",
["sessionid"] = sessionid,
["name"] = name,
["ownerid"] = ownerid,
["code"] = code
};

var response = req(values_to_upload);

var json =
response_decoder.string_to_generic<response_structure>(response);
load_response_struct(json);

if ([Link])
{
if (code == null)
{
[Link]($"Your 2FA Secret is:
{[Link]}");

[Link]("Enter the 6 digit authentication code from your

authentication app: ");
string code6Digit = [Link]();
this.enable2fa(code6Digit);
}
else
{
[Link]("2FA has been successfully enabled!");
[Link](3000);
}
}
else
{
[Link]($"Error: {[Link]}");
[Link](3000);
 TerminateProcess(GetCurrentProcess(), 1);
}
}
/// <summary>
/// Change the data of an existing user variable, *User must be logged in*
/// </summary>
/// <param name="var">User variable name</param>
/// <param name="data">The content of the variable</param>
public void setvar(string var, string data)
{
CheckInit();

var values_to_upload = new NameValueCollection

{
["type"] = "setvar",
["var"] = var,
["data"] = data,
["sessionid"] = sessionid,
["name"] = name,
["ownerid"] = ownerid
};

var response = req(values_to_upload);

var json =
response_decoder.string_to_generic<response_structure>(response);
if ([Link] == ownerid)
{
load_response_struct(json);
}
else
{
TerminateProcess(GetCurrentProcess(), 1);
}
}
/// <summary>
/// Gets the an existing user variable
/// </summary>
/// <param name="var">User Variable Name</param>
/// <returns>The content of the user variable</returns>
public string getvar(string var)
{
CheckInit();

var values_to_upload = new NameValueCollection

{
["type"] = "getvar",
["var"] = var,
["sessionid"] = sessionid,
["name"] = name,
["ownerid"] = ownerid
};

var response = req(values_to_upload);

var json =
response_decoder.string_to_generic<response_structure>(response);
if ([Link] == ownerid)
{
 load_response_struct(json);
if ([Link])
return [Link];
}
else
{
TerminateProcess(GetCurrentProcess(), 1);
}
return null;
}
/// <summary>
/// Bans the current logged in user
/// </summary>
public void ban(string reason = null)
{
CheckInit();

var values_to_upload = new NameValueCollection

{
["type"] = "ban",
["reason"] = reason,
["sessionid"] = sessionid,
["name"] = name,
["ownerid"] = ownerid
};

var response = req(values_to_upload);

var json =
response_decoder.string_to_generic<response_structure>(response);
if ([Link] == ownerid)
{
load_response_struct(json);
}
else
{
TerminateProcess(GetCurrentProcess(), 1);
}
}
/// <summary>
/// Gets an existing global variable
/// </summary>
/// <param name="varid">Variable ID</param>
/// <returns>The content of the variable</returns>
public string var(string varid)
{
CheckInit();

var values_to_upload = new NameValueCollection

{
["type"] = "var",
["varid"] = varid,
["sessionid"] = sessionid,
["name"] = name,
["ownerid"] = ownerid
};

var response = req(values_to_upload);

 var json =
response_decoder.string_to_generic<response_structure>(response);
if ([Link] == ownerid)
{
load_response_struct(json);
if ([Link])
return [Link];
}
else
{
TerminateProcess(GetCurrentProcess(), 1);
}
return null;
}
/// <summary>
/// Fetch usernames of online users
/// </summary>
/// <returns>ArrayList of usernames</returns>
public List<users> fetchOnline()
{
CheckInit();

var values_to_upload = new NameValueCollection

{
["type"] = "fetchOnline",
["sessionid"] = sessionid,
["name"] = name,
["ownerid"] = ownerid
};

var response = req(values_to_upload);

var json =
response_decoder.string_to_generic<response_structure>(response);
load_response_struct(json);

if ([Link])
return [Link];
return null;
}
/// <summary>
/// Fetch app statistic counts
/// </summary>
public void fetchStats()
{
CheckInit();

var values_to_upload = new NameValueCollection

{
["type"] = "fetchStats",
["sessionid"] = sessionid,
["name"] = name,
["ownerid"] = ownerid
};

var response = req(values_to_upload);

var json =
response_decoder.string_to_generic<response_structure>(response);
 load_response_struct(json);

if ([Link])
load_app_data([Link]);
}
/// <summary>
/// Gets the last 50 sent messages of that channel
/// </summary>
/// <param name="channelname">The channel name</param>
/// <returns>the last 50 sent messages of that channel</returns>
public List<msg> chatget(string channelname)
{
CheckInit();

var values_to_upload = new NameValueCollection

{
["type"] = "chatget",
["channel"] = channelname,
["sessionid"] = sessionid,
["name"] = name,
["ownerid"] = ownerid
};

var response = req(values_to_upload);

var json =
response_decoder.string_to_generic<response_structure>(response);
load_response_struct(json);
if ([Link])
{
return [Link];
}
return null;
}
/// <summary>
/// Sends a message to the given channel name
/// </summary>
/// <param name="msg">Message</param>
/// <param name="channelname">Channel Name</param>
/// <returns>If the message was sent successfully, it returns true if not
false</returns>
public bool chatsend(string msg, string channelname)
{
CheckInit();

var values_to_upload = new NameValueCollection

{
["type"] = "chatsend",
["message"] = msg,
["channel"] = channelname,
["sessionid"] = sessionid,
["name"] = name,
["ownerid"] = ownerid
};

var response = req(values_to_upload);

var json =
response_decoder.string_to_generic<response_structure>(response);
 load_response_struct(json);
if ([Link])
return true;
return false;
}
/// <summary>
/// Checks if the current ip address/hwid is blacklisted
/// </summary>
/// <returns>If found blacklisted returns true if not false</returns>
public bool checkblack()
{
CheckInit();
string hwid = [Link]().[Link];

var values_to_upload = new NameValueCollection

{
["type"] = "checkblacklist",
["hwid"] = hwid,
["sessionid"] = sessionid,
["name"] = name,
["ownerid"] = ownerid
};

var response = req(values_to_upload);

var json =
response_decoder.string_to_generic<response_structure>(response);
if ([Link] == ownerid)
{
load_response_struct(json);
if ([Link])
return true;
else
return false;
}
else
{
TerminateProcess(GetCurrentProcess(), 1);
}
return true; // return yes blacklisted if the OwnerID is spoofed
}
/// <summary>
/// Sends a request to a webhook that you've added in the dashboard in a
safe way without it being showed for example a http debugger
/// </summary>
/// <param name="webid">Webhook ID</param>
/// <param name="param">Parameters</param>
/// <param name="body">Body of the request, empty by default</param>
/// <param name="conttype">Content type, empty by default</param>
/// <returns>the webhook's response</returns>
public string webhook(string webid, string param, string body = "", string
conttype = "")
{
CheckInit();

var values_to_upload = new NameValueCollection

{
["type"] = "webhook",
["webid"] = webid,
 ["params"] = param,
["body"] = body,
["conttype"] = conttype,
["sessionid"] = sessionid,
["name"] = name,
["ownerid"] = ownerid
};

var response = req(values_to_upload);

var json =
response_decoder.string_to_generic<response_structure>(response);
if ([Link] == ownerid)
{
load_response_struct(json);
if ([Link])
return [Link];
}
else
{
TerminateProcess(GetCurrentProcess(), 1);
}
return null;
}
/// <summary>
/// KeyAuth acts as proxy and downlods the file in a secure way
/// </summary>
/// <param name="fileid">File ID</param>
/// <returns>The bytes of the download file</returns>
public byte[] download(string fileid)
{
CheckInit();

var values_to_upload = new NameValueCollection

{

["type"] = "file",
["fileid"] = fileid,
["sessionid"] = sessionid,
["name"] = name,
["ownerid"] = ownerid
};

var response = req(values_to_upload);

var json =
response_decoder.string_to_generic<response_structure>(response);
load_response_struct(json);
if ([Link])
return encryption.str_to_byte_arr([Link]);
return null;
}
/// <summary>
/// Logs the IP address,PC Name with a message, if a discord webhook is set
up in the app settings, the log will get sent there and the dashboard if not set up
it will only be in the dashboard
/// </summary>
/// <param name="message">Message</param>
public void log(string message)
 {
CheckInit();

var values_to_upload = new NameValueCollection

{
["type"] = "log",
["pcuser"] = [Link],
["message"] = message,
["sessionid"] = sessionid,
["name"] = name,
["ownerid"] = ownerid
};

req(values_to_upload);
}
/// <summary>
/// Change the username of a user, *User must be logged in*
/// </summary>
/// <param username="username">New username.</param>
public void changeUsername(string username)
{
CheckInit();

var values_to_upload = new NameValueCollection

{
["type"] = "changeUsername",
["newUsername"] = username,
["sessionid"] = sessionid,
["name"] = name,
["ownerid"] = ownerid
};

var response = req(values_to_upload);

var json =
response_decoder.string_to_generic<response_structure>(response);
load_response_struct(json);
}

public static string checksum(string filename)

{
string result;
using (MD5 md = [Link]())
{
using (FileStream fileStream = [Link](filename))
{
byte[] value = [Link](fileStream);
result = [Link](value).Replace("-",
"").ToLowerInvariant();
}
}
return result;
}

public static void error(string message)

{
string folder = @"Logs", file = [Link](folder, "[Link]");

if ()
 {
[Link](folder);
}

if ()
{
using (FileStream stream = [Link](file))
{
[Link](file, [Link] + " > This is the start
of your error logs file");
}
}

[Link](file, [Link] + $" > {message}" +

[Link]);

[Link]("Error: " + message);

[Link]("Press any key to exit");
[Link]();
[Link](0);
}

private static string req(NameValueCollection post_data)

{
try
{
using (WebClient client = new WebClient())
{
[Link] = null;

[Link] +=
assertSSL;

var raw_response =
[Link]("[Link] post_data);

[Link] =
delegate { return true; };

sigCheck([Link](raw_response),
[Link], post_data.Get(0));

[Link]([Link](raw_response) + "\
n");

return [Link](raw_response);
}
}
catch (WebException webex)
{
var response = (HttpWebResponse)[Link];
switch ([Link])
{
case (HttpStatusCode)429: // client hit our rate limit
error("You're connecting too fast to loader, slow down.");
[Link]("You're connecting too fast to loader, slow
down.");
TerminateProcess(GetCurrentProcess(), 1);
return "";
 default: // site won't resolve. you should use [Link]
domain since it's not blocked by any ISPs
error("Connection failure. Please try again, or contact us
for help.");
[Link]("Connection failure. Please try again, or
contact us for help.");
TerminateProcess(GetCurrentProcess(), 1);
return "";
}
}
}

private static bool assertSSL(object sender, X509Certificate certificate,

X509Chain chain, SslPolicyErrors sslPolicyErrors)
{
if ((![Link]("Google Trust Services") && !
[Link]("Let's Encrypt")) || sslPolicyErrors !=
[Link])
{
error("SSL assertion fail, make sure you're not debugging Network.
Disable internet firewall on router if possible. & echo: & echo If not, ask the
developer of the program to use custom domains to fix this.");
[Link]("SSL assertion fail, make sure you're not debugging
Network. Disable internet firewall on router if possible. If not, ask the developer
of the program to use custom domains to fix this.");
return false;
}
return true;
}

private static void sigCheck(string resp, WebHeaderCollection headers,

string type)
{
if(type == "log" || type == "file" || type == "2faenable" || type ==
"2fadisable") // log doesn't return a response.
{
return;
}

try
{
string signature = headers["x-signature-ed25519"];
string timestamp = headers["x-signature-timestamp"];

// Try to parse the input string to a long Unix timestamp

if ()
{
error("Failed to parse the timestamp from the server. Please
ensure your device's date and time settings are correct.");
TerminateProcess(GetCurrentProcess(), 1);
}

// Convert the Unix timestamp to a DateTime object (in UTC)

DateTime timestampTime =
[Link](unixTimestamp).UtcDateTime;

// Get the current UTC time

DateTime currentTime = [Link];
 // Calculate the difference between the current time and the
timestamp
TimeSpan timeDifference = currentTime - timestampTime;

// Check if the timestamp is within 20 seconds of the current time

if ([Link] > 20)
{
error("Date/Time settings aren't synced on your device, please
sync them to use the program");
TerminateProcess(GetCurrentProcess(), 1);
}

var byteSig = encryption.str_to_byte_arr(signature);

var byteKey =
encryption.str_to_byte_arr("5586b4bc69c7a4b487e4563a4cd96afd39140f919bd31cea7d1c6a1
e8439422b");
// ... read the body from the request ...
// ... add the timestamp and convert it to a byte[] ...
string body = timestamp + resp;
var byteBody = [Link](body);

[Link](" Authenticating"); // there's also ... dots being

created inside the CheckValid() function BELOW

bool signatureValid = [Link](byteSig, byteBody,

byteKey); // the ... dots in the console are from this function!
if (!signatureValid)
{
error("Signature checksum failed. Request was tampered with or
session ended most likely. & echo: & echo Response: " + resp);
[Link](resp + "\n");
TerminateProcess(GetCurrentProcess(), 1);
}
}
catch
{
error("Signature checksum failed. Request was tampered with or
session ended most likely. & echo: & echo Response: " + resp);
[Link](resp + "\n");
TerminateProcess(GetCurrentProcess(), 1);
}
}

#region app_data
public app_data_class app_data = new app_data_class();

public class app_data_class

{
public string numUsers { get; set; }
public string numOnlineUsers { get; set; }
public string numKeys { get; set; }
public string version { get; set; }
public string customerPanelLink { get; set; }
public string downloadLink { get; set; }
}

private void load_app_data(app_data_structure data)

{
app_data.numUsers = [Link];
 app_data.numOnlineUsers = [Link];
app_data.numKeys = [Link];
app_data.version = [Link];
app_data.customerPanelLink = [Link];
}
#endregion

#region user_data
public user_data_class user_data = new user_data_class();

public class user_data_class

{
public string username { get; set; }
public string ip { get; set; }
public string hwid { get; set; }
public string createdate { get; set; }
public string lastlogin { get; set; }
public List<Data> subscriptions { get; set; } // array of subscriptions
(basically multiple user ranks for user with individual expiry dates
}
public class Data
{
public string subscription { get; set; }
public string expiry { get; set; }
public string timeleft { get; set; }
public string key { get; set; }
}

private void load_user_data(user_data_structure data)

{
user_data.username = [Link];
user_data.ip = [Link];
user_data.hwid = [Link];
user_data.createdate = [Link];
user_data.lastlogin = [Link];
user_data.subscriptions = [Link]; // array of subscriptions
(basically multiple user ranks for user with individual expiry dates
}
#endregion

[DataContract]
private class TwoFactorData
{
[DataMember(Name = "secret_code")]
public string SecretCode { get; set; }

[DataMember(Name = "QRCode")]
public string QRCode { get; set; }
}

#region response_struct
public response_class response = new response_class();

public class response_class

{
public bool success { get; set; }
public string message { get; set; }
}
 private void load_response_struct(response_structure data)
{
[Link] = [Link];
[Link] = [Link];
}
#endregion

private json_wrapper response_decoder = new json_wrapper(new

response_structure());
}

public static class Logger

{
public static bool IsLoggingEnabled { get; set; } = false; // Disabled by
default
public static void LogEvent(string content)
{
if (!IsLoggingEnabled)
{
//[Link]("Debug mode disabled."); // Optional: Message
when logging is disabled
return; // Exit the method if logging is disabled
}

string exeName =
[Link]([Link]().Loca
tion);

string logDirectory =
[Link]([Link]([Link]
ata), "KeyAuth", "debug", exeName);
if ()
{
[Link](logDirectory);
}

string logFileName = $"{[Link]:MMM_dd_yyyy}_logs.txt";

string logFilePath = [Link](logDirectory, logFileName);

try
{
// Redact sensitive fields - Add more if you would like.
content = RedactField(content, "sessionid");
content = RedactField(content, "ownerid");
content = RedactField(content, "app");
content = RedactField(content, "version");
content = RedactField(content, "fileid");
content = RedactField(content, "webhooks");
content = RedactField(content, "nonce");

using (StreamWriter writer = [Link](logFilePath))

{
[Link]($"[{[Link]}]
[{[Link]}] {content}");
}
}
catch (Exception ex)
{
[Link]($"Error logging data: {[Link]}");
 }
}

private static string RedactField(string content, string fieldName)

{
// Basic pattern matching to replace values of sensitive fields
string pattern = $"\"{fieldName}\":\"[^\"]*\"";
string replacement = $"\"{fieldName}\":\"REDACTED\"";

return [Link](content, pattern,

replacement);
}
}

public static class encryption

{
[DllImport("[Link]", SetLastError = true)]
private static extern bool TerminateProcess(IntPtr hProcess, uint
uExitCode);

[DllImport("[Link]", SetLastError = true)]

private static extern IntPtr GetCurrentProcess();

public static string HashHMAC(string enckey, string resp)

{
byte[] key = [Link](enckey);
byte[] message = [Link](resp);
var hash = new HMACSHA256(key);
return byte_arr_to_str([Link](message));
}

public static string byte_arr_to_str(byte[] ba)

{
StringBuilder hex = new StringBuilder([Link] * 2);
foreach (byte b in ba)
[Link]("{0:x2}", b);
return [Link]();
}

public static byte[] str_to_byte_arr(string hex)

{
try
{
int NumberChars = [Link];
byte[] bytes = new byte[NumberChars / 2];
for (int i = 0; i < NumberChars; i += 2)
bytes[i / 2] = [Link]([Link](i, 2), 16);
return bytes;
}
catch
{
[Link]("The session has ended, open program again.");
TerminateProcess(GetCurrentProcess(), 1);
return null;
}
}

public static string iv_key() =>

[Link]().ToString().Substring(0, 16);
 }

public class json_wrapper

{
public static bool is_serializable(Type to_check) =>
to_check.IsSerializable ||
to_check.IsDefined(typeof(DataContractAttribute), true);

public json_wrapper(object obj_to_work_with)

{
current_object = obj_to_work_with;

var object_type = current_object.GetType();

serializer = new DataContractJsonSerializer(object_type);

if (!is_serializable(object_type))
throw new Exception($"the object {current_object} isn't a
serializable");
}

public object string_to_object(string json)

{
var buffer = [Link](json);

//SerializationException = session expired

using (var mem_stream = new MemoryStream(buffer))

return [Link](mem_stream);
}

public T string_to_generic<T>(string json) =>

(T)string_to_object(json);

private DataContractJsonSerializer serializer;

private object current_object;

}
}