From f947b20ca0a4241ce0343ddf721d005b1f201c5f Mon Sep 17 00:00:00 2001
From: rad9800 <105589633+rad9800@users.noreply.github.com>
Date: Thu, 23 Jan 2025 14:48:04 +0000
Subject: [PATCH] Create float.cpp

---
 generic/float.cpp | 109 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 109 insertions(+)
 create mode 100644 generic/float.cpp

diff --git a/generic/float.cpp b/generic/float.cpp
new file mode 100644
index 0000000..ee6dd67
--- /dev/null
+++ b/generic/float.cpp
@@ -0,0 +1,109 @@
+#include <bit>
+#include <cstdint>
+#include <stdio.h>
+#include <array>
+
+namespace obf {
+    using size_type = decltype(sizeof(0));
+    
+    consteval uint64_t time_hash() {
+        uint64_t hash = 0;
+        const char* time = __TIME__;
+        const char* date = __DATE__;
+        while (*time) hash = hash * 33 + *time++;
+        while (*date) hash = hash * 33 + *date++;
+        return hash;
+    }
+
+    consteval uint8_t generate_key_byte(size_type index) {
+        const uint64_t a = 6364136223846793005ULL;
+        const uint64_t c = 1442695040888963407ULL;
+        uint64_t seed = (time_hash() + index) * a + c;
+        seed ^= (seed >> 32);
+        seed *= 0x45d9f3b;
+        seed ^= (seed >> 32);
+        return static_cast<uint8_t>(seed);
+    }
+
+    template<size_type N>
+    struct xor_key {
+        uint8_t data[N];
+        
+        consteval xor_key() : data() {
+            for(size_type i = 0; i < N; ++i) {
+                data[i] = generate_key_byte(i);
+            }
+        }
+    };
+    
+    consteval float encode_chars(char c1, char c2, uint8_t k1, uint8_t k2) {
+        uint8_t e1 = static_cast<uint8_t>(c1) ^ k1;
+        uint8_t e2 = static_cast<uint8_t>(c2) ^ k2;
+        
+        uint16_t combined = static_cast<uint16_t>((e1 << 8) | e2);
+        uint32_t bits = (0x7Fu << 23) | (combined << 7);
+        return std::bit_cast<float>(bits);
+    }
+    
+    template<size_type N>
+    struct str {
+        alignas(float) float data[(N + 1) / 2 + 1]{};
+        static constexpr size_type chars_size = N;
+        static constexpr auto key = xor_key<N>();
+        
+        consteval str(const char(&s)[N]) {
+            for (size_type i = 0; i < (N - 1 + 1) / 2; ++i) {
+                const size_type idx = i * 2;
+                const char first = s[idx];
+                const char second = (idx + 1 < N - 1) ? s[idx + 1] : '\0';
+                data[i] = encode_chars(first, second, 
+                                     key.data[idx], 
+                                     (idx + 1 < N - 1) ? key.data[idx + 1] : 0);
+            }
+            data[(N - 1 + 1) / 2] = 0.0f;
+        }
+    };
+    
+    template<size_type N>
+    void decrypt_to_buffer(const str<N>& encoded, const uint8_t* key, char* buffer) {
+        size_type pos = 0;
+        for (size_type i = 0; encoded.data[i] != 0.0f && pos + 2 < N; ++i) {
+            const auto bits = std::bit_cast<uint32_t>(encoded.data[i]);
+            const auto combined = static_cast<uint16_t>((bits & 0x007FFFFF) >> 7);
+            
+            uint8_t e1 = static_cast<uint8_t>((combined >> 8) & 0xFF);
+            uint8_t e2 = static_cast<uint8_t>(combined & 0xFF);
+            
+            char c1 = static_cast<char>(e1 ^ key[pos]);
+            char c2 = static_cast<char>(e2 ^ ((pos + 1 < N - 1) ? key[pos + 1] : 0));
+            
+            if (c1) buffer[pos++] = c1;
+            if (c2) buffer[pos++] = c2;
+        }
+        buffer[pos] = '\0';
+    }
+
+
+}
+#define FLOAT_STR(name, s) \
+    static constexpr auto name = []() consteval { \
+        constexpr auto _str = obf::str(s); \
+        return _str; \
+    }(); \
+    static constexpr auto name##_key = name.key.data; \
+    static char name##_buf[name.chars_size]
+
+#define UNFLOAT_STR(name) \
+    (obf::decrypt_to_buffer(name, name##_key, name##_buf), name##_buf)
+
+int main() {
+    FLOAT_STR(path, "LOCALAPPDATA");
+    FLOAT_STR(key, "SECRET_KEY_123");
+    
+    
+    printf("Decoded strings:\n");
+    printf("%s\n", UNFLOAT_STR(path));
+    printf("%s\n", UNFLOAT_STR(key));
+    
+    return 0;
+}