☭ ВАСМ.РФ

Первое правило шифрования - не хранить пароли и ключи в явном/открытом виде!
Ну нет, так нет. Пойдём другим путём.. Будем снимать хэши с шифруемых процедур (в данном случае 'Example') и использовать эти хэши в качестве ключей шифрования. Получается выстрел дробью! Во-первых: для каждой процедуры будет генериться свой/индивидуальный ключ, во-вторых: этот ключ будет играть роль CRC, и если кто-либо захочет забить NOP'ами некую инструкцию в этой процедуре, то мы его обломаем, т.к. изменится хэш, ..а с ним и ключ шифрования:

[....]
    mov   si,Example 
    mov   cx,end_Example
    call  Cryptor 
[....]

;== Криптор ======[ver 0.2]==
;^^^^^^^^^^^^^^^^^^^^^^^^^^^^
Cryptor:
    xor   ax,ax
    sub   cx,si                 ; Длина процедуры
    push  si si cx              ; Запомним для шифрования..
@@: lodsb                       ; Читаем байтики из SI
    add   ah,al                 ; Считаем хэш-сумму в AH
    loop  @b

    pop   cx si di              ; СХ = длина, SI = чтение, DI = запись
@@: lodsb
    xor   al,ah                 ; Шифруем процедуру!
    stosb                       ; Пере/запись байта(DI)
    loop  @b
    ret

Здесь уже нет ключа в явном виде, хотя его можно увидеть в отладчике. Но отладчику можно противостоять тупым вырубанием клавы, перехватом INT-1h, инверсией регистра(SP), и т.д. В любом случае - ключ не бросается в глаза, а это уже вери-гуд.

Но и такой алгоритм имеет свои недостатки..
Здесь мы дешифруем процедуры один раз. После запуска приложения, весь код в памяти уже расшифрован. В зашифрованном состоянии находится только файл на диске. Какой от этого толк? Взломщик снимает дамп памяти после запуска нашего приложения, и получает весь исходный код. Нам остаётся лишь с тоскою поглядывать, как он изучает наши алгоритмы.

Хорошие результаты даёт динамическое шифрование кода. Суть его в том, что все процедуры кода постоянно находится в зашифрованном состоянии как на диске, так и в памяти, и дешифруются только при их вызове. Как только вызываемая процедура отработает, она опять шифруется. В этом случае дамп памяти ничего не даст, и будет похож на кучу навоза. Реализация динамического шифрования на программном уровне требует немалых усилий, но зато оправдывает все надежды.

На второй криптор возложена более ответственная задача, поэтому он шифрует/дешифрует чуть-сложней (если можно так выразиться). Беру в качестве ключа начальное значение(0), и ксорю байты блока данных этим ключом, увеличивая ключ на(3) на каждом шаге. Вы можете придумать свой алгоритм, лишь-бы ключи(1.2) были разные:

Cryptor_2:
    xor   ax,ax
@@: lodsb
    xor   al,ah
    add   ah,3
    loop  @b
    ret

Позже мы добавим в него ещё кучу всего, пока это не важно. Главное представить, как это хозяйство будет функционировать: где будет валяться, у кого будет принимать и кому будет возвращать управление, какие параметры её нужны. Вот об этом и поговорим..

На общей схеме видно, что когда код вызывает процедуру, запрос поступает сперва на дешифратор(2), который расшифровывает запрошенную процедуру. Для своей работы декриптор(2) требует только длину, и адрес начала процедуры в памяти. Расшифрованная, ..пошевелив своей задницей, эта процедура возвращает управление обратно криптору, который зашифровав тело отработавшей процедуры, передаёт уже эстафету по адресу возврата в основной код.

Роль шифратора и дешифратора играет один и тот-же криптор(2), который я закинул в стек от посторонних глаз, и вызываю его по указателю(BP). Кодируется это просто. Запускаю отладчик (у меня GRDB), ввожу код криптора в его окне, чтоб получить опкоды инструкций. Получаю такую строку байтов, которые и представляют из-себя криптор(2):

Cryptor_2:
    db    031h,0C0h,0ACh,030h,0E0h,080h,0C4h,003h,0E2h,0F8h,0C3h,0
[....]

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

В принципе, 12 байт не так-уж и много. Можно не хранить криптор в теле программы, а генерировать его по-необходимости на лету! В нашем распоряжении есть регистры размером по 4 байта, значит если растасовать опкоды криптора по трём/32-битным регистрам и сохранить эти регистры в стеке, то получим код, который можно будет вызывать прямо из стека по указателю. Получится: спонтом-под-зонтом. Кстати, такая фишка будет работать и в защищённом режиме, не вызывая никаких 'Exception'. Только нужно помнить, что стек растёт снизу-вверх, а программа выполняется сверху-вниз, поэтому сохранять строку опкодов в стеке нужно в обратном порядке.

Посмотрим на такую схему.
Пусть наша com'ka занимает в памяти 400h байт:

;...........................;
org 100h                    ; 0100h = адрес первой инструкции кода
push start                  ; 
ret                         ;
start:                      ;
[.....]                     ;
int  20h                    ; 0500h = адрес последней инструкции кода
;...........................;
; Свободное пространство    ;
; в нашем сегменте памяти   ;
;...........................; MOV BP,SP  (BP = адрес криптора в памяти)
; Фрейм в стеке             ;
; для нашего криптора       ;
; 31 C0 AC 30               ;
; E0 80 C4 03               ;
; E2 F8 C3 00               ; 
;...........................; FFFEh = дно стека (значение SP)

Здесь наглядно продемонстрировано, где будет валяться криптор(2). В доках от Intel сказано, что ЦП отвечает за сохранность всех данных, которые расположены выше текущего значения регистра(SP). Естессно, что это относится только к стандартным/стековым операциям, типа PUSH/POP. Мы, при выделении фрейма в стеке, смещаем указатель командой [SUB SP,12], и теперь за свои данные можем не беспокоиться.

Далее, движимые этой идеей создаём 'матку', которая будет воспроизводить потомство крипторов(2):

CreateCryptor:
    pop   si                ; Очищаем стек от адреса возврата
    mov   eax,30ACC031h     ; Растасовываем
    mov   ebx,03C480E0h     ;   ..опкоды криптора
    mov   ecx,00C3F8E2h     ;      ..по-трём регистрам
    push  ecx ebx eax       ; Помещаем их в стек, в нужном порядке
    mov   [pointer],sp      ; Сохраняем в BP (или переменной), указатель на начало криптора
    jmp   si

Проверим, в правильном-ли порядке после таких ПУШ'ей расположились опкоды криптора в стеке:

; Содержимое стека после пушей 32-битных регистров...
GRDB version 1.7 Copyright (c) LADsoft
History enabled
->a
16FA:0100  mov  eax,30ACC031
16FA:0106  mov  ebx,03C480E0
16FA:010D  mov  ecx,00C3F8E2
16FA:0114  push ecx
16FA:0116  push ebx
16FA:0118  push eax
16FA:011A  mov  bp,sp
16FA:011C
.........
->t
eax:30ACC031  ebx:03C480E0  ecx:00C3F8E2  edx:00000000  esi:00000000  edi:00000000
ebp:00000000  esp:0000FFE2  eip:0000011A  eflags:000B3202 NV UP EI PL NZ NA PO NC
ds: 16FA   es:16FA   fs:16FA   gs:16FA   ss:16FA   cs:16FA
16FA:011A 8B EC          mov         bp,sp

->d bp
16FA:FFE0        31 C0 AC 30 E0 80 C4 03 E2 F8 C3 00 00 00   
16FA:FFF0  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
->q
;-----------------------------------------------------------------------------
; Код криптора(2) в опкодах.....
Cryptor_2:
    db    031h,0C0h,0ACh,030h,0E0h,080h,0C4h,003h,0E2h,0F8h,0C3h,0
[....]

Как видим, данные идут в правильном порядке и это радует.
Остаётся вызвать криптор по указателю 'CALL BP', как он исправно отработает и вернёт управление через последний(RET) в своём теле (опкод С3h). Если идея с 'маткой' вам не приглянулась, или кажется трудно/реализуемой, то можно просто сгенерить один раз криптор в стек, и не затирая его оставить там болтаться. Тогда (за ненадобностью) можно затереть саму матку. Но это уже - на вкус и цвет..

Для продолжения экспериментов понадобится какая-нить оболочка. Попробуем сделать из неё полноценную программу с динамическим шифрованием процедур. Не буду сильно мудрить, а наваяю простенький вызов трёх процедур, которые и покажут всю подноготную замысла.

Из прикладных программ нам понадобится только компилятор 'FASM', редактор 'HIEW', ну и виндовый 'CALC' в инженерном виде. HIEW занимает в этой тройке почётное/первое место, т.к. именно в нём мы и будем шифровать программу. Тонкости шифрования оставим на потом, а пока ознакомимся с самой оболочкой:

; fasm code....
org 100h
push Cryptor1                ; Расшифровываем всё тело
ret                          ;    ..от метки 'start' и до подвала!

start:
;----------
about      db   13,10,'Example of the dynamic encryption (c)R71MT'
           db   13,10,'------------------------------------------'
           db   13,10,'Type string..: $'
sizeMess   db   13,10,'Programm size: $'
buff       db   80,0,80 dup(0)

Cryptor2   db   050h,053h,053h,0BAh,002h,000h,031h,0C9h,030h,00Fh
           db   043h,080h,0C1h,003h,039h,0C3h,072h,0F6h,04Ah,074h
           db   007h,05Bh,0FFh,0D3h,05Bh,058h,0EBh,0EAh,0C3h,000h,000h,000h
length     =    $ - Cryptor2
align      16

Begin:                       ; Точка входа в программу
;-----------
     mov   bx,Message1 
     mov   ax,end_Message1
     call  bp                ; Вызов процедуры! (зовём декриптор(2))

     mov   bx,inpBuff
     mov   ax,end_inpBuff
     call  bp                ;

     mov   bx,Message2
     mov   ax,end_Message2
     call  bp                ;

     xor   ax,ax             ; Ждём клавишу..
     int   16h
     int   20h               ; Выход из com-программы!
     dw    9090h
;-----------------------------------------------------------
;--------- П Р О Ц Е Д У Р Ы -------------------------------
;-----------------------------------------------------------
Message1:         ;<---------; Вывести шапку на экран
     mov   ah,9
     mov   dx,about
     int   21h
     ret
end_Message1:
     dw    1234h,8520h,0f0fh,9090h    ; Мусор...

Message2:         ;<---------; Вывести размер программы в байтах
     mov   ah,9
     mov   dx,sizeMess
     int   21h

     lea   ax,[end_Start - start]  ; АХ = размер программы
Hex2Asc:
     xchg  dx,ax              ; Функция выводит на экран(АХ) в HEX-виде
     mov   cx,4
@@:  shld  ax,dx,4
     rol   dx,4
     and   al,0Fh
     cmp   al,0Ah
     sbb   al,69h
     das
     int   29h
     loop  @b
     ret
end_Message2:
     dw    0f0fh,9090h,1234h,8520h      ; Мусор...

inpBuff:           ;<---------; Ввод строки в буфер средствами DOS
     mov   ah,0Ah
     mov   dx,buff
     int   21h
     ret
end_inpBuff:
end_Start:
;--------------------------------------------------------------------------
;================== К О Н Е Ц   П Р О Г Р А М М Ы =========================
;--------------------------------------------------------------------------
Cryptor1:          ;<--------; Декриптор(1)
     mov   si,start          ; 
     mov   al,0A7h           ; Ключ дешифратора
Decrypt:
     xor   byte[si],al       ;
     inc   si                ;
     cmp   si,end_Start      ; Всё расшифровали?
     jb    Decrypt           ;
end_Cryptor1:                ;
     sub   al,al             ; Самоликвидация! (деструкция)
     mov   di,Cryptor1       ;
     lea   cx,[end_Cryptor1 - Cryptor1]
     rep   stosb             ;

copyCryptor2:      ;<--------; Сразу копируем криптор(2) в стек!
     sub   sp,length         ; Выделяем фрейм
     mov   bp,sp             ; Запомним точку входа в него

     mov   si,Cryptor2       ; 
     mov   di,bp             ; 
     mov   cx,length         ; 
     push  cx si             ; 
     rep   movsb             ; Копируем строку из SI в DI

     xor   al,al             ; 
     pop   di cx             ; 
     rep   stosb             ; Затираем строку опкодов нулями
     jmp   Begin    ;<-------; На точку входа в основное тело..
;[...]

Вот пример готовой тушки, над которой можно по-эксперементировать.
Эта программа должна вывести на экран приветствие и запрос на ввод строки, которую просто сохранит в буфере. После ввода строки она должна показать размер своего тела в 16-тиричном формате и выйти в DOS по INT-20h. Помимо декрипторов, в ней 3 процедуры: 'Message1', 'Message2' (с вложеной Hex2Asc) и 'inpBuff' для ввода строки в буфер.

Здесь есть некоторые/умышленные ошибки, чтобы потом можно было на них указать, типа: "Так делать нельзя!". При этом программа на-ходу, и выполняет свою функцию. Если сейчас скопировать этот исходник в окно FASM'a и попытаться его скомпилировать, то компиляция пройдёт успешно, но полученный COM-файл не запустится, а досовская консоль просто подмигнёт нам и закроется. Думаю не трудно догадаться почему..

Исполнение кода начинается с того, что декриптор(1) начинает расшифровку всего тела ключом(A7h). Стоп! Так тело-то ещё не зашифровано! Получается что декриптор вместо расшифровки, наоборот шифрует тушку, поэтому программа и рушится ниже плинтуса. Такой-же подарочек нам приподнесёт и криптор(2) - начнёт шифровать ключами(0..3..6..) вместо расшифровки. Значит мы должны предварительно зашифровать программу, чтоб дать правильный старт дешифровщикам!
Вот тут-то и начинается самое интересное..

Загружаем готовый COM-файл в HIEW. Шифрование начинаем с любой из понравившихся процедур, ..пусть будет 'Message1'. Как видно из отчёта выше, эта процедура начинается с адреса(220h) и заканчивается адресом(22Аh). Сам адрес(22Аh) не входит в процедуру, т.к. отсчёт с нуля, поэтому адресом конца будет(229h) с опкодом RET(C3h).

Юзая HIEW нужно учитывать, что он считает адреса не с ORG-100h (как у нас в программе), а с ORG-0h, поэтому адрес(220h) он будет отображать как 120h. Значит загрузив программу в HIEW жмём в его окне такую последовательность клавиш: [F4->F3->F5->120->Enter] и попадаем сюда:

  00000120: 52                 push      dx
  00000121: B409               mov       ah,009 
  00000123: BA0401             mov       dx,00104
  00000126: CD21               int       021
  00000128: 5A                 pop       dx
  00000129: C3                 retn
  0000012A: 3412               xor       al,012
  0000012C: 20850F0F           and       [di][00F0F],al
  00000130: 90                 nop
  00000131: 90                 nop

У-гу.. Это как-раз процедура 'Message1' которая выводит шапку. Смотрим, что по адресу(129h) действительно находится(RET), значит мы на правильном пути. Ставим курсор на адрес(120h) и жмём последовательность: [F3->F7] или Edit->Crypt. В ответ, HIEW просит нас указать алгоритм шифрования в окне 'Assembler'. Отвечаем ему так:

    xor   cx,cx
    xor   al,cl
    add   cl,3
    loop  2

..после этих команд, выходим по(Esc) из режима ввода алгоритма, и подтверждаем серьёзность наших намерений нажав(F7). HIEW перешёл в режим шифрования, для которого так-же юзается клавиша[F7].

Значит шифруем по(F7) все значения с адреса(120h), до адреса(129h) включительно. Зашифрованные значения меняют свой цвет на жёлтый, что означает ОК! Зашифровав последнее значение(С3h) в процедуре, сохраняем изменения клавишей(F9h). Всё.. Процедуру 'Message1' зашифровали! Зашифрованный код должен выглядеть так:

  00000120: 52                 push      dx
  00000121: B70F               mov       bh,00F
  00000123: B308               mov       bl,008
  00000125: 0E                 push      cs
  00000126: DF34               fbstp     t,[si]
  00000128: 42                 inc       dx
  00000129: D834               fdiv      d,[si]
  0000012B: 1220               adc       ah,[bx][si]
  0000012D: 850F               test      [bx],cx
  0000012F: 0F909052B4         seto      [bx][si][0B452]

Чтобы приступить к шифрованию следующей процедуры 'Message2', нужно полностью выйти из HIEW'а, и по-новой загрузить программу, чтобы задать шифровальщику опять начальное значение(0). Шифрование остальных процедур происходит по такой-же схеме. Адреса процедур в окне HIEW'а будут следующими:

- начало 'Message1': 220h - 100h = 0120h
-  конец 'Message1': 220h + 00Ah = 022Ah - 0101h = 0129h

- начало 'Message2': 232h - 100h = 0132h
-  конец 'Message2': 232h + 029h = 025Bh - 0101h = 015Ah

- начало ' inpBuff': 263h - 100h = 0163h
-  конец ' inpBuff': 263h + 00Ah = 026Dh - 0101h = 016Ch

- начало 'FullSize': 104h - 100h = 0004h
-  конец 'FullSize': 104h + 169h = 026Dh - 0101h = 016Ch

Зашифровав все/три процедуры одинаковым алгоритмом, приступаем к шифровке всего тела, чтобы программа на диске лежала в зашифрованном виде. Тут ничего нового, только вместо 'Edit->Crypt', нужно будет заюзать 'Edit->Xor' с ключом(А7h), т.к. криптор(1) внутри программы расшифровывает тело именно этим ключом. Значит перезапустив HIEW открываем нашу программу с зашифрованными процедурами и жмём последовательность клавиш:

[F4->F2->F5->4->Enter->F3->F8->A7->Enter]

Эта комбинация перевела HIEW в режим шифрования 'XOR' с ключом(А7). Процесс шифрования привязан к клавише(F8). Шифруем все значения от макушки с адресом(0004) и до хвоста с адресом(016Ch) включительно. Шифруемые значения меняют свой цвет с голубого на жёлтый. Достигнув адреса(016Dh) сохраняем изменения по(F9), и с чувством выполненного долга выходим из HIEW'a по(F10). Запустив на исполнение новоиспечённый/шифрованный файл обнаруживаем, что мы всё сделали правильно, о чём свидетельствует окно консоли.

Но бросать чепчики в воздух рановато! Этот мир дермово устроен, и как только файлик попадёт в руки более-менее опытного взломщика, такое шифрование не спасёт его от взлома. Поиск ошибок при шифровании может послужить темой для следующего разговора.

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

В клинических случаях, парольная защита программы строится по такому алгоритму. Юзер вводит пароль, который проверяется программой на валидность. Если пароль совпадает, то типа: 'Thank-you!', иначе: 'Fack-you!'. Этот пример в аккурат показывает, как нельзя делать! Толку от пароля, который опять нужно сравнивать с оригиналом? Можно пойти по-более достойному пути, который заключается в следующем..

1. Снимаем контрольную сумму всей тушки;
2. Сохраняем её в открытом виде;
3. Шифруем всю программу 32-битным ключом: DEAD6666h;
4. Читаем юзерский пассворд, и делаем из него ключ;
5. Дешифруем юзверским ключом тушку;
6. Считаем по-новой контрольную сумму получившегося тела;
7. Сравниваем две контрольные суммы;
8. Здесь (как-правило) Fack-you!

Таким образом мы избавляемся от хранения ключа в открытом виде.
До шифрования снимается CRC-программы, которая не несёт в себе ни йоты полезной инфы. Её можно хранить обнажённой. После шифрования секретным ключом контрольная сумма меняется, и её можно восстановить только дешифровав тело таким-же ключом, которым мы шифровали. Юзерский пасс от фонаря преобразуется в ключ, которым дефишруется тело. Если после этого ни один тушканчик не постадал, то контрольная сумма совпадёт, что будет означать ОК!

Простой алгоритм может вставить такие палки в колёса наших партнёров, что мало не покажется. Ключ шифрования мы использовали только один раз закрывшись в тёмной комнате от всех глаз. Его никто не знает кроме нас и он нигде не хранится. Не знает его и сама программа, которая тупо дешифрует тем, что мы ей подсунем, ..а подсунуть ей мы можем сколько? - точно: 4 млрд. вариантов ключей.

Реализуется это просто..
Допустим мы уже посчитали CRC не зашифрованного тела, который равен 8AE5h. На следующем шаге шифруем его секретным ключом, а внутри программы помещаем такую функцию:

;[....]
len   equ   (end_Start - start)/4       ; Длина в dword
len2  equ   len*4                       ; Длина в байтах
hash  equ   8AE5h                       ; Хэш-сумма всей программы

Doberman:                ;<------; Читаем юзерский пасс
      xor   eax,eax 
      sub   ebx,ebx              ; Здесь будет ключ из пасса
      mov   ecx,8                ; Длина ввода
pass: mov   ah,1                 ; Ввод с эхом средствами DOS
      int   21h
      and   ax,0Fh               ; Оставляем только мл.тетраду
      shrd  ebx,eax,4            ; Двигаем ключ в EBX
      loop  pass                 ; Читаем остальные символы юзверя

Decrypt:                 ;<------; Ключ шифрования в ЕВХ. Дешифруем тушку!
      mov   esi,start 
      mov   edi,esi
      mov   ecx,len
@@:   lodsd
      xor   eax,ebx              ; Ксор ключом..
      stosd
      loop  @b

GetCRC:                  ;<------; Перерсчитаем хэш-сумму в ВХ (2 байта)
      push  0   0
      pop   eax ebx              ; Сбрасываем регистры в нуль
      mov   ecx,len2
      mov   esi,start
@@:   lodsb
      add   bx,ax                ; Считаем сумму в ВХ
      loop  @b

Welcome:                 ;<------; Таможня..
      cmp   bx,hash              ; Сверяем два хэша!
      jne   fack                 ; Если не совпали
      call  @f
      db    'Thank-you!$'        ; Иначе
@@:   pop   dx
      call  @prn
      jmp   Begin        ;<------; На точку входа в программу!!!

fack: call  @f                   ; Не верный пасс юзверя...
      db    'Fack-you!$'
@@:   pop   dx
      call  @prn
      ret
;-----------------------------------------------------------------
@prn: mov   ah,9          ; Функция вывода сообщений
      int   21h     
      ret

Здесь я попытался определить только основные моменты, большая часть которых осталась за-бортом. Не возможно предскать всех действий двух/враждующих сторон, т.к. нет определённого руководства ни для нас, ни для тех, от кого мы собираемся защищаться. Нужно по-возможности изобретать свой велосипед. И пусть он будет с квадратными колёсами и с седлухой выше руля, зато такого ни у кого не будет, и в этом наш выигрыш!

Можно спорить до хрипоты, какие алгоритмы лучше: готовые или самопальные, но последнее слово всегда остаётся за нами. Баян у нас на руках - как хотим, так и играем! (лишь-бы не забывать тискать пимпы иногда).