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
Cita de: AmeRiK@nO en 12 Junio 2009, 06:58 AM
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
Cita de: ny0x en 13 Junio 2009, 01:59 AM
Cita de: AmeRiK@nO en 12 Junio 2009, 06:58 AM
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
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
Cita de: Arcangel_0x7C5 en 14 Junio 2009, 22:15 PM
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
Cita de: Arcangel_0x7C5 en 15 Junio 2009, 01:07 AM
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.
Cita de: YST en 15 Junio 2009, 01:37 AM
Cita de: Arcangel_0x7C5 en 15 Junio 2009, 01:07 AM
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.
Cita de: Yurix en 16 Junio 2009, 21:57 PM
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:
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
Cita de: biribau en 19 Junio 2009, 00:46 AM
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 .
Cita de: Yurix en 22 Junio 2009, 21:11 PM
A que te refieres cuando dices >
"De ese manera lo hago yo :P" ?
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
Cita de: Eternal Idol en 12 Agosto 2009, 11:10 AM
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.
Cita de: Eternal Idol en 12 Agosto 2009, 11:25 AM
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.
Cita de: Eternal Idol en 12 Agosto 2009, 12:53 PM
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?
mov al, 8
not al
: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
Cita de: Karcrack en 25 Septiembre 2009, 18:02 PM
No se si lo he entendido muy bien...
Pero no seria lo mismo que esto?
mov al, 8
not al
:huh:
Taba pensando lo mismo, pero es verdad, juas.