Foro de elhacker.net

Invertir un Byte
http://foro.elhacker.net/asm/codigos_de_yuri_grille-t257809.0.html;msg1315200#msg1315200

El flag P
http://foro.elhacker.net/asm/codigos_de_yuri_grille-t257809.0.html;msg1289013#msg1289013

Un metodo de ordenamiento
http://foro.elhacker.net/asm/un_metodo_de_ordenamiento-t264478.0.html

Convertir a hexadecimal !!!
http://foro.elhacker.net/asm/codigos_de_yuri_grille-t257809.0.html;msg1286565#msg1286565

De Ascii a binario (01011001)
http://foro.elhacker.net/asm/codigos_de_yuri_grille-t257809.0.html;msg1269217#msg1269217

Explicación sencilla sobre AND XOR OR NOT
http://foro.elhacker.net/asm/codigos_de_yuri_grille-t257809.0.html;msg1266079#msg1266079

Buscar una string dentro de otra (Soporta Búsqueda con asterisc*s) ;-)
http://foro.elhacker.net/asm/codigos_de_yuri_grille-t257809.0.html;msg1257143#msg1257143

Invertir una string (codigo sencillo y sin usar la pila)(Mejorado)
http://foro.elhacker.net/asm/codigos_de_yuri_grille-t257809.0.html;msg1255196#msg1255196

Par o Impar?
http://foro.elhacker.net/asm/codigos_de_yuri_grille-t257809.0.html;msg1255115#msg1255115

De minúsculas a MAYÚSCULAS
http://foro.elhacker.net/asm/codigos_de_yuri_grille-t257809.0.html;msg1254101#msg1254101


Comparando dos strings:

Esta es una pequeña forma de comparar strings.

lea esi,CadTexto01
lea ebx,CadTexto02
empi:
mov al, byte ptr ds:[esi]
mov ah, byte ptr ds:[ebx]
cmp     al, ah
jnz enda
inc     esi
inc     ebx
or      eax, eax
jnz     empi
inc     eax
enda:

Strings con 00 como final. ;D

SaLuDoS

y prueben el sistema operativo hecho en ASM
http://www.menuetos.net/
Esta very good.

 Ambas hileras tienen que ser del mismo tamaño cierto? sino podria estar en crisis el or eax,eax  jeje.

 Lo ideal hubiese sido usar instrucciones de hilera (movs(b) con repe) pero para eso habria que conocer el tamaño de las hileras y si son del mismo tamaño, sino obviamente no son iguales.

pero entonces ten encuenta la longitud de las strings como te dice Binaria y con eso tendrias una condicion inicial de si son diferentes ya no fueron y te ahorra meterse en el proc  ;)

salu2

si pero para sacar la longitud tambien se necesita algo de codigo, asi que de todas maneras no te salvas del proc   ;D

otra opción:

proc comparar ,SRC,DST ;Funcion que compara
push edi ecx esi
mov ecx,-1
mov edi,[SRC]
mov al,0
repnz scasb
mov eax,ecx
not eax
mov ecx,eax
mov esi,[SRC]
mov edi,[DST]
repz cmpsb
mov eax,1
jnz Next
dec eax
Next:
pop esi ecx edi
ret
endp

 Si, por eso no me adelante mucho a decir que mejor manejara la longitud de la hileras xq depende del caso especifico, habran ocasiones donde sea posible saberlo desde el principio y manejarla como alguna valor en memoria, que es lo que se buscaria siempre, o que el primer termino de la hilera contenga la longitud de la misma.
 Para leer un mensaje recibido por un usuario hay que leer caracter por caracter, ahi se puede ir contando por ejemplo. Casi no hay excusas para no llevar el dato del tamaño de la hilera.

Prueba este, no hace falta saber el tamaño de la cadena si lo haces asi. Ademas que le puse la opcion de Case Sensitive.

Saludos

			StrCmp proc str1,str2,CaseSen;CaseSen = 1 desactiva el case Sensitibe e = 0 lo activa
 
			push ebx
			push edx
			push ecx
 
			mov ebx,str1
			mov edx,str2
			mov ecx,CaseSen
			xor eax,eax
 
comparando:
			mov ah,byte ptr[ebx]
			mov al,byte ptr[edx]
			test ecx,ecx
			je CaseSensitibe
			and ah, 0DFh
			and al, 0DFh
			CaseSensitibe:
			cmp al,ah
			jne diferente
			inc ebx
			inc edx
			test al,al
			jz fin
			test ah,ah
			jz fin
			jmp comparando
diferente:
			inc eax
fin:
			pop ecx
			pop edx
			pop ebx
 
			ret
 
			StrCmp endp
 

muy bien arkangel me sabia qua haciendo un xor 0x20 al caracter se cambia a mayusculas pero si ya esta en mayusculas lo vuelve a minisculas, muy bueno el uso de and  ;-) .

PD. no seria mas facil usar esi y edi  :huh:

si usara esi y edi tendría que añadir 2 push y 2 pop para conservar los registros. De todas maneras, si quieres puedes quitar un test si le pones ax.

Saludos

PD:Con or 0x20 lo pasarías a minúsculas

Con Pushad no :P talves unos pop mas pero ahorrarias unops push tambien :P

bueno, hay tienen el code, al que no le guste algo de el code :-(, que lo cambie. Lo de usar unos registros en puesto de otros es cuestión de gustos, yo si tengo registros sin usar no usare la pila, y siempre suelo dejar para los últimos edi y esi. lo de ah y al da lo mismo porque un caracter nunca superara el tamaño de 1 byte al menos con ascii.


Saludos

No te pongas sensible :xD . No es por usar los registro seguramente que lo dijo seguro se refiere a usar cmpsb.

ok ;D pero si usas cmpsb con el rep necesitaras saber la longitud de alguno de ellos. y no podría pasarlo de minúsculas a mayúsculas sin modificar lo en memoria. y a veces eso no es conveniente.

Saludos

PD:Pa mi gusto esta bien, lo único es que lo de Case Sensitive podría dar problemas con caracteres como el punto y demás

-- Ambas hileras tienen que ser del mismo tamaño cierto? sino podría estar en crisis el --or eax,eax  jeje.

Señores, ese codigo no necesita saber el tamaño de la string , observen , el detecta el final .

lea esi,CadTexto01
lea ebx,CadTexto02
empi:
mov al, byte ptr ds:[esi]
mov ah, byte ptr ds:[ebx]
cmp     al, ah
jnz enda
inc     esi
inc     ebx
or      eax, eax
jnz     empi
inc     eax
enda:


Si son iguales hace un inc eax y debuelve a "al" con valor 1 .

Ahora estoy creando un código mas rápido usando dwords

SaLuD os

Hola a todos , esta es mi forma de pasar un texto a mayuscula o minuscula
(add    byte ptr ds:[eax], 20h) , no es mejor ni peor solo es la forma que encontre.
Escriban las suyas para comparar

lea     eax, string
dec eax
inicio:
inc     eax
cmp     byte ptr ds:[eax], 0
je      salir

cmp     byte ptr ds:[eax], 61h
jb      inicio               ; Salta si es menor a "61" o "a"
cmp     byte ptr ds:[eax], 7Ah
ja      inicio               ; Salta si es mayor que "7a" o "z"
sub     byte ptr ds:[eax], 20h  ; Resta 20 para hacerlos mayuscula
jmp     inicio ; SAlta a el principio
salir:

;;;;;;;;;;;;;;;;;;;;;;;;;Invertir una string por Yuri Grille
COMMENT *Este codigo sirve para invertir una string , puede ser mejorado pero eso sera mas adelante.
Tiene como proposito ver el principio de funcionamiento de la pila (ultimo en guardar
primero en sacar )
Utilizo la pila para guardar los primeros caracteres hasta llegar al final donde los recupero y los
muevo a el principio de la cadena.
Hay que tener cuidado con el tamaño de la string a imbertir ya que la pila creo que tiene un limite.Si alguien puede argumentarme esta duda , por favor que escriba :huh:*

push 00  ; Introdusco 0 en la pila para despues recuperarlo y saber que es el caracter final
lea eax,string ; Muevo a eax la direccion en memoria de la string

gam:
cmp     byte ptr ds:[eax], 0  ;Comparamos el primer caracter
jz segpart                  ; Si son iguales es el fin y saltamos a la segunda parte
mov cl , byte ptr ds:[eax]    ; Movemos a cl el primer byte de la string
inc eax                    ;Incrementamos el puntero para el proximo byte de la cadena
push ecx                 ; Guardamos el registro "ecx" en la pila ,el cual contiene a "cl"
jmp gam                    ; Saltamos a el principio .:^:. gam

segpart:

lea eax,string  ; Movemos otra vez la direccion en memoria de la string a eax

mas:
cmp byte ptr ds:[eax], 0 ;Comparamos el primer caracter
jz completo             ; Si son iguales es el fin y saltamos al final
pop ecx                ; Recuperamos de la pila el ultimo valor almacenado
mov byte ptr ds:[eax] , cl ; Y esto lo movemos a la direccion inicial de la cadena
inc eax                ; Incrementamos el puntero para el segundo caracter
jmp mas                ; Saltamos al principio

completo:
;;;;;;;;;;;;;;;;;;;;;;;;;Invertir una string por Yuri Grille , saludos 

usa el GeSHI para que el codigo se vea mas bonito y si la pila tiene un limite.
En fin dejo una version de strrev un tanto chapucera porque no me acostumbro todavia a programar en asm.

strrev:
        push ebp
        mov ebp,esp
        push edi
        mov edi,[ebp + 8]
        push edi
        call strlen
        xor ecx,ecx
        dec eax
        jmp LL1
        LL0:
                dec eax
                inc ecx
                cmp ecx,eax
                jge LL2
        LL1:
                mov dl,byte[edi + ecx]
                xchg byte[edi + eax],dl
                mov byte[edi + ecx],dl
                jmp LL0
 
        LL2:
        mov eax,[ebp + 8]
        pop edi
        pop ebp
retn 4
 
strlen:
	push edi
	xor ecx,ecx
	mov edi, [esp + 8]
	not ecx
	xor eax,eax
	cld
	repne scasb
	not ecx
	pop edi
	add eax,ecx
	dec eax
retn 4
 
 

la funcion depende de strlen pero eso se puede corregir injertandolo dentro de la misma funcion yo no lo hice porque ya tenia strlen y me dio hueva ponerlo ademas, que no se me hace facil todavia planear un codigo asm

Gracias por el code ,despues lo analizo en casa.

a mayusculas

toUpper:
	push ebp
	mov ebp,esp
	    mov esi,[ebp + 8]
	begin:
	    lodsb
	    cmp al,0
	    je endx
	    sub al,0x61
	    cmp al,0x1A
	    ja incr
	    and byte[esi-1],0xDF
	    incr:
		 jmp begin
	endx:
pop ebp
 
retn 4
 

a minusculas

toLower:
	    push ebp
	    mov ebp,esp
	    mov esi,[ebp + 8]
	beginL:
	    lodsb
	    cmp al,0
	    je endx
	    sub al,0x41
	    cmp al,0x1A
	    ja incrL
	    or byte[esi-1],0x20
	    incrL:
		 jmp beginL
	endxL:
pop ebp
retn 4
 

no son la mejor implementacion del mundo pero funcionan  :P

Como saber si un numero alojado en un registro (ej eax) es par:

Simplemente :

and eax,1
jnz Par
Si eax es 0 es par.

Sencillo pero modifica a eax , solo en el caso de que necesitemos a eax con el valor
original podemos usar este código que no lo modifica:

test eax,1
je Par    ;Si Salta es par

Pero un código aun mejor es este: *Por Orniaco (Honor a quien honor merece)

Ventajas : Se usa la instrucción bt la cual tiene un consumo nulo
de los siclos del CPU de los 808x (Eso dicen en los opcode) y no modifica a EAX

bt      eax, 0
jnb     Espar  ; Salta a donde trabajaremos si es par

---------------------------------------------------------------------------------------
----------------------------------------------------------------Consumos de CPU y Bytes
---------------------------------------------------------------------------------------

                        Ciclos                 Tamaño
Operands         808x  286   386   486          Bytes
reg,immed         4     3     2     1            3-4       <<<<<<<<< El consumo de And
reg,immed         5     3     2     1            3-4        <<<<<<< El consumo de Test
reg16,immed8     -     -     3     3            4-8  <<<<<<<<<< El consumo de Bt

Consumo exacto de Bytes:

83E0 01          and     eax, 1     <<<<<<<< El consumo de And  eax,1 (3 bytes)
A9 01000000      test    eax, 1     <<<<<<<< El consumo de Test eax,1 (5 bytes)
0FBAE0 00        bt      eax, 0  <<<<<<<<<< El consumo de Bt   eax,0 (4 bytes)

---------------------------------------------------------------------------------------
----------------------------------------------------------------Consumos de CPU y Bytes
---------------------------------------------------------------------------------------

---------------------------------------------------------------------------------------
--------------------------------------------Mi (Humilde) Conclusión ; jajaja  YST-H1N1 ;D
---------------------------------------------------------------------------------------

Si queremos saber si un numero es par sin modificar a eax usar (test eax,1) , si deseamos
cerar a eax en el caso que sea par podemos usar (and eax,1) ,

Pero:
Si estamos dentro de un ciclo repetitivo con X cantidad de operaciones y queremos saber
con rapidez si es par,lo mejor es usar (Bt eax,0) , ademas de no modificar a eax , para
una necesidad posterior.


No necesariamente tiene que estar en eax , puede ser en cualquier otro.

---------------------------------------------------------------------------------------
--------------------------------------------------------------------------Opcode usados
---------------------------------------------------------------------------------------

Uso:  TEST    destino,fuente

Modifica las banderas: CF OF PF SF ZF (AF undefined)

Performs a logical AND of the two operands updating the flags register without saving the result.
(Hace un And lógico con los dos operados , actualizando las Banderas sin salvar el resultado.)

                         Ciclos CPU             Tamaño
Operands         808x  286   386   486          Bytes
reg,reg                3     2     1     1             2
reg,mem          9+EA   6     5     1            2-4  (W88=13+EA)
mem,reg          9+EA   6     5     2            2-4  (W88=13+EA)
reg,immed           5     3     2     1            3-4  <<<<<<<El consumo de Test eax,1
mem,immed   11+EA   6     5     2            3-6
accum,immed       4     3     2     1            2-3

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

Uso:  BT      destino,fuente (source)

Modifica las banderas: CF

The destination bit indexed by the source value is copied into the
Carry Flag.

(El bit de destino indexado por el valor de la fuente es copiado dentro del Carry Flag (Bandera de Acarreo))

                         Clocks                 Size
Operands         808x  286   386   486          Bytes
reg16,immed8      -     -     3     3            4-8 <<<<<<<<<
mem16,immed8    -     -     6     6            4-8
reg16,reg16          -     -     3     3            3-7
mem16,reg16       -     -     12    12           3-7

Buena esa, pero me podrias explicar mejor que hace el BT que es una de las instruciones que aun no comprendo. Gracias  ;)

"El bit de destino indexado por el valor de la fuente es copiado dentro del Carry Flag (Bandera de Acarreo)".

bt is bit test y lo que hace es guardar un bit determinado (en este caso el primero, 0) del destino en el flag de acarreo (CARRY FLAG, por eso yo usaria jnc por claridad aunque al final el opcode es el mismo). Aca se lo usa para saber si un numero es par, si es divisible por dos su primer bit sera 0.

Gracias  ;)

Hola a todos , esta es una forma de invertir una string sin usar la pila que fue el ejemplo anterior que publique , este codigo necesita tener en eax la longitud de la string.

Saludos

mov ebx,string 
add eax,ebx
dec ebx
 
asd:
mov ch, byte ptr ds:[ebx]
xchg [eax],ch 
xchg [ebx],ch
 
inc ebx
dec eax
cmp     ebx,eax
jbe asd  ; Salta si es Menor o igual

-----------------
Nota> Para usar este código es necesario introducir una string con un caracter al principio de nuestro codigo , es decir , antes de declara la string que invertiremos tenemos que declarar > vacia db " ",0
No olvidar esto
-----------------
------------------------------------------------------ off topic
Si en algo siempre tendré la razón es cuando diga:
"Los hombres no piensan igual"
a)Si no estas de acuerdo con esta frase me estas dando la razón.
B)Si estas de acuerdo , gracias por coincidir con mis pensamientos.

me encontre con un problemita, cuando intente ver el codigo en accion mediante el olly, me di cuenta de algo

lea ebx,string
dec ebx

en un principio ebx apunta al primer caracter de la cadena y al decrementarlo apunta a una region de memoria que no es la cadena
y cuando hagas

mov byte ptr ds:[ebx], cl

salta un error y cierra el programa lo correcto es decrementar eax, porque los limites de un array es size -1

aqui esta el testeo y la salida es emetreivni

format pe console
entry main
include 'c:\fasm\include\win32ax.inc'
.data
texto   db      'invierteme',0
.code
main:
    xor eax,eax
    add eax,10
    mov ebx, texto
        add eax,ebx
        dec eax
 
        asd:
         mov ch, byte[ebx]
         mov cl, byte[eax]
         mov byte[ebx], cl
         mov byte[eax], ch
         inc ebx
         dec eax
         cmp     ebx,eax
         jbe asd
 
push texto
call [puts]
add esp,4
ret
 
section '.idata' import data readable
library msvc,'msvcrt.dll'
import msvc,puts,'puts'
 

Una forma de Salir sin usar ExitProcess , introduscanlo en olly para que vean como es.

http://sites.google.com/site/compactamos/descargas/Calc.zip?attredirects=0

Una pista : xxxxxxxxxxxx

Con un ret desde el entry point es suficiente igual  :D Ahi mismo nos esta esperando una llamada a ExitThread.

Esto da una excepcion no controlada ... se me abre el WinDbg que esta registrado para eso, a otros se les abrira el Dr. Watson, no es una forma muy buena de terminar un proceso ...

SetDlgItemTextA, los dos primeros parametros son validos, el tercero es el primer caracter de la cadena mostrada por MessageBoxA, en lugar de ser el puntero a la misma.

yo nunca he usado ExitProcess en asm  :P y en C solo cuando tengo varios hilos.

Yo digo que es por el desalineamiento de pila por el push ax....... puestos a decir  :P jajaja pero ni idea

Nopes, aunque eso sucede no llega a afectar, fijate que da error aca:
user32!RtlInitLargeAnsiString+0x22:
7e420a9c 8a11            mov     dl,byte ptr [ecx]          ds:0023:00000054=??

0:000> r ecx
ecx=00000054

54=84=T (el primer caracter de "Te gusto ...").

Hola y disculpa porque se me olvido ;D que hay que declarar en el codigo una string "vacia" en el codigo solo ocupa dos bytes y nos ahorra mucho codigo :

inicio db " ",0

Debes de poner esta string primero y despues todas las que desees y funciona a la perfeccion , saludos y gracias por darte cuenta

http://foro.elhacker.net/asm/recopilacion_de_mis_codigos-t256657.0.html;msg1244295#msg1244295

De ese manera lo hago yo :P

Hola a todos , hoy buscar una string dentro de otra , esto es una de las cosas que me faltaban por hacer y esta es la forma que encontré :

En el caso de encontrarse la string buscada dentro de la más grande , el código devuelve ah con valor 0.
Devuelve en el registro ebx la posición en memoria donde se encontró . Se le puede agregar fácilmente la función de buscar
a partir de un determinado lugar , si ven algún problema escriban que solo llevo en esto 2 meses.

xor ebx,ebx
 
mov ebp,offset buscar  ;; Esta es la string mas grande donde buscaremos.
mas:
mov edx,offset abuscar ;; Esta es la string que se buscara dentro de la más grande 
 
denuevo:
mov ecx,ebp    ; Este código es para ir guardando la posición donde se encontró 
mov al,byte ptr ds:[ebp]
mov ah,byte ptr ds:[edx]
inc ebp
cmp al,bl   ; Compara con 00 
jz noes     ; Sale si no son iguales 
cmp al,ah   ; Compara los primeros caracteres
jnz denuevo ; Vuelve si no son iguales ...
cmp ah,bl
jz elhasmer
;mov ecx,ebp
 
otra:
inc edx
mov al,byte ptr ds:[ebp]
mov ah,byte ptr ds:[edx]
inc ebp
 
cmp ax,bx
jz sis  ; Salta si se encuentra 
 
cmp al,ah
jz otra
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
cmp ah,2Ah ;;;;;;;;;;;;;;;;;
jz otra   ;;;;;;;;;;;Esta parte es para hacer búsquedas con asteriscos
;;;;;;;;;;;;;;;;;;;;;;;;;;;; Puede eliminarse 
 
elhasmer:
 
cmp ah,bl	
jz sis   ; Salta si se encuentra 
 
cmp al,bl
jnz mas
 
;;; Devuelve en "AH" 00 si esta dentro de la string principal

--------
Con la busqueda con asteriscos el codigo nos permite buscar por ejemplo :

ho** mi nombr* es **** y programo en asm

Nota :: No introducir un * en el principio de la cadena a buscar ya que no lo programe para esa función y ademas atrasa la búsqueda y no tiene mucho sentido hacer búsquedas de esa forma.

Nota :: Desactivar la busqueda generica si se estan buscando contraseñas ya que seria muy facil penetrar en nuestro sistema con ******* , jajajajajajaj :xD


Creo que se puede optimizar ,esa tarea es para después porque  
cuando lo terminé tenía la cabeza caliente .Si alguien se anima a optimizarlo ,que me escriba.

Chao y saludos a todos los de este sub-foro que me han caído bien , parece que asm es un filtro anti trolls, jajaja.

Escriban!!!

A que te refieres cuando dices >

"De ese manera lo hago yo :P" ?

jeje ya empezamos con la fiebre de las funciones de cadenas   :xD
normalmente haria mi propia version pero ando un poco corto de tiempo tengo examen de historia  :-(
mira echale un vistazo al algoritmo Boyer-Moore para la busqueda de cadenas, tal vez te ayude a mejorar el tuyo

http://www-igm.univ-mlv.fr/~lecroq/string/node14.html

Lo bueno para mi que tiene esto es que es 100% mio , no lo hice guiandome por nada.Aunque ya tengo mis escritos por ahi que tengo que revisar ya que los expertos son los expertos y esta gente tienen nombres de científicos volaos en la materia. Estas funciones son de uso general y de mucha utilidad , lo que mas me gusta es buscar con asteriscos alg* , me parece increíble como muchos (para no ser absoluto) editores de texto no traen esta opción para buscar texto .


Saludos desde Seubea


Si no quieren compilar pueden debugear el programa
http://sites.google.com/site/compactamos/descargas/ASM.zip?attredirects=0

ya tienes la busqueda el siguiente paso logico seria reemplazar  o ponerle a la busqueda la opcion case sensitive ;D

Primero quiero acelerar un poco este código , trabajar con Word o Dwords para ir poco mas rápido , aunque si lo hago con Dwords tengo que pensar bien la forma .

Que de esa manera yo invierto las cadenas :xD

Breve explicación sobre AND:
And es una multiplicación entre los bit destino y fuente
   0>0=0
   0>1=0
   1>0=0
   1>1=1

Se multiplican destino y fuente y retorna el resultado
----------------------------------------------------------
Breve explicación sobre XOR:
Para explicarlo de una forma simple y amena lo que hace XOR
es poner un 1 si hay un cambio ( es decir si el destino es
diferente de la fuente ) Si los dos son iguales entonces
es 0 el resultado , si son diferentes es 1

   0>0=0
   0>1=1
   1>0=1
   1>1=0

----------------------------------------------------------
Explicación sobre OR:
   
Devuelve un valor verdadero si cualquiera de las dos
 expresiones es verdadera.

Es decir, si hay un valor 1 en cualquiera de los operados
el resultado es 1. Si los dos son 0 entonces el resultado es 0

En resumen : Es una suma .

----------------------------------------------------------
Explicación sobre NOT:
   
Not lo que hace es invertir el valor , es decir si es 0 pasa a ser 1
y si es 1 pasa a ser 0

0>1
1>0


Saludos y espero que sirva de algo.

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 (http://foro.elhacker.net/asm/codigos_inutiles-t261032.0.html)


Salu DOs

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

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

Interesante... aunque talvez se podria hacer sin utilizar un tabla que contenga los 255 posibles valores hexadecimales de un byte...

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

¿ds es un registro?

Si, es un (d=data) registro de segmento:
http://en.wikipedia.org/wiki/X86#x86_registers

La página de wikipedia esa me va genial, segmentos de mi procesador 64 bits que podria usar :P
Y una cosa, no funcionan los registros de 64 bits en un pc de 32 verdad, me refiero a que si yo creo un .exe en FASM usando registros x86_64 no iran bien en un pc de 32.

Un PE de 64 bits no se puede ejecutar en una maquina (o S.O.) de 32 bits.

Es verdad no me acordaba, pero tampoco tiene que ser un PE, puedes ser un ELF.

Si, efectivamente puede ser un ELF o ELF64 y se mantiene el mismo principio.

Genial, gracias idol :)

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

"In x86 processors, the parity flag reflects the parity only of the least significant byte of the result, and is set if the number of ones is even."

http://en.wikipedia.org/wiki/Parity_flag

Hola , como muchos saben existen muchos métodos de ordenar caracteres, números etc, de diferentes formas , condiciones , hay tantas formas de ordenar algo como distribuciones de linux hay en internet . Cada una de estas formas tienen su nombre y rapidez diferente, una muy conocida es Quick Sort (estará bien escrito?) , ahora la que les voy a mostrar hoy me llego a la cabeza cuando leía la lista de métodos de ordenamiento y es una forma simple, “rápida” (eso espero , tengo que probarla ) . Le he llamado Ordenamiento Grille , como cuando descubres un cráter nuevo en la luna , pero como no tengo telescopio y la luna ya está llena de nombres pues le pongo mi apellido a esta forma de ordenar caracteres.  :xD

Aunque no está implementado este método nos da la posibilidad de poder ordenar un conjunto de datos grande sin tener que cargarlo completamente en memoria ,esto puede ser útil en archivos grandes.

No me queda más nada por decirles , solo que es libre para usarlo bajo las condiciones de la  GPL  :-)
Primero necesitamos la longitud de los datos que ordenaremos. Este dato estará en ECX y EDX , usaremos un loop para ordenar empezando por el final Tendremos una Variable “vacía” con una longitud (en este caso de 4 bytes por cada byte ASCII) .
Es decir 256*4 = 1024 bytes , esto nos da la posibilidad de ordenar hasta (si fuera “necesario”) 4.294.967.295 bytes de datos (pequeño numero  ;D )
Esto puede “incluso” aumentarse para ordenar mas … o menos …
.

tabla db 1024 dup (?)
datos db “hola que tal”,0
mov ecx,12 ; << Longitud de los datos en decimal
mov edx,ecx ; << Longitud de los datos
ordenamiento:
mov al,[datos - 1 + ecx]
inc dword ptr ds:[tabla + eax * 4]
loop ordenamiento
mov al, 0
ciclo:
mov ecx , dword ptr ds:[tabla + eax * 4]
cmp ecx,0 ; Cuando sea Cero , saltamos ya que este caracter no existe!
jz salto
 

; En el caso que usted sepa que existen todos los caracteres puede eliminar esta parte.
; Ma adelante tal vez implemente una forma para detectar esto y hacer todo mas rápido?¿ (hay que probar!)

aun:
mov byte ptr ds:[datos - 1 + edx],al
dec edx
loop aun
salto:
dec al
jnz ciclo

Invertir un Byte. Eso , invertir un byte , por ahí andan formas de hacerlo (en C++ ..) pero siempre trato de hacer lo mio propio y compartirlo con todo aquel que quiera aprender junto a mi este difícil arte.Y Siempre recuerda que no hay nada mejor que aprender usando OLLY

1) Si usted tiene alguna duda no dude en preguntarme . Con mucho gusto aclaro lo que he hecho.
2) No copie y pegue .
3) Y recuerde quien es el author.  ;D
4) Disfrútalo

EJ>> 10010  << 12 hex
      > 01001  << 9  hex

El Byte a invertir esta en EAX , especificamente en AL.

mov ecx,8

giros:
ror al,1
shl ax,1
shr al,1
loop giros

xchg al,ah

Hasta la próxima.

No se si lo he entendido muy bien...

Pero no seria lo mismo que esto?
:huh:

Hola , no es lo mismo que hacer un NOT
Este codigo lo que hace es darle la vuelta como a una tortilla .

Ej 00011 >>> 11000


Si haces un not en el caso de 00011 el resultado es 11100

Mira aqui sobre NOT>
http://foro.elhacker.net/asm/codigos_de_yuri_grille-t257809.0.html;msg1266079#msg1266079

Taba pensando lo mismo, pero es verdad, juas.