CAPITULO 0 INTRODUCCION
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
Despues de mucho leer y practicar estos temas, me he decidido
a contribuir con mi pequenio grano de arena, a difundir y dar a conocer
esta olvidada y oculta "ciencia". He traducido este manual,
porque es muy ameno, facil de leer, y sobre todo por su gran utilidad
para aquellos que quieran empezar a crackear.
Esta es una traduccion y una pequenia ampliacion del tutorial
"Uncle Joe's CrackBook, A beginers guide to cracking" (El libro de
cracks del tio joe, una guia del crackig para principiantes). No
es una traduccion literal, ni totalmente correcta, pero para aquellos
a los que el ingles les molesta, les va a resultar de
muy util.
Espero que les guste...
------------------------------------------------------------------------------
------------------------------------------------------------------------------
EL LIBRO DE CRACKS DEL TIO "PEPE"
O
UNA GUIA DEL CRACKING PARA PRINCIPIANTES
Capitulo 1(X) Vista general
Capitulo 2(X) Algunos trucos para usar un debugger
Capitulo 3( ) Tecnicas basicas de cracking
Capitulo 4( ) Recorrido por un crack sencillo
Capitulo 5( ) Como usar un "disk editor" (editor hexadecimal)
Capitulo 6( ) Otras herramientas del cracking
Capitulo 7( ) Codigo fuente de un parcheador simple
Capitulo 8( ) Conclusion
------------------------------------------------------------------------------
traductor-> Este manual se distribuye conforme va siendo traducido.
Probablemente, no traducire todos los capitulos, porque algunos,
como el septimo, son codigo casi por completo, con pequenios comentarios,
y no merece la pena traducirlos. Si aun asi, teneis mucho interes en
ello, se podria llegar a un acuerdo...
Tambien seria recomendable, tener a mano, el tutorial original
para echar un vistazo a los capitulos no traducidos, y para tener
las dos herramientas y el programa de ejemplo de la guia. (Podeis
encontrar, el fichero original en BBS CLUB: 968-201819 y
968-201262 [Murcia, Espania] o en Internet)
Para distinguir mas o menos, lo que es texto orginal
de lo que son intromisiones mias, voy a escribir mis comentarios, entre
lineas de guiones (----) o entre corchetes ([,]).
------------------------------------------------------------------------------
CAPITULO 1 VISTA GENERAL
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
Te estaras preguntando [perdona el tuteo] que nivel de programacion necesitas
para llegar a ser un cracker. Conocer un lenguaje de alto nivel, como
Basic [ :-) ], Pascal o C, te puede ayudar, para comprender el proceso
en el que esta envuleta la creacion de un programa y como funcionan ciertos
aspectos de un programa. Si no tienes, ningun nivel de programcaion, te queda
un largo camino por recorrer. Pero incluso si puedes programar en un lenguaje
de alto nivel, para crackear necesitas saber ensamblador.
------------------------------------------------------------------------------
traductor-> Efectivamente, para crackear es inevitable usar el ensamblador.
Para empezar a crackear, no es muy imprescindilbe un alto conocimiento
de asm (ensamblador para los amigos), con conocer las instrucciones
del procesador, es suficiente, pero si quieres llegar a ser un buen cracker
tienes que estudiar mucho ensamblador.
Lo del lenguaje de alto nivel tampoco es imprescindible, pero
es muy util conocer la estructura tipica de un programa (loops, saltos,
etc..) porque sino, te vas a perder muchas veces dentro del inmenso
codigo desensamblado de un programa.
------------------------------------------------------------------------------
Realmente no importa, en que lenguaje fue escrito un programa a la hora
de crackearlo, porque todos los programas hacen lo mismo. Y esto es el
uso de los comandos del microprocesador. Todos los programas, cuando
son desensamblados en su forma mas simple, no son mas que una coleccion
de instrucciones del 80xxx [en el caso de los PCs] y de datos especificos
del programa. Este es el nivel del lenguaje ensamblador. En ensamblador
se tiene un total control sobre el sistema. Este nivel es en el que tabaja
el debugger.
------------------------------------------------------------------------------
traductor-> Esto podria ser discutible, porque en algunos casos raros, se
dispone de los fuentes del programa a crackear, lo que facilita mucho el
trabajo, si se conoce el lenguaje en que esta escrito, pero en general, como
el dice, al final, todos los progrmas acaban haciendo mas o menos los mismo.
------------------------------------------------------------------------------
No necesitas llegar a ser un maestro de ensamblador para crackear un programa,
pero serlo, te ayudara. Necesitaras, aprender algunos principios rudimentarios
y tendras que familiarizarte con los registros de la cpu y como las
instrucciones del 8088 las usan. No hay discusion posible sobre esto.
El nivel de ensamblador que tengas, determinara, el nivel de cracking, que
alcanzaras. Podras aprender unas cuantas instrucciones, como
usar el debugger y una o dos tecnicas simples, esto te llevara a quitar unas
pocas "nag screens" (pantallas molestas) shareware y quizas, con un poco de
suerte, eliminar la proteccion de copia, de algun juego, pero eso sera
todo.
Tan pronto, como el programador, coloque algunos codigos anto-debugging
o empiece a cambiar los vectores de las interrupciones, empezaras a quejarte,
para que alguien te mande un crack para esto o para lo otro. Y entonces
tendras que olvidarte para siempre de crackear programas para windows.
------------------------------------------------------------------------------
traductor-> Bueno, algunos de los nuevos debuggers, como el soft-ice, son
capaces de evitar muchos problemas con los codigos anti-debugging, pero la
revectorizacion de interrupciones, todavia sigue siendo un problema para los
crackers, aunque se puede solucionar.
------------------------------------------------------------------------------
Es mucho mas facil, aprender a crackear en DOS que en windows. DOS es el
entorno mas facil de debuggear. Esta guia estara enfocada a los programas
del dos, porque crackear aplicaciones para windows es un poco exagerado,
a menos que ya seas un cracker experimentado. Y si lo eres, esta perdiendo
el tiempo, leyendo esto. Este manual esta dedicado al novato, principiante,
que no tiene ni idea de por donde empezar y necesita un poco de ayuda para
comenzar.
------------------------------------------------------------------------------
traductor-> Sin duda, crackear bajo windows, es mas dificil que en dos, por la
propia estructura de este sistema operativo, y por otras razones como son
el gran tama¤o que suelen tener los ejecutables y el uso extensivo de
librerias. Pero en realidad tampoco se diferencia mucho del cracking en
dos, y algunos programas para windows, son realmente faciles de crackear,
incluso con tecnicas tan simples, como las que se ven en este tutorial.
------------------------------------------------------------------------------
Hay algunos buenos manuales para principiantes por ahi, pero la mayoria
de ellos, asumen que la persona tiene al menos alguna experiencia en el
cracking o conoce como se usan las diferentes herramientas de un cracker.
Y el novato generalmente acaba frustrado con ellos muy deprisa porque
no entiende, los conceptos, que en ellos aparecen.
He escrito esta guia tan primaria, para que los novatos la lean antes de
empezar a leer las otras guias mas completas. He intentado mantenerla, tan
simple como ha sido posible y he dejado gran cantidad de informacion fuera
para no sobrecargar a alguien con demasiada informacion al mismo tiempo.
Por suerte despues de leer esta guia sera mucho mas facil para el
principiante entender los conceptos de las otras guias mas arcanas. Asi
que si estas leyendo esto y te parece poco reparador, recuerda que hubo
un tiempo en el que no sabias para que se usaba un debugger.
------------------------------------------------------------------------------
traductor-> Bueno, segun recuerdo, los otros tutoriales de cracking, que he
leido tampoco eran muy complicados, y la mayoria eran faciles de seguir desde
cero. A lo mejor al final acababas perdiendote, pero si te lo tomabas con
calma y practicabas un poco les cogias el truco. Tal vez el problema mas
grande para el principiante sea el manejo del debugger, ya que suelen ser
programas muy poco amigables, pero ya hay para la mayoria de ellos guias de
uso, e incluso libros escritos. A si que si quieres empezar en serio, pillate
un par de tutoriales de cracking, un buen debugger con sus manuales y manos a
la obra.
------------------------------------------------------------------------------
Ahora en caso de que no estes famirializado con el debugger y con el
editor hexadecimal y cuales son sus diferentes roles en el cracking,
voy a dar una breve explicacion de cada uno. poque estas son las dos
herraminetas mas valiosas del cracker.
El debugger es lo que usaras ahora para crackear el programa. Cuando cargas
un programa que quieres crackear en el debugger, el lo cargara en memoria
y se detendra en la primera instruccion que sera ejecutada en el segmento
de codigo [si no sabes de que va esto, estudia mas ensamblador]. O puedes
tambien opcionalmente detener un programa ya en funcionamiento y el debugger
detendra el programa en la instuccion en la que tu paraste y esperara tus
instrucciones. En este punto tienes el control del programa.
------------------------------------------------------------------------------
traductor-> Como he dicho, ademas de el tutorial de cracking, es muy util tener
a
mano un manual del debugger que vamos a usar. Y practicar con el antes de
ponernos a crackear para cogerle el truco, ya que esta sera la herramienta
con la que mas tiempo pasaremos cuando estemos crackeando.
-------------------------------------------------------------------------------
-
Ahora puedes interactuar dinamicamente con el programa y ejecutar una linea
de codigo cada vez, y ver exactamente que es lo que el programa hace en
tiempo real cuando se ejecuta instrucion por instruccion. Ademas eres capaz
de re-ensamblar las instrucciones (solo en memoria), editar el contenido de
las localizaciones de memoria, manipular los registros de la cpu y ver los
efectos de estas manipulaciones en el programa cuando se ejecute. Este es
ademas el momento en el que tu sistema puede bloquearse [cuando ejecutas
el programa despues de modificarlo]. Hay un monton de intentos y errores
envueltos en el cracking.
------------------------------------------------------------------------------
traductor-> Efectivamente, uno de los problemas del cracking, son los cuelgues,
ya que modificar el contenido de un programa o el de la memoria es un
asunto muy complicado, si no se conoce a fondo el contexto en el que
se trabaja, pero no os preocupeis ya que los nuevos debuggers suelen
aguantar bastante bien los colapsos.
------------------------------------------------------------------------------
Como se menciona arriba, el debugger solo puede modificar el programa cuando
este esta cargado y ejecutandose en memoria. Para hacer permanentes los
cambios, necesitaras cargar el fichero para ser parcheado con el editor
hexadecimal que escribira los cambios que has echo, al disco. Una explicacion
mas detallada de esto, se dara en el capitulo 5.
------------------------------------------------------------------------------
traductor-> Hay otras maneras, de hacer permanente un crack, como son hacer
cargadores o cracks residentes, etc... pero la manera mas sencilla y
rapida es esta, aunque no siempre es posible, como ya veremos.
------------------------------------------------------------------------------
Asi que con esto en mente, necesitaras dos herramientas esenciales... La
primera es un buen debugger. La forma original de esta guia daba instrucciones
explicitas de como usar mi debugger favorito. Despues de una considerable
deliveracion, her decidido re-escribir la guia y hacer las instrucciones mas
genericas para que puedan aplicarse a la mayoria de los debuggers. Tambien
necesitaras un editor hexadecimal, no es muy importane cual uses mientras
sea capaz de cargar el programa, buscar y editar los bytes que quieres cambiar
[y luego guardarlo a disco, claro].
He uuencodeado unas pocas herramientas de cracking que encontraras
imprescindibles y las he puesto al final de esta guia [en la guia en ingles].
No quiero tratar el uso de las herraminetas ahora. Pero creeme
seguramente necesitaras una de ellas, y la otra te librara de muchos
esfuerzos. Ademas he uuencodeado el programa que tendras que crackear
durante el transcurso de la guia.
------------------------------------------------------------------------------
traductor-> No voy a incluir las herramientas en esta version de la guia,
pero recomiendo conseguirlas, sacandolas del tutorial original o buscandolas
en internet.
------------------------------------------------------------------------------
Cuando vayas mejorando, puedes escribir programas que implementen tus
patches si decides distribuirlos. Estos patches no necesitan estar escritos
en ensamblador.
------------------------------------------------------------------------------
traductor-> Esta de moda distribuir los cracks, con presentaciones tipo
demo, muy vistosas, como los cracks de UCF. Pero no es necesario tener
mucho nivel de programacion para hacer un patch, simplemente es un programa
que modifique unos bytes de otro. El lenguaje tampoco importa, incluso
si recordais los tipicos cargadores para spectrum o amiga, que venian
escritos en basic.
------------------------------------------------------------------------------
El codigo que incluyo en este manual para el "byte-patcher" es el
primer parcheador que he escrito y extremadamente simple. Esta escrito
en ensamblador por que es el unico lenguaje en el que se programar. Pero si
eres realmente eficiente en un lenguaje de alto nivel, debe ser
trivial para ti duplicar sus metodos en tu lenguaje preferido.
CAPITULO 2 ALGUNOS TRUCOS PARA USAR EL DEBUGGER
-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
Vale, antes de que empiece, solo quiero expresar lo importante que es
que conozcas al menos algo de ensamblador antes de intentar continuar. Si
no lo conoces estaras perdido muy rapido de aqui en adelante. La
comprension del sistema de base numerica 16 (hexadecimal) tambien es
necesaria.
No voy a dar un remedio para solucionar tus problemas de ensamblador o de
matematica hexadecimal, ya que llevaria mucho tiempo y probablemente dejaria
muchas cuestiones sin responder. Por ahi fuera, hay suficiente informacion
sobre esto disponible en un monton de otras fuentes.
------------------------------------------------------------------------------
traductor-> Hay muchas obras y algunas muy buenas sobre ensamblador y sobre
el formato hexadecimal. En castellano hay un par de libros sobre el tema
muy buenos, y algunos tutoriales, como el curso de ensamblador de aesoft,
muy facil y ameno, disponible, por supuesto en bbs club. En ingles hay cientos
de obras electronicas y escritas, en internet se pueden encontarar cientos de
guias de ensamblador, elige la que mas te guste y a aprender.
------------------------------------------------------------------------------
Asi que, desde aqui en esta guia, asumo que tienes un ligero conocimiento de
ensamblador y del formato hexadecimal. Si digo algo que no entiendas o no
puedes comprender algun concepto, buscalo en algun lugar...
He intentado hacer esta seccion tan generica, como me ha sido posible. He
usado descripciones generales en la explicacion de las teclas y de los
comandos porque los diferentes debuggers usan diferentes teclas y el sintaxis
de los comandos varia para implementar estas funciones.
Tienes que ser capaz de traducir estas instrucciones a las teclas o
comandos que tu debugger usa... Si no sabes como usar un debugger, presta
atencion!! Si ya sabes como usar un debugger puedes saltar esta seccion ya
que solo es una ligera vision de las diferentes ventanas y funciones dise¤ada
para el absoluto principiante que no tiene ni idea de lo que esta viendo.
Primero, dare una vision de las diferentes ventanas que la mayoria de los
debuggers usa.
VENTANA DE REGISTROS: ("register window")
La ventana de registros contiene los registros generales y las banderas
("flags") de la cpu. Te daras cuenta de que los registros generales contienen
valores hexadecimales. Estos valores son los que habia, cuando
has detenido el debugger. Tambien puedes notar que algunas de las banderas
estan iluminadas mientras que otras no. Normalmente las resaltadas son las
que estan activadas, mientras las que no lo estan son las que estan
desactivadas. La forma de esta ventana puede variar de un debugger a otro
pero todas son basicamente lo mismo.
------------------------------------------------------------------------------
traductor-> Algunos debuggers primitivos, como el debug del dos, no funcionan
con ventanas, lo que es bastante molesto y lento. Si el tuyo no dispone de
ventanas, o estas son poco informativas, intenta conseguir un debugger mas
moderno pues sera mas seguro y facil de usar.
------------------------------------------------------------------------------
Desde esta ventana seras capaz de manipular el contenido de los registros de
la cpu. Algunos debuggers permiten esto pulsando en los registros con
el raton y introduciendo el valor. Otros mas potentes usan un inteface de
linea de comandos. Tendras que descubrir como va tu debugger por ti mismo.
Puedes cambiar los valores de los registros mientras estes debuggeando un
programa para cambiar el desarollo de este. Por ejemplo apareces cerca de una
intrucccion JNZ (Salta si la bandera Zero esta activada) [Cualo??, que?!?,
comorl!? = mira el manual de ensamblador] esta instruccion toma la decison de
hacer o no hacer el salto basandose en el estado de la bandera (Z)ero. Tu
puedes modificar la condicion de la bandera (Z)ero para cambiar el transcurso
del codigo del programa.
De la misma manera puedes modificar los registros generales. Digamos que el
registro AX contiene 0000, y el programa basa sus acciones en ese valor.
Modificandolo para que contenga un nuevo valor puedes tambien afectar al
desarrollo del codigo. Cuando empieces a sentirte comodo usando el debugger
comenzaras a apreciar como es de poderosa esta ventana y descubriras tambien
pronto como puede colgar tu sistema totalmente si la jodes.
------------------------------------------------------------------------------
traductor-> La modificacion de los registros puede ser peligrosa, pero es
basica en el cracking, para probar si funcionaria un crack sin necesidad
de modificar el programa en curso (que seria mucho mas peligroso) ni la
memoria, y para muchas otras tareas necesarias en el cracking.
------------------------------------------------------------------------------
VENTANA DE DATOS: ("data window")
La ventana de datos muestra los datos [valga la rebuznancia] como se
encuentran en la memoria. desde esta ventana puedes normalmente, ver, buscar,
editar, llenar y borrar zonas enteras de memoria. Los dos comandos mas comunes
para esta ventana son ver y editar. El comando buscar es tambien normal en el
cracking. Pero para el nivel de debugging que estoy ense¤ando en esta guia,
no voy a hacer uso de esta ventana. Tienes mucho que aprender antes de que
esta ventana llegue a ser util para ti.
------------------------------------------------------------------------------
traductor-> La ventana de datos al principio parece inutil en el cracking,
cuando empiezas a crackear programas sencillos, en los que simplemente hay
que modificar un salto condicional para que el crack funcione. Pero cuando
el nivel de cracking va subiendo y la cantidad de codigo desensamblado es
cada vez mayor, se hace muy dificil el tracear entero un programa y entonces
es necesario hacer un traceado mas selectivo usando mucho las busquedas y
los breakpoints en zonas de memoria estrategicas, sin las cuales seria
imposible encontrar el trozo de codigo clave.
------------------------------------------------------------------------------
VENTANA DE CODIGO: ("code window")
La ventana de codigo es en la que tu interactuaras con el programa en
ejecucuion. Esta es la ventana mas compleja y es donde el grueso del
debugging ocurre. Solo vere un par de teclas y comandos aqui, porque la
mayoria de las lecciones de como usar esta ventana vendran cuando ense¤e
como crackear un programa.
La forma de la ventana es muy simple, el grupo de ocho numeros con los
dos puntos en el centro de ellos en la zona izquierda de la pantalla son
la direccion:offset de la linea de codigo. Cada linea de codigo en esta
ventana es una instruccion que el programa manda al microprocesador y los
parametros para esta instruccion. Los registros que contienen la direccion
para la instruccion actual que espera ser ejecutada es el registro CS:IP
(CodeSegment=segmento de codigo y InstructionPointer=puntero de
instrucciones)
------------------------------------------------------------------------------
traductor-> La ventana de codigo es donde se desarrolara principalmente
el cracking de un programa, desde ella seguiremos el transcurso del
programa linea a linea de codigo. Procurad que esta ventana sea grande y
visible, para que os permita ver un trozo amplio de codigo, para evitar
imprevistos. Otra cosa, ni se os ocurra tocar el registro CS:IP excepto
que esteis totalmente seguros de que podeis hacerlo sin peligro y de que
no se pueda evitar hacerlo de una manera mas facil (como un JMP).
------------------------------------------------------------------------------
Tambien podras ver un grupo de numeros hexadecimales a la derecha de la
direccion, este grupo de numeros es el equivalente hexadecimal a la
intruccion mnemonica [Es el codigo maquina 8-O ]. El siguiente grupo de
palabras y numeros a la derecha seran los propios mnemonicos de las
instrucciones.
TECLAS Y COMANDOS:
Ahora no vamos a mover a las teclas. No voy a verlas todas, solo las mas
comunes y lo mismo para los comandos.
La telca RESTAURAR LA PATALLA DEL USUARIO: ("restore user screeen") Esta
tecla alterna el display entre la pantalla del debugger y la del programa
que estas debuggeando sin que el control vuelva al programa en si mismo. Es
util para comprobar lo que el programa esta haciendo de vez en cuando,
especialmente de pues de pasar un CALL.
La tecla AQUI: ("here") esta tecla es un breakpoint no permanenete. Para
usarla coloca el cursor en la linea de codigo [donde quieres ir] y pulsala. El
programa entonces funcionara hasta que encuentre esa linea. Cuando (y si)
el programa encuentra esa linea, se detiene, y el control vuelve al
debugger y el breakpoint es borrado.
La tecla TRACE: (para tracear) Esta tecla ejecutara una linea de codigo cada
vez y traceara dentro de las llamadas ("CALLs"), loops y interrupciones.
La tecla de BREAKPOINT: Esta es una tecla de breakpoint permanente. Esta
tecla habilita un breakpoint permanente en la linea de codigo donde el cursor
este situado. Cuando un breakpoint permanente es habilitado la ejecucion del
programa de detendra todas las veces que encuentre la linea del breakpoint
y devolvera el control al debugger, hasta que lo quites manualmente.
La tecla de PASO SIMPLE: ("single step") La tecla mas usada del teclado. esta
tecla ejecuta una linea de codigo cada vez pero no tracea dentro de calls,
loops o interrupciones. Cuando saltas un call, interrupcion o loop con esta
tecla, todo el codigo contenido dentro de la sub-rutina es ejecutada antes
de que el control vuelva el debugger. Si el programa nunca vuelve de la
sub-rutina, puedes perder el control del programa que se ejecutara
normalmente.
La tecla EJECUTAR: ("run") Esta tecla devuelve el control al programa que
esta siendo debuggeado y le permite ejecutarse normalmente. El control
no sera devuelto al debugger a menos que un breakpoint que tu hayas puesto
sea encontrado.
------------------------------------------------------------------------------
traductor-> Muchas teclas son a su vez comandos, y los comandos pueden
asignarse a teclas concretas. Por eso la diferencia entre teclas y
comandos en los debuggers modernos, es muy poca. A si que la diferenciacion
que hace en este tutorial no es muy practica. Lo digo para que no haya
lugar a confusiones, si en el manual de tu debugger, encuentras que run,
es un comando no una tecla.
------------------------------------------------------------------------------
Ahora unos comandos:
El comando IR A: ("go to") Funciona como la tecla aqui.
Cuando introduces este comando, el debugger devolvera el control al programa
hasta que encuentre la linea de codigo que especificaste en
el comando IR A. Cuando el registo CS:IP es igual a la direccion que pusiste,
el programa se detendra y el control regresara al debugger y el breakpoint
sera borrado.
Te estaras preguntando porque teclear esta orden cuando puedes en vez de
eso, pulsar la tecla AQUI. La respuesta es esta: La tecla AQUI, es buena
si quieres poner un breakpoint local. Por un breakpoint local entiendo
que el breakpoint que tu quieres situar esta cerca de tu localizacion actual
en el programa.
Pero y si tu quieres situar un breakpoint en una linea de codigo que no
esta en el segmento de codigo actual? No puedes usar la tecla AQUI porque
la direccion no esta cerca del punto en el que tu estas en el programa. Esto,
ademas de otros usos son los que el comando IR A viene a hacer.
------------------------------------------------------------------------------
traductor-> Aqui el autor, se ha liado un poco con la explicacion, y
ademas mi traduccion complica aun mas la cosa. Por si no ha quedado
claro:
-Tecla AQUI ("HERE") >> para moverse a un punto del codigo, cercano a la
situcaion actual, es decir, en el mismo segmento de codigo.
-Comando IR A ("GO TO") >> para ir hacia un punto del codigo, lejos de la
posicion actual, en otro segmento de codigo distinto del actual.
------------------------------------------------------------------------------
El comando ENSAMBLAR: ("assemble") Es el comando que usaras para re-escribir
las instrucciones del programa. Este comando te permite ensamblar nuevas
instrucciones empezando en la direccion que hayas tecleado, o en la posicion
actual CS:IP. Las instrucciones que introduzcas, sustituiran (solo en
memoria) a las existentes en el codigo del programa en las direccion
especificada. Este es otro metodo de alterar el programa en curso para
que haga lo que tu quieras, y no lo que el programador quiso.
EJEMPLO: Supongamos que hay una linea de codigo tal que asi JNZ 04FC, y
queremos cambiarla por una asi JMP 04FC. Usamos el comando ENSAMBLAR y la
direccion del codigo que quieres cambiar, entonces teclea JMP 04FC.
Ahora la linea de codigo en la ventana de codigo cuya direccion pusiste
en el comando ASSEMBLE estara sobre-esctita con el codigo que tecleaste.
Algunos debuggers automaticamente se dirigen por defecto a la direccion
contenida en CS:IP para este comando.
------------------------------------------------------------------------------
traductor-> Como habreis notado, estoy poniendo menos comentarios que de
costumbre, esto se debe a dos razones, el texto, deja poco que decir, y
estoy trabajando en la revista electronica "saqueadores" muy interesante
para los que gustan de estos temas, pero que me esta quitando algo de
concentracion. Si quereis ver mi trabajo en la revista, la podeis
encontrar en bbs club y en www-iberhack (luego dare el url). La revista
trata de hackin, crackin, etc... y seguro que os va a gustar.
Bueno, despues de la publicidad, vamos a volver al trabajo.
------------------------------------------------------------------------------
Hay un monton de otros comandos disponibles en esta ventana, dependiendo del
debugger que estes usando, incluyendo comandos para situar breakpoint en
interrupciones, zonas de memoria, comandos que listan y borran breakpoints,
comandos para desensamblar intruciones, etc... No voy a tratar estos
comandos, las mejores lecciones que puedes aprender son las que tu mismo
te ense¤es.
------------------------------------------------------------------------------
traductor-> La cantidad, variedad y potencia de los comandos depende de cada
debugger. Algunos poseen solo unos pocos, otros poseen listas larguisimas
de comandos especificos. Normalemente solo usaras unos pocos de estos comandos
pero nunca vienen mal unos cuantos para ocasiones especiales. Por eso
consigue un manual de tu debugger, o una lista de los comandos que admite
y experimenta un poco con ellos, para ver lo que hace cada uno. No aprenderas
a usar el debugger hasta que te pongas manos a la obra, e incluso asi,
tardaras bastante en dominarlo.
------------------------------------------------------------------------------
Bien, esto es suficiente para los debuggers en general, sin tratar
instrucciones explicitas para determinados debuggers. La unica cosa que puedo
decirte es que cuanto mas lo uses, mas facil te sera controlarlo. No
esperes que te sea familiar nada mas empezar. Como en todo, la practica lleva
a la perfeccion. Me ha costado 5 a¤os y cientos de horas de debugging
alcanzar el nivel que tengo ahora. Y todavia aprendo algo nuevo o
re-aprendo algo que habia olvidado en cada programa que crackeo. Nunca
pienses que lo sabes todo, crackear es un proceso de aprendizaje
constante.
------------------------------------------------------------------------------
------------------------------------------------------------------------------
------------------------------------------------------------------------------
$$ Los otras entregas de este curso pueden encontrarse en:
- BBS CLUB (Murcia)
968-201819 y 968-201262
- y en internet en
http://www.geocities.com/SiliconValley/park/7574/