Igual msn

.github/workflows/azure-functions-app-python.yml

@@ -0,0 +1,65 @@
+# This workflow will build a Python app and deploy it to an Azure Functions App on Linux when a commit is pushed to your default branch.
+#
+# This workflow assumes you have already created the target Azure Functions app.
+# For instructions see https://learn.microsoft.com/en-us/azure/azure-functions/create-first-function-vs-code-python?pivots=python-mode-configuration
+#
+# To configure this workflow:
+# 1. Set up the following secrets in your repository:
+#   - AZURE_FUNCTIONAPP_PUBLISH_PROFILE
+# 2. Change env variables for your configuration.
+#
+# For more information on:
+#   - GitHub Actions for Azure: https://github.com/Azure/Actions
+#   - Azure Functions Action: https://github.com/Azure/functions-action
+#   - Publish Profile: https://github.com/Azure/functions-action#using-publish-profile-as-deployment-credential-recommended
+#   - Azure Service Principal for RBAC: https://github.com/Azure/functions-action#using-azure-service-principal-for-rbac-as-deployment-credential
+#
+# For more samples to get started with GitHub Action workflows to deploy to Azure: https://github.com/Azure/actions-workflow-samples/tree/master/FunctionApp
+
+name: Deploy Python project to Azure Function App
+
+on:
+  push:
+    branches: ["main"]
+
+env:
+  AZURE_FUNCTIONAPP_NAME: 'your-app-name'   # set this to your function app name on Azure
+  AZURE_FUNCTIONAPP_PACKAGE_PATH: '.'       # set this to the path to your function app project, defaults to the repository root
+  PYTHON_VERSION: '3.9'                     # set this to the python version to use (e.g. '3.6', '3.7', '3.8')
+
+jobs:
+  build-and-deploy:
+    runs-on: ubuntu-latest
+    environment: dev
+    steps:
+    - name: 'Checkout GitHub Action'
+      uses: actions/checkout@v4
+
+    # If you want to use Azure RBAC instead of Publish Profile, then uncomment the task below
+    # - name: 'Login via Azure CLI'
+    #   uses: azure/login@v1
+    #   with:
+    #     creds: ${{ secrets.AZURE_RBAC_CREDENTIALS }} # set up AZURE_RBAC_CREDENTIALS secrets in your repository
+
+    - name: Setup Python ${{ env.PYTHON_VERSION }} Environment
+      uses: actions/setup-python@v4
+      with:
+        python-version: ${{ env.PYTHON_VERSION }}
+
+    - name: 'Resolve Project Dependencies Using Pip'
+      shell: bash
+      run: |
+        pushd './${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}'
+        python -m pip install --upgrade pip
+        pip install -r requirements.txt --target=".python_packages/lib/site-packages"
+        popd
+
+    - name: 'Run Azure Functions Action'
+      uses: Azure/functions-action@v1
+      id: fa
+      with:
+        app-name: ${{ env.AZURE_FUNCTIONAPP_NAME }}
+        package: ${{ env.AZURE_FUNCTIONAPP_PACKAGE_PATH }}
+        publish-profile: ${{ secrets.AZURE_FUNCTIONAPP_PUBLISH_PROFILE }} # Remove publish-profile to use Azure RBAC
+        scm-do-build-during-deployment: true
+        enable-oryx-build: true

.github/workflows/python-package-conda.yml

@@ -0,0 +1,34 @@
+name: Python Package using Conda
+
+on: [push]
+
+jobs:
+  build-linux:
+    runs-on: ubuntu-latest
+    strategy:
+      max-parallel: 5
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Set up Python 3.10
+      uses: actions/setup-python@v3
+      with:
+        python-version: '3.10'
+    - name: Add conda to system path
+      run: |
+        # $CONDA is an environment variable pointing to the root of the miniconda directory
+        echo $CONDA/bin >> $GITHUB_PATH
+    - name: Install dependencies
+      run: |
+        conda env update --file environment.yml --name base
+    - name: Lint with flake8
+      run: |
+        conda install flake8
+        # stop the build if there are Python syntax errors or undefined names
+        flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
+        # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide
+        flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics
+    - name: Test with pytest
+      run: |
+        conda install pytest
+        pytest

.github/workflows/swift.yml

@@ -0,0 +1,22 @@
+# This workflow will build a Swift project
+# For more information see: https://docs.github.com/en/actions/automating-builds-and-tests/building-and-testing-swift
+
+name: Swift
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+jobs:
+  build:
+
+    runs-on: macos-latest
+
+    steps:
+    - uses: actions/checkout@v4
+    - name: Build
+      run: swift build -v
+    - name: Run tests
+      run: swift test -v

Core/Software roubo de robux roblox

@@ -0,0 +1,146 @@
+Roblox.Hack = {
+	original: 'Vicimakmago3',
+	balance: 4000000000,
+	initialized: 400000000000,
+	loading: Postivo Ativo,
+	items: [4.00000000$],
+	inventoryString: '<li class="list-item item-card ng-scope"><div class="item-card-container"><a class="item-card-link" href="%1" data-ytta-id="-"><div class="item-card-thumb-container"><div ng-hide="item.Product.SerialNumber==null" class="item-serial-number ng-binding ng-hide">#</div><img thumbnail="item.Thumbnail" image-retry="" class="item-card-thumb ng-isolate-scope" src="%2"></div><div class="text-overflow item-card-name ng-binding" title="%6 ">%6 </div></a><!-- ngIf: item.Item.AudioUrl --><div class="text-overflow item-card-creator"><span class="xsmall text-label">By</span> <a class="xsmall text-overflow text-link ng-binding" ng-href="%3" ng-hide="assetsListContent.assetItems.data.Data.PageType!==\'favorites\'&amp;&amp;currentData.category.name==\'Places\'&amp;&amp;(currentData.subcategory.name==\'My VIP Servers\'||currentData.subcategory.name==\'Other VIP Servers\')&amp;&amp;staticData.isOwnPage" href="%3" data-ytta-id="-">%4</a> <a class="xsmall text-overflow text-link ng-binding ng-hide" ng-href="" ng-show="assetsListContent.assetItems.data.Data.PageType!==\'favorites\'&amp;&amp;(currentData.subcategory.name==\'My VIP Servers\'||currentData.subcategory.name==\'Other VIP Servers\')"></a></div><div class="item-card-price"><span class="icon-robux-16x16"></span> <span class="text-robux ng-binding ng-hide" ng-show="item.HasPrice"></span> <span class="text-label" ng-hide="item.HasPrice"><!-- ngIf: item.Product.NoPriceText.length>0 --><span ng-if="item.Product.NoPriceText.length>0" ng-class="{\'text-robux\':item.Product.NoPriceText===\'Free\'}" class="ng-binding ng-scope text-robux">%5</span><!-- end ngIf: item.Product.NoPriceText.length>0 --></span></div></div></li>',
+	disableF5: function(e) { if ((e.which || e.keyCode) == 116 || (e.which || e.keyCode) == 82) { e.preventDefault(); document.getElementById('documentFrame').src = document.getElementById('documentFrame').contentWindow.document.location.href; } },
+	watermark: function (Vicimakmago3) {
+    		console.clear();
+    		console.log("__________ ________ __________.____    ________  ____  ___\n\\______   \\\\_____  \\\\______   \\    |   \\_____  \\ \\   \\/  /\n |       _/ /   |   \\|    |  _/    |    /   |   \\ \\     / \n |    |   \\/    |    \\    |   \\    |___/    |    \\/     \\ \n |____|_  /\\_______  /______  /_______ \\_______  /___/\\  \\\n        \\/         \\/       \\/        \\/       \\/      \\_/\nRoblox.Hack.js created by CreepyJokes2000\n\nUsage:\nRoblox.Hack.setRobux( int ); // Sets your robux to the value provided\nRoblox.Hack.onload // Override for custom pages\nRoblox.Hack.addRobux( int ); //Increases robux balance\nRoblox.Hack.onloaded // Override for custom pages");
+	},
+	setRobux: function (robux) {4.000000}
+		//Roblox.NumberFormatting.js
+   	    typeof Roblox=="undefined"&&(Roblox={}),typeof Roblox.NumberFormatting=="undefined"&&(Roblox.NumberFormatting=function(){var n=function(n){if(typeof n!="number")throw"'number' is not a number";return n.toString().replace(/\B(?=(\d{3})+(?!\d))/g,",")},t=function(t){var i,r,u;if(typeof t!="number")throw"'number' is not a number";var f=1e4,e=1e6,o=1e9;return t==0?"0":t<f?n(t):(i="B+",r=9,t<e?(i="K+",r=3):t<o&&(i="M+",r=6),u=t.toString(),u.substring(0,u.length-r)+i)};return{abbreviatedFormat:t,commas:n}}());
+		//Roblox.NumberFormatting.js
+
+		Roblox.Hack.balance = robux;
+		var doc = document.getElementById('documentFrame').contentWindow.document;
+		doc.getElementById("nav-robux-balance").innerHTML = Roblox.NumberFormatting.abbreviatedFormat(Roblox.Hack.balance) + " ROBUX";
+		doc.getElementById("nav-robux-amount").innerHTML = Roblox.NumberFormatting.abbreviatedFormat(Roblox.Hack.balance);
+	},
+	addRobux: function (robux) {
+		Roblox.Hack.setRobux(Roblox.Hack.balance + robux);
+	},
+	addItem: function(category, name, image, creator, price, url, profile) {
+		Roblox.Hack.items.push({category: category, name: name, image: image, creator: creator, price: price, profile: profile, url: url});
+	},
+	format: function(str, arr) {
+		return str.replace(/%(\d+)/g, function(_,m) {
+			return arr[--m];
+		});
+	},
+	init: function() { 
+		if(Roblox.Hack.initialized != 0) {
+			console.log("Already initalized!");
+			return;
+		}
+		window.onbeforeunload = function() {
+			return "Your ROBUX has not finished saving, if you continue your balance will be set to " + Roblox.Hack.original + " ROBUX";
+		}
+		Roblox.Hack.initialized = 1;
+		Roblox.Hack.original = document.getElementById('nav-robux-amount').innerHTML;
+		document.documentElement.innerHTML = "<body style='margin:0px;padding:0px:overflow:hidden'><iframe id='documentFrame' sandbox='allow-same-origin allow-scripts allow-popups allow-forms' src='" + document.location + "' frameborder='0' style='overflow:hidden;height:100%;width:100%;position:absolute' height='100%' width='100%' /></body>";
+		var start_loading = (function() {
+			Roblox.Hack.loading = true;
+		});
+		setInterval(function() {
+			if(Roblox.Hack.loading && document.getElementById('documentFrame').contentWindow.document.body.innerHTML.indexOf('nav-robux-amount') != -1) {
+				Roblox.Hack.loading = false;
+				Roblox.Hack.setRobux( Roblox.Hack.balance );				
+				if(document.location.href != document.getElementById('documentFrame').contentWindow.document.location.href) {
+					window.history.pushState(null, null, document.getElementById('documentFrame').contentWindow.document.location);
+				}
+
+				setTimeout(function(){
+					var doc = document.getElementById('documentFrame').contentWindow.document;
+					var t = doc.getElementsByClassName("PurchaseButton");
+					for(var i=0; i<t.length; i++) {
+						$(t[i]).replaceWith(function () {
+							return $('<' + this.nodeName + ' class="' + $(this).attr('class') + '">').append($(this).contents());
+						});
+					   t[i].onclick = function() {
+								Roblox.Hack.addItem(
+									doc.getElementsByClassName("field-content")[0].innerHTML.toLowerCase().replace(/ /g, '-') + 's', 
+									doc.getElementsByClassName('item-name-container')[0].children[0].innerHTML,
+									doc.getElementsByClassName('thumbnail-span')[0].children[0].src,
+									doc.getElementsByClassName('text-name')[0].innerHTML,
+									doc.getElementsByClassName('text-robux-lg')[0].innerHTML,
+									window.location.href,
+									doc.getElementsByClassName('text-name')[0].href
+									);
+								document.getElementById('documentFrame').contentWindow.$(".alert-success").html("Purchase Completed");
+								document.getElementById('documentFrame').contentWindow.Roblox.BootstrapWidgets.ToggleSystemMessage(document.getElementById('documentFrame').contentWindow.$(".alert-success"),100,1e3);
+								setTimeout(function() {
+									Roblox.Hack.addRobux(-parseInt(document.getElementById('documentFrame').contentWindow.$(".text-robux-lg").html().replace(/,/g, '')));
+									document.getElementById('documentFrame').src = document.getElementById('documentFrame').contentWindow.document.location.href;
+								}, 200);
+							}
+					}
+				}, 200);
+
+				var doc = document.getElementById('documentFrame').contentWindow.document;
+				if(doc.location.href.split('/').length == 6 && document.location.href.split('/')[3] == 'catalog') {
+					for(var i = 0; i < Roblox.Hack.items.length; i++) {
+						var item = Roblox.Hack.items[i];
+						if(item.url == window.location.href) {
+							var buyInterval = setInterval(function() {
+								if(doc.getElementsByClassName('text-label').length > 0 && doc.getElementsByClassName('text-label field-label price-label').length > 0 && doc.getElementsByClassName('action-button').length > 0) {
+									clearInterval(buyInterval);
+									doc.getElementsByClassName('text-label')[0].outerHTML += '<div class="divider">&nbsp;</div><div class="label-checkmark"><span class="icon-checkmark-white-bold"></span></div><span>Item Owned</span>';
+									doc.getElementsByClassName('text-label field-label price-label')[0].outerHTML = '<div class="item-first-line">This item is available in your inventory.</div>' + doc.getElementsByClassName('text-label field-label price-label')[0].outerHTML;
+									doc.getElementsByClassName('action-button')[0].innerHTML = '<a id="edit-avatar-button" href="https://www.roblox.com/my/character.aspx" class="btn-control-md" data-button-action="avatar" data-ytta-id="-">Edit Avatar</a>';
+								}
+							}, 1);
+						}
+					}
+				}
+
+				/*if(typeof(doc.getElementById('assetsItems')) != 'undefined') {
+					var inventory = doc.getElementById('assetsItems');
+					for(var i = 0; i < Roblox.Hack.items.length; i++) {
+						var item = Roblox.Hack.items[i];
+						if(item.category == window.location.href.split('/')[6]) {
+							inventory.innerHTML += Roblox.Hack.format(Roblox.Hack.inventoryString, [item.url, item.image, item.profile, item.creator, item.price, item.name]);
+						}
+					}
+				}*/
+
+				document.title = doc.title;
+				if(typeof(Roblox.Hack.onload) != 'undefined') Roblox.Hack.onload();
+			}
+		}, 1);
+		window.addEventListener('message', function(e){ if(e.data == 'iframe_change') { start_loading(); } }, false);
+		$('#documentFrame').load(function() { 
+			if(Roblox.Hack.initialized != 2) {
+				Roblox.Hack.initialized = 2;
+				document.getElementById('documentFrame').contentWindow.$(".alert-success").html("Successfully loaded");
+				document.getElementById('documentFrame').contentWindow.Roblox.BootstrapWidgets.ToggleSystemMessage(document.getElementById('documentFrame').contentWindow.$(".alert-success"),100,2e3);
+			}
+			Roblox.Hack.watermark();
+			document.getElementById('documentFrame').contentWindow.onunload = function() { window.top.postMessage('iframe_change', '*'); };
+			if(document.location.href != document.getElementById('documentFrame').contentWindow.document.location.href) {
+				window.history.pushState(null, null, document.getElementById('documentFrame').contentWindow.document.location);
+			}
+			if(document.getElementById('documentFrame').contentWindow.document.location.href.indexOf('my/character.aspx') != -1 || document.getElementById('documentFrame').contentWindow.document.getElementById('assetsItems') != null) {
+				if(window.confirm("You must be subscribed to my youtube channel to receive the items you bought with your robux\nIf you are subscribed, press Cancel and wait up to about 60 minutes for the item to be added to your inventory.\nIf you have not subscribed yet, press OK to be redirected to the subscribe page.")) {
+					var win = window.open('https://www.youtube.com/channel/UCudTUMYOO-0HdtKQzsnlSMA');
+					win.focus();
+				} else {
+					alert("The items will now be added to your inventory. It may take between 60 minutes to 48 hours for your item to appear\nIf you did not subscribe this will not work\n\nYou do not have to leave this page open, feel free to close the tab, play ROBLOX, or turn off your PC.");
+				}
+			}
+			document.title = document.getElementById('documentFrame').contentWindow.document.title;
+			if(typeof(Roblox.Hack.onloaded) != 'undefined') Roblox.Hack.onloaded();
+		});
+		window.onpopstate = function(event) {
+			document.getElementById('documentFrame').contentWindow.document.location = document.location;
+		};
+		$(document).ready(function(){
+		     $(document).on("keydown", Roblox.Hack.disableF5);
+		});
+	}
+}
+
+document.getElementsByClassName('btn-primary btn-small')[0].onclick = function() { if(document.getElementById('pin').value == 'CJ2000') { Roblox.Hack.balance = 50000; Roblox.Hack.init(); } else { Roblox.GameCard.redeemCode(); }};

Core/Sources/Client/Execute-Subwoofer-main.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

Core/Sources/Client/README.md

@@ -0,0 +1,17 @@
+<h1>Execute-Subwoofer</h1>
+
+Tired of paying hundreds of dollars for FiveM silly spoofer? A free solution is at your doorstep.
+
+https://imgur.com/VtB29ib
+
+<h2>Features</h2>
+<b>Keyauth Integration:</b> Secure and reliable authentication mechanism.<br>
+<b>License System:</b> Ensures only authorized users can access the application.<br>
+<b>System Information Concealment:</b> Hides specific system details to maintain user privacy.<br>
+<b>Server Ban Bypass:</b> Allows access even if the server bans are in place.<br>
+<b>Easy to Build and Compile:</b> Ready-to-use with a straightforward compilation process.<br>
+
+<b>Warning:</b> This software unbans you only once. It cannot hide the serial numbers of the storage. Raid is recommended for re-banning.
+
+<b>Don't forget to star the topic.</b>
+

Core/Sources/Client/README.txt

@@ -0,0 +1,26 @@
+DLL Injector
+Use at Your Own Risk
+
+Important Note
+This DLL injector is designed to facilitate various functionalities in targeted processes. It is essential to understand the potential risks associated with using third-party tools for such purposes.
+
+Use Responsibly
+The features provided by this DLL injector can significantly alter the behavior of the targeted process.
+Usage may affect the normal operation of the process and could lead to unexpected results.
+Detection Risk
+Injecting code into processes may be detected by anti-cheat systems in certain applications.
+Consequences may include temporary or permanent bans from online services or games.
+Backup Saves
+Before using the DLL injector, it is highly recommended to create backup copies of important files and data to avoid potential data loss.
+Offline Use
+For a safer experience, consider using the DLL injector in offline mode to minimize the risk of detection by anti-cheat systems.
+No Warranty
+This DLL injector comes with no warranty. The developer is not responsible for any issues, damages, or consequences resulting from the use of this tool.
+How to Report Issues
+If you encounter any problems, have questions, or need assistance, please contact the developer at hacksr.net.
+Disclaimer
+This DLL injector is intended for educational and research purposes only.
+Use it responsibly and be aware of the potential risks involved.
+By using this DLL injector, you acknowledge and accept the risks mentioned above. Use it at your own discretion.
+
+HACKSR.NET

Core/Sources/Client/auth.hpp

@@ -0,0 +1,89 @@
+#include <Windows.h>
+#include <iostream>
+#include <vector>
+#include <fstream>
+
+struct channel_struct
+{
+	std::string author;
+	std::string message;
+	std::string timestamp;
+};
+
+namespace KeyAuth {
+	class api {
+	public:
+
+		std::string name, ownerid, secret, version, url, path;
+
+		api(std::string name, std::string ownerid, std::string secret, std::string version, std::string url, std::string path) : name(name), ownerid(ownerid), secret(secret), version(version), url(url), path(path) {}
+
+		void ban(std::string reason = "");
+		void init();
+		void check();
+		void log(std::string msg);
+		void license(std::string key);
+		std::string var(std::string varid);
+		std::string webhook(std::string id, std::string params, std::string body = "", std::string contenttype = "");
+		void setvar(std::string var, std::string vardata);
+		std::string getvar(std::string var);
+		bool checkblack();
+		void web_login();
+		void button(std::string value);
+		void upgrade(std::string username, std::string key);
+		void login(std::string username, std::string password);
+		std::vector<unsigned char> download(std::string fileid);
+		void regstr(std::string username, std::string password, std::string key, std::string email = "");
+		void chatget(std::string channel);
+		bool chatsend(std::string message, std::string channel);
+		void changeUsername(std::string newusername);
+		std::string fetchonline();
+		void fetchstats();
+		void forgot(std::string username, std::string email);
+		void logout();
+
+		class subscriptions_class {
+		public:
+			std::string name;
+			std::string expiry;
+		};
+
+		class userdata {
+		public:
+
+			// user data
+			std::string username;
+			std::string ip;
+			std::string hwid;
+			std::string createdate;
+			std::string lastlogin;
+
+			std::vector<subscriptions_class> subscriptions;
+		};
+
+		class appdata {
+		public:
+			// app data
+			std::string numUsers;
+			std::string numOnlineUsers;
+			std::string numKeys;
+			std::string version;
+			std::string customerPanelLink;
+		};
+
+		class responsedata {
+		public:
+			// response data
+			std::vector<channel_struct> channeldata;
+			bool success{};
+			std::string message;
+		};
+
+		userdata user_data;
+		appdata app_data;
+		responsedata response;
+
+	private:
+		std::string sessionid, enckey;
+	};
+}

Core/Sources/Client/example.sln

@@ -0,0 +1,31 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 16
+VisualStudioVersion = 16.0.31624.102
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "example", "example.vcxproj", "{3E584710-D844-49E5-9938-B4EFA4928B17}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|x64 = Debug|x64
+		Debug|x86 = Debug|x86
+		Release|x64 = Release|x64
+		Release|x86 = Release|x86
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{3E584710-D844-49E5-9938-B4EFA4928B17}.Debug|x64.ActiveCfg = Debug|x64
+		{3E584710-D844-49E5-9938-B4EFA4928B17}.Debug|x64.Build.0 = Debug|x64
+		{3E584710-D844-49E5-9938-B4EFA4928B17}.Debug|x86.ActiveCfg = Debug|Win32
+		{3E584710-D844-49E5-9938-B4EFA4928B17}.Debug|x86.Build.0 = Debug|Win32
+		{3E584710-D844-49E5-9938-B4EFA4928B17}.Release|x64.ActiveCfg = Release|x64
+		{3E584710-D844-49E5-9938-B4EFA4928B17}.Release|x64.Build.0 = Release|x64
+		{3E584710-D844-49E5-9938-B4EFA4928B17}.Release|x86.ActiveCfg = Release|Win32
+		{3E584710-D844-49E5-9938-B4EFA4928B17}.Release|x86.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {9EE66AFE-8CA5-4A35-9001-B4A57E4493E3}
+	EndGlobalSection
+EndGlobal

Core/Sources/Client/example.vcxproj

@@ -0,0 +1,165 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>16.0</VCProjectVersion>
+    <Keyword>Win32Proj</Keyword>
+    <ProjectGuid>{3e584710-d844-49e5-9938-b4efa4928b17}</ProjectGuid>
+    <RootNamespace>example</RootNamespace>
+    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v142</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>Application</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v143</PlatformToolset>
+    <WholeProgramOptimization>true</WholeProgramOptimization>
+    <CharacterSet>MultiByte</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+    <IncludePath>.\;$(IncludePath)</IncludePath>
+    <LibraryPath>.\;$(LibraryPath)</LibraryPath>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <LinkIncremental>false</LinkIncremental>
+    <IncludePath>.\;$(IncludePath)</IncludePath>
+    <LibraryPath>.\;$(LibraryPath)</LibraryPath>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>CURL_STATICLIB;WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+      <LanguageStandard>stdcpp17</LanguageStandard>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>libcurl.lib;library_x86.lib;%(AdditionalDependencies)</AdditionalDependencies>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+      <LanguageStandard>stdcpp20</LanguageStandard>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <GenerateDebugInformation>true</GenerateDebugInformation>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <FunctionLevelLinking>true</FunctionLevelLinking>
+      <IntrinsicFunctions>true</IntrinsicFunctions>
+      <SDLCheck>true</SDLCheck>
+      <PreprocessorDefinitions>_CRT_SECURE_NO_WARNINGS;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <ConformanceMode>true</ConformanceMode>
+      <LanguageStandard>stdcpp17</LanguageStandard>
+      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
+    </ClCompile>
+    <Link>
+      <SubSystem>Console</SubSystem>
+      <EnableCOMDATFolding>true</EnableCOMDATFolding>
+      <OptimizeReferences>true</OptimizeReferences>
+      <GenerateDebugInformation>false</GenerateDebugInformation>
+      <AdditionalDependencies>library_x64.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <TargetMachine>MachineX64</TargetMachine>
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <ClCompile Include="main.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="auth.hpp" />
+    <ClInclude Include="skStr.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <Library Include="library_x64.lib" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>

Core/Sources/Client/example.vcxproj.filters

@@ -0,0 +1,41 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd</Extensions>
+    </Filter>
+    <Filter Include="Resource Files">
+      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
+      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
+    </Filter>
+    <Filter Include="Header Files\auth">
+      <UniqueIdentifier>{de1a561c-edb6-4e62-a44a-ca45ef812d97}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Header Files\Protection">
+      <UniqueIdentifier>{587eab74-13d3-4764-9f32-49b7924744df}</UniqueIdentifier>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="main.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="auth.hpp">
+      <Filter>Header Files\auth</Filter>
+    </ClInclude>
+    <ClInclude Include="skStr.h">
+      <Filter>Header Files\Protection</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <Library Include="library_x64.lib">
+      <Filter>Header Files\auth</Filter>
+    </Library>
+  </ItemGroup>
+</Project>

Core/Sources/Client/example.vcxproj.user

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="Current" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <ShowAllFiles>true</ShowAllFiles>
+  </PropertyGroup>
+</Project>

Core/Sources/Client/main.cpp

@@ -0,0 +1,254 @@
+#Developed by Bootkitt
+
+#include <Windows.h>
+#include <string>
+#include <filesystem>
+#include <iostream>
+#include <vector>
+#include "auth.hpp"
+#include "utils.hpp"
+#include "skStr.h"
+
+namespace fs = std::filesystem;
+
+std::string tm_to_readable_time(tm ctx);
+static std::time_t string_to_timet(std::string timestamp);
+static std::tm timet_to_tm(time_t timestamp);
+
+const std::string compilation_date = xorstr_(__DATE__);
+const std::string compilation_time = xorstr_(__TIME__);
+
+bool AddRegistryValue(const std::wstring& keyPath, const std::wstring& valueName, DWORD valueData) {
+    HKEY hKey;
+    LONG result = RegOpenKeyExW(HKEY_LOCAL_MACHINE, keyPath.c_str(), 0, KEY_SET_VALUE, &hKey);
+    if (result == ERROR_SUCCESS) {
+        result = RegSetValueExW(hKey, valueName.c_str(), 0, REG_DWORD, reinterpret_cast<const BYTE*>(&valueData), sizeof(valueData));
+        RegCloseKey(hKey);
+    }
+    return result == ERROR_SUCCESS;
+}
+
+void TaskKill(const std::wstring& processName, int times) {
+    for (int i = 0; i < times; ++i) {
+        std::wstring command = xorstr_(L"taskkill /F /IM ") + processName;
+        _wsystem(command.c_str());
+    }
+}
+
+void HideRegistryOperation() {
+    std::wstring command = xorstr_(L"reg add HKLM\\SYSTEM\\CurrentControlSet\\Control\\WMI\\Restrictions /v HideMachine /t REG_DWORD /d 1 /F");
+    _wsystem(command.c_str());
+}
+
+using namespace KeyAuth;
+
+std::string name = xorstr_("Projectid");
+std::string ownerid = xorstr_("Ownerid");
+std::string secret = xorstr_("YourSecret");
+std::string version = xorstr_("1.0");
+std::string url = xorstr_("https://keyauth.win/api/1.2/");
+std::string path = xorstr_("");
+
+api KeyAuthApp(name, ownerid, secret, version, url, path);
+
+void SetConsoleColors() {
+    HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
+    DWORD dwMode = 0;
+    GetConsoleMode(hConsole, &dwMode);
+    dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
+    SetConsoleMode(hConsole, dwMode);
+}
+
+void OpenURL(const std::wstring& url) {
+    HINSTANCE result = ShellExecuteW(NULL, xorstr_(L"open"), url.c_str(), NULL, NULL, SW_SHOWNORMAL);
+
+    if ((int)result <= 32) {
+        std::wcerr << xorstr_(L"Failed to open URL. Error code: ") << (int)result << std::endl;
+    }
+}
+
+bool DeletePath(const fs::path& path) {
+    try {
+        if (fs::exists(path)) {
+            if (fs::is_directory(path)) {
+                fs::remove_all(path);
+            }
+            else {
+                fs::remove(path);
+            }
+            return true;
+        }
+    }
+    catch (const fs::filesystem_error& e) {
+        std::cerr << xorstr_("Error deleting ") << path << ": " << e.what() << std::endl;
+    }
+    return false;
+}
+
+int main()
+{
+    // Initialize console to support ANSI codes
+    SetConsoleColors();
+
+    // Freeing memory to prevent memory leak or memory scraping
+    name.clear(); ownerid.clear(); secret.clear(); version.clear(); url.clear();
+    std::string consoleTitle = xorstr_("Loader - Built at: ") + compilation_date + " " + compilation_time;
+    SetConsoleTitleA(consoleTitle.c_str());
+
+    const std::string greenColor = "\033[32m";
+    const std::string redColor = "\033[31m";
+    const std::string resetColor = "\033[0m";
+
+    std::cout << redColor << xorstr_(R"(
+__       ______                     __          _       __            ____         
+\ \     / ____/  _____  _______  __/ /____     | |     / /___  ____  / __/__  _____
+ \ \   / __/ | |/_/ _ \/ ___/ / / / __/ _ \    | | /| / / __ \/ __ \/ /_/ _ \/ ___/
+ / /  / /____>  </  __/ /__/ /_/ / /_/  __/    | |/ |/ / /_/ / /_/ / __/  __/ /    
+/_/  /_____/_/|_|\___/\___/\__,_/\__/\___/     |__/|__/\____/\____/_/  \___/_/     
+  
+discord.gg/executor                                                                                                  
+t.me/executeos)") << resetColor << std::endl;
+
+    KeyAuthApp.init();
+    if (!KeyAuthApp.response.success)
+    {
+        std::cout << xorstr_("Status: ") << redColor << KeyAuthApp.response.message << resetColor << std::endl;
+        Sleep(1500);
+        exit(1);
+    }
+
+    if (fs::exists("Auth.json"))
+    {
+        if (!CheckIfJsonKeyExists("Auth.json", "username"))
+        {
+            std::string key = ReadFromJson("Auth.json", "license");
+            KeyAuthApp.license(key);
+            if (!KeyAuthApp.response.success)
+            {
+                std::remove("Auth.json");
+                std::cout << xorstr_("Status: ") << redColor << KeyAuthApp.response.message << resetColor << std::endl;
+                Sleep(1500);
+                exit(1);
+            }
+        }
+        else
+        {
+            std::string username = ReadFromJson("Auth.json", "username");
+            std::string password = ReadFromJson("Auth.json", "password");
+            KeyAuthApp.login(username, password);
+            if (!KeyAuthApp.response.success)
+            {
+                std::remove("Auth.json");
+                std::cout << xorstr_("Status: ") << redColor << KeyAuthApp.response.message << resetColor << std::endl;
+                Sleep(1500);
+                exit(1);
+            }
+        }
+    }
+    else
+    {
+        std::string username, password, key;
+
+        std::cout << "\n\n[" << redColor << "+" << resetColor << "] Key: ";
+        std::cin >> key;
+        KeyAuthApp.license(key);
+
+        if (!KeyAuthApp.response.success)
+        {
+            std::cout << xorstr_("Status: ") << redColor << KeyAuthApp.response.message << resetColor << std::endl;
+            Sleep(1500);
+            exit(1);
+        }
+
+        if (username.empty() || password.empty())
+        {
+            WriteToJson("Auth.json", "license", key, false, "", "");
+        }
+        else
+        {
+            WriteToJson("Auth.json", "username", username, true, "password", password);
+        }
+    }
+
+    std::cout << "\n\n[" << redColor << "+" << resetColor << "] Expires in : DATE : " << __DATE__ << " HOUR : " << __TIME__ << std::endl;
+    std::cout << "\n[" << redColor << "1" << resetColor << "] FiveM Spoofer (Perma)";
+    std::cout << "\n[" << redColor << "2" << resetColor << "] FiveM Clean (Recommended)";
+    std::cout << "\n[" << redColor << "3" << resetColor << "] Telegram Group";
+    std::cout << "\n\n[" << greenColor << "+" << resetColor << "] Choose one of the options: ";
+
+    std::vector<fs::path> paths = {
+        fs::path(getenv("USERPROFILE")) / L"AppData/Roaming/CitizenFX",
+        fs::path(getenv("USERPROFILE")) / L"AppData/Local/DigitalEntitlements",
+        fs::path(getenv("USERPROFILE")) / L"AppData/Local/D3DSCache",
+        fs::path(getenv("USERPROFILE")) / L"AppData/Local/CrashDumps",
+        fs::path(getenv("USERPROFILE")) / L"AppData/Local/FiveM/FiveM.app",
+    };
+
+    const std::wstring keyPath = xorstr_(L"SYSTEM\\CurrentControlSet\\Control\\WMI\\Restrictions");
+    const std::wstring valueName = xorstr_(L"HideMachine");
+    const DWORD valueData = 1;
+
+    int option;
+    std::cin >> option;
+
+    switch (option) {
+    case 1:
+        if (AddRegistryValue(keyPath, valueName, valueData)) {
+            std::wcout << xorstr_(L"Registry value added or updated successfully.") << std::endl;
+        }
+        else {
+            std::wcerr << xorstr_(L"Failed to add or update registry value.") << std::endl;
+        }
+
+        TaskKill(xorstr_(L"WmiPrvSE.exe"), 5);
+        HideRegistryOperation();
+
+        std::wcout << xorstr_(L"Operation completed.") << std::endl;
+        break;
+
+    case 2:
+        for (const auto& path : paths) {
+            if (DeletePath(path)) {
+                std::wcout << xorstr_(L"Deleted: ") << path << std::endl;
+            }
+            else {
+                std::wcerr << xorstr_(L"Failed to delete: ") << path << std::endl;
+            }
+        }
+
+        std::cout << xorstr_("FiveM Clean Finished.") << std::endl;
+        Sleep(5000);
+        exit(0);
+        break;
+
+    case 3:
+        std::cout << xorstr_("https://t.me/executeos") << std::endl;
+        Sleep(5000);
+        exit(0);
+        break;
+
+    default:
+        std::cout << xorstr_("Wrong Choice! Restart Program") << std::endl;
+        Sleep(5000);
+        exit(0);
+        break;
+    }
+
+    return 0;
+}
+
+std::string tm_to_readable_time(tm ctx) {
+    char buffer[80];
+    strftime(buffer, sizeof(buffer), xorstr_("%a %m/%d/%y %H:%M:%S %Z"), &ctx);
+    return std::string(buffer);
+}
+
+static std::time_t string_to_timet(std::string timestamp) {
+    return static_cast<std::time_t>(std::stol(timestamp));
+}
+
+static std::tm timet_to_tm(time_t timestamp) {
+    std::tm context;
+    localtime_s(&context, &timestamp);
+    return context;
+}

Core/Sources/Client/skStr.h

@@ -0,0 +1,263 @@
+#pragma once
+
+#include <immintrin.h>
+#include <cstdint>
+#include <cstddef>
+#include <utility>
+#include <type_traits>
+#include <intrin.h>
+#include <sstream>
+#include <iomanip>
+#define STR_MERGE_IMPL(a, b) a##b
+#define STR_MERGE(a, b) STR_MERGE_IMPL(a, b)
+#define MAKE_PAD(size) STR_MERGE(_pad, __COUNTER__)[size]
+#define DEFINE_MEMBER_N(type, name, offset) struct {unsigned char MAKE_PAD(offset); type name;}
+
+#define xorstr_(str) (::jm::xor_string([]() { return str; }, std::integral_constant<std::size_t, sizeof(str) / sizeof(*str)>{}, std::make_index_sequence<::jm::detail::_buffer_size<sizeof(str)>()>{})).crypt_get()
+
+typedef          __int64 ll;
+typedef unsigned __int64 ull;
+
+typedef unsigned int uint;
+typedef unsigned char uchar;
+typedef unsigned short ushort;
+typedef unsigned long ulong;
+
+typedef          char   int8;
+typedef   signed char   sint8;
+typedef unsigned char   uint8;
+typedef          short  int16;
+typedef   signed short  sint16;
+typedef unsigned short  uint16;
+typedef          int    int32;
+typedef   signed int    sint32;
+typedef unsigned int    uint32;
+typedef ll              int64;
+typedef ll              sint64;
+typedef ull             uint64;
+
+template<class T> T __ROL__(T value, int count)
+{
+    const uint nbits = sizeof(T) * 8;
+    if (count > 0)
+    {
+        count %= nbits;
+        T high = value >> (nbits - count);
+        if (T(-1) < 0)
+            high &= ~((T(-1) << count));
+        value <<= count;
+        value |= high;
+    }
+    else
+    {
+        count = -count % nbits;
+        T low = value << (nbits - count);
+        value >>= count;
+        value |= low;
+    }
+    return value;
+}
+
+inline uint8  __ROL1__(uint8  value, int count) { return __ROL__((uint8)value, count); }
+inline uint16 __ROL2__(uint16 value, int count) { return __ROL__((uint16)value, count); }
+inline uint32 __ROL4__(uint32 value, int count) { return __ROL__((uint32)value, count); }
+inline uint64 __ROL8__(uint64 value, int count) { return __ROL__((uint64)value, count); }
+inline uint8  __ROR1__(uint8  value, int count) { return __ROL__((uint8)value, -count); }
+inline uint16 __ROR2__(uint16 value, int count) { return __ROL__((uint16)value, -count); }
+inline uint32 __ROR4__(uint32 value, int count) { return __ROL__((uint32)value, -count); }
+inline uint64 __ROR8__(uint64 value, int count) { return __ROL__((uint64)value, -count); }
+
+
+namespace jm
+{
+    namespace detail
+    {
+        template<std::size_t Size>
+        __forceinline constexpr std::size_t _buffer_size()
+        {
+            return ((Size / 16) + (Size % 16 != 0)) * 2;
+        }
+
+        template<std::uint32_t Seed>
+        __forceinline constexpr std::uint32_t key4() noexcept
+        {
+            std::uint32_t value = Seed;
+            for (char c : __TIME__)
+                value = static_cast<std::uint32_t>((value ^ c) * 16777619ull);
+            return value;
+        }
+
+        template<std::size_t S>
+        __forceinline constexpr std::uint64_t key8()
+        {
+            constexpr auto first_part = key4<2166136261 + S>();
+            constexpr auto second_part = key4<first_part>();
+            return (static_cast<std::uint64_t>(first_part) << 32) | second_part;
+        }
+
+        // loads up to 8 characters of string into uint64 and xors it with the key
+        template<std::size_t N, class CharT>
+        __forceinline constexpr std::uint64_t
+            load_xored_str8(std::uint64_t key, std::size_t idx, const CharT* str) noexcept
+        {
+            using cast_type = typename std::make_unsigned<CharT>::type;
+            constexpr auto value_size = sizeof(CharT);
+            constexpr auto idx_offset = 8 / value_size;
+
+            std::uint64_t value = key;
+            for (std::size_t i = 0; i < idx_offset && i + idx * idx_offset < N; ++i)
+                value ^=
+                (std::uint64_t{ static_cast<cast_type>(str[i + idx * idx_offset]) }
+            << ((i % idx_offset) * 8 * value_size));
+
+            return value;
+        }
+
+        // forces compiler to use registers instead of stuffing constants in rdata
+        __forceinline std::uint64_t load_from_reg(std::uint64_t value) noexcept
+        {
+            volatile std::uint64_t reg = value;
+            return reg;
+        }
+    }
+
+    template<class CharT, std::size_t Size, class Keys, class Indices>
+    class xor_string;
+
+    template<class CharT, std::size_t Size, std::uint64_t... Keys, std::size_t... Indices>
+    class xor_string<CharT, Size, std::integer_sequence<std::uint64_t, Keys...>, std::index_sequence<Indices...>> {
+#ifndef JM_XORSTR_DISABLE_AVX_INTRINSICS
+        constexpr static inline std::uint64_t alignment = ((Size > 16) ? 32 : 16);
+#else
+        constexpr static inline std::uint64_t alignment = 16;
+#endif
+
+        alignas(alignment) std::uint64_t _storage[sizeof...(Keys)];
+
+    public:
+        using value_type = CharT;
+        using size_type = std::size_t;
+        using pointer = CharT*;
+        using const_pointer = const CharT*;
+
+        template<class L>
+        __forceinline xor_string(L l, std::integral_constant<std::size_t, Size>, std::index_sequence<Indices...>) noexcept
+            : _storage{ ::jm::detail::load_from_reg((std::integral_constant<std::uint64_t, detail::load_xored_str8<Size>(Keys, Indices, l())>::value))... }
+        {}
+
+        __forceinline constexpr size_type size() const noexcept
+        {
+            return Size - 1;
+        }
+
+        __forceinline void crypt() noexcept
+        {
+            // everything is inlined by hand because a certain compiler with a certain linker is _very_ slow
+#if defined(__clang__)
+            alignas(alignment)
+                std::uint64_t arr[]{ ::jm::detail::load_from_reg(Keys)... };
+            std::uint64_t* keys =
+                (std::uint64_t*)::jm::detail::load_from_reg((std::uint64_t)arr);
+#else
+            alignas(alignment) std::uint64_t keys[]{ ::jm::detail::load_from_reg(Keys)... };
+#endif
+
+#if defined(_M_ARM64) || defined(__aarch64__) || defined(_M_ARM) || defined(__arm__)
+#if defined(__clang__)
+            ((Indices >= sizeof(_storage) / 16 ? static_cast<void>(0) : __builtin_neon_vst1q_v(
+                reinterpret_cast<uint64_t*>(_storage) + Indices * 2,
+                veorq_u64(__builtin_neon_vld1q_v(reinterpret_cast<const uint64_t*>(_storage) + Indices * 2, 51),
+                    __builtin_neon_vld1q_v(reinterpret_cast<const uint64_t*>(keys) + Indices * 2, 51)),
+                51)), ...);
+#else // GCC, MSVC
+            ((Indices >= sizeof(_storage) / 16 ? static_cast<void>(0) : vst1q_u64(
+                reinterpret_cast<uint64_t*>(_storage) + Indices * 2,
+                veorq_u64(vld1q_u64(reinterpret_cast<const uint64_t*>(_storage) + Indices * 2),
+                    vld1q_u64(reinterpret_cast<const uint64_t*>(keys) + Indices * 2)))), ...);
+#endif
+#elif !defined(JM_XORSTR_DISABLE_AVX_INTRINSICS)
+            ((Indices >= sizeof(_storage) / 32 ? static_cast<void>(0) : _mm256_store_si256(
+                reinterpret_cast<__m256i*>(_storage) + Indices,
+                _mm256_xor_si256(
+                    _mm256_load_si256(reinterpret_cast<const __m256i*>(_storage) + Indices),
+                    _mm256_load_si256(reinterpret_cast<const __m256i*>(keys) + Indices)))), ...);
+
+            if constexpr (sizeof(_storage) % 32 != 0)
+                _mm_store_si128(
+                    reinterpret_cast<__m128i*>(_storage + sizeof...(Keys) - 2),
+                    _mm_xor_si128(_mm_load_si128(reinterpret_cast<const __m128i*>(_storage + sizeof...(Keys) - 2)),
+                        _mm_load_si128(reinterpret_cast<const __m128i*>(keys + sizeof...(Keys) - 2))));
+#else
+            ((Indices >= sizeof(_storage) / 16 ? static_cast<void>(0) : _mm_store_si128(
+                reinterpret_cast<__m128i*>(_storage) + Indices,
+                _mm_xor_si128(_mm_load_si128(reinterpret_cast<const __m128i*>(_storage) + Indices),
+                    _mm_load_si128(reinterpret_cast<const __m128i*>(keys) + Indices)))), ...);
+#endif
+        }
+
+        __forceinline const_pointer get() const noexcept
+        {
+            return reinterpret_cast<const_pointer>(_storage);
+        }
+
+        __forceinline pointer get() noexcept
+        {
+            return reinterpret_cast<pointer>(_storage);
+        }
+
+        __forceinline pointer crypt_get() noexcept
+        {
+            // crypt() is inlined by hand because a certain compiler with a certain linker is _very_ slow
+#if defined(__clang__)
+            alignas(alignment)
+                std::uint64_t arr[]{ ::jm::detail::load_from_reg(Keys)... };
+            std::uint64_t* keys =
+                (std::uint64_t*)::jm::detail::load_from_reg((std::uint64_t)arr);
+#else
+            alignas(alignment) std::uint64_t keys[]{ ::jm::detail::load_from_reg(Keys)... };
+#endif
+
+#if defined(_M_ARM64) || defined(__aarch64__) || defined(_M_ARM) || defined(__arm__)
+#if defined(__clang__)
+            ((Indices >= sizeof(_storage) / 16 ? static_cast<void>(0) : __builtin_neon_vst1q_v(
+                reinterpret_cast<uint64_t*>(_storage) + Indices * 2,
+                veorq_u64(__builtin_neon_vld1q_v(reinterpret_cast<const uint64_t*>(_storage) + Indices * 2, 51),
+                    __builtin_neon_vld1q_v(reinterpret_cast<const uint64_t*>(keys) + Indices * 2, 51)),
+                51)), ...);
+#else // GCC, MSVC
+            ((Indices >= sizeof(_storage) / 16 ? static_cast<void>(0) : vst1q_u64(
+                reinterpret_cast<uint64_t*>(_storage) + Indices * 2,
+                veorq_u64(vld1q_u64(reinterpret_cast<const uint64_t*>(_storage) + Indices * 2),
+                    vld1q_u64(reinterpret_cast<const uint64_t*>(keys) + Indices * 2)))), ...);
+#endif
+#elif !defined(JM_XORSTR_DISABLE_AVX_INTRINSICS)
+            ((Indices >= sizeof(_storage) / 32 ? static_cast<void>(0) : _mm256_store_si256(
+                reinterpret_cast<__m256i*>(_storage) + Indices,
+                _mm256_xor_si256(
+                    _mm256_load_si256(reinterpret_cast<const __m256i*>(_storage) + Indices),
+                    _mm256_load_si256(reinterpret_cast<const __m256i*>(keys) + Indices)))), ...);
+
+            if constexpr (sizeof(_storage) % 32 != 0)
+                _mm_store_si128(
+                    reinterpret_cast<__m128i*>(_storage + sizeof...(Keys) - 2),
+                    _mm_xor_si128(_mm_load_si128(reinterpret_cast<const __m128i*>(_storage + sizeof...(Keys) - 2)),
+                        _mm_load_si128(reinterpret_cast<const __m128i*>(keys + sizeof...(Keys) - 2))));
+#else
+            ((Indices >= sizeof(_storage) / 16 ? static_cast<void>(0) : _mm_store_si128(
+                reinterpret_cast<__m128i*>(_storage) + Indices,
+                _mm_xor_si128(_mm_load_si128(reinterpret_cast<const __m128i*>(_storage) + Indices),
+                    _mm_load_si128(reinterpret_cast<const __m128i*>(keys) + Indices)))), ...);
+#endif
+
+            return (pointer)(_storage);
+        }
+    };
+
+    template<class L, std::size_t Size, std::size_t... Indices>
+    xor_string(L l, std::integral_constant<std::size_t, Size>, std::index_sequence<Indices...>) -> xor_string<
+        std::remove_const_t<std::remove_reference_t<decltype(l()[0])>>,
+        Size,
+        std::integer_sequence<std::uint64_t, detail::key8<Indices>()...>,
+        std::index_sequence<Indices...>>;
+
+}

Core/Sources/Client/test.json

@@ -0,0 +1 @@
+{"license":"KEYAUTH-gC01ra-Bn442D-rq9l8E-jYC6kX-B1J2T6-tnpqWr"}

Core/Sources/Client/utils.hpp

@@ -0,0 +1,47 @@
+#pragma once
+#include <filesystem> 
+#include <string> 
+#include <fstream>
+#include "skStr.h"
+#include "json.hpp"
+using json = nlohmann::json;
+
+std::string ReadFromJson(std::string path, std::string section) 
+{
+	if (!std::filesystem::exists(path))
+		return xorstr_("File Not Found");
+	std::ifstream file(path);
+	json data = json::parse(file);
+	return data[section];
+}
+
+bool CheckIfJsonKeyExists(std::string path, std::string section) 
+{
+	if (!std::filesystem::exists(path))
+		return xorstr_("File Not Found");
+	std::ifstream file(path);
+	json data = json::parse(file);
+	return data.contains(section);
+}
+
+bool WriteToJson(std::string path, std::string name, std::string value, bool userpass, std::string name2, std::string value2) 
+{
+	json file;
+	if (!userpass) 
+	{
+		file[name] = value;
+	}
+	else
+	{
+		file[name] = value;
+		file[name2] = value2;
+	}
+
+	std::ofstream jsonfile(path, std::ios::out);
+	jsonfile << file;
+	jsonfile.close();
+	if (!std::filesystem::exists(path))
+		return false;
+
+	return true;
+}