| AND 
 
            
                | Uso: | AND dest,src |  
                | Propósito: | Realiza un AND
                lógico de las dos entradas, reemplazando el dest
                con el resultado |  
                | Ejemplo: | AND BX,03h |  
                | No hay mucho que pueda decirse sobre esta
                llamada, hace lo que dice.
 | 
 
 
 CALL
 
 
            
                | Uso: | CALL address |  
                | Propósito: | Ejecuta una
                función en la dirección 'address' |  
                | Ejemplo: | CALL 10284312 |  
                | Llama la función a la dirección 'address', una
                vez la función ha terminado, el código
                continuará en la línea siguiente a la llamada.
 | 
 
 
 CMP
 
 
            
                | Uso: | CMP dest,scr |  
                | Propósito: | Resta src del dest
                y actualiza las banderas. |  
                | Ejemplo: | CMP AX,03h |  
                | Esta es una instrucción importante hasta donde
                nosotros (crackers) estamos interesados
                :). Está en alguna parte del programa para
                verificar algo, por ejemplo. para comparar el
                número de serie real a uno que nosotros
                introducimos, o para verificar si un programa
                está registrado etc.
 
 Esta instrucción normalmente precede a una
                instrucción de salto de algún tipo.
 | 
 
 
 Flags (Banderas)
 
 
            
                | Las banderas son
                esencialmente como los registros sólo que
                ellos pueden ser sólo verdaderos o falsos (por
                ejemplo 0 o 1). Éstos son juego de ordenes
                como CMP, y se usa para verificar el resultado de
                una llamada, por ejemplo: 
 CMP AX, BX; Compara AX a BX, si igual la bandera
                del cero se pone a 1
 JZ 00124531; Si la bandera del cero se pone,
                salta a 001254531
 
 Para entender esto propiamente, tendrás que
                seguir leyendo probablemente y entonces volverás
                atrás...
 | 
 
 
 INT
 
 
            
                | Uso: | INT
                interrupt_number |  
                | Propósito: | Llama una función
                predefinida (normalmente codificado en la
                BIOS) |  
                | Ejemplo: | INT 10h |  
                | Realmente no verás esta orden mucho (casi en
                absoluto) cuando corriges programas de
                Windows, pero ellos se mueven alrededor del DOS.
                Normalmente los parámetros son pasados en los registros predefinidos
                (AX, BX, CX etc.) .
 
 Hay demasiadas llamadas INT para listarlas aquí,
                mejor conseguir una copia de una lista de
                interrupciones. ¡Ralph
                Browns es muy bueno! :).
 | 
 
 
 JMP
 
 
            
                | Uso: | JMP address |  
                | Propósito: | Equivalente a un
                GOTO en basic, salta a una sección de código |  
                | Ejemplo: | JMP 00402011 |  
                | JMP es un salto incondicional a una sección de
                código. ¡Tan simple como eso! :)
 Hay montones de variaciones de esta instrucción,
                las más importantes son:
 
 JZ Salta si la bandera de cero se pone (lo
                mismo que JE)
 JNZ Salta si la bandera de cero se no se pone (lo
                mismo que JNE)
 
 Éstos normalmente siguen a una instrucción CMP,
                por ejemplo:
 
 CMP RealSerial,BadSerial; Compara el numero de
                serie real a nuestro numero de serie
 JNE GoAwayBadCracker; Si No Igual entonces
                termina.
 
 | 
 
 
 LODSB / LODSW (Cruehead)
 
 
            
                | Uso: | LODSB / LODSW |  
                | Propósito: | Cargas un byte o
                una palabra de DS:SI y lo pone en AL (LODSB) o
                AX (LODSW). Incrementa SI |  
                | Ejemplo: | LODSW |  
                | Permite decir que DS:SI apunta a una palabra que
                posee el valor de EBh
 
 LODSW; Copia la palabra a la que apunta DS:SI y
                lo coloca en AX
 
 AX contendrá el valor de EBh ahora
 
 
 
 Estas instrucciones se usan a menudo junto con la
                instrucción REP.
 | 
 
 
 MOV
 
 
            
                | Uso: | MOV dest,src |  
                | Propósito: | Copia el valor de
                un byte o palabra desde el origen al destino |  
                | Ejemplo: | MOV AX,DX |  
                | Verás esto * mucho * cuando estés caminando a
                través del código, son básicamente los
                recursos (para usar términos de
                BASIC;))
 LET dest = src
 
 Hay varias variantes incluida MOVSX, pero todas
                ellas hacen básicamente la misma cosa. Podría
                ayudar recibir las Especificaciones de
                Programación de Intel de su website.
 
 ¡Si no puedes entender esto, estas fastidiado!
                ;)
 | 
 
 
 MOVSB / MOVSW (Cruehead)
 
 
            
                | Uso: | MOVSB / MOVSW |  
                | Purpose: | Mueve (bien,
                realmente copia) o un byte (MOVSB) o
                una palabra (MOVSW) de DS:SI a ES:DI.
                Incrementa SI |  
                | Ejemplo: | MOVSB |  
                | Permite decir que DS:SI apunta a un byte que
                posee el valor de 5h
 
 MOVSB; Toma el byte al que apunta DS:SI y lo
                coloca en ES:DI
 
 El byte al que apunta ES:DI ahora tiene el valor
                de 5h
 
 
 
 Esta instrucción es muy común en cracking,
                cuando una cadena se copia a otra dirección. Las
                instrucciones se usan entonces junto con la
                instrucción REP
 | 
 
 
 Registers (Registros)
 
 
            
                | Los registros son
                lugares básicamente predefinidos en cuál para
                guardar datos. Los únicos sobre los que nosotros
                necesitamos preocuparnos son: (E)AX, (E)BX, E(CX), E(DX) (La (E) es sólo
                significativa cuando se corrige Código 32-Bit ).
 
 También las parejas del registro:
 
 DS:SI; puede usarse como el origen para las
                operaciones de cadenas
 ES:DI; Usado como el destino para las operaciones
                de cadenas
 
 Entender los registros no es muy importante para
                crackear, generalmente solo con saber que ellos
                son variables para el almacenamiento de datos es
                bastante para que consigas empezar :)
 | 
 
 
 REP
 
 
            
                | Uso: | REP |  
                | Propósito: | Repite una
                instrucción durante el número de veces
                especificado en el registro de CX. Un REP delante
                de un MOVSB , LODSB o STOSB (o delante
                de las versiones de estas instrucciones) causaría
                que esa instrucción se repitiese. |  
                | Ejemplo: | MOV AL,Bh; AL
                contiene bh ahora MOV CX,5h; CX contiene 5h ahora
 REP STOSB; Copia valor de AL (5h) dentro de
                cualquiera de los puntos de DS:SI 5 veces e
                incrementa SI cada vez .
 | 
 
 
 RET
 
 
            
                | Uso: | RET |  
                | Propósito: | Para volver desde
                una función |  
                | Ejemplo: | RET |  
                | Normalmente verás esto al final de una función,
                y simplemente instruye al procesador para
                RETornar a la función, a la dirección de la LLAMADA.
 | 
 
 
 STOSB / STOSW (Cruehead)
 
 
            
                | Uso: | STOSB / STOSW |  
                | Propósito: | Toma el valor en
                AL (STOSB) o AX (STOSW) y lo coloca
                en DS:SI. Incrementa SI. |  
                | Ejemplo: | STOSB |  
                | Permite decir que AX posee el valor de EBh
 
 STOSB
 
 Copia el valor en AX y lo coloca en la palabra a
                la que apunta DS:SI. DS:SI apunta ahora a una
                palabra que contiene EBh
 
 Las instrucciones se usan entonces junto con la
                instrucción REP.
 | 
 
 
 The Stack & Push/Pop
 
 
            
                | Antes de cualquier
                función de llamada, un programa debe ' empuja '
                cualquier parámetro que la función espera hacia
                la pila. Piensa en ello como una pila de platos,
                el primer plato en la pila es el último en ser
                tomado fuera de la pila, es exactamente lo mismo.
                Es importante recordar esto ' primero puesto /
                último quitado ' principalmente al mirar una
                LLAMADA, esto
                significa que los parámetros se pasarán en
                orden inverso... 
 En caso de que mi balbuceo te haya confundido,
                echa mirada a este ejemplo:
 
 La función API GetDlgItemText de Windows
                requiere los parámetros siguientes:
 
 (1) el manipulador de caja de dialogo
 (2) el identificador de control
 (3) la dirección de pulidor para el texto
 (4) el tamaño del máximo de cadena
 
 Por consiguiente éstos podrían pasarse así:
 
 MOV EDI,[ESP+00000220]; Obtiene el Manipulador de
                la caja de dialogo en EDI
 PUSH 00000100; EMPUJA (4) el tamaño Máximo de
                la cadena
 PUSH 00406130; EMPUJA (3) la Dirección del
                buffer para el texto
 PUSH 00000405; EMPUJA (2) el Identificador de
                control
 PUSH EDI; EMPUJA (1) el Manipulador de la caja de
                dialogo
 CALL GetWindowText; LLAMA a la función
 
 ¿Fácil Eh? ¡Ésta puede ser una de las maneras
                más simples de crackear una app de número de
                serie, si conoces la dirección del buffer para
                el número de serie, en este caso 00406130, sólo
                pon un punto de ruptura en él, y normalmente
                acabarás a en o alrededor del procedimiento que
                genera el numero de serie real!! :)
 
 POP es usado simplemente para remover el primer
                elemento de la pila, normalmente hay mucho ellos
                antes del retorno de una función al programa...
 | 
 |