obfuscation.h raw

   1  // Copyright (c) 2025-present The Limenka developers
   2  // Distributed under the MIT software license, see the accompanying
   3  // file COPYING or http://www.opensource.org/licenses/mit-license.php.
   4  
   5  #ifndef LIMENKA_UTIL_OBFUSCATION_H
   6  #define LIMENKA_UTIL_OBFUSCATION_H
   7  
   8  #include <cstdint>
   9  #include <span.h>
  10  #include <tinyformat.h>
  11  #include <util/strencodings.h>
  12  
  13  #include <array>
  14  #include <bit>
  15  #include <climits>
  16  #include <ios>
  17  #include <memory>
  18  
  19  class Obfuscation
  20  {
  21  public:
  22      using KeyType = uint64_t;
  23      static constexpr size_t KEY_SIZE{sizeof(KeyType)};
  24  
  25      Obfuscation() { SetRotations(0); }
  26      explicit Obfuscation(std::span<const std::byte, KEY_SIZE> key_bytes)
  27      {
  28          SetRotations(ToKey(key_bytes));
  29      }
  30  
  31      operator bool() const { return m_rotations[0] != 0; }
  32  
  33      void operator()(Span<std::byte> target, size_t key_offset = 0) const
  34      {
  35          if (!*this) return;
  36  
  37          KeyType rot_key{m_rotations[key_offset % KEY_SIZE]}; // Continue obfuscation from where we left off
  38          if (target.size() > KEY_SIZE) {
  39              // Obfuscate until 64-bit alignment boundary
  40              if (const auto misalign{std::bit_cast<uintptr_t>(target.data()) % KEY_SIZE}) {
  41                  const size_t alignment{std::min(KEY_SIZE - misalign, target.size())};
  42                  XorWord(target.first(alignment), rot_key);
  43  
  44                  target = {std::assume_aligned<KEY_SIZE>(target.data() + alignment), target.size() - alignment};
  45                  rot_key = m_rotations[(key_offset + alignment) % KEY_SIZE];
  46              }
  47              // Aligned obfuscation in 64-byte chunks
  48              for (constexpr auto unroll{8}; target.size() >= KEY_SIZE * unroll; target = target.subspan(KEY_SIZE * unroll)) {
  49                  for (size_t i{0}; i < unroll; ++i) {
  50                      XorWord(target.subspan(i * KEY_SIZE, KEY_SIZE), rot_key);
  51                  }
  52              }
  53              // Aligned obfuscation in 64-bit chunks
  54              for (; target.size() >= KEY_SIZE; target = target.subspan(KEY_SIZE)) {
  55                  XorWord(target.first(KEY_SIZE), rot_key);
  56              }
  57          }
  58          XorWord(target, rot_key);
  59      }
  60  
  61      template <typename Stream>
  62      void Serialize(Stream& s) const
  63      {
  64          // Use vector serialization for convenient compact size prefix.
  65          std::vector<std::byte> bytes{KEY_SIZE};
  66          std::memcpy(bytes.data(), &m_rotations[0], KEY_SIZE);
  67          s << bytes;
  68      }
  69  
  70      template <typename Stream>
  71      void Unserialize(Stream& s)
  72      {
  73          std::vector<std::byte> bytes{KEY_SIZE};
  74          s >> bytes;
  75          if (bytes.size() != KEY_SIZE) throw std::ios_base::failure(strprintf("Obfuscation key size should be exactly %s bytes long", KEY_SIZE));
  76          SetRotations(ToKey(std::span<std::byte, KEY_SIZE>(bytes)));
  77      }
  78  
  79      std::string HexKey() const
  80      {
  81          return HexStr(std::bit_cast<std::array<uint8_t, KEY_SIZE>>(m_rotations[0]));
  82      }
  83  
  84  private:
  85      // Cached key rotations for different offsets.
  86      std::array<KeyType, KEY_SIZE> m_rotations;
  87  
  88      void SetRotations(KeyType key)
  89      {
  90          for (size_t i{0}; i < KEY_SIZE; ++i) {
  91              int key_rotation_bits{int(CHAR_BIT * i)};
  92              if constexpr (std::endian::native == std::endian::big) key_rotation_bits *= -1;
  93              m_rotations[i] = std::rotr(key, key_rotation_bits);
  94          }
  95      }
  96  
  97      static KeyType ToKey(std::span<const std::byte, KEY_SIZE> key_span)
  98      {
  99          KeyType key{};
 100          std::memcpy(&key, key_span.data(), KEY_SIZE);
 101          return key;
 102      }
 103  
 104      static void XorWord(Span<std::byte> target, KeyType key)
 105      {
 106          assert(target.size() <= KEY_SIZE);
 107          if (target.empty()) return;
 108          KeyType raw{};
 109          std::memcpy(&raw, target.data(), target.size());
 110          raw ^= key;
 111          std::memcpy(target.data(), &raw, target.size());
 112      }
 113  };
 114  
 115  #endif // LIMENKA_UTIL_OBFUSCATION_H
 116