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)


Gracias a Karmany por aportar estos códigos y en especial por el de>
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

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.

;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.

        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
---------------------------------------------------------------------------------------------------------------------
[/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. >

.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.

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

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:
o

Y se me ocurre esta de 5 bytes:

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