TRADUCCION AL CASTELLANO DE UNCLE JOE'S CRACKBOOK POR ELJAKER PARA BBS CLUB MURCIA ------------------------------------------------------------------------------ CAPITULO 0 INTROCUCCION -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-= Despues de mucho leer y practicar estos temas, me he decidido a contribuir con mi peque¤o 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 peque¤a 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 inlges les hace molesta su lectura, les va a resultar de muy util. Espero que os 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 peque¤os 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, Espa¤a] 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/