C++: как шифровать строки во время компиляции?

Я также думал, что это невозможно, хотя это очень просто, люди писали решения, где вам нужен пользовательский инструмент для сканирования встроенного файла после этого и сканирования строк и шифрования строк, как это было неплохо, но я хотел пакет, который скомпилирован из Visual Studio, и это возможно сейчас!

что нужно C++ 11 (в Visual Studio 2015 с обновлением 1 из коробки)

магия происходит с этой новой командой constexpr

By магия происходит в этом #define

#define XorString( String ) ( CXorString<ConstructIndexList<sizeof( String ) - 1>::Result>( String ).decrypt() )

он не будет расшифровывать XorString во время компиляции, только во время выполнения, но он будет шифровать строку только во время компиляции, поэтому строки не будут отображаться в исполняемом файле

printf(XorString( "this string is hidden!" ));

выводит "this string is hidden!" но вы не найдете его внутри исполняемого файла в виде строк! проверьте это сами с помощью Microsoft Sysinternals Strings ссылка для загрузки программы: https://technet.microsoft.com/en-us/sysinternals/strings.aspx

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

создайте файл с именем XorString.h

#pragma once

//-------------------------------------------------------------//
// "Malware related compile-time hacks with C++11" by LeFF   //
// You can use this code however you like, I just don't really //
// give a shit, but if you feel some respect for me, please //
// don't cut off this comment when copy-pasting... ;-)       //
//-------------------------------------------------------------//

////////////////////////////////////////////////////////////////////
template <int X> struct EnsureCompileTime {
    enum : int {
        Value = X
    };
};
////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////
//Use Compile-Time as seed
#define 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)
////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////
constexpr int LinearCongruentGenerator(int Rounds) {
    return 1013904223 + 1664525 * ((Rounds> 0) ? LinearCongruentGenerator(Rounds - 1) : Seed & 0xFFFFFFFF);
}
#define Random() EnsureCompileTime<LinearCongruentGenerator(10)>::Value //10 Rounds
#define RandomNumber(Min, Max) (Min + (Random() % (Max - Min + 1)))
////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////
template <int... Pack> struct IndexList {};
////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////
template <typename IndexList, int Right> struct Append;
template <int... Left, int Right> struct Append<IndexList<Left...>, Right> {
    typedef IndexList<Left..., Right> Result;
};
////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////
template <int N> struct ConstructIndexList {
    typedef typename Append<typename ConstructIndexList<N - 1>::Result, N - 1>::Result Result;
};
template <> struct ConstructIndexList<0> {
    typedef IndexList<> Result;
};
////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////
const char XORKEY = static_cast<char>(RandomNumber(0, 0xFF));
constexpr char EncryptCharacter(const char Character, int Index) {
    return Character ^ (XORKEY + Index);
}

template <typename IndexList> class CXorString;
template <int... Index> class CXorString<IndexList<Index...> > {
private:
    char Value[sizeof...(Index) + 1];
public:
    constexpr CXorString(const char* const String)
    : Value{ EncryptCharacter(String[Index], Index)... } {}

    char* decrypt() {
        for(int t = 0; t < sizeof...(Index); t++) {
            Value[t] = Value[t] ^ (XORKEY + t);
        }
        Value[sizeof...(Index)] = '';
        return Value;
    }

    char* get() {
        return Value;
    }
};
#define XorS(X, String) CXorString<ConstructIndexList<sizeof(String)-1>::Result> X(String)
#define XorString( String ) ( CXorString<ConstructIndexList<sizeof( String ) - 1>::Result>( String ).decrypt() )
////////////////////////////////////////////////////////////////////

вы не можете шифровать строки (строковые литералы) компилятором или препроцессором С++, но вы можете написать инструмент предварительной сборки, который будет анализировать исходный код и шифровать строки.

или вы можете попробовать использовать boost::mpl:: string.

о единственном способе сделать ровно вы предлагаете написать действительно ужасный макрос. Но вот несколько альтернатив.

1. хранить зашифрованные строки в файле данных.
2. соберите строки в одном исходном файле, затем в сборке, перед фактической компиляцией, перейдите к нему с помощью инструмента, который их зашифрует (например, sed). Этот шаг можно автоматизировать.
3. используйте мощный редактор, чтобы вы могли зашифровать / расшифровать строки без усилий, пока вы работаете.

Если вы только пытаетесь скрыть строки, то вы можете просто попробовать сжать исполняемый файл с чем-то вроде UPX по.

это, вероятно, не относится к древнему компилятору вопроса, но на более современных реализациях c++ мы можем использовать строку буквальный шаблон оператора это объявлено constexpr для реализации запутывания во время компиляции. Для этого я использовал GCC 7.2.0 с -std=c++17 (и полный набор опций предупреждения, конечно).

во-первых, мы определяем тип для хранения наших запутанных строковых данных с оператором преобразования для создания строки открытого текста на спрос:

#include <array>
#include <string>

template<typename Char>
static const Char SECRET = 0x01;

template<typename Char,
         typename std::basic_string<Char>::size_type Length>
struct obfuscated_string
{
    using String = std::basic_string<Char>;

    const std::array<const Char, Length> storage;

    operator String() const
    {
        String s{storage.data(), Length};
        for (auto& c: s)
            c ^= SECRET<Char>;
        return s;
    }
};

теперь шаблон оператора литерала для преобразования литерала исходного кода в запутанную строку:

template<typename ctype, ctype...STR>
constexpr obfuscated_string<ctype, sizeof... (STR)> operator ""_hidden()
{
    return { { (STR ^ SECRET<ctype>)... } };
}

продемонстрировать:

#include <iostream>
int main()
{
    static const auto message = "squeamish ossifrage"_hidden;
    std::string plaintext = message;
    std::cout << plaintext << std::endl;
}

мы можем проверить код объекта с помощью

независимо от деталей вашего решения это будет включать шифрование строк с помощью некоторой программы шифрования.

вы можете написать сценарий для шифрования литералов в исходном коде.

или для Windows exe вы можете зашифровать литералы в [.rc] файл, встраивание строк в качестве ресурса таблицы строк в exe.

но, вероятно, лучшее решение-не пытаться скрываться.

когда Microsoft попыталась скрыть трюк XOR в коде Windows это произвольно предупредило о том, что не-Microsoft DOS-es ненадежны и несовместимы с этим и тем, это просто обернулось против них. Конечно, идея говорить плохие вещи о конкурентах и связывать это плохое высказывание с Windows была действительно глупой идеей в первую очередь. Но попытка скрыть код была тем, что сделало его публичным смущением: никто не заметил предупреждений, которые код производил, но когда люди обнаружили "зашифрованный" код, естественно, их любопытство было занято, они просто нужно было выяснить, что это такое, и написать об этом статьи.

Cheers & hth.,

любой криптограф, который делается во время компиляции, также должен быть undoable в raw EXE (если вы не делаете что-то действительно странное). И ваше приложение работает на их оборудовании. Обреченный... за исключением DRM, что (на мой взгляд) зло.