xs.h

#pragma once
#ifndef XS_H
#define XS_H

#include <stdint.h>
#include <intrin.h>
#include <stdio.h>

#ifdef __cplusplus
extern "C" {
#endif

#ifndef g_alloc
    static void* __g_alloc(size_t s, int z) {
        uint8_t* p = new uint8_t[s];

        if (!p)
            return 0;

        if (z) {
            size_t np = s / sizeof(size_t);
            size_t n = s % sizeof(size_t);

#if _WIN64
            if (np)
                __stosq((unsigned long long*)p, 0, np);
#elif _WIN32
            if (np)
                __stosd((unsigned long*)p, 0, np);
#endif
            if (n)
                __stosb(p + np * sizeof(size_t), 0, n);
        }

        return p;
    }

#	define g_alloc __g_alloc
#endif

    static void* xs(uint8_t* out, uint64_t key, uint32_t size, const void* buf) {
        const uint8_t* data = (const uint8_t*)buf;
        int32_t count = size / sizeof(size_t); // Number of full size_t elements
        int32_t remainder = size % sizeof(size_t); // Remaining bytes after full size_t elements
        int32_t offset = 0;

#if _WIN64
        // On 64-bit Windows, process each 64-bit chunk
        for (int32_t i = 0; i < count; i++, offset += sizeof(size_t)) {
            *(uint64_t*)(out + offset) = *(const uint64_t*)(data + offset) ^ key;
        }
#else
        // On 32-bit platforms, process each 32-bit chunk
        for (int32_t i = 0; i < count; i++, offset += sizeof(size_t)) {
            *(uint32_t*)(out + offset) = *(const uint32_t*)(data + offset) ^ ((uint32_t*)&key)[i % 2];
        }
#endif

        // Process any remaining bytes individually
        for (int32_t i = 0; i < remainder; i++, offset++) {
            *(uint8_t*)(out + offset) = data[offset] ^ ((uint8_t*)&key)[offset % sizeof(uint64_t)];
        }

        return out;
    }

    static const char* xsa(uint64_t key, uint32_t size, const void* buf) {
        // Allocate memory for the output buffer plus one for null-termination
        char* out = (char*)g_alloc(size + sizeof(char), 0);
        if (!out)
            return NULL; // Use NULL for better clarity in C

        // Perform XOR operation
        xs((uint8_t*)out, key, size, buf);

        // Null-terminate the string
        out[size] = '\0';

        return out;
    }

    static const wchar_t* xsw(uint64_t key, uint32_t size, const void* buf) {
        // Allocate memory for the output buffer plus one for null-termination
        wchar_t* out = (wchar_t*)g_alloc((size + 1) * sizeof(wchar_t), 0);
        if (!out)
            return NULL; // Use NULL for better clarity in C

        // Perform XOR operation, ensuring to process by bytes, not by wchar_t units
        xs((uint8_t*)out, key, size, buf);

        // Null-terminate the wide string
        out[size / sizeof(wchar_t)] = L'\0';

        return out;
    }

#ifdef __cplusplus
}
#endif

#endif

// xs.html
// <!DOCTYPE html>
<html>
	<head>
		<meta charset="UTF-8">
		<meta name="viewport" content="width=device-width, initial-scale=1.0">
		<style>
			.container {
				display: flex; /* Enable flexbox layout for the container */
				width: 100%; /* Make the container span the full width */
			}

			.textarea {
				flex: 1; /* Allocate equal space to each textarea */
				border: 1px solid #ccc; /* Add a simple border */
				padding: 10px; /* Add some padding for readability */
				box-sizing: border-box; /* Include padding in element width/height calculations */
			}
		</style>
	</head>
	<body>
		{0}: xs(key, size, data)<br>
		{1}: text<br>
		{2}: key<br>
		{3}: size<br>
		{4}: data<br><br>
		custom output<br><input type="text" id="tex_customoutput" value="{0}"><br><br>
		key (empty = random)<br><input type="text" id="tex_key" value="" maxlength="16"> 
		<button onclick="getkey(false)">Random</button> 
		<button onclick="getkey(true)">Random (NONZERO)</button><br><br>
		<input type="checkbox" id="chk_multiline">multi-line</input>
		<input type="checkbox" id="chk_escapesequences">escape sequences</input>
		<input type="checkbox" id="chk_utf8">utf-8</input><br><br>
		<button onclick="cvt(false)">char</button>
		<button onclick="cvt(true)">wchar_t</button><br><br>
		<div class="container">
			<textarea id="intext" class="textarea" rows="32"></textarea>
			<textarea id="outext" class="textarea" rows="32"></textarea>
		</div>
		<script src="utf8.js" defer></script>
		<script>
			function randomHex(size) {
				const genRanHex = size => [...Array(size)].map(() => Math.floor(Math.random() * 16).toString(16)).join('');
				return parseInt("0x" + genRanHex(size), 16);
			}

			function randomNumber(max = 0xffffffff, min = 0) {					
				return (randomHex(8) % (max - min + 1)) + min
			}

			function randomString(length = 8, upper = true, lower = true, number = true) {
				if (length <= 0 || (!upper && !lower && !number))
					return "";

				let result = '';
				let charactersU = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
				let charactersL = 'abcdefghijklmnopqrstuvwxyz';
				let numric = '0123456789';

				for ( let i = 0; i < length; ) {
					let t = randomNumber(2);
					
					if ( t == 0 && upper ) {
						result += charactersU.charAt(randomNumber(charactersU.length - 1));
						i++;
					}
					else if ( t == 1 && number ) {
						result += numric.charAt(randomNumber(numric.length - 1));
						i++;
					}
					else if ( t == 2 && lower ) {
						result += charactersL.charAt(randomNumber(charactersL.length - 1));
						i++;
					}
				}

				return result;
			}

			function decimalToHexString(number) {
				if (number < 0)
					number = 0xffffffff + number + 1;

				return number.toString(16).toUpperCase().padStart(8, '0');
			}

			function reverseString(str) {
				return str.split("").reverse().join("");
			}

			function genXorKey(nonzero = true) {
				let key1 = 0;
				let key2 = 0;
				let i = 0;
				let l = 0;

				while (true) {
					let n = randomNumber();

					for (l = 0; i < 8; ) {
						if (l == 8)
							break;

						let o = false;
						let s = 0;

						for (; l < 4; l++) {
							let b = (n >> (l * 8)) & 0xff;
							let lb = (b & 0xf);
							let hb = (b >> 4) & 0xf;

							if (nonzero && (lb == 0 || hb == 0 /*|| lb == hb*/))
								continue;

							s = b;
							o = true;
							l++;
							break;
						}

						if (!o)
							break;

						if (i < 4)
							key1 = key1 | (s << (i * 8));
						else
							key2 = key2 | (s << ((i % 4) * 8));

						i++;
					}

					if (i == 8)
						break;
				}

				return decimalToHexString(key2) + decimalToHexString(key1);
			}
			
			function splitStringToByteArray(s) {
				let o = [];
				for (let i = 0; i < s.length; ++i) {
					let v = s.codePointAt(i);
					let cl = 0;
					for (let l = 3; l >= 0; --l) {
						if (!((v >> (l * 8)) & 0xff)) continue;
						cl = l;
						break;
					}
					cl++;
					for (let l = 0; l < cl; ++l) {
						o.push((v >> (l * 8)) & 0xff);
					}
				}
				return o;
			}
			
			function isDoubleByte(str) {
				for (var i = 0, n = str.length; i < n; i++) {
					if (str.codePointAt( i ) > 255) { return true; }
				}
				return false;
			}
						
			function stringByteSize(s) {
				let l = 0;
				for (let i = 0; i < s.length; ++i) {
					let v = s.codePointAt(i);
					let cl = 0;
					for (let l = 3; l >= 0; --l) {
						if (!((v >> (l * 8)) & 0xff)) continue;
						cl = l;
						break;
					}
					cl++;
					l += cl;
				}
				return l;
			}
			
			function encrypt(str, key, unicode) {
				let o = "";
				let k = key;

				if (unicode) {
					for (let i = 0, l = k.length - 4; i < str.length; i++, l -= 4) {
						if (l < 0)
							l = k.length - 4;
					
						l = l % k.length;

						let r = str.codePointAt(i) ^ parseInt(k.slice(l, l + 4), 16);
						o = o + "\\x" + (r & 0xff).toString(16).padStart(2, '0').toUpperCase() + "\\x" + ((r >> 0x8) & 0xff).toString(16).padStart(2, '0').toUpperCase();
					}
				} else {
					arr = splitStringToByteArray(str);
					for (let i = 0, l = k.length - 2; i < arr.length; i++, l -= 2) {			
						l = l % k.length;
						
						if (l < 0)
							l = k.length - 2;

						let r = arr[i] ^ parseInt(k.slice(l, l + 2), 16);
						o = o + "\\x" + r.toString(16).padStart(2, '0').toUpperCase();
					}
				}

				return "\"" + o + "\"";
			}

			function genClassXorStirng(origstr, str, key, unicode) {
				let encData = encrypt(str, key, unicode);
				return [
					(unicode ? "xsw" : "xsa") + "(0x" + key + ", " + (unicode ? str.length * 2 : stringByteSize(str)) + ", " + encData + ")",
					origstr,
					"0x" + key,
					stringByteSize(str),
					encData
				];
			}
			
			function getkey(nonzero) {
				document.getElementById("tex_key").value = genXorKey(nonzero);
			}

			function cvt(isUnicode) {
				const replaceEscape = (match, char) => {
					switch (char) {
					  case 'n':
						return '\n';
					  case 't':
						return '\t';
					  case 'r':
						return '\r';
					  case '\\':
						return '\\';
					  default:
						return match;
					}
				};
				
				const hex2Byte = (str) => {
				  const regex = /\\x([0-9A-Fa-f]{2})/g;

				  return str.replace(regex, (match, hex) => {
					const byteValue = parseInt(hex, 16);
					return String.fromCharCode(byteValue);
				  });
				
				};

				const formatString = (template, ...args) => {
					return template.replace(/{([0-9]+)}/g, function (match, index) {
						return typeof args[index] === 'undefined' ? match : args[index];
					});
				}

				var text = document.getElementById("intext").value;				
				var key = document.getElementById("tex_key").value;
				var customout = document.getElementById("tex_customoutput").value;
				var muliline = document.getElementById("chk_multiline");
				var escapeSequences = document.getElementById("chk_escapesequences");
				var utf_8 = document.getElementById("chk_utf8");
				var hasKey = key.length != 0;

				if (!customout.length) {
					customout = "{0}";
					document.getElementById("tex_customoutput").innerHTML = customout;
				}

				customout = customout.replace(/\\([nt\r\\])/g, replaceEscape);
				
				if (muliline.checked) {
					if (!hasKey)
						key = genXorKey(false);
				
					if (escapeSequences.checked) {
						text = text.replace(/\\([nt\r\\])/g, replaceEscape);
						text = hex2Byte(text);
					}

					let origText = text;

					if (utf_8.checked) {
						text = utf8.encode(text);
						isUnicode = false;
					} else if (isDoubleByte(text)) {
						isUnicode = true;
					}

					result = genClassXorStirng(origText, text, key, isUnicode);
					result = formatString(customout, result[0], result[1], result[2], result[3], result[4]);
					document.getElementById("outext").innerHTML = result;
				} else {
					var outs = [];
					var lines = text.split(/\n/);
					for (var i = 0; i < lines.length; i++) {
						text = lines[i];

						if (!text.length)
							continue;
							
						if (!hasKey)
							key = genXorKey(false);

						if (escapeSequences.checked) {
							text = text.replace(/\\([nt\r\\])/g, replaceEscape);
							text = hex2Byte(text);
						}
						
						let origText = text;
						
						if (utf_8.checked) {
							text = utf8.encode(text);
							isUnicode = false;
						} else if (isDoubleByte(text)) {
							isUnicode = true;
						}

						result = genClassXorStirng(origText, text, key, isUnicode);
						result = formatString(customout, result[0], result[1], result[2], result[3], result[4]);
						outs.push(result);
					}
					document.getElementById("outext").innerHTML = outs.join("\n");
				}
			}
		</script>
	</body>
</html>

// utf8.js
// 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