El Arte de La Explotacion Vista Previa

8/18/2019 El Arte de La Explotacion Vista Previa

1/42

HACKING: EL ARTE DE LA EXPLOTACIÓN – 2NDA EDICIÓN Traducido por Ivinson 2012

Traductor: Ivinson - @IvinsonCLS


2/42


3/42




4/42



2NDA EDICIÓN

HACKINGEL ARTE DE LA EXPLOTACIÓN

TRADUCIDO POR IVINSONCrackingvenezolano.blogspot.com

JON ERICKSON


5/42



Copyright © 2008 por Jon Erickson.

Todos los derechos reservados. Ninguna parte de este documento puede serreproducida o transmitida en cualquier forma o por cualquier medio, ya seaelectrónico o mecánico, incluyendo el fotocopiado, grabación o por cualquier sistemade almacenamiento o recuperación de información sin el previo permiso escrito delpropietario del derecho de autor y el editor.

Impreso en papel reciclado en los Estados Unidos de América.

11 10 09 08 07 1 2 3 4 5 6 7 8 9ISBN-10: 1-59327-144-1ISBN-13: 978-1-59327-144-2

Autor: William Pollock.Editores de producción: Christina Samuell y Megan Dunchak.Diseño de portada: Octopod Studios.Editor de Desarrollo: Tyler Ortman

Técnico Evaluador: Aaron AdamsEditores de copia: Dmitry Kirsanov y Megan Dunchak.Compositores: Christina Samuell y Kathleen Mish.Corrector: Jim Brook.Indexador: Nancy Guenther.

Para obtener información sobre los distribuidores de libros o traducciones, por favorponte en contacto con No Starch Press, Inc. Directamente:

No Starch Press, Inc.555 De Haro Street, Suite 250, San Francisco, CA 94107.Teléfono: 415.863.9900; fax: 415.863.9950; [email protected]; www.nostarch.com

Library of Congress Cataloging-in-Publication Data

Erickson, Jon, 1977-Hacking: the art of exploitation / Jon Erickson. -- 2nd Ed.p. cm.


6/42



ISBN-13: 978-1-59327-144-2ISBN-10: 1-59327-144-11. Computer security. 2. Computer hackers. 3. Computer networks--Security measures. I. Title.QA76.9.A25E75 2008005.8--dc22

2007042910

No Starch Press y el logotipo No Starch Press son marcas registradas de No StarchPress, Inc. Otros productos y compañías aquí mencionados pueden ser marcascomerciales de sus respectivos propietarios. En lugar de utilizar un símbolo de marcacomercial con cada aparición de un nombre de marca registrada, estamos usando losnombres sólo de manera editorial y en beneficio del propietario de la marca, sin

intención alguna de infracción de la marca registrada.

La información contenida en este libro se distribuye "tal cual", sin garantía. Si bientodas las precauciones se han tomado en la preparación de este trabajo, ni el autor niNo Starch Press, Inc. serán responsables frente a cualquier persona o entidad conrespecto a cualquier pérdida o daño causado o presuntamente causado directa oindirectamente por el la información contenida en el mismo.


7/42



CONTENIDO BREVE

Prefacio....................................................................................................................... xi

Reconocimientos........................................................................................................ xii

0x100 Introducción .......................................................................................................1

0x200 Programación......................................................................................................5

0x300 Explotación. ...................................................................................................115

0x400 Redes …….....................................................................................................195

0x500 Shellcode ......................................................................................................281

0x600 Contramedidas ............................................................................................319

0x700 Criptología ....................................................................................................393

0x800 Conclusión ....................................................................................................451

Índice.........................................................................................................................455


8/42



CONTENIDO DETALLADO

PREFACIO xi

RECONOCIMIENTOS xii

0x100 INTRODUCCIÓN 1

0x200 PROGRAMACIÓN 5

0x210 ¿Qué es la programación? .............................................................. 60x220 Pseudo-código.................................................................................. 70x230 Estructuras de Control ..................................................................... 80x231 If-Then-Else....................................................................................... 80x232 Bucles While/Until ............................................................................. 90x233 Bucles For ......................................................................................... 100x240 Más conceptos fundamentales de programación ............................ 110x241 Variables .......................................................................................... 110x242 Operadores Aritméticos.................................................................... 120x243 Operadores de Comparación........................................................... 14

0x244 Funciones ........................................................................................ 160x250 Metiendo los Pies al Barro ............................................................... 190x251 La Imagen más Grande .................................................................... 200x252 El Procesador x 86 …......................................................................... 230x253 Ensamblador …………....................................................................... 250x260 Regresando a lo Básico .................................................................... 370x261 Strings ............................................................................................... 380x262 Signed, Unsigned, Long, y Short ….................................................. 410x263 Punteros .. ........................................................................................ 43

0x264 Formatos de Strings .......................................................................... 480x265 Typecasting o Conversión de Tipo .................................................. 510x266 Argumentos de Línea de Comandos ................................................. 580x267 Enfoque de Variables ........................................................................ 620x270 Segmentación de Memoria ............................................................... 690x271 Segmentos de Memoria en C ............................................................ 750x272 Usando el Heap ................................................................................. 770x273 Chequeo de Errores con malloc() ...................................................... 800x280 Construyendo lo Básico ..................................................................... 81

0x281 Acceso a Archivos ............................................................................. 81


9/42



0x282 Permisos de Archivos ........................................................................ 870x283 ID´s de Usuarios .............................................................................. 880x284 Estructuras ........................................................................................ 96

0x285 Punteros de Funciones .................................................................... 1000x286 Números Pseudo-random ............................................................... 1010x287 Un juego de azar ……...................................................................... 102

0x300 EXPLOTACIÓN 115

0x310 Técnicas Generalizadas de Exploits ............................................... 1180x320 Desbordamiento de Buffer .............................................................. 1190x321 Vulnerabilidades del Desbordamiento de Buffer ………................. 1220x330 Experimentando con BASH ............................................................. 1330x331 Usando el Entorno …….................................................................... 1420x340 Desbordamientos en Otros Segmentos .......................................... 1500x341 Un Desbordamiento de Heap Básico .............................................. 1500x342 Desbordando Punteros de Funciones ............................................ 1560x350 Formato de Strings .......................................................................... 1670x351 Parámetros de Formato ................................................................... 1670x352 La Vulnerabilidad de Formato de Strings ........................................ 1700x353 Leyendo Direcciones de Memoria Arbitrarias ................................. 1720x354 Escribiendo en Direcciones de Memoria Arbitrarias ........................ 173

0x355 Acceso a Parámetros Directos ........................................................ 1800x356 Usando Escrituras Cortas ................................................................ 1820x357 Desvíos con .dtors............................................................................ 1840x358 Otra Vulnerabilidad de Notesearch ................................................. 1890x359 Sobrescribiendo la Tabla Global de Offsets .................................... 190

0x400 REDES 195

0x410 ModelO OSI ..................................................................................... 196

0x420 Sockets ............................................................................................ 1980x421 Funciones del Socket ...................................................................... 1990x422 Direcciones del Socket ................................................................... 2000x423 Orden de Bytes de Red ................................................................... 2020x424 Conversión de Direcciones de Internet ........................................... 2030x425 Un Ejemplo de un Servidor Sencillo ................................................ 2030x426 Un Ejemplo de Cliente Web ............................................................ 2070x427 Un Servidor Tinyweb ...................................................................... 2130x430 Quitando las capas Inferiores .......................................................... 217

0x431 Capa de Enlace de Datos .............................................................. 218


10/42



0x432 Capa de Red …... ............................................................................ 2200x433 Capa de Transporte ......................................................................... 2210x440 Sniffing en la Red ............................................................................ 224

0x441 Sniffer Tipo Raw Socket ….............................................................. 2260x442 Sniffer Tipo libpcap ......................................................................... 2280x443 Decodificando las Capas ................................................................. 2300x444 Sniffing Activo ….............................................................................. 2390x450 Denegación de Servicio .............................................................. 2510x451 SYN Flooding ............................................................................. 2520x452 El Ping de la Muerte ................................................................... 2560x453 Lágrima ….................................................................................... 2560x454 Ping Flooding ............................................................................. 2570x455 Ataques de Amplificación ........................................................... 2570x456 DoS Flooding Distribuido.............................................................. 2580x460 Secuestrando TCP/IP .................................................................. 2580x461 Secuestrando RST ...................................................................... 2590x462 Continuando con el Secuestro .................................................... 2630x470 Escaneo de Puertos .................................................................... 2640x471 Escaneo Stealth SYN .................................................................. 2640x472 Escaneo FIN, X-mas, y Null.......................................................... 2640x473 Señuelos de Suplantación ........................................................... 2650x474 Idle Scanning.............................................................................. 265

0x475 Defensa Proactiva (Sudario) ....................................................... 2670x480 Hackea a Alguien …… .................................................................. 2720x481 Análisis con GDB …....................................................................... 2730x482 Casi solo cuenta con Granadas de Mano ..................................... 2750x483 Port-Binding Shellcode …………………………………………........ 278

0x500 SHELLCODE 281

0x510 Ensamblador vs. C ......................................................................... 282

0x511 Llamadas al Sistema de Linux en ASM .......................................... 2840x520 El Camino a la Shellcode ............................................................... 2860x521 Instrucciones ASM Usando la Pila …. ............................................ 2870x522 Investigando con GDB …................................................................. 2890x523 Quitando los Bytes Nulos ................................................................ 2900x530 Shell-Spawning Shellcode ............................................................... 2950x531 Un Tema de Privilegio ..................................................................... 2990x532 Y Más Pequeño Aún ....................................................................... 3020x540 Port-Binding Shellcode .................................................................... 303

0x541 Duplicando Descriptores de Archivo Estándar ................................ 307


11/42



0x542 Ramificando Estructuras de Control ................................................ 3090x550 Connect-Back Shellcode ................................................................. 314

0x600 CONTRAMEDIDAS 3190x610 Contramedidas que Detectan ......................................................... 3200x620 System Daemons............................................................................. 3210x621 Curso Intensivo de Señales ............................................................ 3220x622 Tinyweb Daemon …........................................................................ 3240x630 Herramientas del oficio ................................................................ 3280x631 Herramienta de Exploit para Tinyweb ......................................... 3290x640 Archivos de Registro ................................................................... 3340x641 Mezclándose con la multitud ....................................................... 3340x650 Mirando lo Obvio …...................................................................... 3360x651 Un Paso a la Vez …..................................................................... 3360x652 Poniendo las Cosas como estaban ............................................. 3400x653 Trabajadores Infantiles ................................................................ 3460x660 Camuflaje Avanzado ................................................................... 3480x661 Suplantando la Dirección IP Guardada (Spoofing) ..................... 3480x662 Explotación sin Registro .............................................................. 3520x670 La Infraestructura Completa ........................................................ 3540x671 Reutilización del Socket .............................................................. 355

0x680 Contrabando de Payloads ............................................................ 3590x681 Codificando Strings ...................................................................... 3590x682 Cómo Ocultar una Secuencia ...................................................... 3620x690 Restricciones del Buffer ............................................................... 3630x691 Shellcode ASCII Polimórfica e imprimible ................................... 3660x6a0 Reforzando las Contramedidas .................................................. 3760x6b0 Pila no Ejecutable ........................................................................ 3760x6b1 ret2libc .......................................................................................... 3760x6b2 Retornando a system().................................................................. 377

0x6c0 Espacio de Pila Randomizada ...................................................... 3790x6c1 Investigaciones con BASH y GDB ................................................ 3800x6c2 Rebotando en la Puerta de Linux ................................................ 3840x6c3 Conocimiento Aplicado ................................................................. 3880x6c4 Un Primer Intento .......................................................................... 3880x6c5 Jugando con las probabilidades ................................................... 390


12/42



0x700 CRIPTOLOGÍA 393

0x710 Teoría de la Información ................................................................ 394

0x711 Seguridad Incondicional ................................................................. 3940x712 One-Time Pads o Libretas de un Solo Uso ..................................... 3950x713 Distribución de Clave Cuántica ....................................................... 3950x714 Seguridad Computacional …............................................................ 3960x720 Tiempo de ejecución algorítmica ..................................................... 3970x721 Notación asintótica …...................................................................... 3980x730 Encriptación Simétrica ..................................................................... 3980x731 Algoritmo Cuántico de Búsqueda de Lov Grover ............................ 3990x740 Encriptación Asimétrica ................................................................... 4000x741 RSA ................................................................................................. 4000x742 Algoritmo Cuántico de Factorización de Peter Shor ....................... 4040x750 Cifrados Híbridos .......................................................................... 4060x751 Ataques Man-in-the-Middle ............................................................ 4060x752 Diferenciando Los Fingerprints del Host del Protocolo SSH .......... 4100x753 Fingerprints Confusas ..................................................................... 4130x760 Crackeando Contraseñas ............................................................... 4180x761 Ataque por Diccionario ................................................................... 4190x762 Ataques Exhaustivos de Fuerza Bruta .......................................... 4220x763 Tabla de búsqueda de Hashes ........................................................ 423

0x764 Matriz de Probilidades de Contraseña .......................................... 4240x770 Encriptación inalámbrica 802.11b ................................................. 4330x771 Privacidad equivalente por cable ................................................... 4340x772 RC4 Stream Cipher o Cifrado de Flujo RC4 ................................. 4350x780 Ataques WEP ............................................................................... 4360x781 Ataques de Fuerza Bruta Offline .................................................. 4360x782 Reutilización de Keystream .......................................................... 4370x783 Tablas de Diccionarios de Desencriptación Tipo IV ..................... 4380x784 Redirección de IP............................................................................ 438

0x785 Ataques Fluhrer, Mantin, y Shamir ................................................. 439

0x800 CONCLUSIÓN 451

0x810 Referencias ..................................................................................... 4520x820 Fuentes ........................................................................................... 454

ÍNDICE


13/42



PREFACIO

El objetivo de este libro es compartir el arte del Hackingcon todo el mundo. Comprender las técnicas de Hacking es

a menudo difícil, ya que requiere tanto la amplitud yprofundidad de los conocimientos. Muchos textos deHacking parecen esotéricos y confusos por causa de tan sólo unos pocosfallos en esta educación de pre-requisito.

Esta segunda edición de Hacking: El Arte de la Explotación hace que el mundo delHacking sea más accesible, proporcionando la imagen completa, desde laprogramación en código máquina a la explotación. Además, esta edición cuenta conun LiveCD basado en Ubuntu-Linux que puede ser utilizado en cualquiercomputadora con un procesador x86, sin modificar el sistema operativo existente enel equipo. Este CD contiene todo el código fuente del libro y proporciona un entornode desarrollo y explotación que puedes utilizar para seguir junto con ejemplos dellibro y experimentar a lo largo del camino.


14/42



RECONOCIMIENTOS

Me gustaría dar las gracias a Bill Pollock y todos los demásen No Starch Press por hacer de este libro una posibilidad ypermitirme tener un control creativo en el proceso. Además, megustaría agradecer a mis amigos Seth Benson y Aaron Adams por la revisión y

edición, Jack Matheson por ayudarme con ASM, El Dr. Seidel por mantenermeinteresado en la ciencia de la informática, mis padres por comprar ese primerCommodore VIC-20, y la comunidad Hacker por la innovación y la creatividad queprodujo las técnicas explicadas en este libro.


15/42



0x100INTRODUCCIÓN

La idea del Hacking puede evocar imágenes estilizadas de

vandalismo electrónico, el espionaje, el pelo teñido yperforaciones en el cuerpo. La mayoría de la gente asocia elHacking con infringir la ley y asume que todo el que sededica a actividades de Hacking es un criminal. Es ciertoque hay gente ahí fuera que utiliza técnicas de Hacking para violar la ley, peroel Hacking no se trata realmente de eso. De hecho, el Hacking está más cerca deseguir la ley que de romperla.

La esencia del Hacking está encontrando usos no previstos o ignorados por las leyesy propiedades de una situación dada y luego aplicándolas en formas nuevas einventivas para resolver un problema, sea lo que sea.

El problema matemático siguiente ilustra la esencia del Hacking:

Usa cada uno de los números 1, 3, 4, y 6 de una sola vez con cualquiera de las cuatrooperaciones matemáticas básicas (suma, resta, multiplicación y división) para que de

un total de 24. Cada número debe ser usado una vez y sólo una vez, y es posible


16/42



definir el orden de las operaciones, por ejemplo, 3 * (4 + 6) + 1 = 31 es válido, sinembargo incorrecta, ya que no hace un total de 24.

Las reglas para este problema están bien definidas y simples, pero la respuesta escapaa muchos. Al igual que la solución a este problema (que se muestra en la últimapágina de este libro), las soluciones hackeadas siguen las reglas del sistema, peroutilizan los reglas de maneras contrarias a la intuición. Esto pone al límite a loshackers, lo que les permite resolver problemas de maneras inimaginables paraaquellos confinados al pensamiento y metodologías convencionales.

Desde la infancia de los ordenadores, los hackers han estado resolviendo problemascreativamente. A finales de 1950, al club de ferrocarriles modelo MIT se le dio unadonación de piezas, en su mayoría equipos telefónicos viejos. Los miembros del clubutilizaron este equipo para montar un sistema complejo que permitía a múltiplesoperadores controlar diferentes partes de la pista, marcando en las seccionescorrespondientes. Ellos llamaron hacking a este nuevo e inventivo uso de equipotelefónico, y mucha gente considera este grupo como los hackers originales. El grupopasó a la programación de tarjetas perforadas y cinta de teletipo para las primerascomputadoras como la IBM 704 y el TX-0. Mientras que otros se contentaron conescribir programas que resolvían problemas, los primeros hackers estabanobsesionados con los programas de escritura que resuelven problemas también. Unnuevo programa que conseguía el mismo resultado como uno ya existente pero que

utilizaba menos tarjetas perforadas se consideraba el mejor, incluso a pesar de quehizo lo mismo. La diferencia clave es cómo el programa logró sus resultados -elegancia.

Ser capaz de reducir el número de tarjetas perforadas necesarias para un programamostró una maestría artística sobre el equipo. Una mesa bien diseñada puede contenerun jarrón tan bien como una caja de leche puede, pero uno seguramente se ve muchomejor que el otro. Los primeros hackers demostraron que los problemas técnicospueden tener soluciones artísticas, y así transformaron la programación de una mera

tarea de ingeniería en una forma de arte.

Al igual que muchas otras formas de arte, el Hacking fue a menudo mal entendido.Los pocos que lo lograron formaron una subcultura informal que se mantuvoconcentrada intensamente en el aprendizaje y el dominio de su arte. Ellos creían quela información debería ser libre y cualquier cosa que se interpusiera en el camino dela libertad debería ser evitada.

Tales obstáculos incluyen las figuras de autoridad, la burocracia de clases de la

universidad, y la discriminación. En un mar de estudiantes impulsados a graduarse,


17/42



este grupo no oficial de hackers desafiaron las metas convencionales y buscaron elconocimiento mismo. Este deseo de aprender continuamente y explorar trascendióhasta los límites convencionales elaborados por la discriminación, evidentes en la

aceptación de Peter Deutsch, 12, del club de ferrocarriles modelo MIT al demostrarsu conocimiento de la TX-0 y su deseo de aprender. La edad, raza, sexo, apariencia,grados académicos, y la situación social no eran criterios principales para juzgar el

valor de otra persona, no por un deseo de la igualdad, sino por el deseo de promoverel arte emergente del Hacking.

Los hackers originales encontraron el esplendor y la elegancia en la forma cienciasconvencionales y secas de las matemáticas y la electrónica. Vieron la programacióncomo una forma de la expresión artística y la computadora como un instrumento deese arte. Su deseo para diseccionar y entender que no pretendía desmitificar losesfuerzos artísticos, sino que era simplemente una forma de lograr un mayor apreciode ellos. Estos valores hacia del conocimiento con el tiempo se llamarían la ética delhacker: la apreciación de la lógica como una forma de arte y la promoción de la librecirculación de la información, superación de los límites convencionales y lasrestricciones para el simple objetivo de una mejor comprensión del mundo. Esta no esuna nueva tendencia cultural, los pitagóricos de la Grecia antigua tuvieron una éticasimilar y subcultura, a pesar de no poseer computadoras. Ellos vieron la belleza de lasmatemáticas y descubrió muchos conceptos básicos de geometría. Esa sed de

conocimiento y sus subproductos beneficiosos continuarían a través de la historia,desde los pitagóricos a Ada Lovelace a Alan Turing para los hackers del club deferrocarriles modelo MIT.

Hackers modernos como Richard Stallman y Steve Wozniak han continuado ellegado de Hacking, trayéndonos los sistemas operativos modernos, lenguajes deprogramación, ordenadores personales, y muchas otras tecnologías que utilizamoscada día.

¿Cómo se puede distinguir entre los buenos hackers que nos traen las maravillas delprogreso tecnológico y los hackers malignos que roban nuestros números de tarjetade crédito? El término cracker fue acuñado para distinguir los hackers malignos delos buenos. Los periodistas dijeron que crackers se suponen que son los malos,mientras que los hackers eran los buenos. Los hackers se mantuvieron fieles a la éticadel hacker, mientras que los crackers estaban sólo interesado en romper la ley y hacerdinero rápido. Los crackers se consideran mucho menos talentosos que los hackers deélite, ya que simplemente hicieron uso de herramientas y scripts de Hacking escritossin entender cómo funcionaban. Cracker estaba destinado a ser la etiqueta para quien

hiciera cosas sin escrúpulos con un ordenador – pirateando software, destruyendo


18/42



sitios Web, y lo peor de todo, sin entender lo que estaban haciendo. Pero muy pocaspersonas utilizan este término en la actualidad.

La falta de popularidad del término puede ser debido a su etimología confusa -cracker originalmente describió a los que rompen los derechos de autor de software yhacen ingeniería inversa a sistemas de protección de copia. Su impopularidad actualsimplemente pudiera derivarse de sus dos nuevas definiciones ambiguas: un grupo depersonas que se involucran en actividades ilegales con computadoras o personas queson relativamente hackers inexpertos.

Pocos periodistas de tecnología se sienten obligados a utilizar términos con los que lamayoría de sus lectores no están familiarizados. En contraste, la mayoría de la gentees consciente del misterio y la habilidad asociada con el término hacker, así que paraun periodista, la decisión de utilizar el término hacker es fácil. Del mismo modo, eltérmino script kiddie se utiliza a veces para referirse a los crackers, pero simplementeno tiene el mismo gusto que el hacker sombrío. Hay algunos que todavía sostienenque hay una línea clara entre hackers y crackers, pero creo que cualquiera que tengael espíritu hacker es un hacker, a pesar de las leyes que él o ella pueda romper.

Las leyes actuales restringiendo la criptografía y la investigación criptográfica opacanla línea entre los hackers y los crackers. En 2001, el profesor Edward Felten y suequipo de investigadores de la Universidad de Princeton estaban a punto de publicar

un artículo que discutía las debilidades de los distintos sistemas de marcas de aguadigitales.

Este documento responde a un desafío lanzado por Secure Digital Music Initiative(SDMI) en el Reto Público de SDMI, lo que alentó al público para intentar romperestos esquemas de marcas de agua. Antes de que Felten y su equipo pudieran publicarel artículo, fueron amenazados tanto por la Fundación SDMI y Recording IndustryAssociation of America (RIAA).

Digital Millennium Copyright Act (DCMA) de 1998 establece que es ilegal discutir oproporcionar tecnología que pudiera utilizarse para evitar los controles de la industriade consumo. Esta misma ley fue utilizada contra Dmitry Sklyarov, un programadorinformático ruso y hacker.

Había escrito software para burlar el cifrado demasiado simplista en el software deAdobe y presentó sus conclusiones en una convención de hackers en los EstadosUnidos. El FBI se abalanzó y lo arrestaron, lo que lo llevó a una larga batalla legal.Según la ley, la complejidad de los controles de la industria de consumo no importa-

que sería técnicamente ilegal hacer ingeniería inversa o incluso discutir el Pig Latin si


19/42



se utiliza como un control de consumo de la industria. ¿Quiénes son los hackersinformáticos y que son los crackers ahora? Cuando las leyes parecen interferir con lalibertad de expresión, ¿los chicos buenos que dicen lo que sienten de repente se

vuelven malos? Creo que el espíritu del hacker trasciende las leyes gubernamentales,en lugar de ser definido por ellos.

Las ciencias de la física nuclear y la bioquímica se pueden utilizar para matar, sinembargo, también nos proveen con el avance científico significativo y la medicinamoderna. No hay nada bueno o malo sobre el conocimiento mismo; la moralidadreside en la aplicación de los conocimientos. Incluso si quisiéramos, no podríamossuprimir el conocimiento de cómo convertir la materia en energía o detener elprogreso tecnológico continuo de la sociedad. De la misma manera, el espíritu hackerno puede ser detenido, ni puede ser clasificado fácilmente o disecado.

Los hackers siempre estarán empujando los límites del comportamiento aceptable y elconocimiento, nos obliga a explorar más y más.

Parte de este camino se traduce en una beneficiosa co-evolución de seguridad a travésde la competencia entre los hackers atacantes y defensores. Así como la gacela rápidase adaptó a ser perseguida por el leopardo, y el leopardo se volvió aún más rápidopor perseguir a la gacela, la competencia entre los hackers proporciona a los usuariosuna mejor y más fuerte seguridad, así como técnicas de ataque más complejas y

sofisticadas. La introducción y el avance de los sistemas de detección de intrusos(IDS) es un buen ejemplo de este proceso co-evolutivo. Los hackers defensores creanIDS para añadirlos a su arsenal, mientras que los hackers atacantes desarrollantécnicas de evasión de IDS, que finalmente tuvo una compensación en productos IDSmás grandes y mejores.

El resultado neto de esta interacción es positivo, ya que produce personas másinteligentes, mejora la seguridad, el software es más estable, técnicas inventivas deresolución de problemas, e incluso una nueva economía.

La intención de este libro es enseñarte sobre el verdadero espíritu del Hacking.

Veremos técnicas de hackers diversos, desde el pasado hasta el presente,diseccionando para aprender cómo y por qué funcionan. Se incluye con este libro unLiveCD booteable que contiene todo el código fuente utilizado en este documento,así como un entorno Linux preconfigurado. La exploración y la innovación sonfundamentales para el arte del Hacking, por lo que este CD te permitirá seguiradelante y experimentar por tu cuenta. El único requisito es un procesador x86, que

es utilizado por todas las máquinas de Microsoft Windows y los nuevos ordenadores


20/42



Macintosh, simplemente inserta el CD y reinicia. Este entorno Linux suplente nomolesta a tu sistema operativo existente, por lo que cuando hayas terminado,simplemente reinicia de nuevo y extrae el CD.

De esta manera, ganarás una comprensión práctica y apreciación del Hacking quepueden inspirarte a mejorar las técnicas existentes o incluso de inventar otras nuevos.

Esperamos que este libro estimule la naturaleza hacker curiosa en ti y te pida quecontribuyas al arte del Hacking, de alguna manera, sin importar de qué lado de lavalla elijas estar.


21/42



0x200 PROGRAMACIÓN Hacker es un término tanto para los que escriben código y

los que lo explotan. A pesar de que estos dos grupos dehackers tienen diferentes objetivos finales, ambos gruposutilizan técnicas de resolución de problemas similares. Ya

que, la comprensión de la programación ayuda a los queexplotan, y una comprensión de explotación ayuda aquienes programan, muchos hackers hacen ambas cosas. Hay hacksinteresantes que se encuentran tanto en las técnicas utilizadas para escribir códigoelegante y las técnicas utilizadas en Exploits para programas.

El Hacking es realmente sólo el acto de encontrar una solución inteligente y contrariaa la intuición de un problema.

Los hacks que se encuentran en Exploits para programas suelen utilizar las reglas dela computadora para evitar la seguridad en formas nunca previstas. Los hacks deprogramación son similares en que también utilizan las reglas de la computadora deformas nuevas e inventivas, pero el objetivo final es la eficiencia o código fuente máspequeño, no necesariamente un compromiso de seguridad. En realidad, hay unnúmero infinito de programas que pueden ser escritos para llevar a cabo una tareadeterminada, pero la mayoría de estas soluciones son innecesariamente grandes,complejas y descuidadas. Las pocas soluciones que quedan son pequeñas, eficientes yordenadas. Los programas que tienen estas cualidades se dice que tienen la elegancia,


22/42



y las soluciones inteligentes e innovadoras que tienden a conducir a esta eficacia, lascuales se llaman hacks. Los hackers en ambos lados de programación aprecian labelleza del código elegante y el ingenio de los hacks inteligentes.

En el mundo de los negocios, se le da más importancia a la producción de códigofuncional que al logro de la elegancia y hacks inteligentes. Debido al enormecrecimiento exponencial de la potencia de cálculo y la memoria, gastar cinco horasextras para crear un trozo de código un poco más rápido y más eficiente con respectoa la memoria simplemente no tiene sentido para los negocios cuando se trata decomputadoras modernas que tienen giga Hertz de ciclos de procesamiento ygigabytes de memoria. Mientras que las optimizaciones de tiempo y memoria van sinprevio aviso por todos excepto el más sofisticado de los usuarios, una nuevacaracterística es comercializable. Cuando el resultado final es el dinero, pasar tiempoen hacks inteligentes para la optimización simplemente no tiene sentido.

La verdadera apreciación de la elegancia de la programación se deja para los hackers:aficionados a los ordenadores cuyo objetivo final no es obtener beneficios, sinoexprimir cada pedacito posible de la funcionalidad de su viejo Commodore 64s,escritores de Exploits que necesitan escribir trozos de código pequeños ysorprendentes para deslizarse a través de grietas estrechas de seguridad, y cualquierpersona que aprecie la persecución y el reto de encontrar la mejor solución posible.

Estas son las personas que se entusiasman acerca de la programación y realmenteaprecian la belleza de un trozo de código elegante o la ingenuidad de un hackinteligente. Ya que la comprensión de la programación es un requisito previo paraentender cómo los programas pueden ser explotados, la programación es un punto departida natural.

0x210 ¿Qué es la programación?

La programación es un concepto muy natural e intuitivo. Un programa no es más queuna serie de instrucciones escritas en un idioma específico. Los programas están entodas partes, e incluso los tecnófobicos del mundo, usan programas a diario.

Direcciones de manejo, recetas de cocina, juegos de fútbol, y el ADN son todos lostipos de programas.


23/42



Un programa típico para direcciones de manejo podría ser algo como esto:

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

“Comience por la calle principal hacia el este. Continúe por la calle principal hastaque vea una iglesia a su derecha. Si la calle está bloqueada debido a la construcción,cruce a la derecha allí en la calle 15, gire a la izquierda en Pine Street, y luego a laderecha en la calle 16. De lo contrario, usted puede continuar y girar a la derecha enla calle 16.

Continúe por la calle 16 y gire a la izquierda en la calle de destino. Siga derecho 5millas por Destination Road, y entonces verá la casa a la derecha.

La dirección es 743 Destination Road.-------------------------------------------------------------------------------------------------------

Cualquiera que sepa español, puede entender y seguir estas indicaciones para viajar,ya que están escritas en español. Por supuesto, no es elocuente, pero cada instrucciónes clara y fácil de entender, al menos para alguien que lea español.

Pero una computadora no entiende español de forma nativa, sino que sólo comprendeel lenguaje de máquina. Para indicarle a un ordenador que haga algo, lasinstrucciones deben ser escritas en su idioma. Sin embargo, el lenguaje de máquina es

arcano y difícil de trabajar con él - consiste en bits y bytes primos, y es diferente dearquitectura en arquitectura. Para escribir un programa en lenguaje de máquina paraun procesador Intel x86, tendrías que calcular el valor asociado a cada instrucción,cómo interactúa cada instrucción, y una miríada de detalles de bajo nivel.

La programación de este tipo es laboriosa y engorrosa, y ciertamente no es intuitiva.Lo que se necesita para superar la complicación de escribir en lenguaje de máquina esun traductor. Un ensamblador es una forma de traductor de lenguaje de máquina: esun programa que traduce el lenguaje ensamblador en código legible por la máquina.

El lenguaje ensamblador es menos críptico que el lenguaje de máquina, ya que utilizalos nombres de las diferentes instrucciones y variables, en lugar de usar sólonúmeros.

Sin embargo, el lenguaje ensamblador aún está lejos de ser intuitivo. Los nombres deinstrucciones son muy esotéricos, y el lenguaje es específico de la arquitectura. Asícomo el lenguaje máquina para procesadores Intel x86 es diferente al lenguajemáquina para los procesadores Sparc, el lenguaje ensamblador x86 es diferente allenguaje ensamblador de Sparc.


24/42



Cualquier programa escrito utilizando el lenguaje ensamblador para la arquitectura deun procesador no funcionará en otra arquitectura de procesador. Si un programa estáescrito en lenguaje ensamblador x86, debe ser reescrito para ejecutarse en la

arquitectura Sparc. Además, con el fin de escribir un programa eficaz en lenguajeensamblador, todavía tienes que saber muchos detalles de bajo nivel de laarquitectura del procesador para el que estás escribiendo.

Estos problemas pueden ser mitigados por otra forma de traductor llamadocompilador. Un compilador convierte un lenguaje de alto nivel a lenguaje demáquina.

Los lenguajes de alto nivel son mucho más intuitivos que el lenguaje ensamblador yse puede convertir en muchos tipos de lenguaje de máquina diferentes paraarquitecturas de procesador. Esto significa que si un programa está escrito en unlenguaje de alto nivel, el programa sólo es necesario que se escriba una vez, el mismotrozo de código del programa puede ser compilado en lenguaje de máquina paradiferentes arquitecturas específicas. C, C++ y Fortran son ejemplos de lenguajes dealto nivel.

Un programa escrito en un lenguaje de alto nivel es parecido al inglés y mucho másfácil de leer que el lenguaje ensamblador o lenguaje de máquina, pero aún debesseguir reglas muy estrictas acerca de cómo las instrucciones están redactadas, o el

compilador no será capaz de entenderlo.

0x220 Pseudo-código

Los programadores tienen todavía otra forma de lenguaje de programación llamadopseudo-código. Pseudo-código es simplemente inglés arreglado con una estructurageneral similar a un lenguaje de alto nivel. No se entiende por los compiladores,ensambladores u otros equipos, sino que es un modo útil para que un programadororganice instrucciones.

El pseudo-código no está bien definido, de hecho, la mayoría de la gente escribepseudo-código ligeramente diferente. Es una especie de nebulosa en el vínculoperdido entre lenguajes de programación en inglés y de alto nivel como C. El pseudo-código hace una excelente introducción a los conceptos de programación comunesuniversales.


25/42



0x230 Estructuras de Control

Sin estructuras de control, un programa no sería más que una serie de instrucciones

ejecutadas en orden secuencial. Esto está bien para programas muy simples, pero lamayoría de los programas, como el ejemplo de direcciones de manejo, no son tansimples. Las direcciones de manejo incluían afirmaciones como: Continúe por lacalle principal hasta que vea una iglesia a la derecha y si la calle está bloqueadaa causa de la construcción… Estos enunciados son conocidos como estructuras decontrol, y cambian el flujo del programa de ejecución de una orden secuencial simplede un flujo más complejo y más útil.

0x231 If-Then-Else

En el caso de nuestras indicaciones para viajar, la Calle Principal puede estar enconstrucción.

Si es cierto, un conjunto especial de instrucciones debe abordar esta situación. De locontrario, el conjunto original de instrucciones deben ser seguidas. Estos tipos decasos especiales pueden ser contabilizados en un programa con una de las estructurasde control más naturales: la estructura if -then-else. En general, se ve algo como esto:

-------------------------------------------------------------------------------------------------------If (condición) then //If significa Si y Then entonces. {

Conjunto de instrucciones que se ejecutarán si la condición se cumple;}Else{

Conjunto de instrucciones que se ejecutarán si la condición no se cumple;}-------------------------------------------------------------------------------------------------------

Para este libro, se utilizará un pseudo-código tipo lenguaje C, por lo que cadainstrucción terminará con un punto y coma, y los conjuntos de instrucciones seagruparán con llaves y sangría.


26/42



La estructura de pseudo-código if-then-else de acuerdo a las indicacionesprecedentes, podría ser algo como esto:

-------------------------------------------------------------------------------------------------------Conducir por la calle principal;

If (la calle está bloqueada)

{Gire a la derecha en la calle 15;Gire a la izquierda en Pine Street;Gire a la derecha en la calle 16;

}Else{

Gire a la derecha en la calle 16;}-------------------------------------------------------------------------------------------------------

Cada instrucción está en su propia línea, y los diversos conjuntos de instruccionescondicionales se agrupan entre llaves y sangría para facilitar la lectura.

En C y muchos otros lenguajes de programación, la palabra clave entonces estáimplícita y por lo tanto queda fuera, por lo que también se ha omitido en el pseudo-código precedente.

Por supuesto, otros lenguajes requieren la palabra clave then en su sintaxis - BASIC,Fortran, e incluso Pascal, por ejemplo. Estos tipos de diferencias sintácticas de loslenguajes de programación son sólo superficiales, la estructura subyacente siguesiendo la misma. Una vez que un programador entiende los conceptos que estoslenguajes están tratando de transmitir, el aprendizaje de las diferentes variaciones

sintácticas es bastante trivial. Puesto que se utilizará C en las secciones posteriores, elpseudo-código utilizado en este libro sigue una sintaxis similar a C, pero recuerdaque el pseudo-código puede tomar muchas formas.

Otra regla común de sintaxis similar a C es cuando un conjunto de instruccionesdelimitadas por llaves consiste en una sola instrucción, las llaves son opcionales. Enaras de la legibilidad, es una buena idea ponerle sangría a estas instrucciones, pero noes sintácticamente necesario.


27/42



Las direcciones de manejo de antes pueden volverse a escribir siguiendo esta reglapara producir un trozo de pseudo-código equivalente:

-------------------------------------------------------------------------------------------------------Conducir por la calle principal;

If (la calle está bloqueada)

{Gire a la derecha en la calle 15;Gire a la izquierda en Pine Street;Gire a la derecha en la calle 16;

}Else{

Gire a la derecha en la calle 16;}-------------------------------------------------------------------------------------------------------

Esta regla acerca de los conjuntos de instrucciones es válida para todas las estructurasde control mencionadas en este libro, la cual puede ser descrita en pseudo-código.

-------------------------------------------------------------------------------------------------------If (sólo hay una instrucción en un conjunto de instrucciones)

El uso de llaves para agrupar las instrucciones es opcional;

Else

{El uso de llaves es necesario;

Ya que debe haber una manera lógica de agrupar estas instrucciones;}-------------------------------------------------------------------------------------------------------

Incluso la descripción de una sintaxis puede ser pensada como un programa sencillo.Hay variaciones de if-then-else, como las instrucciones select / case, pero la lógicasigue siendo básicamente la misma: Si esto ocurre, haz estas cosas, de lo contrariohaz otras cosas (que podrían consistir en más sentencias if-then).


28/42



0x232 Bucles While/Until

Otro concepto de programación elemental es la estructura de control de

tiempo, que es un tipo de bucle. Un programador a menudo tendrá queejecutar un conjunto de instrucciones más de una vez. Un programa puederealizar esta tarea a través de un bucle, pero se requiere un conjunto decondiciones que le indique cuándo debe dejar de bucle, para que no continúehasta el infinito. Un bucle while dice que se ejecute el siguiente conjunto deinstrucciones en un bucle mientras una condición es verdadera. Un programasencillo para un ratón hambriento podría ser algo como esto:-------------------------------------------------------------------------------------------------------While (tengas hambre) //While significa “Mientras”.

{Encuentra algo de comida;Cómete la comida;}-------------------------------------------------------------------------------------------------------

El conjunto de las dos instrucciones siguientes a la sentencia while serepetirá mientras el ratón se queda con hambre. La cantidad de comida queel ratón encuentra cada vez puede ir desde una pequeña miga de pan hasta

todo el pan. Del mismo modo, el número de veces que el conjunto deinstrucciones de la sentencia while se ejecute cambia en función de lacantidad de alimentos que el ratón encuentra.

Otra variación sobre el bucle while es un bucle Until o hasta que, unasintaxis que está disponible en el lenguaje de programación Perl (C no utilizaesta sintaxis). Un bucle Until no es más que un bucle While con la sentenciacondicional invertida. El programa del mismo ratón utilizando un bucle Untilsería:

-------------------------------------------------------------------------------------------------------Until (No tengas hambre) //Until significa “Hasta que”.

{Encuentra algo de comida;Cómete la comida;}-------------------------------------------------------------------------------------------------------


29/42



Lógicamente, cualquier sentencia tipo Until se puede convertir en un buclewhile. Las direcciones de manejo anteriores tenían la declaración Continúeen la calle principal hasta que vea una iglesia a su derecha. Esto puede ser

fácilmente cambiado por un bucle While estándar simplemente invirtiendo lacondición.

-------------------------------------------------------------------------------------------------------While (No haya una iglesia a la derecha) Conduce por la calle principal;-------------------------------------------------------------------------------------------------------

0x233 Bucles For

Otra estructura de control de bucle es el bucle For. Este se utilizageneralmente cuando un programador desea repetir o iterar para un ciertonúmero de veces. La dirección de manejo Siga derecho 5 millas porDestination Road se puede convertir en un bucle parecido a esto:

-------------------------------------------------------------------------------------------------------For (5 iteraciones) Siga derecho 1 milla;-------------------------------------------------------------------------------------------------------

En realidad, un bucle For es un bucle While con un contador. La mismaafirmación puede ser escrita así:

-------------------------------------------------------------------------------------------------------Pon el contador a 0;

While (el contador sea menor que 5)

{Sigue derecho 1 milla;Añade 1 al contador;}-------------------------------------------------------------------------------------------------------


30/42



La sintaxis de pseudo-código similar a C de un bucle For hace esto aún másevidente:

-------------------------------------------------------------------------------------------------------For (i=0; i


31/42



0x240 Más conceptos fundamentales de programación

En las secciones siguientes, serán introducidos los conceptos de

programación más universales. Estos conceptos se utilizan en muchoslenguajes de programación, con unas pocas diferencias sintácticas. Alintroducir estos conceptos, los integraré en los ejemplos de pseudo-códigoutilizando sintaxis como C. Al final, el pseudo-código debe ser muy similar alcódigo C.

0x241 Variables

El contador utilizado en el bucle For es realmente un tipo de variable. Una

variable sólo puede ser pensada como un objeto que contiene los datos quese pueden cambiar, de ahí el nombre. También hay variables que nocambian, que son acertadamente 12 0x200 denominadas constantes.

Volviendo al ejemplo de manejo, la velocidad del carro sería una variable,mientras que el color sería una constante. En pseudocódigo, las variablesson simples conceptos abstractos, pero en C (y en muchos otros lenguajes),las variables deben ser declaradas y se declara el tipo antes de que puedanser utilizadas. Esto es porque un programa en C eventualmente se compilaráen un programa ejecutable. Al igual que una receta de cocina que enumeratodos los ingredientes necesarios antes de dar las instrucciones, lasdeclaraciones de variables te permiten hacer los preparativos antes de entraren la carne del programa. En última instancia, todas las variables sealmacenan en memoria en algún lugar, y sus declaraciones permiten que elcompilador organice esta memoria de manera más eficiente. Al final, sinembargo, a pesar de todas las declaraciones de tipos de variables, todo essolo memoria.

En C, a cada variable se da un tipo que describe la información destinada a

ser almacenada en esa variable. Algunos de los tipos más comunes son int (valores enteros), float (valores decimales de coma flotante) y char (valoresde caracteres simples). Las variables se declaran simplemente usando estaspalabras claves antes de enumerar las variables, como se puede ver acontinuación.-------------------------------------------------------------------------------------------------------int a, b;float k;char z;

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


32/42



La variables a y b se definen ahora como enteros, k puede aceptar valoresde punto flotante (por ejemplo: 3,14), y z se espera que mantenga un valorde carácter, como “A” o “w”. A las variables se le pueden asignar valores que

hayan sido declarados o en cualquier momento después, utilizando eloperador =.

-------------------------------------------------------------------------------------------------------int a = 13, b;float k;char z = 'A';

k = 3.14;z = 'w';b = a + 5;-------------------------------------------------------------------------------------------------------

Después de que las siguientes instrucciones se ejecutan, la variable a vale13, k contendrá el número 3,14, z contendrá el carácter w, y b contendrá elvalor 18, puesto que 13 más 5 es igual a 18. Las variables son simplementeuna manera de recordar los valores, sin embargo, con C, primero debesdeclarar cada tipo de variable.

0x242 Operadores Aritméticos

La declaración b = a + 7 es un ejemplo de un operador aritmético muysimple.

En C, los siguientes símbolos son utilizados en operaciones de cálculodiferentes.

Las primeras cuatro operaciones deberían parecerte familiares. Reducción

de módulo puede parecer un concepto nuevo, pero en realidad essimplemente tomar el resto después de la división.

Si a es 13, entonces 13 dividido por 5 es igual a 2, con un resto de 3, lo quesignifica que a % 5 = 3. También, puesto que las variables a y b son númerosenteros, la instrucción b = a / 5 resultará en el valor de 2 almacenado en b,ya que es la parte entera de la misma. Las variables de punto flotante debenser utilizadas para retener la respuesta más correcta de 2,6.


33/42



Operación Símbolo Ejemplo

Suma + b = a + 5

Resta - b = a - 5Multiplicación * b = a * 5División / b = a / 5Reducción de módulo % b = a % 5

Para lograr que un programa utilice estos conceptos, hay que hablar sulenguaje. El lenguaje C también ofrece varias formas abreviadas para estasoperaciones aritméticas. Una de ellas se ha mencionado anteriormente y seutiliza comúnmente en los bucles For.

Expresión completa Abrev. Explicación

i = i + 1 i++ o ++i Añade 1 a la variable.i = i - 1 i-- o --i Resta 1 a la variable.

Estas expresiones abreviadas se pueden combinar con otras operacionesaritméticas para producir expresiones más complejas. Aquí es donde ladiferencia entre i++ y ++i se hace evidente. La primera expresión significaIncrementar el valor de i a 1 después de evaluar la operación aritmética,mientras que la segunda expresión significa incrementar el valor de i a 1 antes de evaluar la operación aritmética. El siguiente ejemplo ayudará aaclarar.

-------------------------------------------------------------------------------------------------------int a, b;a = 5;b = a++ * 6;-------------------------------------------------------------------------------------------------------


34/42



Al final de este conjunto de instrucciones, b valdrá 30 y también 6, ya que laabreviatura de b = a++ * 6; es equivalente a las siguientes afirmaciones:

-------------------------------------------------------------------------------------------------------b = a * 6;a = a + 1;-------------------------------------------------------------------------------------------------------

Sin embargo, si la instrucción b = ++a * 6; se utiliza, el orden de la suma de a cambia, dando como resultado las instrucciones equivalentes siguientes:

-------------------------------------------------------------------------------------------------------a = a + 1;b = a * 6;-------------------------------------------------------------------------------------------------------

Ya que el orden se ha modificado, en este caso b contendrá 36, y a todavíacontendrá 6.

Muy a menudo en los programas, las variables deben ser modificadas en sulugar. Por ejemplo, puede que tengas que agregar un valor arbitrario como12 a una variable, y almacenar el resultado de nueva en esa variable (por

ejemplo, i = i + 12). Esto ocurre con bastante frecuencia y también existeabreviatura para ello.

Expresión completa Abrev. Explicación

i = i + 12 i+=12 Añade un valor a la variable.i = i - 12 i-=12 Resta un valor a la variable.

i = i * 12 i*=12 Multiplica un valor por la variable.i = i / 12 i/=12 Divide un valor de la variable.


35/42



0x243 Operadores de Comparación

Las variables se utilizan con frecuencia en las sentencias condicionales de

las estructuras de control previamente explicadas. Estas declaracionescondicionales se basan en algún tipo de comparación. En C, los operadoresde comparación utilizar una sintaxis abreviada que es bastante común enmuchos lenguajes de programación.

Condición Símbolo Ejemplo

Menor que < (a < b)Mayor que > (a > b)Menor o igual a = b)Igual a == (a == b)Diferente a != (a != b)

La mayoría de estos operadores no necesitan explicación, sin embargo,observa que la forma abreviada de igual a usa doble signo de igual (==).Esta distinción es importante, ya que el doble signo de igual se utiliza paraprobar la equivalencia, mientras que el signo igual se utiliza para asignar unvalor a una variable. La sentencia a = 7 significa pon el valor 7 en lavariable a , mientras que a == 7 significa chequea si la variable a es igual a7 . (Algunos lenguajes de programación como Pascal realmente usan: = parala asignación de variables para eliminar la confusión visual.) También,observa que un signo de exclamación significa generalmente no. Estesímbolo puede ser utilizado por sí mismo para invertir cualquier expresión.

-------------------------------------------------------------------------------------------------------!(a < b) es equivalente a (a >= b)-------------------------------------------------------------------------------------------------------


36/42



Los operadores de comparación también se pueden unir utilizando laabreviatura de OR y AND.

Lógico Símbolo Ejemplo

OR || ((a < b) || (a < c))AND && ((a < b) && ! (a < c))

La declaración de ejemplo consta de las dos condiciones más pequeñasunidas con OR lógico que serán verdaderas si a es menor que b, o si a esmenor que c. De manera similar, la sentencia del ejemplo consta de doscomparaciones más pequeñas unidas con AND lógico que serán verdaderassi a es menor que b y si a no es que c. Estas declaraciones deben seragrupadas con paréntesis y pueden contener muchas variaciones diferentes.

Muchas cosas pueden resumirse en las variables, operadores decomparación y estructuras de control. Volviendo al ejemplo del ratón enbusca de alimento, el hambre se puede traducir en una variable Boolean, osea true o false (verdadero o falso). Naturalmente, 1 significa verdadero y 0significa falso.

------------------------------------------------------------------------------------------------------- While (Hambriento == 1)

{Busca comida;Cómete la comida;}

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

Aquí hay otra abreviatura utilizada por los programadores y hackers amenudo. C no tiene realmente ningún operador boolean, por lo que cualquiervalor distinto de cero es considerado verdadero, y una declaración seconsidera falsa si contiene 0. De hecho, los operadores de comparación enrealidad retornan un 1 si la comparación es verdadera y 0 si es falsa. Paracomparar si la variable Hambriento es igual a 1 retorna 1 si tiene Hambriento es igual a 1 y 0 si tiene Hambriento es igual a 0. Dado que el programa sólo


37/42



utiliza estos dos casos, el operador de comparación se puede quitar porcompleto.

------------------------------------------------------------------------------------------------------- While (Hambriento)

{Busca comida;Cómete la comida;}-------------------------------------------------------------------------------------------------------

Un programa de ratón más inteligente con más entradas muestra cómo losoperadores de comparación se pueden combinar con variables.

------------------------------------------------------------------------------------------------------- While ((Hambriento) && (gato_presente!)) {Busca comida;

If (! (La_comida_está_en_la_trampa)) Cómete la comida;

}-------------------------------------------------------------------------------------------------------

Este ejemplo asume que hay también variables que describen la presenciade un gato y la ubicación de la comida, con 1 para verdadero y 0 para falso.

Sólo recuerda que cualquier valor distinto a cero se considerará verdadero, y0 se considerará falso.

0x244 Funciones

A veces habrá un conjunto de instrucciones que el programador sabe que vaa necesitar varias veces. Estas instrucciones se pueden agrupar en unsubprograma más pequeño llamado función. En otros lenguajes, lasfunciones que se conocen como subrutinas o procedimientos. Por ejemplo, laacción de cruzar un carro en realidad se compone de muchas instruccionespequeñas: Enciende el intermitente correspondiente, reduce la velocidad,verifica el tráfico, gira el volante en la dirección adecuada, y así

sucesivamente. Las direcciones de manejo desde el principio de este


38/42



capítulo requieren pocos giros, sin embargo, listando cada instrucciónpequeña por cada vuelta sería tedioso (y menos legible). Puedes pasarvariables como argumentos a una función con el fin de modificar la forma en

que la función opera. En este caso, a la función se le pasa la dirección delgiro.

------------------------------------------------------------------------------------------------------- Funtion Cruzar (variable_de_direccion) {Activar el intermitente de la variable_de_direccion;Disminuye la velocidad;Comprueba si vienen carros;while (vienen carros){Detente;Ten cuidado con el tráfico en dirección contraria;}Gira el volante hacia la variable_de_direccion;While (El giro no esté completo) {if (velocidad


39/42



En C, las funciones no están marcadas con una de palabra clave "function",sino que son declaradas por el tipo de datos de la variable que estánretornando.

Este formato es muy similar a la declaración de variables. Si una funcióndebe retornar un entero (tal vez una función que calcule el factor de algúnnúmero x), la función podría tener este aspecto:

------------------------------------------------------------------------------------------------------- int factor(int x)

{int i;for (i=1; i


40/42



utilizada en cualquier otro lugar, ya que el compilador ya sabe. Un ejemplode un prototipo de función para la función factor() sería algo como esto:

------------------------------------------------------------------------------------------------------- int factor(int);-------------------------------------------------------------------------------------------------------

Por lo general, los prototipos de función se encuentran cerca del comienzode un programa. No hay necesidad de definir realmente los nombres devariables en el prototipo, ya que esto se hace en la propia función. Lo únicoque el compilador le importa es el nombre de la función, los tipos de datos deretorno y los tipos de datos de sus argumentos funcionales.

Si una función no tiene ningún valor a retornar, debe ser declarada comoVoid (vacío), como es el caso de la función Cruzar() que utilizamos como unejemplo anterior. Sin embargo, función Cruzar() todavía no capta toda lafuncionalidad que nuestras direcciones de manejo necesitan. Cada giro enlas direcciones tiene una dirección y un nombre de calle. Esto significa queuna función de giro debe tener dos variables: la dirección del giro y de lacalle a girar. Esto complica la función de giro, ya que la calle apropiada debeestar situada antes de que el cambio se pueda hacer. Una de las funcionesde giro más completa utilizando la sintaxis correcta similar a C se enumera a

continuación en pseudo-código.

------------------------------------------------------------------------------------------------------- Void Cruzar (variable_de_direccion, nombre_de_la_calle)

{Busca un aviso en la calle;nombre_de_interseccion_actual = leer aviso en la calle;

while (nombre_de_interseccion_actual != nombre_de_la_calle )

{Busca otro aviso en la calle;nombre_de_interseccion_actual = leer aviso en la calle; }

Activa el intermitente de variable_de_direccion;Disminuye la velocidad;

Compruebe si vienen carros;


41/42



while (hay tráfico de frente)

{

Detente;Ten cuidado con el tráfico en dirección contraria;}

Gira el volante hacia la variable_de_direccion;While (el giro no esté completo)

{if (velocidad


42/42


ElseCruzar(Derecha, Calle 16);Cruzar (Izquierda, Destination Road);

For (i=0; i

El Arte de La Explotacion Vista Previa

Documents

Transcript of El Arte de La Explotacion Vista Previa