Class ObfuscatedString

include/advobfuscator/string.h:42–128

  /// \tparam N The number of bytes of the string (including the null terminal byte).
  template<std::size_t N>
  struct ObfuscatedString {
    /// Construct an obfuscated string of characters.
    /// \param str The array of characters (including the null terminal byte).
    consteval ObfuscatedString(char const (&str)[N]) noexcept
    : algos_{generate_sum(str)} {
      encode(str);
    };

    /// Construct an obfuscated string of characters.
    /// \param str The array of characters (including the null terminal byte).
    /// \param params The parameters for the obfuscation (key and algorithms).
    consteval ObfuscatedString(char const (&str)[N], const Parameters &params) noexcept
    : algos_{params} {
      encode(str);
    }

    /// Construct an obfuscated string of characters.
    /// \param str The array of characters (including the null terminal byte).
    /// \param params An array of parameters for the obfuscations (keys and algorithms).
    template<std::size_t A>
    consteval ObfuscatedString(char const (&str)[N], const Parameters (&params)[A]) noexcept
    : algos_{params} {
      static_assert(A <= details::MAX_NB_ALGORITHMS, "Maximum number of parameters overflow");
      encode(str);
    }

    /// Destruct an obfuscated string by first erasing its content.
    constexpr ~ObfuscatedString() noexcept { erase(); }

    /// Implicit conversion to a pointer to (const) characters, like a regular string.
    operator const char* () noexcept {
      constexpr auto random = call::generate_random(__LINE__);
      const ObfuscatedMethodCall call{random, &ObfuscatedString::decode_inplace};
      call(random, this);
      return data_.data();
    }

    /// Get the raw (encrypted) content.
    [[nodiscard]] const char *raw() const noexcept { return data_.data(); }

    /// Get the actual length of the string.
    [[nodiscard]] constexpr std::size_t size() noexcept { return N - 1; }

    /// Decode the obfuscated string
    [[nodiscard]] constexpr std::string decode() const {
      std::array<std::uint8_t, N> buffer;
      std::copy(data_.begin(), data_.end(), buffer.begin());
      if(obfuscated_) algos_.decode(0, buffer.begin(), buffer.end());
      std::string str;
      str.resize(N - 1);
      std::copy(buffer.begin(), buffer.end() - 1, str.begin());
      return str;
    }

    /// Encoded or decoded data.
    std::array<char, N> data_{};
    /// Obfuscations used to encode the data.
    Obfuscations algos_;