admin/gmh5225-awesome-game-security
1
0
Fork 0
mirror of https://github.com/gmh5225/awesome-game-security synced 2026-06-21 13:56:22 +00:00
Code Issues Packages Projects Releases Wiki Activity

archive: add 1 repo prompt(s) [skip ci]

Browse Source
This commit is contained in:
github-actions[bot]
2026-05-30 11:18:32 +00:00
parent ad7d9f138a
commit 9dd163141f
1 changed files with 432 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
archive/x86byte/sbox.txt
+432
View File
@@ -0,0 +1,432 @@
Project Path: arc_x86byte_sbox_f6boepdd
Source Tree:
```txt
arc_x86byte_sbox_f6boepdd
├── EXAMPLES
│ ├── sbox_test.cpp
│ └── sbox_test1.cpp
├── LICENSE
├── Makefile
├── README.md
└── sbox.hpp
```
`EXAMPLES/sbox_test.cpp`:
```cpp
#include "../sbox.hpp"
string enc(vector<string> &s, sbox sx)
{
cout << "[#] Encrypting....\n";
return (sx.encode(s));
}
vector<string> dec(string s, sbox sx)
{
cout << "[#] Decrypting....\n";
return (sx.decode(s));
}
int main()
{
sbox sx;
vector<string> s;
s.push_back(_OBF("ama obfuscation addicted"));
s.push_back(_OBF("x86byte logic is invisible"));
s.push_back(_OBF("static analysis is for losers?"));
auto res = enc(s, sx);
cout << " [+] Encrypted strings :\n - " << res << endl;
auto recovered = dec(res, sx);
cout << " [+] Decrypted strings :\n";
for(auto& str : recovered)
cout << " - " << str << endl;
return 0;
}
```
`EXAMPLES/sbox_test1.cpp`:
```cpp
#include "../sbox.hpp"
int main()
{
string s = ObfStr("ama obfuscation addicted");
cout << "the string : " << s << endl;
return 0;
}
```
`LICENSE`:
```
MIT License
Copyright (c) 2026 x86byte
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
```
`Makefile`:
```
CMP := g++
SRC := sbox.hpp
main_src := EXAMPLES/sbox_test.cpp
main_src2 := EXAMPLES/sbox_test1.cpp
p_name = sbox
all:
$(CMP) $(SRC) $(main_src) -o sbox
clean:
rm sbox
test2:
$(CMP) $(SRC) $(main_src2) -o sbox
```
`README.md`:
```md
# sbox - Compile-time AES string obfuscation for C++
Standard solutions rely on `length + "#" + string`. That is trivial to reverse.
**sbox** utilizes a `constexpr` AES-128 block cipher to mutate strings into high-entropy noise.
### The Story
During the Neetcode "Encode and Decode Strings" challenge, I ported the AES engine from my obfuscation project, **[Obfusk8](https://github.com/x86byte/Obfusk8)**.
The implementation passed in **7ms** on the first submission. Cryptographic security shouldn't be a trade-off for performance.
### Features
- **No Delimiters:** Fixed-width headers and block mutation replace predictable separators.
- **Binary Safe:** Effortlessly handles raw payloads and null bytes.
- **Static Stealth:** Plaintext is eliminated at compile-time. Using the provided macros, `strings.exe` (or `strings` in linux) returns zero results.
### How to Use
Check the [EXAMPLES](https://github.com/x86byte/sbox/tree/main/EXAMPLES) folder for implementation details:
1. **Multi-String Example (`sbox_test.cpp`):**
Demonstrates how to handle a `vector<string>` using the `_OBF(str)` macro for batch processing. Useful for transit-ready obfuscation.
2. **Single String Example (`sbox_test1.cpp`):**
Demonstrates atomic materialization using the `ObfStr(str)` macro. Best for single variable assignments:
```cpp
string s = ObfStr("ama obfuscation addicted");
```
### Performance
**7ms runtime.**
Proving that overkill can still be optimal.
---
**Author:** [x86byte](https://github.com/x86byte)
```
`sbox.hpp`:
```hpp
/*
* sbox - Delimiter-less string obfuscation
* Ported from: https://github.com/x86byte/Obfusk8
*/
#include <iostream>
#include <vector>
#include <string>
#include <array>
#include <cstring>
using namespace std;
#pragma region AES_CONSTEXPR
namespace aes_constexpr
{
constexpr uint8_t sbox[256] = {
0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16
};
constexpr uint8_t rsbox[256] = {
0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb,
0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb,
0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e,
0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25,
0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92,
0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84,
0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06,
0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b,
0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73,
0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e,
0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b,
0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4,
0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f,
0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef,
0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61,
0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d
};
constexpr uint8_t rcon[11] = { 0x8d, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36 };
constexpr void KeyExpansion(const uint8_t* key, uint8_t* w) {
for (int i = 0; i < 4; i++) {
w[4 * i] = key[4 * i]; w[4 * i + 1] = key[4 * i + 1]; w[4 * i + 2] = key[4 * i + 2]; w[4 * i + 3] = key[4 * i + 3];
}
for (int i = 4; i < 44; i++) {
uint8_t temp[4] = { w[4 * (i - 1)], w[4 * (i - 1) + 1], w[4 * (i - 1) + 2], w[4 * (i - 1) + 3] };
if (i % 4 == 0) {
uint8_t t = temp[0];
temp[0] = sbox[temp[1]] ^ rcon[i / 4]; temp[1] = sbox[temp[2]]; temp[2] = sbox[temp[3]]; temp[3] = sbox[t];
}
w[4 * i] = w[4 * (i - 4)] ^ temp[0]; w[4 * i + 1] = w[4 * (i - 4) + 1] ^ temp[1]; w[4 * i + 2] = w[4 * (i - 4) + 2] ^ temp[2]; w[4 * i + 3] = w[4 * (i - 4) + 3] ^ temp[3];
}
}
constexpr void AddRoundKey(uint8_t* state, const uint8_t* roundKey) { for (int i = 0; i < 16; i++) state[i] ^= roundKey[i]; }
constexpr void SubBytes(uint8_t* state) { for (int i = 0; i < 16; i++) state[i] = sbox[state[i]]; }
constexpr void InvSubBytes(uint8_t* state) { for (int i = 0; i < 16; i++) state[i] = rsbox[state[i]]; }
constexpr void ShiftRows(uint8_t* state) {
uint8_t temp[16] = { 0 };
for (int i = 0; i < 16; i++)
temp[i] = state[i];
state[1] = temp[5]; state[5] = temp[9];
state[9] = temp[13]; state[13] = temp[1];
state[2] = temp[10]; state[6] = temp[14];
state[10] = temp[2]; state[14] = temp[6];
state[3] = temp[15]; state[7] = temp[3];
state[11] = temp[7]; state[15] = temp[11];
}
constexpr void InvShiftRows(uint8_t* state) {
uint8_t temp[16] = { 0 };
for (int i = 0; i < 16; i++)
temp[i] = state[i];
state[1] = temp[13]; state[5] = temp[1];
state[9] = temp[5]; state[13] = temp[9];
state[2] = temp[10]; state[6] = temp[14];
state[10] = temp[2]; state[14] = temp[6];
state[3] = temp[7]; state[7] = temp[11];
state[11] = temp[15]; state[15] = temp[3];
}
constexpr uint8_t gmul(uint8_t a, uint8_t b) {
uint8_t p = 0;
for (int i = 0; i < 8; i++)
{
if (b & 1)
p ^= a;
bool hi = a & 0x80; a <<= 1;
if (hi)
a ^= 0x1B; b >>= 1;
}
return p;
}
constexpr void MixColumns(uint8_t* state) {
uint8_t tmp[16] = {}; for (int i = 0; i < 16; i++) tmp[i] = state[i];
for (int i = 0; i < 4; i++) {
state[4*i] = gmul(tmp[4*i], 2) ^ gmul(tmp[4*i+1], 3) ^ tmp[4*i+2] ^ tmp[4*i+3];
state[4*i+1] = tmp[4*i] ^ gmul(tmp[4*i+1], 2) ^ gmul(tmp[4*i+2], 3) ^ tmp[4*i+3];
state[4*i+2] = tmp[4*i] ^ tmp[4*i+1] ^ gmul(tmp[4*i+2], 2) ^ gmul(tmp[4*i+3], 3);
state[4*i+3] = gmul(tmp[4*i], 3) ^ tmp[4*i+1] ^ tmp[4*i+2] ^ gmul(tmp[4*i+3], 2);
}
}
constexpr void InvMixColumns(uint8_t* state) {
uint8_t tmp[16] = {}; for (int i = 0; i < 16; i++) tmp[i] = state[i];
for (int i = 0; i < 4; i++) {
state[4*i] = gmul(tmp[4*i], 0x0e) ^ gmul(tmp[4*i+1], 0x0b) ^ gmul(tmp[4*i+2], 0x0d) ^ gmul(tmp[4*i+3], 0x09);
state[4*i+1] = gmul(tmp[4*i], 0x09) ^ gmul(tmp[4*i+1], 0x0e) ^ gmul(tmp[4*i+2], 0x0b) ^ gmul(tmp[4*i+3], 0x0d);
state[4*i+2] = gmul(tmp[4*i], 0x0d) ^ gmul(tmp[4*i+1], 0x09) ^ gmul(tmp[4*i+2], 0x0e) ^ gmul(tmp[4*i+3], 0x0b);
state[4*i+3] = gmul(tmp[4*i], 0x0b) ^ gmul(tmp[4*i+1], 0x0d) ^ gmul(tmp[4*i+2], 0x09) ^ gmul(tmp[4*i+3], 0x0e);
}
}
constexpr void EncryptBlock(uint8_t* in, const uint8_t* key) {
uint8_t w[176] = {}; KeyExpansion(key, w);
AddRoundKey(in, w);
for (int r = 1; r < 10; r++)
{
SubBytes(in); ShiftRows(in);
MixColumns(in); AddRoundKey(in, w + r * 16);
}
SubBytes(in);
ShiftRows(in);
AddRoundKey(in, w + 160);
}
constexpr void DecryptBlock(uint8_t* in, const uint8_t* key) {
uint8_t w[176] = {}; KeyExpansion(key, w);
AddRoundKey(in, w + 160);
for (int r = 9; r > 0; r--)
{
InvShiftRows(in); InvSubBytes(in);
AddRoundKey(in, w + r * 16); InvMixColumns(in);
}
InvShiftRows(in);
InvSubBytes(in);
AddRoundKey(in, w);
}
}
#pragma endregion AES_CONSTEXPR
class sbox
{
const uint8_t master_key[16] = {
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10
};
public:
string encode(vector<string>& strs)
{
string enc = "";
for (const string& s : strs) {
uint32_t len = (uint32_t)s.length();
enc.append((char*)&len, sizeof(uint32_t));
size_t num_blocks = (len + 15) / 16;
if (!len)
num_blocks = 1;
for (size_t b = 0; b < num_blocks; ++b) {
uint8_t block[16] = { 0 };
for (size_t i = 0; i < 16; ++i) {
const size_t idx = b * 16 + i;
if (idx < len)
block[i] = (uint8_t)s[idx];
}
aes_constexpr::EncryptBlock(block, master_key);
enc.append((char*)block, 16);
}
}
return enc;
}
vector<string> decode(const string s)
{
vector<string> re;
size_t cursor = 0;
const size_t sz = s.size();
while (cursor < sz)
{
uint32_t len;
if (cursor + 4 > sz) break;
memcpy(&len, &s[cursor], 4);
cursor += 4;
size_t num_blocks = (len + 15) / 16;
if (len == 0) num_blocks = 1;
string current_str = "";
for (size_t b = 0; b < num_blocks; ++b) {
if (cursor + 16 > sz) break;
uint8_t block[16];
memcpy(block, &s[cursor], 16);
cursor += 16;
aes_constexpr::DecryptBlock(block, master_key);
for (size_t i = 0; i < 16; ++i)
if (current_str.size() < len)
current_str += (char)block[i];
}
re.push_back(current_str);
}
return re;
}
};
////////////////////////////////////////////////
// for single string
template <size_t N>
struct sbox_string {
uint8_t data[((N + 15) / 16) * 16] = {0};
size_t len = N;
constexpr sbox_string(const char (&str)[N]) {
for(size_t i = 0; i < N; ++i)
data[i] = (uint8_t)str[i];
uint8_t key[16] = {0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10};
for (size_t b = 0; b < (N + 15) / 16; ++b)
aes_constexpr::EncryptBlock(&data[b * 16], key);
}
};
#define ObfStr(str) ([&]() -> string { \
static constexpr sbox_string<sizeof(str)> _h(str); \
uint8_t _t[sizeof(_h.data)]; \
memcpy(_t, _h.data, sizeof(_t)); \
uint8_t _k[16] = {0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10}; \
for(int _b = 0; _b < sizeof(_t)/16; _b++) \
aes_constexpr::DecryptBlock(&_t[_b*16], _k); \
return string((char*)_t, _h.len - 1); \
}())
////////////////////////////////////////////////
////////////////////////////////////////////////
// for array or list or whatever its called, of strings
template <size_t N>
struct sbox_strings {
uint8_t data[((N + 15) / 16) * 16] = {0};
size_t len = N;
constexpr sbox_strings(const char (&str)[N]) {
for(size_t i = 0; i < N; ++i)
data[i] = (uint8_t)str[i];
uint8_t key[16] = {0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10};
for(size_t b = 0; b < (N + 15) / 16; ++b)
aes_constexpr::EncryptBlock(&data[b * 16], key);
}
};
#define _OBF(str) ([&]() -> string { \
static constexpr sbox_strings<(sizeof(str))> _h(str); \
uint8_t _t[sizeof(_h.data)]; \
memcpy(_t, _h.data, sizeof(_t)); \
uint8_t _k[16] = {0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10}; \
for(int _b = 0; _b < sizeof(_t)/16; _b++) \
aes_constexpr::DecryptBlock(&_t[_b*16], _k); \
return string((char*)_t, _h.len - 1); \
}())
////////////////////////////////////////////////
```