obfuscatedstring.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <cstddef>
#include <cstdint>
#include <promeki/namespace.h>
#include <promeki/string.h>
#include <promeki/fnv1a.h>
 
PROMEKI_NAMESPACE_BEGIN
 
template <size_t N, uint64_t Seed> class ObfuscatedString {
        public:
                consteval ObfuscatedString(const char (&str)[N]) : _data{} {
                        uint64_t state = initState();
                        for (size_t i = 0; i < N - 1; ++i) {
                                uint64_t      key = keyAt(i);
                                unsigned char k0 = static_cast<unsigned char>(key);
                                unsigned char k1 = static_cast<unsigned char>(key >> 8);
                                unsigned char c = static_cast<unsigned char>(str[i]);
 
                                // Round 1: XOR with position-derived key byte.
                                c ^= k0;
                                // Round 2: modular add of CBC state byte.
                                c = static_cast<unsigned char>(c + static_cast<unsigned char>(state));
                                // Round 3: rotate left by 1-7 bits (derived from second key byte).
                                unsigned shift = (k1 & 0x07) | 1;
                                c = static_cast<unsigned char>((c << shift) | (c >> (8 - shift)));
                                // Round 4: XOR with second key byte.
                                c ^= k1;
 
                                _data[i] = static_cast<char>(c);
                                state = advanceState(state, c, key);
                        }
                }
 
                String decode() const {
                        String   out(N - 1, '\0');
                        uint64_t state = initState();
                        for (size_t i = 0; i < N - 1; ++i) {
                                uint64_t      key = keyAt(i);
                                unsigned char k0 = static_cast<unsigned char>(key);
                                unsigned char k1 = static_cast<unsigned char>(key >> 8);
                                unsigned char c = static_cast<unsigned char>(_data[i]);
 
                                // Undo round 4: XOR with second key byte.
                                c ^= k1;
                                // Undo round 3: rotate right.
                                unsigned shift = (k1 & 0x07) | 1;
                                c = static_cast<unsigned char>((c >> shift) | (c << (8 - shift)));
                                // Undo round 2: subtract CBC state byte.
                                c = static_cast<unsigned char>(c - static_cast<unsigned char>(state));
                                // Undo round 1: XOR.
                                c ^= k0;
 
                                out.setCharAt(i, Char(static_cast<char>(c)));
                                state = advanceState(state, static_cast<unsigned char>(_data[i]), key);
                        }
                        return out;
                }
 
                operator String() const { return decode(); }
 
        private:
                // Initial 64-bit CBC state derived from the full seed.
                static constexpr uint64_t initState() {
                        uint64_t h = Seed * 0xbf58476d1ce4e5b9ULL;
                        h ^= h >> 31;
                        h *= 0x94d049bb133111ebULL;
                        h ^= h >> 31;
                        return h;
                }
 
                // Per-byte 64-bit key derived from Seed and position (splitmix64 finalizer).
                static constexpr uint64_t keyAt(size_t i) {
                        uint64_t h =
                                (Seed ^ (static_cast<uint64_t>(i) * 0x9e3779b97f4a7c15ULL)) * 0xbf58476d1ce4e5b9ULL;
                        h ^= h >> 31;
                        h *= 0x94d049bb133111ebULL;
                        h ^= h >> 31;
                        return h;
                }
 
                // Advance the 64-bit CBC state using ciphertext and key.
                static constexpr uint64_t advanceState(uint64_t state, unsigned char cipher, uint64_t key) {
                        state ^= static_cast<uint64_t>(cipher) | (key << 8);
                        state *= 0x517cc1b727220a95ULL;
                        state ^= state >> 29;
                        return state;
                }
 
                char _data[N - 1];
};
 
PROMEKI_NAMESPACE_END
 
// NOLINTNEXTLINE(bugprone-macro-parentheses)
 
#define PROMEKI_OBFUSCATE_SEED                                                                                         \
        (::promeki::fnv1a(__FILE__) ^ (static_cast<uint64_t>(__LINE__) * 0x9e3779b97f4a7c15ULL) ^                      \
         ::promeki::fnv1a(__DATE__ __TIME__))
 
// NOLINTNEXTLINE(bugprone-macro-parentheses)
#define PROMEKI_OBFUSCATE(str)                                                                                         \
        ([]() {                                                                                                        \
                static constexpr auto _obf = ::promeki::ObfuscatedString<sizeof(str), PROMEKI_OBFUSCATE_SEED>(str);    \
                return _obf.decode();                                                                                  \
        }())
 
#endif // PROMEKI_ENABLE_CORE