Шифрование строки времени компиляции с использованием constexpr

Ответ 1

Вот как бы я это сделал:

1.) Используйте шаблон str_const для описанной здесь операции со строкой constexpr: Удобное объявление строк времени компиляции в С++

код:

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" и манипулировать message в функциях constexpr.

2.) Сделайте простой псевдослучайный генератор компиляции, используя макросы __TIME__ и __LINE__ для генерации семени. Это подробно описано здесь: Генерировать случайные числа в С++ во время компиляции

Они дают код на основе шаблонов.

3.) Создайте struct с constexpr ctor, который принимает либо const char [], либо сами шаблоны против размера аналогично примеру str_const, или просто принимает str_const, и генерирует два str_const который является его переменными-членами.

• A str_const длины n, содержащей псевдослучайные символы без знака, сгенерированные с использованием псевдослучайного генератора, где n - длина ввода. ( "строка шума" )
• A str_const длины n, содержащей входную мутацию (как беззнаковые символы) входных символов с символами шума. ( "шифрованный текст" )

Затем он имеет функцию-член decrypt, которая не обязательно должна быть constexpr и может возвращать std::string, которая просто вычитает каждый символ строки шума из соответствующего символа шифрованного текста и возвращает результирующую строку.

Если ваш компилятор все еще хранит исходный строковый литерал в двоичном формате, это означает, что он хранит литерал входной строки (аргумент конструктора), который я не думаю, что он должен делать с момента его временного или в основном вставляя функцию decrypt, и вы должны быть в состоянии предотвратить это путем обфускации ее указателями на функции или маркировкой ее volatile или аналогичной.

Изменить: я не уверен, требует ли стандарт, чтобы временные объекты constexpr не отображались в двоичном формате. На самом деле мне сейчас интересно. Я ожидаю, что по крайней мере в сборке релиза хороший компилятор должен удалить их, когда они больше не нужны.

Изменить: Итак, вы уже приняли мой ответ. Но в любом случае для полноты, здесь есть некоторый исходный код, который реализует вышеупомянутые идеи, используя только стандарт С++ 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};
    }
};

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 up doc"));
    std::cout << S1 << std::endl;
    std::cout << S2 << std::endl;
}

Ответ 2

У меня будет такой код:

#if GENERATE_CODE
.... code to generate the C++ code describing the encrypted literal
.... generating exactly the code in the #else part
#else
static char encryptedLicense [32] = "..."; or whatever
#endif

Не пытайтесь быть умным. Скопируйте код #if в отдельный файл, скомпилируйте и запустите, вставьте результат обратно.