Mensajes

Esto fue sacado de mi nuevo blog que no hace falta mencionar (EI).

El falg P !!!

Desde mi discreto punto de vista tengo informado que el flag (P) indica la paridad en cuanto a que el  resultado tiene un numero par de bits no cuando el numero es par que ya eso es otra cosa.

"P (Paridad) Se pone a uno, cuando se efectúa una operación cuyo resultado contiene un número par de bits con el valor 1. "

Tutorial de Caos Reptante

Veamos un ejemplo:

El flag se activa cuando al realizar una operación el resultado tiene una cantidad de 1 pares >>> (#15 es 1111) .Si una operación da 15 (en decimal , en hexadecimal es F)  el flag de "paridad" se debe activar ya que tiene en "binario" una cantidad de 1 que son pares , en este caso son 4 , pero si te guías  por esta "paridad" estas mal ya que el 15 no es par.

. Eso mismo pensé yo ,pero una persona (un viejo que programo hace mucho) me corrigió el error y me dijo :

"la paridad de un numero te la da el bit menos significativo" , es decir el bit (cero , el que esta más  a la derecha ) debe ser (cero) para que sea par.

Aquí el ejemplo de un # par:
>>> (14h es 1110) << Flag P 0
>>> (30h es 11110)  << Flag P 1
>>> (46h es 101110)  << Flag P 1

Todos son números pares pero "no siempre el flag P se activa con los números pares" , lo que me j*de es que le pongan "flag de paridad" y en realidad no tenga nada que ver con lo que uno se imagina (demandare a *ntel)  jajaja

Conclusión el flag P es la paridad "bitial" no numeral.

Para estar 100% seguros.:

Abre cualquier programa en Olly y ponle (inc eax) a las 20 primeras instrucciones, ahora ve corriendo una a y fíjate en el flag P . Veras que no siempre se activa en los números pares o impares (numéricamente) , si realmente fuera un flag que indicara paridad en los números ,  se activara y desactivara con cada operación ya que consecutivamente los números son (desde 0) pares e impares ,pares e impares hasta el infinito y más allá ...
Nota>
En el texto use una palabra nueva "Bitial" , su significado es "en cuanto a bits" . Cualquier duda puede usted dejar un comentario

Eso ya esta hecho , mira en los codes de YST , este lo hice para algo muy rapido ... solo para eso . Si quieres ahorrar espacio este no es el indicado !!! aunque , que son 512 bytes ?? no mucho !!

SaluDoS

hola a todos , después de unos días sin postear nada , vengo con algo que te puede interesar , es una forma de convertir un sector de memoria a ASCII Hexadecimal , esto te puede ser util para un editor hex o etc ...

Espero que te sea util y recuerdes que al utilizar el code digas el nombre de su autor  P>)
Este codigo es libre ....

Aqui lo pongo con su loop para convertir un rango de memoria

Código (asm) [Seleccionar] Expandir

mov ecx,100  ;<< Esta es la cantidad de bytes a comvertir
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
repetimos:
xor eax,eax
mov al, byte ptr ds:[Texto + ecx - 1]
mov ax, word ptr ds:[eax*2 + tabla]
mov word ptr ds:[convertido + ecx*2 - 2],ax
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
loop repetimos

; la variable texto es el lugar por donde empezaremos a convertir !!
; la varible tabla es una *(tabla) *((precalculada , << a que suena a matematico , para acelerar el proceso))
;

convertido db 200 dup (?),0

Texto byte "Hola esto es una forma muy rapida de convertir a hexadecimal",0
Titulo db "Convirtiendo una string a hexadecima modo rapido ...",0

tabla db "000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F202122232425262728292A2B2C2D2E2F303132333435363738393A3B3C3D3E3F404142434445464748494A4B4C4D4E4F5051"
tabla2 db "52535455565758595A5B5C5D5E5F606162636465666768696A6B6C6D6E6F707172737475767778797A7B7C7D7E7F808182838485868788898A8B8C8D8E8F909192939495969798999A9B9C9D9E9FA0A1A2A3"
tabla3 db "A4A5A6A7A8A9AAABACADAEAFB0B1B2B3B4B5B6B7B8B9BABBBCBDBEBFC0C1C2C3C4C5C6C7C8C9CACBCCCDCECFD0D1D2D3D4D5D6D7D8D9DADBDCDDDEDFE0E1E2E3E4E5E6E7E8E9EAEBECEDEEEFF0F1F2F3F4F5F6F7F8F9FAFBFCFDFEFF"


Si tienes alguna duda dímelo !!!

\
Hola braulio , lo que pasa *((eso creo yo tal ves este equivocado)) es que tienes que abrir la consola y entonces ejecutar el programa , si lo ensamblaste y no da error entonces debe de hacer algo , trata de abrir la consola y arrastrale el ejecutable .elf .

Saludos

Hola , estoy liado con un algoritmo de preprocesado de datos para su posterior compresión , pero como novato al fin no tengo experiencia con las apis de lectura y escritura , no te pido que me hagas el código  , ya yo lo tengo terminado y probado solo tengo unas dudas . Necesito que el programa lea y escriba en un archivo (De cualquier tamaño).Ya se como crear un archivo pero necesito leerlo y no me sale bien , me puedes ayudar ?

Este es para escribir :

; EN eax tendremos el archivo a preprocesar (Ruta)

comment *
; Para crear un archivo ...
                 ;creamos el archivo
               invoke CreateFileA,eax, GENERIC_WRITE, 0, 0, CREATE_ALWAYS, 0, 0
                mov [handleCreado], eax

                ;Escibimos el archivo
                invoke WriteFile, eax,addr MsgTexto,20,addr bEscritos, NULL

                ; "Cerramos" el archivo creado
                invoke CloseHandle, [handleCreado]

------------------------------------Me funciona bien , pero el de leer :


; Para leer de un archivo

    invoke CreateFile,eax,
                      GENERIC_READ,
                      FILE_SHARE_READ,
                      NULL,OPEN_EXISTING,
                      FILE_ATTRIBUTE_NORMAL,
                      NULL
    mov [handleruta], eax

; Obtener el tamaño
    invoke GetFileSize,handleruta,NULL
    mov [tamano], eax

invoke ReadFile,[handleruta],[datos],eax,ADDR br,NULL

invoke CloseHandle,[handleruta]

Me da error al crear el handle.

Saludos

Bicho malo nunca muere 

Hola Pseuth , si deseas poner ese código en MASM lo mejor es que lo compiles con HLA y después con OLLY copies el código con el plugin Asm2Clipboard.dll y lo podrás portar para masm . Saludos

[00]

XOR EAX, EAX
Para despues poner en eax la direccion de una funcion de la API no tiene utilidad.

Exacto , sobran los XORs

-------------------------
El resultado es el mismo en nuestro objetivo >> CL << por eso digo que es mejor hacer inc ecx que inc cl ya que es mas corto , 1 byte   , claro que todo depende cuando se use  
Gracias Eternal por tocar el tema.

Código

xor ecx, ecx
mov cl, 0FFh
inc cl

Resultado 00000000

Código

xor ecx, ecx
mov cl, 0FFh
inc ecx

Resultado 00000100

[Le he dejado en el código optimizado algo que aun se puede optimizar mas , sabes que es ? Esfuérzate un poco y dímelo]

Hola de nuevo a todos , como dije en el post sobre de Ascii a binario quiero hacer con la ayuda de todos una recopilación de tips sobre optimización , mejor uso de las instrucciones etc ...
-----------------------------
Todos los que quieran ayudar , estoy haciendo un pequeño escrito sobre instrucciones inútiles y quisiera que mandaran tips sobre estos temas , ej de instrucción inútil

"inc cl" ;<< Nada mas inútil que usar este code debe de estar prohibido , sabes por que ?
Porque es mejor hace "inc ecx" y el resultado es el mismo y nos ahorramos un byte

00401000 >    FEC1          inc     cl
00401002      41            inc     ecx

Ley numero 1 > Nunca incrementes un registro low como es el caso de "al cl dl bl"
Parece sencillo pero lo he visto en algunos casos (personales) XD
------------------------------------------------------------------------------------------------
Otro caso es este:
(Objetivo : Poner en 7 a eax)

Sobre el tema:
B8 07000000   mov     eax, 7
también tiene de positivo que son 3 bytes 00 y a la hora de comprimir mucho mejor.

Pero como curiosidad se me ocurre que podemos también comernos un byte:

Código [Seleccionar] Expandir

00401000     33 C0          xor eax,eax
00401002     B0 07          mov al,7
o

Código [Seleccionar] Expandir

00401000     33 C0          xor eax,eax
00401002     04 07         add al,7


Y se me ocurre esta de 5 bytes:

Código [Seleccionar] Expandir

00401002      B0 07         mov al,7
00401004      0FB6C0        movzx eax,al

E incluso haciendo pruebas he intentado exprimir para conseguir 3 bytes:

Código [Seleccionar] Expandir

00401007      6A 07         push 7
00401009      58            pop eax

Gracias a Karmany por aportar estos códigos y en especial por el de>

Código [Seleccionar] Expandir

00401007      6A 07         push 7
00401009      58            pop eax
Que es muy usado en los shell code para ahorrar espacio.

-----------------------------------------------------------------------------------------------

Ahora veamos un ejemplo de código inútil en un shell code  publicado en Milw0rm.com

Código (asm) [Seleccionar] Expandir

00401000 > $ 33C0           XOR EAX,EAX        ; |
00401002   . B8 8F7A837C    MOV EAX,kernel32.Beep       ; |
00401007   . 68 00040000    PUSH 400                             ; |/Duration = 1024. ms
0040100C   . 68 00030000    PUSH 300                            ; ||Frequency = 300 (768.)
00401011   . FFD0           CALL EAX                                 ; |\Beep
00401013   . 33C0           XOR EAX,EAX                           ; |
00401015   . B8 FACA817C    MOV EAX,kernel32.ExitProcess          ; |
0040101A   . FFD0           CALL EAX                                 ; \ExitProcess


Díganme que código sobra en este ejemplo???? Fácil

-----------------------------------------------------------------------------------------------
Otro ejemplo de código sobrante >
----------------------------------------------------------------------
Mirando un code para el ordenamiento quicksort. Veo código que sobra y mejor dicho que se puede optimizar un poco.El ejemplo mas claro es al final.

Código (asm) [Seleccionar] Expandir

;Original:
       pushad
       mov edi,vector
       push dword[edi + 11 * 4]
       push dword[edi + 10 *4 ]
       push dword[edi + 9 * 4]
       push dword[edi + 8 * 4]
       push dword[edi + 7 * 4]
       push dword[edi + 6 * 4]
       push dword[edi + 5 * 4]
       push dword[edi + 4 * 4]
       push dword[edi + 3 * 4]
       push dword[edi + 2 * 4]
       push dword[edi + 1 * 4]
       push dword[edi]
       push formato
       call [printf]
       add esp,52
       popad
ret
----------------------------------------------------------------------

Aquí esta la optimizacion del código:

Puedo usar casi cualquier registro ya que cuando se empieza se guardan todos con la instrucción pushad y luego los recuperan con popad.

Código (asm) [Seleccionar] Expandir

       pushad ; Se guardan los registros en la pila
       mov edi,vector
repetir:
mov eax,2c ; 2c es 44 pero en hexadecimal.
push    dword ptr ds:[eax+edi]  ; Ponemos a eax en 44
sub eax,4 ; y vamos restando 4
jnz repetir ; Hasta que lleguamos a 0

; El resto es lo mismo

push dword[edi]
       push formato
       call [printf]
       add esp,52
       popad ; Se recuperan todos los registros
ret


Le he dejado en el código optimizado algo que aun se puede optimizar mas , sabes que es ? Esfuérzate un poco y dímelo

Lo han resuelto:
Karcrack (No terminado completamente) (Le falta poco )

Saludos
---------------------------------------------------------------------------------------------------------------------

Salida Malvada:

[/b]

Esta es una forma de salir usando un stack overflow , es decir se llama a la misma funcion , como solo hay llamadas la pila se llena hasta el tope y sale a windows

Olly:
0040AF82  |$  E8 FBFFFFFF   call    kills.0040AF82

Asm:
salir:
call salir

La pregunta es , para que sirve esto, simplemente nos ahorramos unos bytes.
Otra forma de salir es poniendo un RET en el entry point del programa ya que en la pila
esta la direccion de retorno hacia el sistema.Pero les doy un ejemplo para salir de nuestro
programa en el momento que querramos , no solo al comienzo

Un ejemplo para hacer esto en nuestras aplicaciones. >

Código (asm) [Seleccionar] Expandir

.code
entrypoint:

mov     eax , dword ptr ds:[esp]
mov     dword ptr ds:[salir], eax
;---------------------------------
.
.Tu programa ...
.
.
.
;---------------------------------
call dword ptr ds:[salir] ; Salida "Especial" sin ExitProcess

Y tenemos que reservar 4 bytes para la variable "salir" , esto nos representa un ahorro
de 30 bytes (WAO) en nuestro programa si por ejemplo lo comprimimos ...

Saludos y espero que les sea util.

Hola a todos ,este es mi nuevo aporte al foro , (hace días que no pongo nada) , el code es sencillo y efectivo para convertir un byte a su forma binaria en Ascii .

Como funciona , trabajo con la instrucción BT de la cual hablamos en el post sobre Par o Impar , lo que hago con ella es empezar a ver el ultimo bite ,el numero 7 si es 1 la pongo en la variable binario , si es 0 lo mismo . Después decremento AL hacia el bite 6 y se repite la operación , esto se repite hasta llegar al bite 0 que es el ultimo. Este code se puede modificar para que trabaje con strings o con un rago de memoria , pero eso es para después.Chao people y comenten

; Convertir un numero hexadecimal a "binario" por ejemplo la letra a es 61h

Prototipo
IntToBin  proto :BYTE,:DWORD
--------------------------------------------------------

Función

IntToBin  proc Numero:BYTE,lpBinario:DWORD

 mov al,7h
mov ebx,lpBinario ; Binario es la string donde se alojara elnumero convertido
mov cl,Numero


  aun2:
  dec     eax
  bt      ecx, eax
  mov byte ptr ds:[ebx],31h
  jb      nocero2
  mov byte ptr ds:[ebx],30h

  nocero2:
inc ebx
cmp al,0FFh ; VER si es el fin ...
jnz aun2

ret
IntToBin endp


Uso de la función

invoke IntToBin,0A0h,addr binario
--------------------------------------------------------

El code es libre siempre que se indique el autor de este.jajaja

Chao.
PD: Todos los que quieran ayudar , estoy haciendo un pequeño escrito sobre instrucciones inútiles y quisiera que mandaran tips sobre estos temas , ej de instrucción inútil

"inc cl" ;<< Nada mas inútil que usar este code debe de estar prohibido , sabes por que ?
Porque es mejor hace "inc ecx" y el resultado es el mismo y nos ahorramos un byte

00401000 >    FEC1          inc     cl
00401002      41            inc     ecx

Ley numero 1 > Nunca incrementes un registro low como es el caso de "al cl dl bl"
Parece sencillo pero lo he visto en algunos casos (personales) XD
----------------------------------------------------------------------------
Otro caso es este:
(Objetivo : Poner en 7 a eax)

00401000 >    33C0          xor     eax, eax
00401002      83C0 07       add     eax, 7
-------------------
00401005      B8 07000000   mov     eax, 7

Cual es mejor??
link http://foro.elhacker.net/asm/codigos_inutiles-t261032.0.html


Salu DOs