在编译时加密/混淆字符串文字

Question

我想在编译时对字符串进行加密/编码，以便原始字符串不会出现在编译后的可执行文件中。

我见过几个例子，但它们不能将字符串文字作为参数。请参阅以下示例：

template<char c> struct add_three {
    enum { value = c+3 };
};

template <char... Chars> struct EncryptCharsA {
    static const char value[sizeof...(Chars) + 1];
};

template<char... Chars>
char const EncryptCharsA<Chars...>::value[sizeof...(Chars) + 1] = {
    add_three<Chars>::value...
};

int main() {   
    std::cout << EncryptCharsA<'A','B','C'>::value << std::endl;
    // prints "DEF"
}

我不想像以前那样单独提供每个字符。我的目标是传递一个字符串文字，如下所示：

EncryptString<"String to encrypt">::value

还有一些类似这样的示例：

#define CRYPT8(str) { CRYPT8_(str "\0\0\0\0\0\0\0\0") }
#define CRYPT8_(str) (str)[0] + 1, (str)[1] + 2, (str)[2] + 3, (str)[3] + 4, (str)[4] + 5, (str)[5] + 6, (str)[6] + 7, (str)[7] + 8, '\0'

// calling it
const char str[] = CRYPT8("ntdll");

但它限制了字符串的大小。

有什么办法可以实现我想要的吗？

Answer 1

我认为这个问题值得更新答案。

几年前，当我问这个问题时，我没有考虑混淆和加密之间的区别加密。如果我当时就知道这种差异，我就会在标题中包含术语“混淆”。

C++11 和 C++14 具有的功能可以以有效且相当简单的方式实现编译时字符串混淆（可能还有加密，尽管我还没有尝试过） ，并且已经完成了。

ADVobfuscator 是 Sebastien Andrivet 创建的混淆库，使用 C++11/14 生成编译时混淆无需使用任何外部工具即可编写代码，只需 C++ 代码。无需创建额外的构建步骤，只需包含并使用它即可。我不知道不使用外部工具或构建步骤的更好的编译时字符串加密/混淆实现。如果你这样做，请分享。

它不仅混淆字符串，而且还有其他有用的东西，例如编译时 FSM (有限状态机< /a>) 可以随机混淆函数调用，以及编译时伪随机数生成器，但这些超出了本答案的范围。

以下是使用 ADVobfuscator 的简单字符串混淆示例：

#include "MetaString.h"

using namespace std;
using namespace andrivet::ADVobfuscator;

void Example()
{
    /* Example 1 */

    // here, the string is compiled in an obfuscated form, and
    // it's only deobfuscated at runtime, at the very moment of its use
    cout << OBFUSCATED("Now you see me") << endl;

    /* Example 2 */

    // here, we store the obfuscated string into an object to
    // deobfuscate whenever we need to
    auto narrator = DEF_OBFUSCATED("Tyler Durden");

    // note: although the function is named `decrypt()`, it's still deobfuscation
    cout << narrator.decrypt() << endl;
}

您可以将宏 DEF_OBFUSCATED 和 OBFUSCATED 替换为您自己的宏。例如：

#define _OBF(s) OBFUSCATED(s)

...

cout << _OBF("klapaucius");

---

它是如何工作的？

如果你看看MetaString.h，你会看到：

#define DEF_OBFUSCATED(str) MetaString<andrivet::ADVobfuscator::MetaRandom<__COUNTER__, 3>::value, andrivet::ADVobfuscator::MetaRandomChar<__COUNTER__>::value, Make_Indexes<sizeof(str) - 1>::type>(str)

#define OBFUSCATED(str) (DEF_OBFUSCATED(str).decrypt())

基本上，MetaString类有三种不同的变体（字符串混淆的核心） ）。每个都有自己的混淆算法。使用库的伪随机数生成器 (MetaRandom) 以及所选变量使用的随机 char，在编译时随机选择这三个变体之一对字符串字符进行异或运算的算法。

“嘿，但是如果我们计算一下，3 种算法 * 255 个可能的字符键（不使用 0）= 765 个混淆字符串的变体”

你是对的。同一个字符串只能用 765 种不同的方式进行混淆。如果您有理由需要更安全的东西（您偏执/您的应用程序需要更高的安全性），您可以扩展库并实现您自己的算法，使用更强的混淆甚至加密（白盒加密在库的路线图中）。

---

它在哪里/如何存储混淆的字符串？

我发现此实现有趣的一件事是它不会将混淆的字符串存储在可执行文件的数据部分中。
相反，它静态存储到 MetaString 对象本身（在堆栈上），并且算法在运行时对其进行解码。这种方法使得静态或运行时查找混淆的字符串变得更加困难。

您可以自行更深入地实施。这是一个非常好的基本混淆解决方案，可以作为更复杂解决方案的起点。

Answer 2

使用模板元编程可以为自己省去很多麻烦，只需编写一个独立的程序来加密字符串并生成一个 cpp 源文件，然后编译该文件。该程序将在您编译之前运行，并生成一个 cpp 和/或头文件，其中包含供您使用的加密字符串。

因此，您可以从以下内容开始：

1. 加密的字符串.cpp 和加密的字符串.h（空白）
2. 将文本文件作为输入并覆盖加密的字符串.cpp 和加密的字符串.h 的脚本或独立应用程序

如果脚本失败，则您的编译将会失败，因为您的代码中将引用不存在的变量。你可以变得更聪明，但这足以让你开始。

Answer 3

您找到的示例之所以不能将字符串文字作为模板参数，是因为 ISO C++ 标准不允许这样做。这是因为，尽管 c++ 有一个 string 类，但字符串文字仍然是 const char *。因此，即使您可以访问此类编译时字符串文字的字符，您也不能或不应该更改它（导致未定义的行为）。

我看到的唯一方法是使用定义，因为它们是由预处理器在编译器之前处理的。在这种情况下，也许 boost 会给你提供帮助。

Answer 4

基于宏的解决方案是采用可变参数并将字符串的每个部分作为单个标记传递。然后对令牌进行字符串化并对其进行加密并连接所有令牌。最终结果看起来像这样，

CRYPT(m y _ s t r i n g)

其中 _ 是空白字符文字的一些占位符。非常混乱，我更喜欢其他所有解决方案。

像这样的东西可以做到这一点，尽管 Boost.PP 序列并没有使它变得更漂亮。

#include <iostream>
#include <boost/preprocessor/stringize.hpp>
#include <boost/preprocessor/seq/for_each.hpp>

#define GARBLE(x) GARBLE_ ## x
#define GARBLE_a x
#define GARBLE_b y
#define GARBLE_c z

#define SEQ (a)(b)(c)
#define MACRO(r, data, elem) BOOST_PP_STRINGIZE(GARBLE(elem))

int main() {
  const char* foo = BOOST_PP_SEQ_FOR_EACH(MACRO, _, SEQ);
  std::cout << foo << std::endl;
}