Windows 32 bit-asm

SÜLEYMAN DEMİREL ÜNİVERSİTESİ
SİBER GÜVENLİK LABORATUVARI
Windows 32-Bit Assembly
İsmail BOZKURT

This Tutorial About
SDÜ-CYBERLAB Assembly
 Workshop Amacı:
Amacımız windows işletim sistemi üzerinde tersine mühendislik yapmak isteyen
arkadaşlara kod analiz edilirken işlemlerin sırası, api yapısı ve kullanımı, shellcode
yazımı konusunda giriş seviyesinde bir eğitim verektir.
 Kullanılan Toollar:
• WinDBG
• HexWorkshop
• Immunity Debugger
• GVIM
• Notepad++
 Kullanılan İşletim Sistemi
• Windows XP 32 bit sp3

Digits System
 Binary Sayı Sistemi
• Bilgisayar sistemleri binary sayi sistemi üzerine kurulmuştur.
• 0 -> Voltaj 0 Volt, 1 -> Voltaj 5 Volt.
• Binary sayi sistemini iyi anlamak, bu eğitimde öğreneceğimiz assembly dili için çok önemli !
• Sayinin binary formatta olduğunu belirtmek için <0b> tagını sayinin başına ekleriz.
• 23’ten büyük 2’nin katı olan en yakın sayı seçilir. Bu örnekte
25
𝑠𝑒ç𝑖𝑦𝑜𝑟𝑢𝑧. 𝑌𝑎𝑛𝑖 𝑏𝑖𝑛𝑎𝑟𝑦 𝑠𝑎𝑦𝚤𝑚𝚤𝑧𝑑𝑎 [][][][][] slotumuz olur.
• [ ] [ ] [ ] [ ] [ ]
• 24
23
22
21
20
• 23 sayısının binary karsılığı hesaplarken 23’e en yakın 2 nin katı secilir ve sayi 1 yada 0 olana dek aynı
işlem tekrarlanır.
• Çıkartılan 2’nin katlarını boş slotlarımızda 1 degerini veririz.
• 24
= 16, 23
= 8, 22
= 4, 21
= 2, 20
= 1
• 1. Adim : 23 – 16[24
] = 7
• 7 – 4[22
] = 3
• 3 – 2[21
] = 1[20
]
• 0b[1][0][1][1][1] = 23.

Digits System
 Hexedecimal Sayı Sistemi
• Hexedecimal sayi sistemi bellek adreslerini ifade ederken kullanırız.
• 0x00406010 şeklinde bellekte adresleri görürüz.
• Hexedecimal sayi sistemini iyi anlamak, bu eğitimde öğreneceğimiz assembly dili için çok önemli !
• Hexedecimal sayi sistemindeki sayilar: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A[10], B[11], C[12], D[13], E[14], F[15]
• Sayinin hexedecimal olduğunu belirtmek için sayinin başına <0x> tagını ekleriz.
• 0x10111 sayisinin hexedecimal karşığını hesaplarken binary sayinin sağından başlayarak 4’erli gruplar
halinde ayırırız.
• 0b0001 ve 0b0111 olur.
• 0b0001 = 1 ve 0b0111 = 7 olur.
• 23 sayısının Hexedecimal karşılığı: 0x17 olur.

Logic Operations
 XOR Kapısı

Logic Operations
 OR Kapısı

Logic Operations
 AND Kapısı

Logic Operations
 NOT Kapısı

Working With Binaries
 5 ^ 3 = ?
Click to add
text
5 = 0b0101
3 = 0b0011
101
011
^ -----
0b111 = 6.
5 = 0b0101
3 = 0b0011
101
011
| -----
0b111 = 7.
5 = 0b0101
3 = 0b0011
101
011
& ----
0b001 = 1.
XOR OR AND NOT
 5 | 3 = ?  5 & 3 = ?  !5
5 = 0b0101
101
! ----
0b010 = 2.

X86 Memory Segments
0xFFFFFFFF
0x00000000

x86 Memory Segments
• Stack : Bellek üzerinde bir veriyi tekrar tekrar kullanmak istediğimizde veya
bir fonksiyona girdiğimizde fonksiyonların argumanlarını tutmak amacıyla
sakladığımız hafıza alanıdır. Register’lardan sonra belleğin en hızlı alanıdır.
Stack LIFO(Last In First Out) mantığıyla çalışır. Yani stack’e attığımız son
eleman stack’ten ilk alınmaktadır.
 Hafızadaki hangi alan ne için kullanılır ?

x86 Memory Segments
• İnitialized ???
• Örnek üzerinden anlatmak gerekirse:
#include <stdio.h>
int main(){
int a;  uninitialized
int b=5;  initialized
}
• Heap : Dinamik bellek alanımızdır. Malloc(), alloc(), free() gibi fonksiyonlar
ile bu alandan yer isteyip kullanabilir ve alınan alanı geri verebiliriz.
Stack’ten farklı olarak bu alanımız FIFO(First In First Out) mantığıyla calisir.
• .Text : Assembly kodlarımızı yazdığımız, programcının kodlarının
çalıştırıldıgı alandır.
• .bss : data segmentimizdeki uninitialized data’ların tutulduğu hafıza
alanıdır.
• .data : data segmentimizdeki initialized data’ların tutulduğu hafıza alanıdır.

Binary Add and Sub Operations
22 – 7 = 15 Bu işlemi bilgisayarlarımız nasıl yapıyor ?
22 = 0b10110
7 = 0b00111
• 0b00111 sayisinin her bir bitini NOT işlemine tabi tutuyoruz.  0b11000
• Ardından en değersiz bit’ine 1 ekliyoruz.  0b11001
• Şimdi 22 sayisiyla birlikte topluyoruz.
10110
11001
+ --------
1[01111]  En baştaki bir değerimiz sayımızın negatif olduğunu belirtir.
0b1111 sayisinin decimal karşığı : 15

Signed Numbers Operations
• Bellekte negatif sayilari ifade ederken binary sayının ilk biti ‘1’ ile başlamaktadır.
8 bitlik alanda inceleyelim.
Örneğin: 79 sayisi
79: 0100 1111
Her bir biti NOT işlemine sokarız.
1011 0000 + 20
= 1011 0001 -79 olur.

Registers
• EAX : Acumulator Register.
• EBX : Base Register.
• ECX : Counter Register
• EDX : Data Register
• ESI : String işlemlerinde string’in indexlerine ulaşmakta kullanılır.
• EDI : String işlemlerinde string’in kopyalanmak istenilen adresin indexleri tutar.
• ESP : Stack Pointer. Stack’in en üstündeki verinin adresini işaret eder.
• EBP : Base Pointer. Fonksiyon arguman ve local degiskenlere ulaşmada kullanılır.
• EIP : Instructor Pointer. Bir sonraki calistirilacak komutun adresini işaret eder.
EAX,EBX,ECX,EDX temelde birbirlerinden hiç bir farkı yoktur.

Registers

Registers Logic
0 15 31
0 7 15 23 31
EAX(Extended Acumulator Register)
Örneğin:
eax = 0xABCD1234
ax = 0x1234
ah = 0x12
al = 0x34

Flag Registers
16 bitlik özel register’lardır.
• CF(Carry Flag)  Toplama,çıkarma gibi işlemlerde taşan bit bu flage set edilir.
• PF(Parity Flag)  Binary sayının bitlerindeki 1 sayılarının toplamı çift ise set edilir.
• ZF(Zero Flag)  İşlemin sonucu 0 ise bu flag set edilir.Şartlı dallanmalarda kullanılır.
• SF(Sign Flag)  İşlemin sonucu negatif ise bu flag set edilir.
• TF(Trap Flag)  Flag set edilirse program durdurulur.
• OF(Overflow Flag)  İşaretli sayılar üzerindeki taşma olursa bu flag set edilir.
• IF(Interrupt Flag)  CPU’nun çeşitli aygıtlardan kesme isteklerini dikkate almak
istenildiğinde bu flag set edilir.
• DF(Direction Flag)  Bu flag dizgi işlemleri üzerindeki işlemin yönün belirlemek için kullanılır.
Bazı assembly instruction’ları flagleri set veya reset eder.
Örneğin:
xor eax, eax  eax = 0
xor ebx, ebx  ebx = 0
cmp eax, ebx  işlemi sonucu ZF=0 olarak set edilir.

Segment Registers
• Segment register’ları programımızın bilgisayarın belleğe yüklendiği zaman bellek içerisinde
oluşturulan bölümlerin başlangıç adreslerini tutar.
• CS(Code Segment) : Programımızın çalıştırılabilir bellek bölgesinin başlangıç adresini tutar
• DS(Data Segment) : Programımız içerisindeki değişkenlerin saklandığı bölümdür.
• SS(Stack Segment) : Programımız için ayrılan stack bölümünün başlangıç adresini tutar.
• ES(Extra Segment) : Dizgi işlemlerinde kullanılır.

Some Assembly Commands
• MOV : 2 parametre alır. 2.ci parametredeki degeri 1. parametreye kopyalar.
Örn: mov eax, 5 ;5 değerini eax registerina kopyaladik
• ADD : 2 parametre alır. 2.nci parametre ile 1.nci parametreyi toplar ve 1.nci parametreye
yazar.
Örn: mov eax, 5
add eax, 3 ;işlem sonucu eax = 8 olur.
• SUB : 2 parametre alır. 2.nci parametre’den 1.nci parametreyi çıkartır ve sonucu 1.nci
parametrede tutar.
Örn: mov eax, 8
sub eax, 5 ;işlem sonucu eax = 3 olur.
• INC : 1 parametre alır. Aldığı parametredeki değeri 1 artırır.
• DEC : 1 parametre alır. Aldığı parametredeki değeri 1 eksiltir.
Örn: xor eax, eax
inc eax ; işlem sonucu eax = 1 olur.
dec eax ; işlem sonucu eax = 0 olur.
• CMP : 2 parametre alır. İki argumanı karşılaştırır ve sonuca göre flagler set edilir.

• MUL: 1 parametre alır. Diğer instructionlardaki gibi basit değil biraz kafa karıştırıcıdır.
Çarpma işlemine sokulan değer kaç bitlik ise(örn:32 bit) işlem sonucu 64 bitlik bir
alana yazilir.
Örnek üzerinden anlamaya çalışalım.
Örn: mov eax, 0x00000044
mov ecx, 0x00000002
mov edx, 0x41424344
mul ecx ; burada işlemciye ecx registeri
ile eax registerini kısmını çarp. Sonucu edx ve eax
registerlarında tut. İşlem sonucu:
eax = 0x00000088
ecx = 0x00000002
edx = 0x00000000
• mul si : işlem sonucu dx:ax registerlarında tutulur. İşlemin low kısmı ax, high
kısmı dx registerinda tutulur.

• DIV(Unsigned Division) : 1 arguman alır. Bölme işlemleri için kullanılır.
Genelde bellekte görmeyiz.
• Arguman 8 bitlik ise:
Örn: al  ax / arg
ah  ax % arg
• Arguman 32 bitlik ise:
Örn: eax  edx:eax / arg Bölümün sonucu
edx  edx:eax % arg Bölümden kalan
• Örn:
mov eax, 0x00000044
mov edx, 0x00000000
mov ebx, 0x00000002
div ebx ; eax registeri ile ebx registeri bölme işlemi
gerçekleştirilir. İşlem sonucu eax = 0x00000021,
edx = 0x00000000 olur.

• STOS(Store String):
STOSB(Byte):
[edi]  al
edi’nin ilk byte’ina al’deki degeri atıyoruz.
STOSW(Word):
[edi]  ax
edi’nin ilk 2 byte’ina ax’deki degeri atıyoruz.
STOSD(Dword):
[edi]  eax
edi’nin ilk 4 byte’ina eax’deki degeri atıyoruz.
Bu komut DF(Direction Flag)’e göre EDI registerinin üzerinde gezer. Eger DF reset edilmişse
Soldan sağa, set edilmişse sağdan sola doğru hareket eder.
CLD(Clear Direction Flag)
STD(Set Direction Flag)

 Şartlı Dallanmalar
• Dallanmalar arguman olarak adres alır !
• JMP(Jump) : Belirtilen adrese koşulsuz dallanma gerçekleşir.
• JE(Jump if equals) : ZF=1 set edilmişse dallanma gerçekleşir.
• JZ(Jump if zero) : ZF=1 set edilmişse dallanma gerçekleşir.
• JNE(Jump if not equals) : ZF=0 set edilmişse(reset) dallanma gerçekleşir.
• JNZ(Jump if not zero) : ZF=0 set edilmişse dallanma gerçekleşir.
• JB(Jump if below)/JC(Jump if carry)/JNAE(Jump if not above or equals)
CF=1 set edilmişse dallanma gerçekleşir.
• JBE(Jump if blow or equals)/JNA(jump if not above) : CF=0 ise dallanma
gerçekleşir.
• Ve çok daha fazlası ...

Introduction The Fasm
 Neden FASM(Flat Assembler) ?
• Assembly ile proje geliştirme için elverişli.
• FASM’ı seviyoruz.
• Herhangi bir syntax hatası yapıldığında hatalı satır hata ayıklayıcısı tarafından
programcıya gösteriliyor.
• Daha çok FASM FASM FASM
• FASM ile çalışırken bilmemiz gerekenler
• .bss, .text, .data gibi segmentlerin tanımlanma şekli
• .idata nedir ? Ne işe yarar ? Yeniliyor mu ?
• include bulunamadı diyor mu ?
• FASM.exe’yi yola(PATH) eklemek nasıl oluyor ?

 FASM Yola Ekleme


 FASM Yola Ekleme
• ;C:Documents and SettingsreverseDesktopFASM
• FASM’ı yola eklememizin sebebi FASM.exe’yi komut satırında hangi
dizinde olursak olalım çağırabilmek için.

 FASM’da Bulunan INCLUDE Klasörünü Yola Ekleme

Introduction The FASM
 .text segment tanımlaması:
 section ‘.bss’ readable writeable
input_handle dd ?
 .bss segment tanımlaması:
 .data segment tanımlaması:
 section ‘.text’ code readable executable
start:
xor eax, eax
...
...
 section ‘.data’ data readable writeable
my_str db ‘’cyberlabsdu‘’,10,0

 .idata segment tanımlaması:
 section ‘.idata’ import data readable
library kernel32,’kernel32.dll’,
msvcrt,’msvcrt.dll’
import kernel32,
ExitProcess,’ExitProcess’,
WriteFile,’WriteFile’
Sonra cart cart cart

Welcome To ExitWorld !
 Assembly ile ilk basit programımız:
format PE console
entry start
include ‘win32a.inc’
section ‘.text’ code readable executable
start:
push 0
call [Exit]
section ‘.idata’ import data readable
library kernel32,’kernel32.dll’
import kernel32,
Exit,’ExitProcess’
• exit.asm şeklinde kaydedip console üzerinden « fasm exit.asm » şeklinde
derleyebilirsiniz.

Lets Talk About Conditional Branching
Assembly kodumuz:
format PE console
entry start
include ‘win32a.inc’
section ‘.text’ code readable executable
start:
mov eax, 5
my_loop:
dec eax
jnz my_loop
push 0
call [Exit]
section ‘.idata’ import data readable
library kernel32,’kernel32.dll’
import kernel32,
Exit,’ExitProcess’

Lets Play With Strings
mov eax, 1fh
cld
stosd
stosd
mov ax, 2255h
stosw
stosw

String işlemlerini daha iyi anlayabilmek için aynı işlevi yapan farklı farklı kodlar yazıcaz.
Challange1(Stosb):
format PE console
entry start
include 'win32a.inc'
MAX_ARRAY_LENGTH = 20h
section '.data' data readable writeable
my_str db 'SDUCYBERLABWIN32ASM!',0
bas db 'String uzunlugu: %d',10,0
section '.bss' readable writeable
target_str db MAX_ARRAY_LENGTH dup(?)
section '.text' code readable executable
import kernel32,
Exit,'ExitProcess'
import msvcrt,
printf,'printf'

start:
mov esi, my_str ;esi’de stringmiz tutuluyor
mov edi, target_str ;edi’de stringimizi kopyalayacagımız destination adresimiz
xor bl, bl ;stringin sonu kontrol registeri
xor edx, edx ;sayac
my_loop:
mov al, byte[esi + edx] ;stringmizin o andaki indexindeki
karakteri al registerina atıyoruz
inc edx ;sayacı artır
stosb ;al registerindaki degeri edi registerina kopyala
cmp bl, al ;string sonundamıyız ?
jnz my_loop ;sonundaysak devam et degilsek my_loop geri don.
push edx ;format string'izin isaret ettigi sayi
push bas ;.bss segmentimizdeki bas stringmiz
call [printf]; Do it
add esp, 8 ;Islem sonrasi stack'e attigimiz verileri temizliyoruz.

here_exit:
push 0
call [Exit]
section '.idata' import data readable
library kernel32,'kernel32.dll',
msvcrt,'msvcrt.dll'
import kernel32,
Exit,'ExitProcess'
import msvcrt,
printf,'printf'

Challange2(lodsb):
format PE console
entry start

start:
mov esi, my_str ;stringimizi esi registerina atiyoruz.
xor bl, bl ;stringimizin sonuna gelinip gelinmedigini sorgulamak icin ebx registerinin
8 byte'lik low kismini kullaniyoruz. bl=0
xor edx, edx ;edx registeri ile stringmizin uzunlugunu olcuyoruz.
my_loop:
inc edx ;sayaci artir
lodsb ;esi'de bulunan stringin indexindeki karakteri al registerina atadik.
cmp bl, al ;0 mi kontrol ettik
jnz my_loop ;Eger sifir degilse yaniyani string'in sonuna gelmemissek
my_loop'a don geldiysek yola devam
;Ekrana_bas
push edx ;format string'izin isaret ettigi sayi
call [printf] ; Do it
;Cikis
here_exit:
push 0
call [Exit]

msvcrt,'msvcrt.dll'
import kernel32,
Exit,'ExitProcess'
import msvcrt,
printf,'printf'

Challange3(movsb):
format PE console
entry start
MAX_ARRAY_LENGTH = 20h
section '.bss' readable writeable
target_str db MAX_ARRAY_LENGTH dup(?)

start:
mov esi, my_str
mov edi, target_str
xor al, al
xor ecx, ecx
my_loop:
inc ecx
cmp al, byte [esi]
movsb
jnz my_loop
push ecx ;format string'izin isaret ettigi sayi
call [printf] ; Do it
;Cikis
here_exit:
push 0
call [Exit]

Challange4(repz):
format PE console
entry start
yaz db 'String uzunlugu: %d',10,0

start:
mov edi, my_str ;Destionation index'e datamızı koyuyoruz.
mov ebx, edi ;String uzunlugunu net olarak almak icin edi'nin ilk adresini ebx
registerina atıyoruz.
xor al, al ;eax'in 8 byte'lık low kısmını sıfırlıyoruz. stringimizin sonuna geldik
gelmedik mi karşılaştırmasını "al" ile yapıyoruz.
repnz scasb ;repnz[repeat as long as not zero] scasb[scan string byte] :
yaniyani stringin sonuna gelene kadar tekrar et.
;scasb komutu edi registerinin degerini her seferinde 1 artırır.String
dizisinin bir sonraki karakterini al registeri ile karsılastır.
mov eax, edi ;yukarıdaki işlem tamamlandıgında edi registerinin son degeri
string'in son indexini gösteriyor olur.
sub eax, ebx ;burada edi'de bulunan string'in ilk byte'indan son byte'ini
cıkarıyoruz. and we got it our string length.

push eax ;format stringimize karsilik gelen deger yaniyani strigimizin uzunlugu !
push yaz ; .data sectiondaki "String uzu....."
call [printf] ;ekrana bastır
add esp,4*2 ; işlem sonucunda fonksiyondan cikildiginda fonksiyona vermek
icin stack'e attıgımız degerler oldugu gibi yerinde durdugu icin onları temizliyoruz.
push 0 ; exit cikis kodu
call [ExitProcess] ; do it

msvcrt,'msvcrt.dll'
import kernel32,
ExitProcess,'ExitProcess'
import msvcrt,
printf,'printf'

Lets Talk About Sub Routine
Sub Routine nedir ?
Sub Routine assembly kodumuz herhangi bir fonksiyonun mesela printf gibi herhangi bir fonksiyonun içerisine
dallandığında fonksiyona hangi adreste girdiğini, fonksiyondan çıktıktan sonra nereden devam edeceğini işlemcinin
bilmesi gerekiyor. İşlemcinin bunları yapabilmesi için kendi içerisinde bir kuralı vardır ve bunun adı subroutine olarak
geçer. Daha yakından bakalım.
print_str:
push ebp ;fonksiyona girdikten sonra ebp’yi kaydediyor.
mov esp, ebp ; stack’i fonksiyon için ayarlıyor
sub esp, 4*6 ;local değişkenler için stackten yer ayırıyoruz. Bu durumda pek gerekli olmasada.
push eax ;registerlar bizim için değerli ise esi,edi gibi registerlarda eklenebilir. Yada hepsini kaydetmek için pushad komutu kulllanılabilir.
push ebx
push ecx
push edx
push esi ;string veriliyor.
call [printf] ;ekrana yazdırılıyor.
add esp,4 ;stack’te en son pushlanan esi registerini temizliyoruz.
pop edx ;registarlari eski haline getiriyoruz.
pop ecx
pop ebx
pop eax
add esp, 4*6 ;local degiskenler için ayrılan alan geri veriliyor.
mov ebp, esp ;stack pointer fonksiyona girildiğindeki değerine geri dönderilyor.
pop ebp ;eski ebp fonksiyona girildiğindeki degerine donderiliyor.
ret ;ve fonksiyona girdiği adresten bir sonraki adrese yaniyani eip’nin işaret ettiği adrese donderiliyor.

Introduction Immunity Debugger

Introduction Immunity Debugger
Bazı kısayollar:
F7: Step in
F8: Step over
F9: Continue
F2: Break Point Soft
CTRL+G:Search
Daha fazlası için ImmLib -> Lib
References

Introduction The WinDBG
 WinDBG

 bp(break point) $exentry(programın başlangıç adresi)

 g(continue/go)

 t(step in)

 Memory

 r(show)/dd(data dword): 00401000 adresindeki verileri dword halinde göster !

 lm(list modules)

 u(stands for unassemble)

 a(stands for assemble): istedigimiz register’a yada adrese istedigimiz girdiyi vermemize
sağlar.

 ?: r komutuna benzerdir daha gelişmişidir. Genelde pointerlar’da kullanırız.

 poi(stands for pointer): Adresin işaret ettiği değeri elde etmemizi sağlar.

 s(search): Bellekte aradığımız adres içerisinde string,sayi ne istersek 2.arguman olarak
vererek arama yapmamızı sağlar.

Windows API Introduction
Yazılan programlar doğrudan işletim sistemine erişemez.
İşletim sistemi geliştiricileri programcıların işletim sistemi üzerinde kod geliştirmesi için
API dediğimiz özel fonksiyonlar geliştirmişlerdir.
API(Application Programming Interface)
Windows API’ler windows işletim sistemi üzerinde ‘.dll’(Dynamic Linked Library) dosyalarda
tutulur.

Dynamic Linked Library
DLL’ler çalıştırabilir bir dosyadır. Entry Point dediğimiz programımızın işletim sistemi
tarafından çalıştırılmaya başladığı başlangıç adresi dll dosyalarında bulunmamaktadır.
Herhangi bir çalıştırılabilir dosya dll dosyalarını kullanabilir.
DLL’ler fiziksel hafızaya sadece 1 kere yüklenirler ve birçok program tarafından defalarca
kullanılabilirler.
Her DLL işletim sistemine ait olmayabilir. Kendi dll dosyamızı istersek yazabiliriz.

Some DLL’s
Kernel32.dll
Dosya Sistemi, Hafıza Yönetimi, Processler, Threadler, Error Handler
User32.dll
Windows GUI
Gdi32.dll
Grafik: Monitor çıktısı, yazıcılar vs vs
Msvcrt.dll
String işlemleri ve daha bir çoğu.
Bir çok dll mevcut daha fazlası için msdn.com

API Samples
format PE console
entry start
start:
push 0 ;Exit cikis kodu
call [Exit] ;Exit fonksiyonunu cagiriyoruz.
library kernel32,'kernel32.dll' ;kernel32.dll dll'ini kernel32 adiyla tanimliyoruz.
import kernel32,
Exit,'ExitProcess' ;kernel32.dll dosyasindan ExitProcess
fonksiyonunu
;"Exit" programa import ediyoruz.

API Samples
format PE console
entry start
start:
push 0 ;Exit cikis kodu
call [Exit] ;Exit fonksiyonunu cagiriyoruz.
library kernel32,'kernel32.dll' ;kernel32.dll dll'ini kernel32 adiyla tanimliyoruz.
import kernel32,
Exit,'ExitProcess' ;kernel32.dll dosyasindan ExitProcess fonksiyonunu
;"Exit" programa import ediyoruz.

API Samples

API Samples
; Complex macro example
include 'win32ax.inc' ; complex macro include file is here
.code
start:
invoke MessageBox,HWND_DESKTOP,"Hi! I'm the example
program!",invoke GetCommandLine,MB_OK
invoke ExitProcess,0
.end start

Thanks
İletişim:
Mail: BozkurTR000@gmail.com
Linkedin: https://www.linkedin.com/in/ismail-bozkurtr-019059b1
Github: https://github.com/ismailbozkurt
Teşekkürler

Windows 32 bit-asm

Recommended

Recommended

More Related Content

Viewers also liked

Viewers also liked (15)

Similar to Windows 32 bit-asm

Similar to Windows 32 bit-asm (9)

Windows 32 bit-asm