c++ - 使用 constexpr 编译时间字符串加密

Question

我想要一个编译时字符串加密，这样我就可以在我的代码中编写:

const auto encryptedInvalidLicense = ENCRYPT("Invalid license");
std::cout << encryptedInvalidLicense.decrypt() << std::endl; // outputs "Invalid license"

并且字符串“Invalid license”不会出现在二进制文件中。预构建可能是答案，但我正在寻找一个纯 c++ constexpr 解决方案来解决这个问题，并且它将得到 VS2015 的支持。

有什么建议吗？

---

1. 我已经查看了 Compile-time string encryption ，它没有为问题提供 constexpr 解决方案。

2. 我也看过 http://www.unknowncheats.me/forum/c-and-c/113715-compile-time-string-encryption.html .虽然它是一个 constexpr 解决方案，但 VS2015 仍然将字符串纯文本添加到二进制文件中。

Answer 1

我会这样做:

1.) 使用 str_const 模板进行此处描述的 constexpr 字符串操作:Conveniently Declaring Compile-Time Strings in C++

代码:

class str_const {
    // constexpr string
private:
    const char * const p_;
    const std::size_t sz_;

public:
    template <std::size_t N>
    constexpr str_const(const char(&a)[N])
            : p_(a)
            , sz_(N - 1)
    {}

    constexpr char operator[](std::size_t n) const { return n < sz_ ? p_[n] : throw std::out_of_range(""); }
    constexpr std::size_t size() const { return sz_; }

    constexpr const char * get() const { return p_; }
};

这使您可以执行 str_const message = "Invalid license" 之类的操作，并在 constexpr 函数中操作 message。

2.) 制作一个简单的编译时伪随机生成器，使用宏 __TIME__ 和 __LINE__ 生成种子。这在此处进行了详细描述:Generate random numbers in C++ at compile time

他们提供了一些基于模板的代码。

3.) 使用 constexpr ctor 制作一个结构体，该 ctor 采用 const char [] 和模板本身的大小，类似于 str_const 示例，或者只接受一个 str_const，并生成两个 str_const 作为其成员变量。

• 一个长度为 n 的 str_const 包含伪随机无符号字符，使用伪随机生成器生成，其中 n 是输入的长度。 (“噪声字符串”)
• 长度为 n 的 str_const 包含输入字符与噪声字符的逐项总和(作为无符号字符)。 (“密文”)

然后它有一个成员函数decrypt，它不需要是constexpr，并且可以返回一个std::string，它只是简单地从噪声字符串中减去每个字符密文对应的字符，并返回结果字符串。

如果您的编译器仍在二进制中存储原始字符串文字，这意味着它要么存储输入字符串文字(构造函数参数)，我认为它不应该这样做，因为它是临时的，或者它基本上内联 decrypt 函数，您应该能够通过使用函数指针对其进行混淆，或将其标记为 volatile 或类似内容来防止这种情况发生。

编辑:我不确定标准是否要求临时 constexpr 对象不应出现在二进制文件中。其实我现在很好奇。我的期望是，至少在发布版本中，一个好的编译器应该在不再需要它们时将它们删除。

编辑:所以，你已经接受了我的回答。但无论如何，为了完整起见，这里有一些实现上述想法的源代码，仅使用 C++11 标准。它适用于 gcc-4.9 和 clang-3.6，即使优化被禁用，据我所知。

#include <array>
#include <iostream>
#include <string>

typedef uint32_t u32;
typedef uint64_t u64;
typedef unsigned char uchar;

template<u32 S, u32 A = 16807UL, u32 C = 0UL, u32 M = (1UL<<31)-1>
struct LinearGenerator {
    static const u32 state = ((u64)S * A + C) % M;
    static const u32 value = state;
    typedef LinearGenerator<state> next;
    struct Split { // Leapfrog
        typedef LinearGenerator< state, A*A, 0, M> Gen1;
        typedef LinearGenerator<next::state, A*A, 0, M> Gen2;
    };
};

// Metafunction to get a particular index from generator
template<u32 S, std::size_t index>
struct Generate {
    static const uchar value = Generate<LinearGenerator<S>::state, index - 1>::value;
};

template<u32 S>
struct Generate<S, 0> {
    static const uchar value = static_cast<uchar> (LinearGenerator<S>::value);
};

// List of indices
template<std::size_t...>
struct StList {};

// Concatenate
template<typename TL, typename TR>
struct Concat;

template<std::size_t... SL, std::size_t... SR>
struct Concat<StList<SL...>, StList<SR...>> {
    typedef StList<SL..., SR...> type;
};

template<typename TL, typename TR>
using Concat_t = typename Concat<TL, TR>::type;

// Count from zero to n-1
template<size_t s>
struct Count {
    typedef Concat_t<typename Count<s-1>::type, StList<s-1>> type;
};

template<>
struct Count<0> {
    typedef StList<> type;
};

template<size_t s>
using Count_t = typename Count<s>::type;

// Get a scrambled character of a string
template<u32 seed, std::size_t index, std::size_t N>
constexpr uchar get_scrambled_char(const char(&a)[N]) {
    return static_cast<uchar>(a[index]) + Generate<seed, index>::value;
}

// Get a ciphertext from a plaintext string
template<u32 seed, typename T>
struct cipher_helper;

template<u32 seed, std::size_t... SL>
struct cipher_helper<seed, StList<SL...>> {
    static constexpr std::array<uchar, sizeof...(SL)> get_array(const char (&a)[sizeof...(SL)]) {
        return {{ get_scrambled_char<seed, SL>(a)... }};
    }
};

template<u32 seed, std::size_t N>
constexpr std::array<uchar, N> get_cipher_text (const char (&a)[N]) {
    return cipher_helper<seed, Count_t<N>>::get_array(a);
}

// Get a noise sequence from a seed and string length
template<u32 seed, typename T>
struct noise_helper;

template<u32 seed, std::size_t... SL>
struct noise_helper<seed, StList<SL...>> {
    static constexpr std::array<uchar, sizeof...(SL)> get_array() {
        return {{ Generate<seed, SL>::value ... }};
    }
};

template<u32 seed, std::size_t N>
constexpr std::array<uchar, N> get_key() {
    return noise_helper<seed, Count_t<N>>::get_array();
}


/*
// Get an unscrambled character of a string
template<u32 seed, std::size_t index, std::size_t N>
char get_unscrambled_char(const std::array<uchar, N> & a) {
    return static_cast<char> (a[index] - Generate<seed, index>::value);
}
*/

// Metafunction to get the size of an array
template<typename T>
struct array_info;

template <typename T, size_t N>
struct array_info<T[N]>
{
    typedef T type;
    enum { size = N };
};

template <typename T, size_t N>
struct array_info<const T(&)[N]> : array_info<T[N]> {};

// Scramble a string
template<u32 seed, std::size_t N>
class obfuscated_string {
private:
    std::array<uchar, N> cipher_text_;
    std::array<uchar, N> key_;
public:
    explicit constexpr obfuscated_string(const char(&a)[N])
        : cipher_text_(get_cipher_text<seed, N>(a))
        , key_(get_key<seed,N>())
    {}

    operator std::string() const {
        char plain_text[N];
        for (volatile std::size_t i = 0; i < N; ++i) {
            volatile char temp = static_cast<char>( cipher_text_[i] - key_[i] );
            plain_text[i] = temp;
        }
        return std::string{plain_text, plain_text + (N - 1)};///We do not copy the termination character
    }
};

template<u32 seed, std::size_t N>
std::ostream & operator<< (std::ostream & s, const obfuscated_string<seed, N> & str) {
    s << static_cast<std::string>(str);
    return s;
}

#define RNG_SEED ((__TIME__[7] - '0') * 1  + (__TIME__[6] - '0') * 10  + \
              (__TIME__[4] - '0') * 60   + (__TIME__[3] - '0') * 600 + \
              (__TIME__[1] - '0') * 3600 + (__TIME__[0] - '0') * 36000) + \
              (__LINE__ * 100000)


#define LIT(STR) \
    obfuscated_string<RNG_SEED, array_info<decltype(STR)>::size>{STR}

auto S2 = LIT(("Hewwo, I'm hunting wabbits"));

int main() {
    constexpr auto S1 = LIT(("What's up doc"));
    std::cout << S1 << std::endl;
    std::cout << S2 << std::endl;
}