Если хоть раз мечтал написать crack или keygen

Дня 3 назад заглянул на сайт crackmes.one попробовать силы во взломе защит. Просто наугад взялся за «hitTman’s Kolay One!»: просто по оценке Difficulty: 2.0 и Quality: 4.0. Не примитивно, но и не слишком сложно.

Оказалось, форма ввода пароля с подсказкой: текст кнопки «submit password» после нажатия меняется на число. Если попробовать разные символы пароля, заметно, что для одних и тех же символов число не меняется. Очевидно, пароль подается в хеш-функцию, а ее результат попадает на кнопку. Пробуя пары символов, легко узнать что число на кнопке — сумма чисел для символов пароля.

Логично, что программа сравнивает хеш с эталоном прежде чем выдает сообщение «Try harder!». Ищем в сообщение строках бинарника. Повезло: оно даже не зашифровано и на него единственная ссылка в коде.

Очевидно, рядом же и эталон хеша: 12Eh. Легко проверить: из известных хешей символов составить пароль, например «AaAaAaAaAaAaAaAaAaAaAaAaAaAaAa//» и предложить программе, на что она выдает «Great Job».

Автор просил: «find a Valid pass!», но это оказалось просто, да и верный пароль — не один. Куда интересней написать генератор ключей. Пригодится таблица хеш-значений для всего алфавита. Руками вводить символы пароля и записывать на бумаге их хеши долго и скучно, ведь можно заставить программу саму перебрать алфавит.

У OllyDbg есть коллега — Immunity Debugger, он умеет выполнять скрипты на Python. Отыщем хеш-функцию и заставим ее обработать алфавит.

В обработчике ButtonClick (sub_45385C) прямо перед сравнением хеша с эталоном находится вызов sub_4537C4. Похоже, это и есть хеш-функция: она принимает строку пароля и возвращает хеш в EAX. Привычных push для передачи параметров не видно, вероятно, они передаются через регистры. Если так, то var_C содержит указатель на строку-пароль.

Выше вызов sub_432A4C принимает два аргумента: адрес var_C и еще какой-то указатель по смещению от EBX. Ищем что записано в EBX: выше по коду ButtonClick в него записывается содержимое EAX, но прежде нет записей в EAX, значит там тоже находится параметр процедуры. Заглянув в документацию по Delphi видим, что обработчику ButtonClick передается адрес TObject sender. Можно догадаться, что второй аргумент sub_432A4C — это адрес поля ввода на форме, с которого она читает пароль.

Таких вызовов в ButtonClick два: если запустить программу в отладчике, увидим, что sub_00432A4C действительно записывает указатель на строку-пароль в переменную-аргумент.

Если дальше выполнять ButtonClick пошагово в отладчике, можно заметить, что в переменной на стеке появится и текст кнопки — число. Легко догадаться, что sub_407CE0 — это int to string, [ebx+2FCh] — это указатель на кнопку, а sub_00432A7C — это setButtonText.

Теперь подменим пароль перед хешированием: ставим breakpoint по адресу 0x004538B3 — прямо перед вызовом hashFn она же sub_4537C4. Вводим пароль 1234 и средствами отладчика отредактируем содержимое памяти var_C — введем букву A и символ конца строки \0. Сейчас хеш-функция должна вернуть в EAX значение 0x13 (19). Шагаем вперед и… Первая неудача: в EAX — 0x56 (86). Долго думал, пробовал, грешил на Юникод или еще какие скрытые хитрости программы. Оказалось, программа где-то запоминает длину строки и Вместо хеша «A\0» вычисляет хеш «A\034». Хеш \0 равен 0, поэтому если ввести пароль A34 получим хеш 0x56. Значит введем один символ пароля и повторим правки в отладчике — теперь получилось!

Теперь нужно повторить действия для всего алфавита:

• остановиться перед вызовом hashFn

• сменить символ пароля на следующий по алфавиту

• остановиться после вызова hashFn и запомнить хеш символа

• вернуть программу к вызову hashFn

Вот скрипт на Python, который это сделает:

import immlib  imm = immlib.Debugger()  def main(args):     table = {} # break после hashFn     imm.setBreakpoint(0x004538B8)     mem_password = imm.getRegs()["EAX"] # цикл по печатным символам ASCII      for c in range(0x20, 0x7F):         b = bytearray()         b.append(c)         b.append(b'\x00')         if imm.writeMemory(mem_password, bytes(b)) <= 0:             imm.log("Failed to write password '{0}'".format(chr(c)))             return "ERROR"                  imm.run() # запоминаем хеш         table[c] = imm.getRegs()["EAX"]          # Возвращаемся к вызову hashFn         imm.setReg("EIP", 0x004538B3) # снова передали указатель на строку-пароль в EAX         imm.setReg("EAX", mem_password)         imm.run()      # запишем результаты в файл     with open("C:/a.csv", "w") as out:         for c in table:             out.write("{0} ".format(chr(c)))             out.write("0x{:02X}\n".format(table[c]))              return "Kolay done"

Как вариант можно вводить пароль 1234 и вызывать imm.writeLong(mem_password, с), чтобы записать байт символа и три нуля следом.

Алфавитом овладели, правило хеширования пароля знаем. Как генерировать пароли?

Наивное решение: перебор всех ключей и проверка каждого. Вот код, что найдет все ключи длины 2:

const string alphabet = //... const unordered_map<char, int> weights = //... const int N = 2; const int S = 0x12E; string key;  void generateKeys(ostream& out) {     if (N <= key.length()) {         if (S == sum) {             out << key << "\n";         }     } else {         for (char c : alphabet) {             const int w = weights.at(c);             if (sum + w <= S) {                 key.push_back(c);                 sum += w;                 generateKeys(out);                 key.pop_back();                 sum -= w;             }         }     } }

Работает, но захлебывается уже на ключах длиной больше 5.

От перестановки мест слагаемых сумма не меняется, так что код можно улучшить: пусть он перебирает сочетания.

bool nextCombination(vector<int>& nums, int n) {     const int k = nums.size();     for (int i = k - 1; 0 <= i; --i) {         if (nums[i] < n - k + i) {             ++nums[i];             for (int j = i + 1; j < k; ++j) {                 nums[j] = nums[j - 1] + 1;             }             return true;         }     }     return false; }  bool TestKey(const vector<int>& nums) {     int sum = 0;     for (int i : nums) {         sum += weights.at(alphabet[i]);     }     return S == sum; }  string MakeKey(const vector<int>& nums) {     string key;     for (int i : nums) {         key.push_back(alphabet[i]);     }     return key; }  void generateKeys(ostream& out) {     vector<int> nums(N);     for (int i = 0; i < N; ++i) {         nums[i] = i;     }      do {         if (TestKey(nums)) {             ++cnt;             out << MakeKey(nums) << '\n';         }     } while (nextCombination(nums, alphabet.size())); }

Теперь можно дождаться, пока он найдет все сочетания длины 7.

А если хочется ключи длиннее? Можно останавливаться на первом найденном ключе — авось повезет. Время, когда перебор наткнется на первый верный ключ непредсказуемо. Я так и не дождался, пока программа найдет первый верный ключ длины 20.

Можно ли найти лучшее решение, чем перебор всех сочетаний? Например, если известен один верный ключ, как перейти к следующему?
vx -> ?

Аналогия: чтобы получить следующее число, добавляем 1 к младшему разряду и, если необходимо, выполняем перенос:
18, 19, 20, …

Можно заменять символы пароля так, чтобы его хеш не менялся. Беда в том, что для ‘x’ нет равноценной замены.

0x01 001: %)+/5;=CGIOSYaegkmq 0x08 008: 1 0x0c 00c: y 0x0d 00d: # 0x0f 00f: ! 0x11 011: '7 0x13 013: AM 0x14 014: " 0x15 015: 3[ 0x16 016: & 0x17 017: 9U 0x19 019: _w 0x1a 01a: . 0x1b 01b: E 0x1d 01d: s 0x1f 01f:  } 0x20 020: : 0x21 021: -W 0x22 022: > 0x23 023: ] 0x28 028: ,JQ 0x29 029: ?o 0x2b 02b: 2 0x2c 02c: R 0x2d 02d: { 0x2e 02e: 4V 0x31 031: K 0x32 032: (^ 0x36 036: * 0x37 037: $ 0x38 038: j 0x39 039: c 0x3a 03a: D 0x3e 03e: v 0x3f 03f: @ 0x40 040: 8Lz 0x41 041: u 0x42 042: 6 0x49 049: b 0x4a 04a: F 0x4c 04c: 0\ 0x4e 04e: B 0x57 057: i 0x5a 05a: N 0x5c 05c: X 0x5e 05e: t 0x64 064: | 0x6a 06a: Phn 0x6c 06c: < 0x72 072: f 0x75 075: d 0x7b 07b: H 0x7e 07e: r 0x88 088: p 0x8c 08c: T 0x90 090: Z 0x9c 09c: ` 0xac 0ac: l 0xba 0ba: ~ 0xf0 0f0: x

Возьмем другой ключ из 3х символов: Zr%. Заменяя % можно пройтись по нескольким ключам:
Zr% -> Zr) -> Zr+ -> ... -> Zrq
Попробуем найти замену для rq. Пришлось обойти все пары символов алфавита и вычислить их хеши.
Zrq -> Zt- -> ZtW -> Zuv

Что делать дальше — непонятно. Сменить Z на другой символ? У Z нет равноценных замен, придется перебором снова найти первый подходящий ключ.

Так и не придумал алгоритм перехода от одного известного ключа к следующему: если есть идеи, пишите в комментариях.

Что если вместо перебора всех сочетаний склеивать пары ключей и складывать их хеши? По сложности алгоритм оказался не лучше перебора: время работы быстро растет с увеличением алфавита и длины ключа, к тому же программа падает из-за нехватки памяти. Можно ее чуть сэкономить, но количество пар на каждом шаге все равно растет слишком быстро при алфавите в 95 букв.

// Длина ключа N - степень двойки void generateKeys(ostream& out) {     for (int n = 1; n < N; n <<= 1) {         unordered_map<string, int> next_weights;         for (auto i = weights.begin(); i != weights.end(); ++i) {             for (auto j = next(i); j != weights.end(); ++j) {                 const string& s1 = i->first;                 int w1 = i->second;                 const string& s2 = j->first;                 int w2 = j->second;                 int len = s1.length() + s2.length();                 if (len == n * 2) {                     string s3(len, 0);                     int w3 = w1 + w2;                     merge(s1.begin(), s1.end(), s2.begin(), s2.end(), s3.begin());                     if (len < N) {                         next_weights[s3] = w3;                     }                      if (N == len && S == w3) {                         out << s3 << '\n';                         ++cnt;                     }                 }             }         }         weights.swap(next_weights);     } }