在 C++ 中模糊敏感字符串的技术

Question

我需要在我的 C++ 应用程序中存储敏感信息（我想要保密的对称加密密钥）。简单的方法是这样做：

std::string myKey = "mysupersupersecretpasswordthatyouwillneverguess";

但是，通过 strings 进程（或任何其他从二进制应用程序中提取字符串的进程）运行应用程序将显示上述字符串。

应该使用什么技术来隐藏此类敏感数据？

编辑：

好吧，几乎所有人都说过“你的可执行文件可以被逆向工程”-当然！这是我的一个小烦恼，所以我要在这里咆哮一下：

为什么这个网站上 99%（好吧，也许我夸大了一点）所有与安全相关的问题都是用一大堆的答案来回答的“没有可能的方法来创建一个完全安全的程序” - 这不是一个有用的答案！安全性是一种介于完美可用性和无安全性以及完美安全性但无可用性之间的滑动标尺。

关键是，您可以根据您想要执行的操作以及软件运行的环境来选择您在滑动标尺上的位置。 我不是在为军事设施编写应用程序，而是为家用电脑编写应用程序。我需要使用预先知道的加密密钥在不受信任的网络上加密数据。在这些情况下，“通过默默无闻实现安全”可能就足够了！当然，有足够时间、精力和技能的人可以对二进制文件进行逆向工程并找到密码，但你猜怎么着？我不在乎：

我实施一流安全系统所花费的时间比破解版本造成的销售损失更昂贵（不是我实际上在卖这个，但你明白我的意思）。至少可以说，新程序员中这种“让我们用绝对最好的方式来做”的编程趋势是愚蠢的。

感谢您花时间回答这个问题 - 他们非常有帮助。不幸的是，我只能接受一个答案，但我已经投票了所有有用的答案。

Answer 1

基本上，任何有权访问您的程序和调试器的人都可以并且如果愿意的话，将会在应用程序中找到密钥。

但是，如果您只是想确保在二进制文件上运行 strings 时密钥不会显示，您可以例如确保密钥不在可打印范围内。

使用 XOR 隐藏密钥

例如，您可以使用 XOR 将密钥拆分为两个字节数组：

key = key1 XOR key2

如果您创建的 key1 与 key 具有相同的字节长度，则可以使用 (完全）随机字节值，然后计算 key2：

key1[n] = crypto_grade_random_number(0..255)
key2[n] = key[n] XOR key1[n]

您可以在构建环境中执行此操作，然后仅将 key1 和 key2 存储在您的应用程序中。

保护您的二进制文件

另一种方法是使用工具来保护您的二进制文件。例如，有多种安全工具可以确保您的二进制文件被混淆并启动其运行的虚拟机。这使得调试变得困难，并且也是许多商业级安全应用程序（还有，恶意软件）受到保护的常规方式。

最重要的工具之一是 Themida，它在保护二进制文件方面做得非常出色。它经常被 Spotify 等知名程序用来防止逆向工程。它具有防止在 OllyDbg 和 Ida Pro 等程序中进行调试的功能。

还有一个更大的列表，可能有些过时了，保护二进制文件的工具< /a>.
其中一些是免费的。

密码匹配

这里有人讨论了哈希密码+盐。

如果您需要存储密钥以将其与某种用户提交的密码进行匹配，则应使用单向哈希函数，最好将用户名、密码和盐结合起来。但这样做的问题是，您的应用程序必须知道盐才能执行单向操作并比较生成的哈希值。因此，您仍然需要将盐存储在应用程序中的某个位置。但是，正如 @Edward 在下面的评论中指出的那样，这将有效地防止使用彩虹表等字典攻击。

最后，您可以结合使用上述所有技术。

Answer 2

有一个（非常轻）只有标头的项目 obfuscate 由 adamyaxley 制作，效果非常好。它基于 lambda 函数和宏，并在编译时使用 XOR 密码对字符串进行加密。如果需要，我们可以更改每个字符串的种子。

以下代码不会在编译的二进制文件中存储字符串“hello world”。

#include "obfuscate.h"

int main()
{
  std::cout << AY_OBFUSCATE("Hello World") << std::endl;
  return 0;
}

我已经使用 c++17 和 Visual Studio 2019 进行了测试，并通过 IDA 检查，确认该字符串已隐藏。与 ADVobfuscator 相比，一个宝贵的优势是它可以转换为 std::string （同时仍然隐藏在编译后的二进制文件）：

std::string var = AY_OBFUSCATE("string");

Answer 3

首先，要意识到你无法阻止足够坚定的黑客，而且周围有很多这样的黑客。每个游戏和主机的保护最终都会被破解，所以这只是一个临时修复。

您可以做四件事来增加您隐藏一段时间的机会。

1）以某种方式隐藏字符串的元素——一些明显的东西，比如将字符串与另一个字符串进行异或（^运算符），就足以使字符串无法被搜索。

2）将字符串分割成几部分——分割字符串并将其弹出到奇怪模块中奇怪命名的方法中。不要让搜索和查找包含该字符串的方法变得容易。当然，某些方法必须调用所有这些位，但这仍然使它变得有点困难。

3) 永远不要在内存中构建字符串——大多数黑客使用的工具可以让他们在编码后看到内存中的字符串。如果可能的话，请避免这种情况。例如，如果您要将密钥发送到服务器，请逐个字符地发送，这样整个字符串就不会存在。当然，如果您通过 RSA 编码之类的方式使用它，那么这就更棘手了。

4) 执行一个临时算法——除此之外，添加一两个独特的变化。也许只需在您生成的所有内容中添加 1，或者进行两次加密，或者添加糖。这只会让黑客变得更加困难，因为他们已经知道当有人使用普通 md5 散列或 RSA 加密时要寻找什么。

最重要的是，请确保您的密钥何时被发现（如果您的应用程序变得足够流行，那么将会是何时），这并不是太重要！

Answer 4

我过去使用的策略是创建一系列看似随机的角色。您首先插入，然后通过代数过程定位您的特定字符，其中从 0 到 N 的每一步都会产生一个数字 <包含混淆字符串中下一个字符的数组的大小。 （这个答案现在感觉很混乱！）

示例：

给定一个字符数组（数字和破折号仅供参考）

0123456789
----------
ALFHNFELKD
LKFKFLEHGT
FLKRKLFRFK
FJFJJFJ!JL

和一个前六个结果为：3,6,7,10,21,47的方程

将产生单词“你好！”从上面的数组中。

Answer 5

我同意@Checkers，你的可执行文件可以进行逆向工程。

更好的方法是动态创建它，例如：

std::string myKey = part1() + part2() + ... + partN();

Answer 6

当然，将私有数据存储在交付给用户的软件中始终存在风险。任何受过充分教育（且专注）的工程师都可以对数据进行逆向工程。

话虽如此，您通常可以通过提高人们泄露您的私人数据所需克服的障碍来使事情足够安全。这通常是一个很好的妥协。

在您的情况下，您可以使用不可打印的数据使字符串变得混乱，然后在运行时使用简单的辅助函数对其进行解码，如下所示：

void unscramble( char *s )
{
    for ( char *str = s + 1; *str != 0; str += 2 ) {
        *s++ = *str;
    }
    *s = '\0';
}

void f()
{
    char privateStr[] = "\001H\002e\003l\004l\005o";
    unscramble( privateStr ); // privateStr is 'Hello' now.

    string s = privateStr;
    // ...
}

Answer 7

我为字符串创建了一个简单的加密工具，它可以自动生成加密的字符串，并且有一些额外的选项可以做到这一点，例如：

作为全局变量的字符串：

// myKey = "mysupersupersecretpasswordthatyouwillneverguess";
unsigned char myKey[48] = { 0xCF, 0x34, 0xF8, 0x5F, 0x5C, 0x3D, 0x22, 0x13, 0xB4, 0xF3, 0x63, 0x7E, 0x6B, 0x34, 0x01, 0xB7, 0xDB, 0x89, 0x9A, 0xB5, 0x1B, 0x22, 0xD4, 0x29, 0xE6, 0x7C, 0x43, 0x0B, 0x27, 0x00, 0x91, 0x5F, 0x14, 0x39, 0xED, 0x74, 0x7D, 0x4B, 0x22, 0x04, 0x48, 0x49, 0xF1, 0x88, 0xBE, 0x29, 0x1F, 0x27 };

myKey[30] -= 0x18;
myKey[39] -= 0x8E;
myKey[3] += 0x16;
myKey[1] += 0x45;
myKey[0] ^= 0xA2;
myKey[24] += 0x8C;
myKey[44] ^= 0xDB;
myKey[15] ^= 0xC5;
myKey[7] += 0x60;
myKey[27] ^= 0x63;
myKey[37] += 0x23;
myKey[2] ^= 0x8B;
myKey[25] ^= 0x18;
myKey[12] ^= 0x18;
myKey[14] ^= 0x62;
myKey[11] ^= 0x0C;
myKey[13] += 0x31;
myKey[6] -= 0xB0;
myKey[22] ^= 0xA3;
myKey[43] += 0xED;
myKey[29] -= 0x8C;
myKey[38] ^= 0x47;
myKey[19] -= 0x54;
myKey[33] -= 0xC2;
myKey[40] += 0x1D;
myKey[20] -= 0xA8;
myKey[34] ^= 0x84;
myKey[8] += 0xC1;
myKey[28] -= 0xC6;
myKey[18] -= 0x2A;
myKey[17] -= 0x15;
myKey[4] ^= 0x2C;
myKey[9] -= 0x83;
myKey[26] += 0x31;
myKey[10] ^= 0x06;
myKey[16] += 0x8A;
myKey[42] += 0x76;
myKey[5] ^= 0x58;
myKey[23] ^= 0x46;
myKey[32] += 0x61;
myKey[41] ^= 0x3B;
myKey[31] ^= 0x30;
myKey[46] ^= 0x6C;
myKey[35] -= 0x08;
myKey[36] ^= 0x11;
myKey[45] -= 0xB6;
myKey[21] += 0x51;
myKey[47] += 0xD9;

带解密循环的 unicode 字符串：

// myKey = "mysupersupersecretpasswordthatyouwillneverguess";
wchar_t myKey[48];

myKey[21] = 0x00A6;
myKey[10] = 0x00B0;
myKey[29] = 0x00A1;
myKey[22] = 0x00A2;
myKey[19] = 0x00B4;
myKey[33] = 0x00A2;
myKey[0] = 0x00B8;
myKey[32] = 0x00A0;
myKey[16] = 0x00B0;
myKey[40] = 0x00B0;
myKey[4] = 0x00A5;
myKey[26] = 0x00A1;
myKey[18] = 0x00A5;
myKey[17] = 0x00A1;
myKey[8] = 0x00A0;
myKey[36] = 0x00B9;
myKey[34] = 0x00BC;
myKey[44] = 0x00B0;
myKey[30] = 0x00AC;
myKey[23] = 0x00BA;
myKey[35] = 0x00B9;
myKey[25] = 0x00B1;
myKey[6] = 0x00A7;
myKey[27] = 0x00BD;
myKey[45] = 0x00A6;
myKey[3] = 0x00A0;
myKey[28] = 0x00B4;
myKey[14] = 0x00B6;
myKey[7] = 0x00A6;
myKey[11] = 0x00A7;
myKey[13] = 0x00B0;
myKey[39] = 0x00A3;
myKey[9] = 0x00A5;
myKey[2] = 0x00A6;
myKey[24] = 0x00A7;
myKey[46] = 0x00A6;
myKey[43] = 0x00A0;
myKey[37] = 0x00BB;
myKey[41] = 0x00A7;
myKey[15] = 0x00A7;
myKey[31] = 0x00BA;
myKey[1] = 0x00AC;
myKey[47] = 0x00D5;
myKey[20] = 0x00A6;
myKey[5] = 0x00B0;
myKey[38] = 0x00B0;
myKey[42] = 0x00B2;
myKey[12] = 0x00A6;

for (unsigned int fngdouk = 0; fngdouk < 48; fngdouk++) myKey[fngdouk] ^= 0x00D5;

作为全局变量的字符串：

// myKey = "mysupersupersecretpasswordthatyouwillneverguess";
unsigned char myKey[48] = { 0xAF, 0xBB, 0xB5, 0xB7, 0xB2, 0xA7, 0xB4, 0xB5, 0xB7, 0xB2, 0xA7, 0xB4, 0xB5, 0xA7, 0xA5, 0xB4, 0xA7, 0xB6, 0xB2, 0xA3, 0xB5, 0xB5, 0xB9, 0xB1, 0xB4, 0xA6, 0xB6, 0xAA, 0xA3, 0xB6, 0xBB, 0xB1, 0xB7, 0xB9, 0xAB, 0xAE, 0xAE, 0xB0, 0xA7, 0xB8, 0xA7, 0xB4, 0xA9, 0xB7, 0xA7, 0xB5, 0xB5, 0x42 };

for (unsigned int dzxykdo = 0; dzxykdo < 48; dzxykdo++) myKey[dzxykdo] -= 0x42;

Answer 8

正如 joshperry 指出的那样，这在某种程度上取决于您想要保护的内容。
根据经验，我想说，如果它是保护您的软件的某些许可计划的一部分，那么就不必费心了。他们最终会对它进行逆向工程。只需使用像 ROT-13 这样的简单密码来保护它免受简单攻击（在其上运行字符串的行）。
如果是为了保护用户敏感数据，我会质疑使用本地存储的私钥保护该数据是否是明智之举。这又取决于你想要保护什么。

编辑：如果你打算这样做，那么克里斯指出的技术组合将比 rot13 好得多。

Answer 9

正如之前所说，没有办法完全保护你的琴弦。但有一些方法可以以合理的安全性来保护它。

当我必须这样做时，我确实在代码中放入了一些看起来无辜的字符串（例如，版权声明，或一些伪造的用户提示或修复不相关代码的人不会更改的任何其他内容），并使用自身进行加密作为密钥，对其进行哈希处理（添加一些盐），然后使用结果作为密钥来加密我真正想要加密的内容。

当然，这可能会被黑客攻击，但确实需要坚定的黑客才能做到这一点。

Answer 10

如果您使用 Windows 用户 DPAPI，http://msdn.microsoft.com/ en-us/library/ms995355.aspx

正如之前的文章所说，如果您使用的是 Mac，请使用钥匙串。

基本上，从安全角度来看，所有这些关于如何将私钥存储在二进制文件中的可爱想法都非常糟糕，因此您不应该这样做。任何人获得您的私钥都是一件大事，不要将其保存在您的程序中。根据您的应用程序的导入方式，您可以将私钥保存在智能卡上、代码与之对话的远程计算机上，或者您可以执行大多数人所做的操作并将其保存在本地计算机上非常安全的位置（“密钥”） store”，有点像一个奇怪的安全注册表），它受到权限和操作系统的所有强度的保护。

这是一个已解决的问题，答案不是将密钥保留在程序中:)

Answer 11

尝试这个。源代码解释了如何动态加密和解密给定 Visual Studio C++ 项目中的所有字符串。

Answer 12

我最近尝试的一种方法是：

1. 获取私有数据的哈希（SHA256）并将其填充到代码中，如 part1
2. 对私有数据及其哈希进行异或，并将其填充到代码中，如 part2 code>
3. 填充数据：不要将其存储为 char str[]，而是使用赋值指令在运行时填充（如下面的宏所示）
4. 现在，通过对 part1 和 part2
5. 附加步骤：计算生成数据的哈希值并将其与 part1 进行比较。它将验证私有数据的完整性。

填充数据的宏：

假设私有数据有 4 个字节。我们为它定义一个宏，它以某种随机顺序保存带有赋值指令的数据。

#define POPULATE_DATA(str, i0, i1, i2, i3)\
{\
    char *p = str;\
    p[3] = i3;\
    p[2] = i2;\
    p[0] = i0;\
    p[1] = i1;\
}

现在，在需要保存 part1 和 part2 的代码中使用此宏，如下所示：

char part1[4] = {0};
char part2[4] = {0};
POPULATE_DATA(part1, 1, 2, 3, 4); 
POPULATE_DATA(part2, 5, 6, 7, 8);

Answer 13

您可能希望向用户请求并通过外部 密码管理器，类似于 Mac OS X 钥匙串访问。

Answer 14

依赖于上下文，但您可以只存储密钥的哈希加上盐（常量字符串，容易混淆）。

然后，当（如果）用户输入密钥时，您添加盐，计算哈希并进行比较。

在这种情况下，salt 可能是不必要的，如果可以隔离哈希值，它可以阻止暴力字典攻击（Google 搜索也可以工作）。

黑客仍然只需在某处插入 jmp 指令即可绕过整个过程，但这比简单的文本搜索要复杂得多。