elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Rompecabezas de Bitcoin, Medio millón USD en premios


  Mostrar Temas
Páginas: [1]
1  Programación / ASM / [ASM]Algoritmo de Ordenacion Quicksort en: 24 Junio 2009, 04:04 am
Bueno aqui les dejo una traduccion a ensamblador del algoritmo de QuickSort me costo algo de trabajo y estuve un buen depurando pero por fin salio.
Lo malo es que solo funciona con numeros de 32 bits positivos pero se puede arreglar para que funcionen con bytes y words (ahora lo de negativos no se intente cambiar jl y jg por jb y ja pero me los pone como mayores que cualquier positivo)

Si de casualidad alguien no entiende el codigo que me diga y le pongo comentarios   ;)

Código
  1. format pe console
  2. include '\fasm\include\win32ax.inc'
  3. entry start
  4. .data
  5. vector          dd      32,9,11,5,99,3,1,2,5,12,100,4365
  6. formato         db      '%i %i %i %i %i %i %i %i %i %i %i %i',13,10,0
  7. .code
  8. start:
  9.         call Dump
  10.         push 11
  11.         push 0
  12.         push vector
  13.         call quicksort
  14.         call Dump
  15.  
  16. ret
  17.  
  18. quicksort:
  19.          push ebp
  20.          mov ebp,esp
  21.          push esi
  22.          push ebx
  23.          push ecx
  24.          push edx
  25.          mov ebx,dword[ebp + 12]
  26.          mov ecx,dword[ebp + 16]
  27.          cdq
  28.          mov eax, ebx
  29.          add eax, ecx
  30.          push ecx
  31.          mov ecx,2
  32.          div ecx
  33.          pop ecx
  34.          xchg edx,eax
  35.          mov esi, [ebp + 8]
  36.          mov edx,dword[esi + edx * 4]
  37.          qs@L1:
  38.                 qs@L1@L1:
  39.                         cmp dword[esi + ebx * 4],edx
  40.                         jge qs@L1@L1@out
  41.                         inc ebx
  42.                         jmp qs@L1@L1
  43.                 qs@L1@L1@out:
  44.                 qs@L1@L2:
  45.                         cmp dword[esi + ecx * 4],edx
  46.                         jle qs@L1@L2@out
  47.                         dec ecx
  48.                         jmp qs@L1@L2
  49.                 qs@L1@L2@out:
  50.                 qs@L1@IF1:
  51.                         cmp ebx, ecx
  52.                         jg qs@L1@IF1@out
  53.                         mov eax, dword[esi + ebx * 4]
  54.                         xchg eax, dword[esi + ecx * 4]
  55.                         mov dword[esi + ebx * 4], eax
  56.                         inc ebx
  57.                         dec ecx
  58.                 qs@L1@IF1@out:
  59.                 cmp ebx,ecx
  60.                 jle qs@L1
  61.          qs@L1@out:
  62.          qs@IF1:
  63.                 cmp dword[ebp + 12],ecx
  64.                 jge qs@IF1@out
  65.                 push ecx
  66.                 push dword[ebp + 12]
  67.                 push esi
  68.                 call quicksort
  69.          qs@IF1@out:
  70.          qs@IF2:
  71.                 cmp ebx, dword[ebp + 16]
  72.                 jge qs@IF2@out
  73.                 push dword[ebp + 16]
  74.                 push ebx
  75.                 push esi
  76.                 call quicksort
  77.          qs@IF2@out:
  78.          pop edx
  79.          pop ecx
  80.          pop ebx
  81.          pop esi
  82.          pop ebp
  83. retn 12
  84.  
  85. Dump:
  86.         pushad
  87.         mov edi,vector
  88.         push dword[edi + 11 * 4]
  89.         push dword[edi + 10 *4 ]
  90.         push dword[edi + 9 * 4]
  91.         push dword[edi + 8 * 4]
  92.         push dword[edi + 7 * 4]
  93.         push dword[edi + 6 * 4]
  94.         push dword[edi + 5 * 4]
  95.         push dword[edi + 4 * 4]
  96.         push dword[edi + 3 * 4]
  97.         push dword[edi + 2 * 4]
  98.         push dword[edi + 1 * 4]
  99.         push dword[edi]
  100.         push formato
  101.         call [printf]
  102.         add esp,52
  103.         popad
  104. ret
  105. section '.idata' import data readable
  106. library msvc,'msvcrt.dll'
  107. import msvc,printf,'printf'
  108.  

los parametros se pasan por la pila
y son asi
quicksort(int *vector, int izq, int der)
2  Programación / ASM / [ASM]Syscall no me funciona + fallo de segmentacion en: 14 Junio 2009, 06:11 am
hola tengo un problema, estoy tratando de aprender algo de las syscalls de linux con asm pero tengo un problema, mi codigo no funciona, el comportamiento es el siguiente.

se supone que pide un texto e imprime su longitud pero sucede:
pide texto, falla de segmentacion
la consola toma lo que tecle y me dice como que si lo hubiera escrito como un comando ejemplo:
si en el programa pongo hola
no me imprime nada y despues la terminal me dice
bash: ola comando no encontrado

mi code es el siguiente

Código
  1. include '/home/nyox/include/linux.inc'
  2. format ELF executable
  3. entry start
  4. segment readable executable
  5.  
  6. start:
  7. 	mov eax,SYS_READ
  8. 	mov ebx, STDIN
  9. 	mov ecx,texto
  10. 	mov edx,size
  11. 	int 0x80
  12.  
  13. 	push texto
  14. 	call strlen
  15. 	push eax
  16. 	push numtexto
  17. 	call itoa
  18.  
  19. 	push numtexto
  20. 	call strlen
  21.  
  22. 	mov edx,eax
  23. 	mov eax, SYS_WRITE
  24. 	mov ebx, STDOUT
  25. 	mov ecx, numtexto
  26. 	int 0x80
  27.  
  28.  
  29. 	mov eax, SYS_EXIT
  30. 	xor ebx,ebx
  31. 	int 0x80
  32.  
  33. strlen:
  34. 	push edi
  35. 	xor ecx,ecx
  36. 	mov edi, [esp + 8]
  37. 	not ecx
  38. 	xor eax,eax
  39. 	cld
  40. 	repne scasb
  41. 	not ecx
  42. 	pop edi
  43. 	add eax,ecx
  44. 	dec eax
  45. 	retn 4
  46.  
  47. strrev:
  48.         push ebp
  49.         mov ebp,esp
  50.         push edi
  51.         mov edi,[ebp + 8]
  52.         push edi
  53.         call strlen
  54.         xor ecx,ecx
  55.         dec eax
  56.         jmp LL1
  57.         LL0:
  58.                 dec eax
  59.                 inc ecx
  60.                 cmp ecx,eax
  61.                 jge LL2
  62.         LL1:
  63.                 mov dl,byte[edi + ecx]
  64.                 xchg byte[edi + eax],dl
  65.                 mov byte[edi + ecx],dl
  66.                 jmp LL0
  67.  
  68.         LL2:
  69.         pop edi
  70.         pop ebp
  71. retn 4
  72.  
  73. itoa:
  74.       push ebp
  75.       mov ebp,esp
  76.       pushad
  77.       mov edi,[ebp + 8]
  78.       mov eax,[ebp + 12]
  79.       mov ebx,10
  80.       L@@1:
  81.         xor edx,edx
  82.         div ebx
  83.         xchg eax,edx
  84.         or eax,48
  85.         stosb
  86.         mov eax,edx
  87.         cmp eax,0
  88.         jnz L@@1
  89.         inc edi
  90.         mov byte[edi],al
  91.         push dword[ebp + 8]
  92.         call strrev
  93.       popad
  94.       pop ebp
  95. retn 8
  96.  
  97. numtexto	db	5 dup(0)
  98. texto	db	10 dup(0)
  99. size 	dd	9
  100.  

SYS_WRITE = 4
SYS_READ = 3
STDIN = 0
STDOUT = 1

el codigo rula perfectamente en win aunque no es lo mismo porque uso printf y scanf asi que supongo que mi error esta en el uso de las syscalls a ver si me pueden echar una mano

el code en win es

Código
  1. format PE console
  2. entry start
  3. include 'c:\fasm\include\win32ax.inc'
  4. .code
  5.  
  6. start:
  7.         invoke scanf,"%s",texto
  8.  
  9.         push texto
  10.         call strlen
  11.         push eax
  12.         push numtexto
  13.         call itoa
  14.  
  15.         push numtexto
  16.         call strlen
  17.  
  18.         invoke printf,numtexto
  19. leave
  20. ret
  21.  
  22. strlen:
  23.         push edi
  24.         xor ecx,ecx
  25.         mov edi, [esp + 8]
  26.         not ecx
  27.         xor eax,eax
  28.         cld
  29.         repne scasb
  30.         not ecx
  31.         pop edi
  32.         add eax,ecx
  33.         dec eax
  34.         retn 4
  35.  
  36. strrev:
  37.         push ebp
  38.         mov ebp,esp
  39.         push edi
  40.         mov edi,[ebp + 8]
  41.         push edi
  42.         call strlen
  43.         xor ecx,ecx
  44.         dec eax
  45.         jmp LL1
  46.         LL0:
  47.                 dec eax
  48.                 inc ecx
  49.                 cmp ecx,eax
  50.                 jge LL2
  51.         LL1:
  52.                 mov dl,byte[edi + ecx]
  53.                 xchg byte[edi + eax],dl
  54.                 mov byte[edi + ecx],dl
  55.                 jmp LL0
  56.  
  57.         LL2:
  58.         pop edi
  59.         pop ebp
  60. retn 4
  61.  
  62. itoa:
  63.       push ebp
  64.       mov ebp,esp
  65.       pushad
  66.       mov edi,[ebp + 8]
  67.       mov eax,[ebp + 12]
  68.       mov ebx,10
  69.       L@@1:
  70.         xor edx,edx
  71.         div ebx
  72.         xchg eax,edx
  73.         or eax,48
  74.         stosb
  75.         mov eax,edx
  76.         cmp eax,0
  77.         jnz L@@1
  78.         inc edi
  79.         mov byte[edi],al
  80.         push dword[ebp + 8]
  81.         call strrev
  82.       popad
  83.       pop ebp
  84. retn 8
  85. section '.data' data readable writeable
  86. numtexto        db      5 dup(0)
  87. texto   db      10 dup(0)
  88. size    dd      9
  89.  
  90. section '.idata' import data readable
  91. library msvc,'msvcrt.dll'
  92. import msvc,printf,'printf',scanf,'scanf'
  93.  

no cambia mucho solo el uso de entrada y salida

gracias de antemano
3  Programación / Ingeniería Inversa / mi primer crackme en: 21 Mayo 2009, 00:12 am
Bueno me estuve dando una vuelta por este subforo y me parecio interesante el tema de los crackmes, asi que aqui les dejo mi primer crackme en C. La respuesta es un poco obvia, pero nunca habia intentado hacer un programa de estos.
http://www.megaupload.com/?d=M51KHACB

me estare leyendo los tutos porque no pude resolver el de  invisible y eso que todos dicen que esta facil. A ver si mis pocos conocimientos de asm me ayudan :P

espero les sirva aunque sea para distraerse un rato  ;D

P.D un user incorrecto o pass incorrecta provocan una exepcion. La unica manera de que no pase es poner el verdadero user y pass

1.-Høl¥   primero  ;-) ;-)
Arkangel_0x7C5 segundo   ;-) ;-)
4  Programación / ASM / [ayuda]con un codigo asm, en: 19 Mayo 2009, 04:47 am
Hola tengo un problema, este programa pide el nombre de un proceso y despues procede a terminarlo, pero no lo hace la funcion Process32First me devuelve nul y no se porque, yo creo que pase bien los parametros, por favor ayudenme a encontrar el error, esta un poco enredado porque soy novato, lo organize lo mejor que pude

Código
  1. format pe console
  2. entry main
  3. include 'c:\fasm\include\win32ax.inc'
  4. .data
  5. ;Data begin--------------------------------------------------\
  6. struct PROCESSENTRY32                                        ;
  7.        dwSize                    dd              ?           ;
  8.        cntUsage                  dd              ?           ;
  9.        th32ProcessID             dd              ?           ;
  10.        th32DefaultHeapID         dw              ?           ;
  11.        th32ModuleID              dd              ?           ;
  12.        cntThreads                dd              ?           ;
  13.        th32ParentProcessID       dd              ?           ;
  14.        pcPriClassBase            dd              ?           ;
  15.        dwFlags                   dd              ?           ;
  16.        szExeFile                 rb              MAX_PATH    ;
  17. ends                                                         ;
  18. pInfo                   PROCESSENTRY32                       ;
  19. hProcess                dd              ?                    ;
  20. hProcesses              dd              ?                    ;
  21. TH32CS_SNAPPROCESS      equ             0x00000002           ;
  22. NORM_IGNORECASE         equ             0x00000001           ;
  23. LOCALE_USER_DEFAULT     equ             0x0400               ;
  24. CSTR_EQUAL              equ             0x2                  ;
  25. PROCESS_TERMINATE       equ             0x0001               ;
  26. lpExe                   db              256 dup(0)           ;
  27. ;Data ends---------------------------------------------------/
  28. .code
  29. ;Code Begins-------------------------------------------------\
  30. main:                                                        ;
  31.         invoke printf,"Escriba el proceso a terminar: "      ;
  32.         invoke scanf,"%s",addr lpExe                         ;
  33.         xor eax,eax                                          ;
  34.         push eax                                             ;
  35.         push TH32CS_SNAPPROCESS                              ;
  36.         call [CreateToolhelp32Snapshot]                      ;
  37.         cmp eax,INVALID_HANDLE_VALUE                         ;
  38.         jne NoE1                                             ;
  39.         push 1                                               ;
  40.         call ErrorReport                                     ;
  41.         jmp main@Salir                                       ;
  42.    NoE1:                                                     ;
  43.         mov [hProcesses],eax                                 ;
  44.         push pInfo                                           ;
  45.         push [hProcesses]                                    ;
  46.         call [Process32First]                                ;
  47.         cmp eax,FALSE                                        ;
  48.         jne NoE2                                             ;
  49.         push 2                                               ;
  50.         call ErrorReport                                     ;
  51.         jmp main@Salir                                       ;
  52.    NoE2:                                                     ;
  53.         bucle1:                                              ;
  54.                 push 0xFFFFFFFF                              ;
  55.                 push lpExe                                   ;
  56.                 push 0xFFFFFFFF                              ;
  57.                 push pInfo.szExeFile                         ;
  58.                 push NORM_IGNORECASE                         ;
  59.                 push LOCALE_USER_DEFAULT                     ;
  60.                 call [CompareString]                         ;
  61.                 cmp eax,CSTR_EQUAL                           ;
  62.                 jne Next                                     ;
  63.                 push pInfo.th32ProcessID                     ;
  64.                 push FALSE                                   ;
  65.                 push PROCESS_TERMINATE                       ;
  66.                 call [OpenProcess]                           ;
  67.                 cmp eax,0                                    ;
  68.                 je Next                                      ;
  69.                 mov [hProcess],eax                           ;
  70.                 push 0                                       ;
  71.                 push [hProcess]                              ;
  72.                 call [TerminateProcess]                      ;
  73.                 push [hProcess]                              ;
  74.                 call [CloseHandle]                           ;
  75.                                                              ;
  76.            Next:                                             ;
  77.                 push pInfo                                   ;
  78.                 push [hProcesses]                            ;
  79.                 call [Process32Next]                         ;
  80.                 cmp eax,FALSE                                ;
  81.                 je FinBucle1                                 ;
  82.         jmp bucle1                                           ;
  83.         FinBucle1:                                           ;
  84.         push [hProcesses]                                    ;
  85.         call [CloseHandle]                                   ;
  86. main@Salir:                                                  ;
  87.                                                              ;
  88. leave                                                        ;
  89. ret                                                          ;
  90. ;Main Ends''''''''''''''''''''''''''''''''''''''''''''''''''';
  91. ;ErrorReport Begins'''''''''''''''''''''''''''''''''''''''''';                                                             ;
  92. proc ErrorReport,raz                                         ;
  93. call [GetLastError]                                          ;
  94. cmp [raz],1                                                  ;
  95. je @0                                                        ;
  96. cmp [raz],2                                                  ;
  97. je @1                                                        ;
  98. cmp [raz],3                                                  ;
  99. je @2                                                        ;
  100. jmp @def                                                     ;
  101. @0:                                                          ;
  102.         invoke printf,"Error Handle Invalido code %d ",eax    ;
  103.         jmp Error@Salir                                      ;
  104. @1:                                                          ;
  105.         invoke printf,"Error cannot open the process ",eax    ;
  106.         jmp Error@Salir                                      ;
  107. @2:                                                          ;
  108.         jmp Error@Salir                                      ;
  109. @def:                                                        ;
  110.         invoke printf,"Error desconocido code %d ",eax        ;
  111. Error@Salir:                                                 ;
  112. call [GetLastError]                                          ;
  113. invoke printf,"%d",eax                                       ;
  114. leave                                                        ;
  115. ret                                                          ;
  116. endp                                                         ;
  117. ;ErrorReports ends''''''''''''''''''''''''''''''''''''''''''';
  118. ;.code ends--------------------------------------------------/
  119. section '.idata' import data readable
  120. library k32,'kernel32.dll',msv,'msvcrt.dll'
  121. import k32,CreateToolhelp32Snapshot,'CreateToolhelp32Snapshot',\
  122. GetLastError,'GetLastError',Process32First,'Process32First',\
  123.        CompareString,'CompareStringA', OpenProcess,'OpenProcess',\
  124.        TerminateProcess,'TerminateProcess', \
  125.        CloseHandle,'CloseHandle',Process32Next,'Process32Next'
  126. import msv,printf,'printf',scanf,'scanf'
  127.  

saludos
5  Programación / ASM / [Ayuda]con punteros en asm en: 12 Mayo 2009, 19:44 pm
Hola a todos quiero aprender a programar en asm, porque he oido que es el lenguaje mas rapido que hay, y tambien estoy enterado de todas sus desventajas. Pero bueno mi duda es esta como puedo usar punteros en asm.
Ya se que es un poco pronto porque estoy empezando. Pero esto de practicar mientras aprendo me ha servido, antes mi idea es hacer una funcion para sacar la longitud de una cadena usando el caracter nulo. Para esto necesito hacer un puntero que apunte al principio de una cadena para irlo incrementndo pero no se nada estoy en cero. Bueno se lo basico como los registros, algunas instrucciones pero hasta ahi nada mas.
No estoy pidiendo que me den una funcion hecha sino que me guien a como la puedo hacer yo.

gracias
Páginas: [1]
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines