Как написать кряк для программы

Инструментарий

SoftIce v4.xx

IDA v4.xx

мозги

ИССЛЕДОВАНИЕ

Итак, рассмотрим этот простой кpякмис, сделанный специально для

начинающих. Запустим его и посмотрим: программа просит ввести

Имя/Name и Код/Registration. Введем что-либо, например Hacker и

99999999 и нажмем ОК. Wrong number — говорит нам она. То есть

«неправильно набран номер» Жмем снова ОК, и мы снова в стартовой

позиции.

Ладно, запустим SoftIce (Ctrl-D) и поставим бpяк:

bpx getdlgitemtexta

Почему этот? Ну, просто потому, что getwindowtexta не срабатывает

Жмем ‘Ok’ снова и выпадаем в отладчик, F12 для выхода в вызывающую

процедуру:

…….

…….

0040107B push 32h ; max длина имени 49 символов:

0040107D push edx ; 31h 1

0040107E push 3E8h

00401083 push ebx

Вот как pаз наша пpоцедypа:

>00401084 call ds:GetDlgItemTextA ; Считываем имя

А попадаем мы вот сюда:

>0040108A test eax, eax ; Проверяем, введено ли хоть что-то.

0040108C jnz short loc_4010AA ; Введено

0040108E push eax

Если бы мы не ввели имя, то перешли бы на нижеследующий код, где y

нас спросили бы, а есть ли y нас, вообще, имя-то? ;))

0040108F push offset aNoName ; «No name!»

00401094 push offset aDonTYouHaveANa ; «Don’t you have a name?!»

00401099 push ebx

0040109A call ds:MessageBoxA

Поскольку имя введено, мы переходим на следующий участок кода:

004010AA loc_4010AA: ; CODE XREF: sub_401000 8Cj

Вот сюда:

>004010AA xor esi, esi ; esi=0

004010AC push edi

004010AD xor edx, edx ; edi=0

Здесь производится суммирование hex — значений символов имени и

вычисляется его длина:

004010AF Name: ; CODE XREF: sub_401000 C6j

004010AF movsx eax, byte ptr [ebp edx-40h] ; символ имени

004010B4 add esi, eax ;суммируем символы имени

004010B6 lea edi, [ebp var_40] ; edi=offset ‘cr0AKer’

004010B9 or ecx, 0FFFFFFFFh

004010BC xor eax, eax

004010BE inc edx ; N символов

004010BF repne scasb ; ищем конец строки ‘cr0AKer’

004010C1 not ecx

004010C3 dec ecx ; N символов

004010C4 cmp edx, ecx ;Все ли символы?

004010C6 jbe short Name ; Не все

004010C8 mov [ebp arg_0], esi ; Сохраним сумму

В нашем случае сумма равна esi=268h

Далее производится операция сдвига над посчитанной суммой:

004010CB shl [ebp arg_0], 7 ;

В нашем случае получим shl 268h, 7h = 13400h

Теперь производится считывание введенного нами кода:

004010CF lea ecx, [ebp var_C] ; подготовка к

004010D2 push 0Ah ; считыванию

004010D4 push ecx ; введенного

004010D5 push 3E9h ; кода (max= 0Ah — 1 символов)

004010DA push ebx

004010DB call ds:GetDlgItemTextA ; считываем

004010E1 test eax, eax ; Есть код?

004010E3 pop edi

004010E4 jnz short loc_401102 ; Есть

Если бы программа не обнаружила бы введенный код, то она бы перешла

на следующий участок кода и сказала бы все, что она дyмает.

004010E6 push eax

004010E7 push offset aNoSerial ; «No serial!»

004010EC push offset aNoSerialNumber ; «No serial number entered!»

004010F1 push ebx

004010F2 call ds:MessageBoxA

Но поскольку мы, не будь дураки, ввели код, то нас препроводят в

другое место, а именно сюда:

00401102 loc_401102: ; CODE XREF: sub_401000 E4j

Что же мы здесь видим? А видим мы следующее: наш введенный код

преобразовывается при помощи стандартной С’шной функции _atoi

(ASCII—>int) в целое число, которое возвращается в eax:

00401102 lea edx, [ebp var_C] ; edx=offset ‘99999999’

00401105 push edx

00401106 call _atoi ; ‘Code’ ASCII —> int

В eax сейчас преобразованный код, который в нашем случае равен

05F5E0FFh.

А далее мы подходим к финальной части — сравнению. Hо сначала еще

надо подготовить одно из сравниваемых значений:

Берется значение, полученное после операции сдвига над суммой

hex-значений символов нашего имени и складывается с самой суммой,

которое y нас до сих пор хранится в esi. Во как.

0040110B mov ecx, [ebp arg_0] ; преобразованное ‘cr0AKer’

0040110E add esp, 4

00401111 add ecx, esi ; складываем

В нашем случае оно будет равно ecx = 13668h

Вот и все! Теперь сравниваем и видим, что, естественно, значения не

совпадают

00401113 cmp ecx, eax ; Сравнение

00401115 push 0

00401117 jnz short loc_401134 ; Если равно, то Ок!

00401119 push offset aGood ; «Good!»

0040111E push offset aCongratulation ; «Congratulations!!»

00401123 push ebx

00401124 call ds:MessageBoxA

В нашем слyчае 13668h, конечно, не равно 05F5E0FFh.

ПИШЕМ КЕЙГЕН

Итак, приступим к решению. Что мы знаем?

Что из символов введенного имени высчитывается определенное число,

которое равно результату сдвига влево hex-сyммы каждого hex-значения

символа нашего имени. Что это определенное число должно быть равно

значению, полученному путем преобразования введенного кода из

ASCII-стpоки в целое.

Вот и все! Все, что нам нужно — это взять наше имя, произвести над

ним операцию, описанную в пункте 1) и преобразовать его из

_целого_в_ASCII_. Таким образом мы и получим код, соответствующий

нашему имени. В общем, на нормальном языке это называется

pевеpснyть (от слова reverse) алгоритм.

Статья взята с www.cyberinfo.ru

Дня 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 и символ конца строки . Сейчас хеш-функция должна вернуть в EAX значение 0x13 (19). Шагаем вперед и… Первая неудача: в EAX — 0x56 (86). Долго думал, пробовал, грешил на Юникод или еще какие скрытые хитрости программы. Оказалось, программа где-то запоминает длину строки и Вместо хеша «A» вычисляет хеш «A34». Хеш равен 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);
    }
}