Bezpieczne programowanie.
Aplikacje hakeroodporne

Autor: Jacek Ross
ISBN: 978-83-246-2405-8
Format: 158

×235, stron: 312

WyobraŸ sobie sytuacjê, w której poœwiêcasz mnóstwo czasu na stworzenie nowego,
ciekawego rozwi¹zania w œwiecie informatyki. Kosztuje Ciê to wiele dni i nocy ogromnego
wysi³ku. Dok³adnie w momencie opuszczenia Twojego bezpiecznego komputera,
udostêpniony œwiatu, Twój pomys³ zostaje wystawiony na ciê¿k¹ próbê – w sieci
dzia³aj¹ krakerzy, którzy za wszelk¹ cenê bêdê próbowali z³amaæ Twoje zabezpieczenia
lub wykorzystaæ luki w Twojej aplikacji. Jak tego unikn¹æ? Jak tworzyæ oprogramowanie
odporne na ich ataki?

Proste i przejrzyste odpowiedzi na podobnie skomplikowane pytania znajdziesz w³aœnie
w tej ksi¹¿ce! Podczas lektury poznasz zagro¿enia, na jakie nara¿ony jest programista,
oraz proste sposoby utrudniania krakerom zadania. Dodatkowo zdobêdziesz wiedzê na
temat metod szyfrowania danych i wyznaczania sygnatur. Jednak, co najwa¿niejsze,
zobaczysz, jak wykorzystaæ tê wiedzê w praktyce! W publikacji „Bezpieczne programowanie.
Aplikacje hakeroodporne” znajdziesz równie¿ sporo ciekawych informacji na temat
zabezpieczania aplikacji sieciowych oraz zaawansowane metody, gwarantuj¹ce
podniesienie bezpieczeñstwa Twojego produktu do wysokiego poziomu. To jeszcze
nie wszystko! W kolejnych rozdzia³ach autor prezentuje sposoby ochrony przed
debugerami, patenty na bezpieczne tworzenie kodu na platformie .NET oraz
psychologiczne aspekty tworzenia hakeroodpornych aplikacji!

• Przegl¹d zagro¿eñ, rodzaje oszustw i naruszeñ bezpieczeñstwa
• Zabezpieczenie programu przy u¿yciu numeru seryjnego
• Dostêpne na rynku systemy zabezpieczania aplikacji
• Algorytmy szyfruj¹ce
• Tworzenie skrótów wiadomoœci
• Wykorzystanie szyfrowania przy zabezpieczaniu oprogramowania
• Zabezpieczenia aplikacji wykorzystuj¹cych PHP i .NET
• Ochrona przed atakami typu: wstrzykiwanie SQL, XSS, DOS i DDOS
• U¿ywanie zaawansowanych metod ochrony oprogramowania
• Sposoby zaciemniania programu
• Ochrona kodu przed debugerami
• Zastosowanie kluczy sprzêtowych i technik biometrycznych
• Psychologiczne aspekty ochrony oprogramowania

Dowiedz siê, jak tworzyæ aplikacje odporne na ataki!

Spis treci

Wstp

.............................................................................................. 9

Rozdzia 1. Zagroenia czyhajce na programistów ........................................... 11

1.1. Dawno, dawno temu w wiecie gier ........................................................................... 11
1.2. Moje przygody z gr Metal Knights ........................................................................ 14
1.3. Niebezpieczny edytor map, czyli sabe punkty ........................................................ 16
1.4. A jak to robi w Diablo... czyli co o bezpieczestwie aplikacji sieciowych .......... 19
1.5. Rodzaje oszustw i narusze bezpieczestwa ........................................................... 21

1.5.1. Nieuprawnione uycie bd kopiowanie programu ........................................ 21
1.5.2. Nielegalna podmiana autorstwa kodu ............................................................. 23
1.5.3. Nieuprawniona modyfikacja kodu .................................................................. 23

1.6. Pirat, Robin Hood, kraker? ...................................................................................... 24
1.7. Czy ja take mam myle o zabezpieczeniach? ....................................................... 25
1.8. Czym si róni kraker od zodzieja samochodów? .................................................. 27
Zadania do samodzielnego wykonania ........................................................................... 30
Pytania kontrolne ............................................................................................................ 31

Rozdzia 2. Proste metody zabezpieczenia programów ......................................... 33

2.1. Wstp ....................................................................................................................... 33
2.2. Numer seryjny ......................................................................................................... 33
2.3. CrackMe — przykady saboci prostych zabezpiecze

przed nieuprawnionym uytkowaniem programu ................................................. 35

2.3.1. CrackMe1 ....................................................................................................... 35
2.3.2. CrackMe2 ....................................................................................................... 42

2.4. Gotowe systemy zabezpieczania aplikacji przed nieuprawnionym uyciem ........... 44

Przegld systemów zabezpieczajcych dostpnych na rynku ................................... 47

2.5. Zakoczenie ............................................................................................................. 50
Zadania do samodzielnego wykonania ........................................................................... 51
Pytania kontrolne ............................................................................................................ 51

Rozdzia 3. Teoria szyfrowania. Algorytmy szyfrujce w praktyce ....................... 53

3.1. Wstp ....................................................................................................................... 53
3.2. Szyfrowanie i kodowanie informacji ....................................................................... 53
3.3. Historyczne algorytmy szyfrowania i kodowania .................................................... 54

3.3.1. Pocztki .......................................................................................................... 54
3.3.2. Szyfry przestawieniowe i podstawieniowe, szyfr Cezara ............................... 55
3.3.3. Szyfry polialfabetyczne .................................................................................. 55
3.3.4. Zasada Kerckhoffsa ........................................................................................ 56

4

Bezpieczne programowanie. Aplikacje hakeroodporne

3.4. Wspóczesne algorytmy szyfrowania ................................................................... 56

3.4.1. Rozwój algorytmów szyfrowania ................................................................... 56
3.4.2. Algorytmy symetryczne. Algorytm RC4 ........................................................ 57
3.4.3. Szyfrowanie symetryczne, algorytm DES ...................................................... 61
3.4.4. Szyfrowanie symetryczne, algorytm AES ...................................................... 61
3.4.5. Szyfrowanie asymetryczne, algorytm RSA .................................................... 61
3.4.6. Podpis cyfrowy ............................................................................................... 63
3.4.7. Szyfr z kluczem jednorazowym ...................................................................... 63

3.5. Algorytmy wyznaczajce sygnatury (skróty) danych .............................................. 64

3.5.1. Algorytm wyznaczania CRC .......................................................................... 64
3.5.2. Algorytm MD5 ............................................................................................... 65
3.5.3. Algorytm SHA-1 ............................................................................................ 65

3.6. Generatory liczb pseudolosowych ........................................................................... 69
3.7. Do czego moe suy szyfrowanie w zabezpieczaniu programów? ....................... 70
Zadania do samodzielnego wykonania ........................................................................... 71
Pytania kontrolne ............................................................................................................ 71

Rozdzia 4. Zabezpieczanie programów sieciowych na przykadzie jzyka PHP ... 73

4.1. Wstp ....................................................................................................................... 73
4.2. Obsuga danych z zewntrz ..................................................................................... 74
4.3. Przekazywanie danych midzy skryptami ............................................................... 75
4.4. Uwierzytelnianie w PHP .......................................................................................... 76
4.5. Niebezpieczne konstrukcje jzyka ........................................................................... 79

4.5.1. Konstrukcja include ($plik) ............................................................................ 80
4.5.2. eval($code), konstrukcja $$ ............................................................................ 81
4.5.3. fopen($url) ...................................................................................................... 82

4.6. Bezpieczna obsuga bdów ..................................................................................... 83
4.7. Bezpieczestwo systemu plików ............................................................................. 84
4.8. Cross site scripting ................................................................................................... 85
4.9. Wstrzykiwanie kodu SQL ........................................................................................ 86

4.9.1. Wstrzykiwanie kodu SQL — przykad 1. ....................................................... 87
4.9.2. Wstrzykiwanie kodu SQL — przykad 2. ....................................................... 90
4.9.3. Uycie PDO .................................................................................................... 91
4.9.4. Ataki wielofazowe .......................................................................................... 92
4.9.5. Sposoby ochrony ............................................................................................ 92

4.10. Wstrzykiwanie polece systemowych (shell injection) ......................................... 93
4.11. Wstrzykiwanie zawartoci e-mail (e-mail injection) .............................................. 94
4.12. Cross site request forgery ...................................................................................... 95
4.13. Przejcie kontroli nad sesj (session fixation) ....................................................... 97
4.14. Session poisoning ................................................................................................ 101

4.14.1. Przechowywanie stanu aplikacji w niezabezpieczonych miejscach ........... 101
4.14.2. Przypisanie wartoci do zmiennej sesyjnej

o nazwie stworzonej na podstawie danych od uytkownika ................... 104

4.14.3. Podmiana sekwencji wywoa przez wamywacza. Problem wycigu ....... 105
4.14.4. Uywanie tych samych zmiennych sesyjnych do rónych celów ............... 106
4.14.5. Zmienne sesyjne nie s gwarancj bezpieczestwa .................................... 108

4.15. Ataki typu DOS i DDOS ..................................................................................... 110
4.16. Dyrektywa register_globals ................................................................................. 112
4.17. Narzdzie zaciemniajce kod ródowy jzyka PHP ........................................... 114
Zakoczenie .................................................................................................................. 116
Zadania do samodzielnego wykonania ......................................................................... 116
Pytania kontrolne .......................................................................................................... 116

Spis treci

5

Rozdzia 5. Zaawansowane metody zabezpieczania programów ....................... 121

5.1. Wstp ..................................................................................................................... 121
5.2. Klucze rejestracyjne przypisane do uytkownika .................................................. 122

5.2.1. Idea kluczy rejestracyjnych przypisanych do uytkownika .......................... 122
5.2.2. Typowe techniki ........................................................................................... 124
5.2.3. Tworzenie kluczy rejestracyjnych w aplikacjach sieciowych ....................... 125

5.3. Samotestujcy si program .................................................................................... 126

5.3.1. Testowanie integralnoci programu gwarancj jego oryginalnoci .............. 126
5.3.2. Przykad — weryfikacja integralnoci pliku wykonywalnego ..................... 127
5.3.3. Przykad — weryfikacja integralnoci kodu programu ................................ 132

5.4. Sprawdzanie integralnoci danych ......................................................................... 135

5.4.1. Ukryj moje dane ........................................................................................... 136
5.4.2. Testowanie integralnoci danych ulegajcych zmianom .............................. 137
5.4.3. Wersje czasowe oprogramowania — kopoty z shareware ........................... 138
5.4.4. Bezpieczne przechowywanie danych — przykad ........................................ 140

5.5. Samomodyfikujcy si program ............................................................................ 144

5.5.1. Samomodyfikujcy si program.

Brzydka sztuczka czy eleganckie zabezpieczenie? ................................. 144

5.5.2. Sabota, czyli jak ukara krakera? ................................................................ 146
5.5.3. „Za 5 sekund ten program ulegnie samozniszczeniu”

— automatyczna deinstalacja programu ................................................. 147

5.5.4. „Kod o ograniczonej przydatnoci do wykonania” ............................................ 148

5.6. Klucz programowy ................................................................................................ 150

5.6.1. Klucz programowy — przykad ................................................................... 151
5.6.2. Deszyfrowanie fragmentów programu w trakcie jego dziaania ................... 156
5.6.3. Przykad programu deszyfrujcego si w trakcie dziaania .......................... 158

5.7. Zaciemnianie kodu i danych programu .................................................................. 161

5.7.1. Czy to wci open source? Zaciemnianie kodu jako metoda obronna .......... 161

5.8. Zabezpieczenia. Jak to w praktyce wprowadzi w ycie .................................... 163

5.8.1. Zabezpieczenia a etapy produkcji ................................................................. 163
5.8.2. Generator zabezpiecze ................................................................................ 164

Zadania do samodzielnego wykonania ......................................................................... 165
Pytania kontrolne .......................................................................................................... 166

Rozdzia 6. Zabezpieczenie programów przed debugerami ............................... 167

6.1. Wstp ..................................................................................................................... 167
6.2. Wykrywanie debugerów ........................................................................................ 168
6.3. Utrudnianie debugowania ...................................................................................... 169

6.3.1. Wstawki kodu utrudniajce debugowanie .................................................... 169
6.3.2. Generator wstawek kodu utrudniajcych debugowanie ................................ 172

Zadania do samodzielnego wykonania ......................................................................... 175
Pytania kontrolne .......................................................................................................... 175

Rozdzia 7. Wykorzystanie internetu do zabezpieczania programów .................. 177

7.1. Wstp ..................................................................................................................... 177
7.2. Rejestracja programu przez internet ...................................................................... 178
7.3. Aktywacja numeru seryjnego przez internet .......................................................... 179
7.4. Kontrola uytkowania aplikacji z czciowym dostpem do internetu .................. 180
7.5. Weryfikacja prawidowej pracy aplikacji przez sie .............................................. 181
7.6. Przechowywanie poufnych danych uytkownika .................................................. 182
7.7. Deszyfrowanie programu w trakcie dziaania a internet ........................................ 183
7.8. Fragmentaryczne dane pobierane z internetu ......................................................... 185
7.9. Przesyanie informacji o programie do centralnego serwera .................................... 186

6

Bezpieczne programowanie. Aplikacje hakeroodporne

7.9.1. Totalna inwigilacja? Rejestrowanie informacji

o zachowaniu programu i uytkownika ..................................................... 186

7.9.2. Zdalne sprawdzanie tosamoci uytkownika .............................................. 188
7.9.3. Zdalne i lokalne blokowanie dziaania programu

sterowanego danymi z centralnego serwera ............................................... 191

7.10. Wirtualne wybory ................................................................................................ 192
Zadania do samodzielnego wykonania ......................................................................... 196
Pytania kontrolne .......................................................................................................... 196

Rozdzia 8. Zabezpieczanie programów przy uyciu kluczy sprztowych

oraz technik biometrycznych ......................................................... 197

8.1. Wstp ..................................................................................................................... 197
8.2. Zabezpieczenie aplikacji za pomoc kluczy sprztowych ..................................... 198

8.2.1. Karty magnetyczne i elektroniczne .............................................................. 198
8.2.2. Podpis cyfrowy na trwaym noniku ............................................................ 199
8.2.3. Klucze sprztowe w zabezpieczaniu oprogramowania ................................. 200

8.3. Technologie GPS i RFID, geolokalizacja .............................................................. 201

8.3.1. Technologie GPS i RFID .............................................................................. 201
8.3.2. Problemy etyczne i moralne postpu technicznego

zwizanego z lokalizacj i kontrol uytkowników ................................... 202

8.4. Weryfikacja tosamoci za pomoc technik biometrycznych ................................... 203

8.4.1. Techniki biometryczne ................................................................................. 203
8.4.2. Indywidualne oprogramowanie .................................................................... 204

8.5. Szpiegostwo elektroniczne .................................................................................... 204

8.5.1. Wamania do sieci bezprzewodowych .......................................................... 204
8.5.2. Przechwytywanie fal elektromagnetycznych ................................................ 205

Pytania kontrolne .......................................................................................................... 206

Rozdzia 9. Tworzenie bezpiecznych aplikacji w rodowisku .NET ..................... 207

9.1. Wstp ..................................................................................................................... 207
9.2. Autoryzacja oparta na uprawnieniach i rolach (Role-Based Authorization) .......... 208

9.2.1. Uprawnienia, interfejs IPermission, klasa Principal ..................................... 209
9.2.2. Autoryzacja nakazowa oparta na rolach (Imperative Role-Based Security) ........ 210
9.2.3. Autoryzacja deklaracyjna oparta na rolach (Declarative Role-Based

Security) ............................................................................................................... 213

9.3. Zabezpieczenie dostpu kodu do zasobów (Code Access Security) ......................... 215

9.3.1. Nakazowe zabezpieczenie dostpu kodu do zasobów

(Imperative Code Access Security) ............................................................... 215

9.3.2. Deklaracyjne zabezpieczenie dostpu kodu do zasobów

(Declarative Code Access Security) .............................................................. 219

9.3.3. Poziomy regu bezpieczestwa (Security Policy Level) ............................... 220
9.3.4. Narzdzie The Code Access Security Policy Utility — caspol.exe .............. 221

9.4. Bezpieczestwo ASP.NET .................................................................................... 222

9.4.1. Metody uwierzytelniania w ASP.NET ......................................................... 222
9.4.2. Dostp anonimowy ....................................................................................... 223
9.4.3. Uwierzytelnianie systemu Windows ............................................................ 223
9.4.4. Uwierzytelnianie przy uyciu formularza ..................................................... 226
9.4.5. Uwierzytelnianie za pomoc .NET Passport ................................................ 228
9.4.6. Bezpieczna komunikacja za pomoc SSL .................................................... 228

9.5. Tworzenie silnych nazw podzespoom .................................................................. 230
Zadania do samodzielnego wykonania ......................................................................... 231
Pytania kontrolne .......................................................................................................... 232

Spis treci

7

Rozdzia 10. Bezpieczny Program ..................................................................... 235

10.1. Wstp ................................................................................................................... 235
10.2. Opis programu ..................................................................................................... 236
10.3. Przegld kodu ródowego ................................................................................... 238

10.3.1. BezpiecznyProgram.exe ............................................................................. 238
10.3.2. ZabezpieczBP.exe ...................................................................................... 245
10.3.3. StwórzKluczBP.exe .................................................................................... 246

10.4. Wnioski ............................................................................................................... 247
Zadania do samodzielnego wykonania ......................................................................... 249

Rozdzia 11. Psychologiczna strona bezpieczestwa ......................................... 251

11.1. Wstp ................................................................................................................... 251
11.2. Wpyw architektury programu na jego bezpieczestwo ...................................... 251
11.3. „Tylne wejcia” i kod tymczasowy ......................................................................... 253
11.4. Uycie gotowego kodu ........................................................................................ 254
11.5. Open source ......................................................................................................... 256
11.6. Taczce winki kontra bezpieczestwo ............................................................. 257
11.7. Security by obscurity — zabezpieczanie przez zaciemnianie .............................. 258
11.8. Karanie wamywacza ........................................................................................... 260
11.9. Brzytwa Ockhama ............................................................................................... 261
11.10. Uycie socjotechniki .......................................................................................... 261
11.11. Nie poprawiaj wamywacza ............................................................................... 262
11.12. Walka ze script kiddies ...................................................................................... 263
11.13. Ochrona przed automatami ................................................................................ 264
11.14. Ataki z wewntrz ............................................................................................... 267
11.15. acuch a sie zabezpiecze ............................................................................. 267
11.16. Caociowe spojrzenie na problem bezpieczestwa ........................................... 268
Pytania kontrolne .......................................................................................................... 270

Podsumowanie

............................................................................. 273

Odpowiedzi do pyta kontrolnych .................................................. 281

Sowniczek

poj

......................................................................... 293

Skorowidz .................................................................................... 301

Rozdzia 6.

Zabezpieczenie programów
przed debugerami

6.1. Wstp

Wykrywanie aktywnych debugerów oraz programów zrzucajcych fragment pamici
typu

ProcDump

to czynno, która moe by opacalna, jednak nie jest tak prosta, jak

si wydaje. Istnieje wiele wyrafinowanych sztuczek wykrywajcych te programy, jednak
zdecydowana wikszo z nich wykrywa dokadnie okrelone programy, jak na przykad
SoftIce czy OllyDbg, i w dodatku czsto tylko okrelone ich wersje. Najgorsz infor-
macj jest jednak to, e istnieje mnóstwo atek i rozszerze popularnych debugerów,
które zabezpieczaj si przed wykryciem. Programy te po modyfikacjach (wykona-
nych czsto przez samych krakerów dla siebie) ukrywaj si i stosuj techniki mylce.
Dlatego wykrywanie debugerów jest zadaniem czsto skazanym na porak. Zwykle
jest si pó kroku do tyu, a nawet jeli uda nam si poprzez zaimplementowanie
wielu technik jednoczenie wykry skutecznie wszystkie istniejce debugery, to i tak
jest to tylko chwilowe zwycistwo, bo za chwil powstan takie, których nie wykry-
jemy. Jest to wic typowe leczenie objawów, a nie przyczyn choroby.

Nie oznacza to, e nie naley w ogóle przejmowa si problemem i nie stosowa adnych
zabezpiecze. Jednak jeli Czytelnik nie jest geniuszem assemblera, powinien zostawi
to zadanie innym i uy do tego celu programu pobranego z internetu. Jest ich wiele,
zarówno darmowych, jak i patnych. Do tych drugich nale m.in. opisane w rozdziale
drugim TheMida czy AsProtect. Dziki temu zaoszczdzimy sobie czasu na próby,
których wyniki mog by wtpliwe, a co wicej, których rezultat ciko bdzie nam
zweryfikowa, poniewa nie bdziemy dysponowa odpowiedni iloci wersji debuge-
rów. Procedury kontrolujce dziaanie takich programów nie musz by niestandar-
dowe i dlatego warto pozostawi je fachowcom.

168

Bezpieczne programowanie. Aplikacje hakeroodporne

Z tych wanie powodów w rozdziale tym nie znajdziecie wielu wyrafinowanych sztuczek
blokujcych debugery. Opisz jedynie kilka najprostszych, aby kady móg sobie wy-
robi opini na ten temat i w razie potrzeby poszuka bardziej zaawansowanych in-
formacji w innych ródach. Zamiast tego skupi si na ogólnych metodach utrudniania
debugowania, które mog by uyteczne niezalenie od stosowania funkcji wykry-
wajcych debugery lub komercyjnych systemów zabezpiecze, które równie takowe
funkcje posiadaj.

6.2. Wykrywanie debugerów

Najprostszym sposobem wykrywania debugerów jest wstawienie do kodu po prostu:

if(IsDebuggerPresent())

// wykonaj jaki kod, np. zamknij program;

Mona to atwo przetestowa, wpisujc w miejsce komentarza na przykad polecenie
wywietlenie jakiego komunikatu i uruchamiajc aplikacj krok po kroku w Visual
Studio. Debuger VS zostanie wykryty i program wywietli komunikat. Uruchamiajc
program z pliku wykonywalnego, nie zobaczymy komunikatu.

Tego typu zabezpieczenie bdzie jednak cakowicie nieskuteczne w przypadku za-
awansowanych debugerów uywanych przez krakerów, takich jak SoftIce czy OllyDbg.
Wamywacze uywaj zmodyfikowanych wersji tych programów, które s zabezpie-
czone nie tylko przed opisan powyej weryfikacj, ale take przed wieloma bardziej
zaawansowanymi metodami. Twój program musiaby mie naprawd szerok gam
testów, aby mona byo mie pewno wykrycia wikszoci mutacji tych debugerów.
Dlatego wanie lepiej jest uy gotowego narzdzia wykonanego przez specjalistów,
a samemu skupi si na innych zabezpieczeniach. Jako ciekawostk podam jeszcze
przykady dwóch rozwiza tego typu:

mov ah,43h
int 68h
cmp eax,0F386h
jz mamy_debugger

W tym tecie próbujemy zbada, czy uruchomiony zosta program SoftIce poprzez
wykrywanie sterownika debugera systemowego. Kolejny przykad opiera si na wy-
krywaniu

int 41h

uywanego przez debugery:

xor ax,ax
mov es,ax
mov bx, cs
lea dx, int41handler
xchg dx, es:[41h*4]
xchg bx, es:[41h*4+2]
in al, 40h
xor cx,cx
int 41h
xchg dx, es:[41h*4]
xchg bx, es:[41h*4+2]

Rozdzia 6.

i Zabezpieczenie programów przed debugerami

169

cmp cl,al
jnz si_jest

int41handler PROC
mov cl,al
iret
int41handler ENDP

Obydwa powysze przykady wykrywania debugera SoftIce pochodz ze strony:
http://4programmers.net/Assembler/FAQ/Wykrywanie_debuggera_(SoftICE)

1

.

6.3. Utrudnianie debugowania

6.3.1. Wstawki kodu utrudniajce debugowanie

Utrudnienie debugowania mona wykona, wklejajc w wiele miejsc kodu ródowego
programu relatywnie nieskomplikowane wstawki. Jeli uywamy jzyka C/C++, sprawa
jest prosta, moemy bowiem wykorzysta makra preprocesora, co w poczeniu z twór-
czym uyciem instrukcji skoku bezwarunkowego (tak oczerniane przez wszystkich

goto

), wstawek assemblerowych czy konstrukcji takich jak

setjmp

czy

longjmp

, moe

solidnie skomplikowa ledzenie programu w debugerze. Wane jest, aby tego typu
wstawki pozostaway neutralne dla kodu.

Oto przykad:

jmp_buf env;
#define AD(kod, numer) if( setjmp(env) == 0 )

\

{

\

goto skok_ad_##numer;

\

}

\

else

\

{

\

kod;

\

}

\

goto koniec_ad_##numer;

\

skok_ad_##numer:

\

longjmp(env, 1);

\

koniec_ad_##numer:

\

;

Powysze makro wstawia kod wygldajcy mniej wicej tak:

if( setjmp(env) == 0 )
{

goto skok_ad_1;

}
else

1

Tre udostpniona na zasadach licencji Creative Commons Attribution:
http://creativecommons.org/licenses/by/2.0/pl/legalcode.

170

Bezpieczne programowanie. Aplikacje hakeroodporne

{

// WACIWY FRAGMENT KODU

}
goto koniec_ad_1;
skok_ad_1:

longjmp(env, 1);

koniec_ad_1:

W trakcie wykonania instrukcja

setjmp(env) == 0

wywoana po raz pierwszy ustawi

punkt powrotu dla skoku

longjmp

na miejsce swojego wywoania oraz zwróci warto

TRUE

. W zwizku z tym kolejn wykonywan instrukcj bdzie

goto skok_ad_1

. Nastpnie

wykona si

longjmp(env,1)

, które spowoduje przesunicie wykonania z powrotem do

pierwszej linii kodu. Tym razem jednak warunek nie bdzie ju speniony i wykonany
zostanie cig instrukcji oznaczony jako

WACIWY FRAGMENT KODU

. Na koniec instrukcja

goto koniec_ad_1

zapewni prawidowe opuszczenie tego bloku kodu. Caa konstrukcja

ma wple w kod kilka dziwnych i zaciemniajcych sens skoków wyduajcych
i utrudniajcych ledzenie wykonania w debugerze. Oczywicie powinna by uyta
w programie wiele razy, aby by naprawd skuteczn.

Uycie makra jest nastpujce. Kod, który zaciemniamy, otacza si wywoaniem makra:

AD(kod, x)

. Pewn wad tego makra jest to, e trzeba go wywoywa z dodatkowym

parametrem, który za kadym razem musi by inny. To, co przed zaciemnieniem wy-
glda tak:

for( int i = 0; i < 10; i++)
for( int j = 0; j < i; j++)

if( x[i] < x[j])

{

int tmp = x[i];
x[i] = x[j];
x[j] = tmp;

}

po — bdzie wyglda tak:

AD(
for( int i = 0; i < 10; i++)

for( int j = 0; j < i; j++)

AD(if( x[i] < x[j])
{

int tmp = x[i];
AD(x[i] = x[j] ,2);
AD(x[j] = tmp ,3);

}
, 1)

, 0)

Inne makra mog korzysta wprost ze wstawek assemblerowych:

#define WSTAWKA_START_ASM __asm PUSH EAX __asm PUSH EBX __asm PUSH ECX __asm PUSHF

#define WSTAWKA_STOP_ASM __asm POPF __asm POP ECX __asm POP EBX __asm POP EAX

#define WSTAWKA_PUSTA_1 WSTAWKA_START_ASM __asm MOV EAX, ECX __asm MOV EAX, 0 __asm
´ADD EAX, 0xD007 _asm MOV EBX, EAX WSTAWKA_STOP_ASM

Rozdzia 6.

i Zabezpieczenie programów przed debugerami

171

#define WSTAWKA_PUSTA_2 WSTAWKA_START_ASM MAKE_DUMMY_1 __asm TEST EAX, EAX __asm
´PUSHF __asm POP EAX __asm MOV EAC, EAX MAKE_STOP_ASM

#define WSTAWKA_PUSTA_3 WSTAWKA_START_ASM __asm MOV EAX, EBX __asm ADD EAX, 0x01ac
__asm PUSH EAX __asm MOV EAX, EBX __asm POP EBX WSTAWKA_STOP_ASM

Powysze kody nie maj adnego sensu, natomiast nie zmieniaj stanu rejestrów ani
flag (dziki uyciu makr

WSTAWKA_START_ASM

i

WSTAWKA_STOP_ASM)

. Uycie jest proste:

wywoanie makra wstawia si po prostu do kodu.

for( int i = 0; i < 10; i++)
for( int j = 0; j < i; j++)

if( x[i] < x[j])

{

WSTAWKA_PUSTA_3
int tmp = x[i];
WSTAWKA_PUSTA_3 WSTAWKA_PUSTA_2
x[i] = x[j];
WSTAWKA_PUSTA_3 WSTAWKA_PUSTA_1 WSTAWKA_PUSTA_3
x[j] = tmp;

WSTAWKA_PUSTA_2

}

Prawda, e proste? Polecam obejrzenie kodu assemblerowego wygenerowanego przez
kompilator dla kadej z trzech powyszych wersji kodu. Powiciwszy 3 – 4 godziny,
mona wyprodukowa kilkanacie czy nawet kilkadziesit podobnych fragmentów
kodu i uy ich w setkach miejsc, wykonujc po prostu prac typu kopiuj/wklej. Nie
powstrzyma to samo w sobie adnego krakera, ale utrudni mu nieco prac. Oczywi-
cie takie wstawki wyduaj kod oraz nieznacznie spowalniaj jego wykonanie. Jeli
jednak bdziemy uywa ich wycznie w najbardziej krytycznych fragmentach pro-
gramu, dotyczcych zabezpiecze, to jest to opacalne. Zwaszcza e przy dzisiej-
szych prdkociach procesorów tych kilkadziesit instrukcji maszynowych nie bdzie
duym obcieniem.

Powysze makra s banalne i maj wycznie posuy jako przykad tego, co mona
robi. W prawdziwym systemie warto posiedzie nieco duej i doda nastpujce
elementy:



Wstawki assemblerowe z du iloci skoków wymieszanych bez adu, na
przykad:

WSTAWKA_START_ASM

__asm JMP skok_1x;

skok_1x: __asm TEST EAX,EBX;

__asm JMP skok_3x;

skok_5x:

__asm MOV EAX, EBX;
__asm JMP skok_4x;

skok_2x: __asm MOV EAX, ECX;

__asm JMP skok_5x;

skok_4x: __asm POPF;

__asm JMP skok_6x;

skok_3x: __asm MOV EAX, 0;

__asm PUSH EAX;
__asm MOV EAX, EBX;

172

Bezpieczne programowanie. Aplikacje hakeroodporne

__asm TEST EAX, EAX;
__asm JNZ skok_4x;
__asm JMP skok_2x;

skok_6x: __asm MOV EAX,EBX;
WSTAWKA_STOP_ASM



Uycie nie tylko skoków bezwzgldnych, ale take duej iloci zagniedonych
funkcji oraz skoków warunkowych (jak w powyszym przykadzie skok

JNZ

).



Wstawianie instrukcji, które nie bd nigdy wykonane, w poblie waciwego
kodu. Mona tego dokona poprzez skoki. Ciekaw instrukcj, któr mona
w takie miejsce wstawi, jest

__asm int 3

, czyli instrukcja przerwania

programowego.



Mona nawet pokusi si o sterowanie przepywem wykonania za pomoc
wyjtków.

Przez cay czas powinnimy mie jednak na uwadze to, e jest to tylko dodatek, i uwaa,
aby nie zaciemni sobie kodu nadmiernie.

6.3.2. Generator wstawek kodu utrudniajcych

debugowanie

Makra, o których pisaem powyej, to interesujca technika, ale maj one kilka wad:



Nie kady jzyk posiada makra preprocesora. Mona jeszcze ratowa si uyciem
funkcji rozwijanych w miejscu wywoania (

inline

), ale nie zawsze i nie

wszystko uda si nimi zastpi.



Makra pisane rcznie s zazwyczaj schematyczne. Ciko je sparametryzowa
czy zmienia im dynamicznie tre.



Nawet najwygodniejsze w uyciu widniej w kodzie ródowym, zmniejszajc
jego czytelno oraz utrudniajc testowanie (i debugowanie, ale w kocu po to
zostay napisane).

Lepszym rozwizaniem bdzie wic zostawienie wersji deweloperskiej kodu w stanie
czystym i wstawianie kodu antydebugowego przez automat dopiero w procesie pro-
dukcji oprogramowania. Dziki uyciu zautomatyzowanych systemów produkcji
oprogramowania takich jak na przykad CruiseControl .NET, systemów kontroli wer-
sji takich jak CVS czy SVN oraz narzdzi skryptowych takich jak NANT, Python czy
Ruby proces ten nie powinien by skomplikowany. Wyglda on nastpujco:



Prace deweloperskie wykonywane s przez programistów. Programista,
koczc prace, wysya kod ródowy do repozytorium systemu kontroli wersji.



Automat pobiera zmodyfikowane róda do swojej lokalnej kopii.



Prekompilacja — wygenerowanie przez automat wstawek antydebugowych
i wstawienie ich do kodu.



Kompilacja zmodyfikowanego kodu.



Wykonanie testów automatycznych.

Rozdzia 6.

i Zabezpieczenie programów przed debugerami

173

Automat taki moe generowa wstawki losowo sporód zbioru elementów w miejsca
oznaczone w kodzie w specyficzny sposób. Dziki temu jedyne, co musi zrobi pro-
gramista, to wstawi takie oznaczenia wszdzie, gdzie chce. Moe to by na przykad
specyficzny komentarz:

// ZABEZPIECZ
for( int i = 0; i < 10; i++)
for( int j = 0; j < i; j++)

if( x[i] < x[j])

{
// ZABEZPIECZ

int tmp = x[i];

// ZABEZPIECZ

x[i] = x[j];

// ZABEZPIECZ

x[j] = tmp;

// ZABEZPIECZ

}

// ZABEZPIECZ

Na pycie CD znajduje si kod ródowy programu GenerujZabezpieczenia napisanego
w jzyku C#. Jest to program uruchamiany z linii polece, którego jedynym parametrem
jest cieka do pliku ródowego (w jzyku C++), w którym wstawki

// ZABEZPIECZ

maj zosta zmienione na wstawki antydebugowe. Czytelnik moe rozbudowa i zmody-
fikowa go wedug wasnych potrzeb. Mona zmieni go w nastpujcy sposób:



Dodanie wikszej iloci elementów sucych do generowania wstawek.



Dodanie generacji wstawek dla rónych jzyków programowania.



Dodanie generacji kilku rodzajów wstawek, w tym parametryzowanych.



Stworzenie bardziej skomplikowanych wstawek.



Stworzenie mniej schematycznych wstawek.

Naley przy tym pamita o tym, e program po prostu wstawia wstawk tam, gdzie
zobaczy stosowny tekst. Moe wic si zdarzy, e kod ródowy po modyfikacji nie
bdzie si kompilowa lub w ogóle nie bdzie dziaa. Zaley to od sposobu uycia
oznakowania wstawek. Jeli ich tre pojawi si w nietypowym miejscu, na przykad
w cigu znaków do wywietlenia na konsoli itp., to dziaanie programu moe zmieni
si na nieprawidowe.

Kod programu jest do prosty. Podstawow funkcj jest

ModyfikujPlik

, która odczytuje

plik, wyszukuje frazy

// ZABEZPIECZ

i podmienia je na losowo wygenerowane wstawki

assemblerowe. Generowane s dwa typy wstawek:



Statyczna — od 1 do 9 rozkazów assemblera wylosowanych z tablicy

statyczneWstawki

.



Faszywe skoki — trzy przeplatajce si fragmenty kodu (wylosowane jak wstawka
statyczna).

174

Bezpieczne programowanie. Aplikacje hakeroodporne

Oto gówna funkcja:

static void ModyfikujPlik(string acieka)

{
// odczyt pliku
TextReader reader = new StreamReader(acieka,

´System.Text.Encoding.Default);

string zawarto = reader.ReadToEnd();
reader.Close();

// modyfikacja zawartoci
int ile = 0;
while (zawarto.IndexOf(oznaczenieWstawki) != -1)
{
int indeksWstawki = zawarto.IndexOf(oznaczenieWstawki);
string wstawka = UtwórzWstawk();
zawarto = zawarto.Substring(0, indeksWstawki) + wstawka +

´zawarto.Substring(indeksWstawki + oznaczenieWstawki.Length);

ile++;
}

// zapis pliku
TextWriter writer = new StreamWriter(acieka, false,

´System.Text.Encoding.Default);

writer.Write(zawarto);
writer.Close();

Console.WriteLine(acieka + " zosta zmodyfikowany "

´+ ile.ToString() + " razy");

}

Pojedyncz wstawk tworzy funkcja

UtwórzWstawk()

:

static string UtwórzWstawk()
{
string cigPodmiany = pocztekWstawki;
int ile = rd.Next(1, 3);
for (int i = 0; i < ile; i++)
{
if(rd.Next(0,2) == 0)
cigPodmiany += UtwórzSztuczneSkoki();
else
cigPodmiany += UtwórzStatycznWstawk();
}
return cigPodmiany + koniecWstawki;
}

T funkcj zmodyfikuj, jeli chcesz mie wicej typów wstawek. Po prostu nie losuj
liczb z zakresu <0; 2), lecz wikszego, i zastp warunek instrukcj

switch

. Funkcje

UtwórzSztuczneSkoki

i

UtwórzStatycznWstawk

wygldaj nastpujco:

static string UtwórzStatycznWstawk()
{
int ile = rd.Next(1, 10);
string retWart = "";
for (int i = 0; i < ile; i++)

{

Rozdzia 6.

i Zabezpieczenie programów przed debugerami

175

retWart += statyczneWstawki[rd.Next(0, statyczneWstawki.Length)] +

´"\r\n";

}

return retWart;
}

static string UtwórzSztuczneSkoki()
{
string retWart = "";
string etykieta1 = UtwórzEtykiet();
string etykieta2 = UtwórzEtykiet();
string etykieta3 = UtwórzEtykiet();
retWart += "__asm JMP " + etykieta1 + ";\r\n";
retWart += etykieta2 + ":" + UtwórzStatycznWstawk();
retWart += "__asm JMP " + etykieta3 + ";\r\n";
retWart += etykieta1 + ":" + UtwórzStatycznWstawk();
retWart += "__asm JMP " + etykieta2 + ";\r\n";
retWart += etykieta3 + ":" + UtwórzStatycznWstawk();
return retWart;
}

Druga z nich tworzy skoki ukadajce si w cig:

1.

Id do 3

2.

Id do 4

3.

Id do 2

4.

Koniec

Pomidzy nimi znajduj si statyczne wstawki wygenerowane przez

UtwórzStatyczn-

Wstawk ()

, której z kolei kod jest tak prosty, e raczej nie trzeba go objania. Warto

jeszcze doda, e kada wstawka zaczyna si odoeniem stanu rejestrów i flag na
stos, a koczy pobraniem ich stamtd. Dziki temu stan programu nie zmienia si.

Zadania do samodzielnego wykonania

1.

Rozwi program GenerujZabezpieczenia zgodnie z sugestiami w treci rozdziau.

Pytania kontrolne

P 6.1. Jakie s wady makr antydebugowych
wstawianych rcznie do kodu?

a)

S cakowicie nieskuteczne i nie przeszkadzaj krakerom.

b)

W niektórych jzykach programowania ich implementacja moe by trudna.

176

Bezpieczne programowanie. Aplikacje hakeroodporne

c)

Nie jest atwo napisa takie makra nieschematycznie, zwykle s podobne do
siebie.

d)

Znajduj si w kodzie ródowym, co zaciemnia go i utrudnia testowanie.