методы для затемнения чувствительных строк в C++

Конечно, хранение личных данных в программном обеспечении, поставляемом пользователю, всегда сопряжено с риском. Любой достаточно образованный (и преданный своему делу) инженер может реконструировать данные.

При этом часто можно сделать вещи достаточно безопасными, подняв барьер, который люди должны преодолеть, чтобы раскрыть ваши личные данные. Обычно это хороший компромисс.

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

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;
    // ...
}

Как было сказано ранее, невозможно полностью защитить вашу строку. Но есть способы защитить его при разумной безопасности.

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

Конечно, это можно взломать, но для этого нужен решительный хакер.

Стратегия, которую я использовал в прошлом, заключается в создании массива, казалось бы, случайных символов. Сначала вы вставляете, а затем находите свои конкретные символы с помощью алгебраического процесса, где каждый шаг от 0 до N будет давать число <размер массива, который содержит следующий символ в вашей обфусцированной строке. (Этот ответ сейчас кажется запутанным!)

Пример:

Дан массив символов (числа и тире приведены только для справки)

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

И уравнение, первые шесть результатов которого: 3, 6, 7, 10 , 21, 47

Получится слово "ПРИВЕТ!" из массива выше.

Прежде всего, поймите, что вы ничего не можете сделать, чтобы остановить достаточно решительного хакера, а таких вокруг полно. Защита каждой игры и каждой консоли рано или поздно будет взломана, так что это только временное решение.

Вы можете сделать 4 вещи, которые увеличат ваши шансы на некоторое время оставаться скрытыми.

1) Скрыть элементы строки каким-то образом - что-то очевидное, например xoring (оператор ^), строка с другой строкой будет достаточно хороша, чтобы сделать строку невозможной для поиска.

2) Разделите строку на части - разделите строку и вставьте ее кусочки в методы со странными названиями в странных модулях. Не упрощайте поиск и поиск метода со строкой в ​​нем. Конечно, какой-то метод должен будет вызывать все эти биты, но это все равно немного усложняет задачу.

3) Никогда не создавайте строку в памяти - большинство хакеров используют инструменты, которые позволяют им видеть строку в памяти после вы его закодировали. По возможности избегайте этого. Если, например, вы отправляете ключ на сервер, отправляйте его символ за символом, чтобы не было всей строки. Конечно, если вы используете его из чего-то вроде кодирования RSA, тогда это будет сложнее.

4) Создайте специальный алгоритм - поверх всего этого добавьте один или два уникальных поворота. Может быть, просто добавьте 1 ко всему, что вы создаете, или сделайте любое шифрование дважды, или добавьте сахар.

Контекст зависимо, но вы можете просто сохранить хэш ключа плюс соль (постоянная строка, которую легко скрыть).

Затем, когда (если) пользователь вводит ключ, вы добавьте соль , вычислите хэш и сравните.

Соль , вероятно, не нужна в этом случае, она останавливает атаку по словарю, если хэш может быть изолирован (также известно, что работает поиск в Google).

Хакеру все еще нужно где-то вставить инструкцию jmp, чтобы обойти все это, но это гораздо сложнее, чем простой текстовый поиск.

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

РЕДАКТИРОВАТЬ: Если вы собираетесь это сделать, то комбинация методов, на которую указывает Крис, будет намного лучше, чем rot13.

Если вы используете Windows DPAPI, http: //msdn.microsoft.com/en-us/library/ms995355.aspx

Как сказано в предыдущем сообщении, если вы используете Mac, используйте связку ключей.

По сути, все эти милые идеи о том, как хранить ваш закрытый ключ внутри вашего двоичного файла, достаточно плохи с точки зрения безопасности, поэтому вам не следует их делать. Любой, кто получит ваш закрытый ключ, - это большое дело, не храните его в своей программе. В зависимости от того, как импортируется ваше приложение, вы можете хранить свои закрытые ключи на смарт-карте, на удаленном компьютере, с которым общается ваш код, или вы можете делать то, что делает большинство людей, и хранить их в очень безопасном месте на локальном компьютере («ключ store ", который похож на странный безопасный реестр), защищенный разрешениями и всеми возможностями вашей ОС.

Это решенная проблема, и ответ - НЕ хранить ключ внутри вашей программы :)

Вместо того, чтобы хранить закрытый ключ в исполняемом файле, вы можете запросить его у пользователя и сохранить его с помощью внешнего диспетчера паролей , что-то подобное к связке ключей Mac OS X.

Я согласен с @Checkers, ваш исполняемый файл может быть реконструирован.

Немного лучше создать его динамически, например:

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

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

Строка как глобальная переменная:

// 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;