El Arte de La Explotacion Vista Previa

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

Traductor: Ivinson - @IvinsonCLS


CRÍTICAS CONSTRUCTIVAS PARA LA PRIMERA EDICIÓN DE HACKING: EL ARTE DE LA EXPLOTACIÓN

“El tutorial más completo en técnicas de Hacking. Finalmente, un libro que no sólo muestra cómo utilizar los Exploits, sino cómo desarrollarlos.” -PHRACK “De todos los libros que he leído hasta ahora, consideraría este manual de Hackers seminal.” -SECURITY FORUMS “Recomiendo este libro sólo por la sección de programación.” -UNIX REVIEW “Yo recomiendo este libro. Está escrito por alguien que sabe de lo que dice, con código útil, herramientas y ejemplos.” -IEEE CIPHER “El libro de Erickson es una guía compacta y lógica para los hackers novatos, está lleno de código real, técnicas de Hacking y explicaciones de cómo que trabajan.” - COMPUTER POWER USER (CPU) MAGAZINE “Éste es un libro excelente. Aquellos que están dispuestos a pasar al [siguiente nivel] deberían tener este libro y leerlo a fondo.” - ABOUT.COM INTERNET/NETWORK SECURITY





2NDA EDICIÓN

HACKING EL ARTE DE LA EXPLOTACIÓN TRADUCIDO POR IVINSON Crackingvenezolano.blogspot.com

JON ERICKSON



Copyright © 2008 por Jon Erickson. Todos los derechos reservados. Ninguna parte de este documento puede ser reproducida o transmitida en cualquier forma o por cualquier medio, ya sea electrónico o mecánico, incluyendo el fotocopiado, grabación o por cualquier sistema de almacenamiento o recuperación de información sin el previo permiso escrito del propietario 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 9 ISBN-10: 1-59327-144-1 ISBN-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 Adams Editores 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 favor ponte 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, 1977Hacking: the art of exploitation / Jon Erickson. -- 2nd Ed. p. cm.



ISBN-13: 978-1-59327-144-2 ISBN-10: 1-59327-144-1 1. Computer security. 2. Computer hackers. 3. Computer networks--Security measures. I. Title.

QA76.9.A25E75 2008 005.8--dc22 2007042910 No Starch Press y el logotipo No Starch Press son marcas registradas de No Starch Press, Inc. Otros productos y compañías aquí mencionados pueden ser marcas comerciales de sus respectivos propietarios. En lugar de utilizar un símbolo de marca comercial con cada aparición de un nombre de marca registrada, estamos usando los nombres 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 bien todas las precauciones se han tomado en la preparación de este trabajo, ni el autor ni No Starch Press, Inc. serán responsables frente a cualquier persona o entidad con respecto a cualquier pérdida o daño causado o presuntamente causado directa o indirectamente por el la información contenida en el mismo.



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



CONTENIDO DETALLADO

PREFACIO

xi

RECONOCIMIENTOS

xii

0x100 INTRODUCCIÓN

1

0x200 PROGRAMACIÓN

5

0x210 ¿Qué es la programación? .............................................................. 6 0x220 Pseudo-código.................................................................................. 7 0x230 Estructuras de Control ..................................................................... 8 0x231 If-Then-Else....................................................................................... 8 0x232 Bucles While/Until ............................................................................. 9 0x233 Bucles For ......................................................................................... 10 0x240 Más conceptos fundamentales de programación ............................ 11 0x241 Variables .......................................................................................... 11 0x242 Operadores Aritméticos.................................................................... 12 0x243 Operadores de Comparación........................................................... 14 0x244 Funciones ........................................................................................ 16 0x250 Metiendo los Pies al Barro ............................................................... 19 0x251 La Imagen más Grande .................................................................... 20 0x252 El Procesador x86 …......................................................................... 23 0x253 Ensamblador …………....................................................................... 25 0x260 Regresando a lo Básico .................................................................... 37 0x261 Strings ............................................................................................... 38 0x262 Signed, Unsigned, Long, y Short ….................................................. 41 0x263 Punteros .. ........................................................................................ 43 0x264 Formatos de Strings .......................................................................... 48 0x265 Typecasting o Conversión de Tipo .................................................. 51 0x266 Argumentos de Línea de Comandos ................................................. 58 0x267 Enfoque de Variables ........................................................................ 62 0x270 Segmentación de Memoria ............................................................... 69 0x271 Segmentos de Memoria en C ............................................................ 75 0x272 Usando el Heap ................................................................................. 77 0x273 Chequeo de Errores con malloc() ...................................................... 80 0x280 Construyendo lo Básico ..................................................................... 81 0x281 Acceso a Archivos ............................................................................. 81



0x282 Permisos de Archivos ........................................................................ 87 0x283 ID´s de Usuarios .............................................................................. 88 0x284 Estructuras ........................................................................................ 96 0x285 Punteros de Funciones .................................................................... 100 0x286 Números Pseudo-random ............................................................... 101 0x287 Un juego de azar ……...................................................................... 102 0x300 EXPLOTACIÓN

115

0x310 Técnicas Generalizadas de Exploits ............................................... 118 0x320 Desbordamiento de Buffer .............................................................. 119 0x321 Vulnerabilidades del Desbordamiento de Buffer ………................. 122 0x330 Experimentando con BASH ............................................................. 133 0x331 Usando el Entorno …….................................................................... 142 0x340 Desbordamientos en Otros Segmentos .......................................... 150 0x341 Un Desbordamiento de Heap Básico .............................................. 150 0x342 Desbordando Punteros de Funciones ............................................ 156 0x350 Formato de Strings .......................................................................... 167 0x351 Parámetros de Formato ................................................................... 167 0x352 La Vulnerabilidad de Formato de Strings ........................................ 170 0x353 Leyendo Direcciones de Memoria Arbitrarias ................................. 172 0x354 Escribiendo en Direcciones de Memoria Arbitrarias ........................ 173 0x355 Acceso a Parámetros Directos ........................................................ 180 0x356 Usando Escrituras Cortas ................................................................ 182 0x357 Desvíos con .dtors............................................................................ 184 0x358 Otra Vulnerabilidad de Notesearch ................................................. 189 0x359 Sobrescribiendo la Tabla Global de Offsets .................................... 190 0x400 REDES

195

0x410 ModelO OSI ..................................................................................... 196 0x420 Sockets ............................................................................................ 198 0x421 Funciones del Socket ...................................................................... 199 0x422 Direcciones del Socket ................................................................... 200 0x423 Orden de Bytes de Red ................................................................... 202 0x424 Conversión de Direcciones de Internet ........................................... 203 0x425 Un Ejemplo de un Servidor Sencillo ................................................ 203 0x426 Un Ejemplo de Cliente Web ............................................................ 207 0x427 Un Servidor Tinyweb ...................................................................... 213 0x430 Quitando las capas Inferiores .......................................................... 217 0x431 Capa de Enlace de Datos .............................................................. 218



0x432 Capa de Red …... ............................................................................ 220 0x433 Capa de Transporte ......................................................................... 221 0x440 Sniffing en la Red ............................................................................ 224 0x441 Sniffer Tipo Raw Socket ….............................................................. 226 0x442 Sniffer Tipo libpcap ......................................................................... 228 0x443 Decodificando las Capas ................................................................. 230 0x444 Sniffing Activo ….............................................................................. 239 0x450 Denegación de Servicio .............................................................. 251 0x451 SYN Flooding ............................................................................. 252 0x452 El Ping de la Muerte ................................................................... 256 0x453 Lágrima ….................................................................................... 256 0x454 Ping Flooding ............................................................................. 257 0x455 Ataques de Amplificación ........................................................... 257 0x456 DoS Flooding Distribuido.............................................................. 258 0x460 Secuestrando TCP/IP .................................................................. 258 0x461 Secuestrando RST ...................................................................... 259 0x462 Continuando con el Secuestro .................................................... 263 0x470 Escaneo de Puertos .................................................................... 264 0x471 Escaneo Stealth SYN .................................................................. 264 0x472 Escaneo FIN, X-mas, y Null.......................................................... 264 0x473 Señuelos de Suplantación ........................................................... 265 0x474 Idle Scanning.............................................................................. 265 0x475 Defensa Proactiva (Sudario) ....................................................... 267 0x480 Hackea a Alguien …… .................................................................. 272 0x481 Análisis con GDB …....................................................................... 273 0x482 Casi solo cuenta con Granadas de Mano ..................................... 275 0x483 Port-Binding Shellcode …………………………………………........ 278 0x500 SHELLCODE

281

0x510 Ensamblador vs. C ......................................................................... 282 0x511 Llamadas al Sistema de Linux en ASM .......................................... 284 0x520 El Camino a la Shellcode ............................................................... 286 0x521 Instrucciones ASM Usando la Pila …. ............................................ 287 0x522 Investigando con GDB …................................................................. 289 0x523 Quitando los Bytes Nulos ................................................................ 290 0x530 Shell-Spawning Shellcode ............................................................... 295 0x531 Un Tema de Privilegio ..................................................................... 299 0x532 Y Más Pequeño Aún ....................................................................... 302 0x540 Port-Binding Shellcode .................................................................... 303 0x541 Duplicando Descriptores de Archivo Estándar ................................ 307



0x542 Ramificando Estructuras de Control ................................................ 309 0x550 Connect-Back Shellcode ................................................................. 314 0x600 CONTRAMEDIDAS

319

0x610 Contramedidas que Detectan ......................................................... 320 0x620 System Daemons............................................................................. 321 0x621 Curso Intensivo de Señales ............................................................ 322 0x622 Tinyweb Daemon …........................................................................ 324 0x630 Herramientas del oficio ................................................................ 328 0x631 Herramienta de Exploit para Tinyweb ......................................... 329 0x640 Archivos de Registro ................................................................... 334 0x641 Mezclándose con la multitud ....................................................... 334 0x650 Mirando lo Obvio …...................................................................... 336 0x651 Un Paso a la Vez …..................................................................... 336 0x652 Poniendo las Cosas como estaban ............................................. 340 0x653 Trabajadores Infantiles ................................................................ 346 0x660 Camuflaje Avanzado ................................................................... 348 0x661 Suplantando la Dirección IP Guardada (Spoofing) ..................... 348 0x662 Explotación sin Registro .............................................................. 352 0x670 La Infraestructura Completa ........................................................ 354 0x671 Reutilización del Socket .............................................................. 355 0x680 Contrabando de Payloads ............................................................ 359 0x681 Codificando Strings ...................................................................... 359 0x682 Cómo Ocultar una Secuencia ...................................................... 362 0x690 Restricciones del Buffer ............................................................... 363 0x691 Shellcode ASCII Polimórfica e imprimible ................................... 366 0x6a0 Reforzando las Contramedidas .................................................. 376 0x6b0 Pila no Ejecutable ........................................................................ 376 0x6b1 ret2libc .......................................................................................... 376 0x6b2 Retornando a system().................................................................. 377 0x6c0 Espacio de Pila Randomizada ...................................................... 379 0x6c1 Investigaciones con BASH y GDB ................................................ 380 0x6c2 Rebotando en la Puerta de Linux ................................................ 384 0x6c3 Conocimiento Aplicado ................................................................. 388 0x6c4 Un Primer Intento .......................................................................... 388 0x6c5 Jugando con las probabilidades ................................................... 390



0x700 CRIPTOLOGÍA

393

0x710 Teoría de la Información ................................................................ 394 0x711 Seguridad Incondicional ................................................................. 394 0x712 One-Time Pads o Libretas de un Solo Uso ..................................... 395 0x713 Distribución de Clave Cuántica ....................................................... 395 0x714 Seguridad Computacional …............................................................ 396 0x720 Tiempo de ejecución algorítmica ..................................................... 397 0x721 Notación asintótica …...................................................................... 398 0x730 Encriptación Simétrica ..................................................................... 398 0x731 Algoritmo Cuántico de Búsqueda de Lov Grover ............................ 399 0x740 Encriptación Asimétrica ................................................................... 400 0x741 RSA ................................................................................................. 400 0x742 Algoritmo Cuántico de Factorización de Peter Shor ....................... 404 0x750 Cifrados Híbridos .......................................................................... 406 0x751 Ataques Man-in-the-Middle ............................................................ 406 0x752 Diferenciando Los Fingerprints del Host del Protocolo SSH .......... 410 0x753 Fingerprints Confusas ..................................................................... 413 0x760 Crackeando Contraseñas ............................................................... 418 0x761 Ataque por Diccionario ................................................................... 419 0x762 Ataques Exhaustivos de Fuerza Bruta .......................................... 422 0x763 Tabla de búsqueda de Hashes ........................................................ 423 0x764 Matriz de Probilidades de Contraseña .......................................... 424 0x770 Encriptación inalámbrica 802.11b ................................................. 433 0x771 Privacidad equivalente por cable ................................................... 434 0x772 RC4 Stream Cipher o Cifrado de Flujo RC4 ................................. 435 0x780 Ataques WEP ............................................................................... 436 0x781 Ataques de Fuerza Bruta Offline .................................................. 436 0x782 Reutilización de Keystream .......................................................... 437 0x783 Tablas de Diccionarios de Desencriptación Tipo IV ..................... 438 0x784 Redirección de IP............................................................................ 438 0x785 Ataques Fluhrer, Mantin, y Shamir ................................................. 439 0x800 CONCLUSIÓN 451 0x810 Referencias ..................................................................................... 452 0x820 Fuentes ........................................................................................... 454 ÍNDICE



PREFACIO

El objetivo de este libro es compartir el arte del Hacking con todo el mundo. Comprender las técnicas de Hacking es a menudo difícil, ya que requiere tanto la amplitud y profundidad de los conocimientos. Muchos textos de Hacking parecen esotéricos y confusos por causa de tan sólo unos pocos fallos en esta educación de pre-requisito. Esta segunda edición de Hacking: El Arte de la Explotación hace que el mundo del Hacking sea más accesible, proporcionando la imagen completa, desde la programación en código máquina a la explotación. Además, esta edición cuenta con un LiveCD basado en Ubuntu-Linux que puede ser utilizado en cualquier computadora con un procesador x86, sin modificar el sistema operativo existente en el equipo. Este CD contiene todo el código fuente del libro y proporciona un entorno de desarrollo y explotación que puedes utilizar para seguir junto con ejemplos del libro y experimentar a lo largo del camino.



RECONOCIMIENTOS

Me gustaría dar las gracias a Bill Pollock y todos los demás en No Starch Press por hacer de este libro una posibilidad y permitirme tener un control creativo en el proceso. Además, me gustarí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 mantenerme interesado en la ciencia de la informática, mis padres por comprar ese primer Commodore VIC-20, y la comunidad Hacker por la innovación y la creatividad que produjo las técnicas explicadas en este libro.



0x100 INTRODUCCIÓN

La idea del Hacking puede evocar imágenes estilizadas de vandalismo electrónico, el espionaje, el pelo teñido y perforaciones en el cuerpo. La mayoría de la gente asocia el Hacking con infringir la ley y asume que todo el que se dedica a actividades de Hacking es un criminal. Es cierto que hay gente ahí fuera que utiliza técnicas de Hacking para violar la ley, pero el Hacking no se trata realmente de eso. De hecho, el Hacking está más cerca de seguir la ley que de romperla. La esencia del Hacking está encontrando usos no previstos o ignorados por las leyes y propiedades de una situación dada y luego aplicándolas en formas nuevas e inventivas 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 cuatro operaciones 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



definir el orden de las operaciones, por ejemplo, 3 * (4 + 6) + 1 = 31 es válido, sin embargo incorrecta, ya que no hace un total de 24. Las reglas para este problema están bien definidas y simples, pero la respuesta escapa a muchos. Al igual que la solución a este problema (que se muestra en la última página de este libro), las soluciones hackeadas siguen las reglas del sistema, pero utilizan los reglas de maneras contrarias a la intuición. Esto pone al límite a los hackers, lo que les permite resolver problemas de maneras inimaginables para aquellos confinados al pensamiento y metodologías convencionales. Desde la infancia de los ordenadores, los hackers han estado resolviendo problemas creativamente. A finales de 1950, al club de ferrocarriles modelo MIT se le dio una donación de piezas, en su mayoría equipos telefónicos viejos. Los miembros del club utilizaron este equipo para montar un sistema complejo que permitía a múltiples operadores controlar diferentes partes de la pista, marcando en las secciones correspondientes. Ellos llamaron hacking a este nuevo e inventivo uso de equipo telefónico, y mucha gente considera este grupo como los hackers originales. El grupo pasó a la programación de tarjetas perforadas y cinta de teletipo para las primeras computadoras como la IBM 704 y el TX-0. Mientras que otros se contentaron con escribir programas que resolvían problemas, los primeros hackers estaban obsesionados con los programas de escritura que resuelven problemas también. Un nuevo 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 que hizo 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 programa mostró una maestría artística sobre el equipo. Una mesa bien diseñada puede contener un jarrón tan bien como una caja de leche puede, pero uno seguramente se ve mucho mejor que el otro. Los primeros hackers demostraron que los problemas técnicos pueden 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 mantuvo concentrada intensamente en el aprendizaje y el dominio de su arte. Ellos creían que la información debería ser libre y cualquier cosa que se interpusiera en el camino de la 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,



este grupo no oficial de hackers desafiaron las metas convencionales y buscaron el conocimiento 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 demostrar su 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 promover el arte emergente del Hacking. Los hackers originales encontraron el esplendor y la elegancia en la forma ciencias convencionales y secas de las matemáticas y la electrónica. Vieron la programación como una forma de la expresión artística y la computadora como un instrumento de ese arte. Su deseo para diseccionar y entender que no pretendía desmitificar los esfuerzos artísticos, sino que era simplemente una forma de lograr un mayor aprecio de ellos. Estos valores hacia del conocimiento con el tiempo se llamarían la ética del hacker: la apreciación de la lógica como una forma de arte y la promoción de la libre circulación de la información, superación de los límites convencionales y las restricciones para el simple objetivo de una mejor comprensión del mundo. Esta no es una nueva tendencia cultural, los pitagóricos de la Grecia antigua tuvieron una ética similar y subcultura, a pesar de no poseer computadoras. Ellos vieron la belleza de las matemá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 de ferrocarriles modelo MIT. Hackers modernos como Richard Stallman y Steve Wozniak han continuado el legado de Hacking, trayéndonos los sistemas operativos modernos, lenguajes de programación, ordenadores personales, y muchas otras tecnologías que utilizamos cada día. ¿Cómo se puede distinguir entre los buenos hackers que nos traen las maravillas del progreso tecnológico y los hackers malignos que roban nuestros números de tarjeta de crédito? El término cracker fue acuñado para distinguir los hackers malignos de los 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 ética del hacker, mientras que los crackers estaban sólo interesado en romper la ley y hacer dinero 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 escritos sin entender cómo funcionaban. Cracker estaba destinado a ser la etiqueta para quien hiciera cosas sin escrúpulos con un ordenador – pirateando software, destruyendo



sitios Web, y lo peor de todo, sin entender lo que estaban haciendo. Pero muy pocas personas 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 y hacen ingeniería inversa a sistemas de protección de copia. Su impopularidad actual simplemente pudiera derivarse de sus dos nuevas definiciones ambiguas: un grupo de personas que se involucran en actividades ilegales con computadoras o personas que son relativamente hackers inexpertos. Pocos periodistas de tecnología se sienten obligados a utilizar términos con los que la mayoría de sus lectores no están familiarizados. En contraste, la mayoría de la gente es consciente del misterio y la habilidad asociada con el término hacker, así que para un periodista, la decisión de utilizar el término hacker es fácil. Del mismo modo, el término script kiddie se utiliza a veces para referirse a los crackers, pero simplemente no tiene el mismo gusto que el hacker sombrío. Hay algunos que todavía sostienen que hay una línea clara entre hackers y crackers, pero creo que cualquiera que tenga el 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 opacan la línea entre los hackers y los crackers. En 2001, el profesor Edward Felten y su equipo 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 agua digitales. 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 romper estos esquemas de marcas de agua. Antes de que Felten y su equipo pudieran publicar el artículo, fueron amenazados tanto por la Fundación SDMI y Recording Industry Association of America (RIAA). Digital Millennium Copyright Act (DCMA) de 1998 establece que es ilegal discutir o proporcionar tecnología que pudiera utilizarse para evitar los controles de la industria de consumo. Esta misma ley fue utilizada contra Dmitry Sklyarov, un programador informático ruso y hacker. Había escrito software para burlar el cifrado demasiado simplista en el software de Adobe y presentó sus conclusiones en una convención de hackers en los Estados Unidos. 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 importaque sería técnicamente ilegal hacer ingeniería inversa o incluso discutir el Pig Latin si



se utiliza como un control de consumo de la industria. ¿Quiénes son los hackers informáticos y que son los crackers ahora? Cuando las leyes parecen interferir con la libertad 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, sin embargo, también nos proveen con el avance científico significativo y la medicina moderna. No hay nada bueno o malo sobre el conocimiento mismo; la moralidad reside en la aplicación de los conocimientos. Incluso si quisiéramos, no podríamos suprimir el conocimiento de cómo convertir la materia en energía o detener el progreso tecnológico continuo de la sociedad. De la misma manera, el espíritu hacker no puede ser detenido, ni puede ser clasificado fácilmente o disecado. Los hackers siempre estarán empujando los límites del comportamiento aceptable y el conocimiento, 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és de la competencia entre los hackers atacantes y defensores. Así como la gacela rápida se adaptó a ser perseguida por el leopardo, y el leopardo se volvió aún más rápido por perseguir a la gacela, la competencia entre los hackers proporciona a los usuarios una 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 crean IDS para añadirlos a su arsenal, mientras que los hackers atacantes desarrollan técnicas de evasión de IDS, que finalmente tuvo una compensación en productos IDS más grandes y mejores. El resultado neto de esta interacción es positivo, ya que produce personas más inteligentes, mejora la seguridad, el software es más estable, técnicas inventivas de resolució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 un LiveCD 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 son fundamentales para el arte del Hacking, por lo que este CD te permitirá seguir adelante 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



Macintosh, simplemente inserta el CD y reinicia. Este entorno Linux suplente no molesta 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 que pueden 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 que contribuyas al arte del Hacking, de alguna manera, sin importar de qué lado de la valla elijas estar.



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 de hackers tienen diferentes objetivos finales, ambos grupos utilizan técnicas de resolución de problemas similares. Ya que, la comprensión de la programación ayuda a los que explotan, y una comprensión de explotación ayuda a quienes programan, muchos hackers hacen ambas cosas. Hay hacks interesantes que se encuentran tanto en las técnicas utilizadas para escribir código elegante y las técnicas utilizadas en Exploits para programas. El Hacking es realmente sólo el acto de encontrar una solución inteligente y contraria a la intuición de un problema. Los hacks que se encuentran en Exploits para programas suelen utilizar las reglas de la computadora para evitar la seguridad en formas nunca previstas. Los hacks de programación son similares en que también utilizan las reglas de la computadora de formas nuevas e inventivas, pero el objetivo final es la eficiencia o código fuente más pequeño, no necesariamente un compromiso de seguridad. En realidad, hay un número infinito de programas que pueden ser escritos para llevar a cabo una tarea determinada, pero la mayoría de estas soluciones son innecesariamente grandes, complejas y descuidadas. Las pocas soluciones que quedan son pequeñas, eficientes y ordenadas. Los programas que tienen estas cualidades se dice que tienen la elegancia,



y las soluciones inteligentes e innovadoras que tienden a conducir a esta eficacia, las cuales se llaman hacks. Los hackers en ambos lados de programación aprecian la belleza 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ódigo funcional que al logro de la elegancia y hacks inteligentes. Debido al enorme crecimiento exponencial de la potencia de cálculo y la memoria, gastar cinco horas extras para crear un trozo de código un poco más rápido y más eficiente con respecto a la memoria simplemente no tiene sentido para los negocios cuando se trata de computadoras modernas que tienen giga Hertz de ciclos de procesamiento y gigabytes de memoria. Mientras que las optimizaciones de tiempo y memoria van sin previo aviso por todos excepto el más sofisticado de los usuarios, una nueva característica es comercializable. Cuando el resultado final es el dinero, pasar tiempo en 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, sino exprimir cada pedacito posible de la funcionalidad de su viejo Commodore 64s, escritores de Exploits que necesitan escribir trozos de código pequeños y sorprendentes para deslizarse a través de grietas estrechas de seguridad, y cualquier persona 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 realmente aprecian la belleza de un trozo de código elegante o la ingenuidad de un hack inteligente. Ya que la comprensión de la programación es un requisito previo para entender cómo los programas pueden ser explotados, la programación es un punto de partida natural.

0x210 ¿Qué es la programación? La programación es un concepto muy natural e intuitivo. Un programa no es más que una serie de instrucciones escritas en un idioma específico. Los programas están en todas 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 los tipos de programas.



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 hasta que 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 la derecha en la calle 16. De lo contrario, usted puede continuar y girar a la derecha en la calle 16. Continúe por la calle 16 y gire a la izquierda en la calle de destino. Siga derecho 5 millas 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ón es 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 comprende el lenguaje de máquina. Para indicarle a un ordenador que haga algo, las instrucciones 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 de arquitectura en arquitectura. Para escribir un programa en lenguaje de máquina para un 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 es un traductor. Un ensamblador es una forma de traductor de lenguaje de máquina: es un 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 utiliza los nombres de las diferentes instrucciones y variables, en lugar de usar sólo números. Sin embargo, el lenguaje ensamblador aún está lejos de ser intuitivo. Los nombres de instrucciones 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 lenguaje máquina para los procesadores Sparc, el lenguaje ensamblador x86 es diferente al lenguaje ensamblador de Sparc.



Cualquier programa escrito utilizando el lenguaje ensamblador para la arquitectura de un 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 lenguaje ensamblador, todavía tienes que saber muchos detalles de bajo nivel de la arquitectura del procesador para el que estás escribiendo. Estos problemas pueden ser mitigados por otra forma de traductor llamado compilador. Un compilador convierte un lenguaje de alto nivel a lenguaje de máquina. Los lenguajes de alto nivel son mucho más intuitivos que el lenguaje ensamblador y se puede convertir en muchos tipos de lenguaje de máquina diferentes para arquitecturas de procesador. Esto significa que si un programa está escrito en un lenguaje de alto nivel, el programa sólo es necesario que se escriba una vez, el mismo trozo de código del programa puede ser compilado en lenguaje de máquina para diferentes arquitecturas específicas. C, C++ y Fortran son ejemplos de lenguajes de alto nivel. Un programa escrito en un lenguaje de alto nivel es parecido al inglés y mucho más fácil de leer que el lenguaje ensamblador o lenguaje de máquina, pero aún debes seguir 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 llamado pseudo-código. Pseudo-código es simplemente inglés arreglado con una estructura general 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 programador organice instrucciones. El pseudo-código no está bien definido, de hecho, la mayoría de la gente escribe pseudo-código ligeramente diferente. Es una especie de nebulosa en el vínculo perdido entre lenguajes de programación en inglés y de alto nivel como C. El pseudocódigo hace una excelente introducción a los conceptos de programación comunes universales.



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 la mayoría de los programas, como el ejemplo de direcciones de manejo, no son tan simples. Las direcciones de manejo incluían afirmaciones como: Continúe por la calle principal hasta que vea una iglesia a la derecha y si la calle está bloqueada a causa de la construcción… Estos enunciados son conocidos como estructuras de control, y cambian el flujo del programa de ejecución de una orden secuencial simple de 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 en construcción. Si es cierto, un conjunto especial de instrucciones debe abordar esta situación. De lo contrario, el conjunto original de instrucciones deben ser seguidas. Estos tipos de casos especiales pueden ser contabilizados en un programa con una de las estructuras de 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 cada instrucción terminará con un punto y coma, y los conjuntos de instrucciones se agruparán con llaves y sangría.



La estructura de pseudo-código if-then-else de acuerdo a las indicaciones precedentes, 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 instrucciones condicionales 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 pseudocó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 los lenguajes de programación son sólo superficiales, la estructura subyacente sigue siendo la misma. Una vez que un programador entiende los conceptos que estos lenguajes 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, el pseudo-código utilizado en este libro sigue una sintaxis similar a C, pero recuerda que el pseudo-código puede tomar muchas formas. Otra regla común de sintaxis similar a C es cuando un conjunto de instrucciones delimitadas por llaves consiste en una sola instrucción, las llaves son opcionales. En aras de la legibilidad, es una buena idea ponerle sangría a estas instrucciones, pero no es sintácticamente necesario.



Las direcciones de manejo de antes pueden volverse a escribir siguiendo esta regla para 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 estructuras de 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ógica sigue siendo básicamente la misma: Si esto ocurre, haz estas cosas, de lo contrario haz otras cosas (que podrían consistir en más sentencias if-then).



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á que ejecutar un conjunto de instrucciones más de una vez. Un programa puede realizar esta tarea a través de un bucle, pero se requiere un conjunto de condiciones que le indique cuándo debe dejar de bucle, para que no continúe hasta el infinito. Un bucle while dice que se ejecute el siguiente conjunto de instrucciones en un bucle mientras una condición es verdadera. Un programa sencillo 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 se repetirá mientras el ratón se queda con hambre. La cantidad de comida que el 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 de instrucciones de la sentencia while se ejecute cambia en función de la cantidad de alimentos que el ratón encuentra. Otra variación sobre el bucle while es un bucle Until o hasta que, una sintaxis que está disponible en el lenguaje de programación Perl (C no utiliza esta sintaxis). Un bucle Until no es más que un bucle While con la sentencia condicional invertida. El programa del mismo ratón utilizando un bucle Until sería: ------------------------------------------------------------------------------------------------------Until (No tengas hambre) //Until significa “Hasta que”. { Encuentra algo de comida; Cómete la comida; } -------------------------------------------------------------------------------------------------------



Lógicamente, cualquier sentencia tipo Until se puede convertir en un bucle while. Las direcciones de manejo anteriores tenían la declaración Continúe en 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 la condició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 utiliza generalmente cuando un programador desea repetir o iterar para un cierto número de veces. La dirección de manejo Siga derecho 5 millas por Destination 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 misma afirmació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; } -------------------------------------------------------------------------------------------------------



La sintaxis de pseudo-código similar a C de un bucle For hace esto aún más evidente: ------------------------------------------------------------------------------------------------------For (i=0; i<5; i++) Sigue derecho 1 milla; ------------------------------------------------------------------------------------------------------En este caso, el contador es llamado i, y la declaración se dividió en tres secciones, separadas por punto y coma. La primera sección declara el contador y la establece en su valor inicial, en este caso 0. La segunda sección es como una declaración mientras se utiliza el contador: Mientras que el contador cumpla con esta condición, sigue iterando o repitiendo. La tercera y última sección describe las medidas que se deben tomar en el contador durante cada iteración. En este caso, i++ es una forma corta de decir: Añade 1 al contador llamado i. Con todas las estructuras de control, las direcciones de manejo de la página 23 se pueden convertir en pseudo-código similar a C algo como lo siguiente: ------------------------------------------------------------------------------------------------------Comienza yendo hacia el este en la calle principal; While (no haya una iglesia a la derecha) Conduce por la calle principal; If (la calle está bloqueada) { Gira a la derecha en la calle 15; Gira a la izquierda en Pine Street; Gira a la derecha en la calle 16; } Else Gira a la derecha en la calle 16; Gira a la izquierda en Destination Road; For (i=0; i<5; i++) Sigue derecho 1 milla; Para en Destination Road 743; -------------------------------------------------------------------------------------------------------



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 muchos lenguajes de programación, con unas pocas diferencias sintácticas. Al introducir estos conceptos, los integraré en los ejemplos de pseudo-código utilizando sintaxis como C. Al final, el pseudo-código debe ser muy similar al có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 que se pueden cambiar, de ahí el nombre. También hay variables que no cambian, 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 variables son simples conceptos abstractos, pero en C (y en muchos otros lenguajes), las variables deben ser declaradas y se declara el tipo antes de que puedan ser utilizadas. Esto es porque un programa en C eventualmente se compilará en un programa ejecutable. Al igual que una receta de cocina que enumera todos los ingredientes necesarios antes de dar las instrucciones, las declaraciones de variables te permiten hacer los preparativos antes de entrar en la carne del programa. En última instancia, todas las variables se almacenan en memoria en algún lugar, y sus declaraciones permiten que el compilador organice esta memoria de manera más eficiente. Al final, sin embargo, a pesar de todas las declaraciones de tipos de variables, todo es solo 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 (valores de caracteres simples). Las variables se declaran simplemente usando estas palabras claves antes de enumerar las variables, como se puede ver a continuación. ------------------------------------------------------------------------------------------------------int a, b; float k; char z; -------------------------------------------------------------------------------------------------------



La variables a y b se definen ahora como enteros, k puede aceptar valores de punto flotante (por ejemplo: 3,14), y z se espera que mantenga un valor de 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 el operador =. ------------------------------------------------------------------------------------------------------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 vale 13, k contendrá el número 3,14, z contendrá el carácter w, y b contendrá el valor 18, puesto que 13 más 5 es igual a 18. Las variables son simplemente una manera de recordar los valores, sin embargo, con C, primero debes declarar cada tipo de variable. 0x242 Operadores Aritméticos La declaración b = a + 7 es un ejemplo de un operador aritmético muy simple. En C, los siguientes símbolos son utilizados en operaciones de cálculo diferentes. Las primeras cuatro operaciones deberían parecerte familiares. Reducción de módulo puede parecer un concepto nuevo, pero en realidad es simplemente 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 que significa que a % 5 = 3. También, puesto que las variables a y b son números enteros, 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 deben ser utilizadas para retener la respuesta más correcta de 2,6.



Operación

Símbolo Ejemplo

Suma Resta Multiplicación División Reducción de módulo

+ * / %

b=a+5 b=a-5 b=a*5 b=a/5 b=a%5

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

Expresión completa

Abrev.

Explicación

i=i+1 i=i-1

i++ o ++i i-- o --i

Añade 1 a la variable. Resta 1 a la variable.

Estas expresiones abreviadas se pueden combinar con otras operaciones aritméticas para producir expresiones más complejas. Aquí es donde la diferencia entre i++ y ++i se hace evidente. La primera expresión significa Incrementar 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á a aclarar. ------------------------------------------------------------------------------------------------------int a, b; a = 5; b = a++ * 6; -------------------------------------------------------------------------------------------------------



Al final de este conjunto de instrucciones, b valdrá 30 y también 6, ya que la abreviatura 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ía contendrá 6. Muy a menudo en los programas, las variables deben ser modificadas en su lugar. Por ejemplo, puede que tengas que agregar un valor arbitrario como 12 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 existe abreviatura para ello.

Expresión completa Abrev. Explicación i = i + 12 i = i - 12 i = i * 12 i = i / 12

i+=12 i-=12 i*=12 i/=12

Añade un valor a la variable. Resta un valor a la variable. Multiplica un valor por la variable. Divide un valor de la variable.



0x243 Operadores de Comparación Las variables se utilizan con frecuencia en las sentencias condicionales de las estructuras de control previamente explicadas. Estas declaraciones condicionales se basan en algún tipo de comparación. En C, los operadores de comparación utilizar una sintaxis abreviada que es bastante común en muchos lenguajes de programación.

Condición

Símbolo

Ejemplo

Menor que Mayor que Menor o igual a Mayor o igual a Igual a Diferente a

< > <= >= == !=

(a < b) (a > b) (a <= b) (a >= b) (a == b) (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 para probar la equivalencia, mientras que el signo igual se utiliza para asignar un valor a una variable. La sentencia a = 7 significa pon el valor 7 en la variable a, mientras que a == 7 significa chequea si la variable a es igual a 7. (Algunos lenguajes de programación como Pascal realmente usan: = para la asignación de variables para eliminar la confusión visual.) También, observa que un signo de exclamación significa generalmente no. Este símbolo puede ser utilizado por sí mismo para invertir cualquier expresión. ------------------------------------------------------------------------------------------------------!(a < b) es equivalente a (a >= b) -------------------------------------------------------------------------------------------------------



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

Lógico

OR AND

Símbolo

|| &&

Ejemplo

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

La declaración de ejemplo consta de las dos condiciones más pequeñas unidas con OR lógico que serán verdaderas si a es menor que b, o si a es menor que c. De manera similar, la sentencia del ejemplo consta de dos comparaciones más pequeñas unidas con AND lógico que serán verdaderas si a es menor que b y si a no es que c. Estas declaraciones deben ser agrupadas con paréntesis y pueden contener muchas variaciones diferentes. Muchas cosas pueden resumirse en las variables, operadores de comparación y estructuras de control. Volviendo al ejemplo del ratón en busca de alimento, el hambre se puede traducir en una variable Boolean, o sea true o false (verdadero o falso). Naturalmente, 1 significa verdadero y 0 significa falso. ------------------------------------------------------------------------------------------------------While (Hambriento == 1) { Busca comida; Cómete la comida; } ------------------------------------------------------------------------------------------------------Aquí hay otra abreviatura utilizada por los programadores y hackers a menudo. C no tiene realmente ningún operador boolean, por lo que cualquier valor distinto de cero es considerado verdadero, y una declaración se considera falsa si contiene 0. De hecho, los operadores de comparación en realidad retornan un 1 si la comparación es verdadera y 0 si es falsa. Para comparar 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



utiliza estos dos casos, el operador de comparación se puede quitar por completo. ------------------------------------------------------------------------------------------------------While (Hambriento) { Busca comida; Cómete la comida; } ------------------------------------------------------------------------------------------------------Un programa de ratón más inteligente con más entradas muestra cómo los operadores 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 presencia de 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, y 0 se considerará falso. 0x244 Funciones A veces habrá un conjunto de instrucciones que el programador sabe que va a necesitar varias veces. Estas instrucciones se pueden agrupar en un subprograma más pequeño llamado función. En otros lenguajes, las funciones que se conocen como subrutinas o procedimientos. Por ejemplo, la acción de cruzar un carro en realidad se compone de muchas instrucciones pequeñ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



capítulo requieren pocos giros, sin embargo, listando cada instrucción pequeña por cada vuelta sería tedioso (y menos legible). Puedes pasar variables 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 del giro. ------------------------------------------------------------------------------------------------------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 <5 mph) Acelera; } Gira el volante a la posición original; Apaga la luz intermitente de la variable_de_direccion; } ------------------------------------------------------------------------------------------------------Esta función describe todas las instrucciones necesarias para cruzar. Cuando un programa que sabe acerca de esta función tiene que cruzar, sólo puede llamar a esta función. Cuando la función es llamada, las instrucciones que se encuentran dentro de ella se ejecutan con los argumentos que se le pasan; después, la ejecución vuelve a donde estaba en el programa, después de la llamada a la función. Izquierda o derecha se pueden pasar en esta función, que hace que la función cruce en esa dirección. De forma predeterminada en C, las funciones pueden retornar un valor al llamador. Para quienes están familiarizados con funciones en matemáticas, esto tiene mucho sentido. Imagina una función que calcula el factor de un número - naturalmente, retorna el resultado.



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án retornando. Este formato es muy similar a la declaración de variables. Si una función debe retornar un entero (tal vez una función que calcule el factor de algún número x), la función podría tener este aspecto: ------------------------------------------------------------------------------------------------------int factor(int x) { int i; for (i=1; i


utilizada en cualquier otro lugar, ya que el compilador ya sabe. Un ejemplo de 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 comienzo de un programa. No hay necesidad de definir realmente los nombres de variables en el prototipo, ya que esto se hace en la propia función. Lo único que el compilador le importa es el nombre de la función, los tipos de datos de retorno y los tipos de datos de sus argumentos funcionales. Si una función no tiene ningún valor a retornar, debe ser declarada como Void (vacío), como es el caso de la función Cruzar() que utilizamos como un ejemplo anterior. Sin embargo, función Cruzar() todavía no capta toda la funcionalidad que nuestras direcciones de manejo necesitan. Cada giro en las direcciones tiene una dirección y un nombre de calle. Esto significa que una función de giro debe tener dos variables: la dirección del giro y de la calle a girar. Esto complica la función de giro, ya que la calle apropiada debe estar situada antes de que el cambio se pueda hacer. Una de las funciones de 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;



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 <5 mph) Acelera; } Gira el volante a la posición original; Apaga la luz intermitente de la variable_de_direccion; } ------------------------------------------------------------------------------------------------------Esta función incluye una sección que busca la intersección correcta buscando señales en la calle, leyendo el nombre de cada aviso y almacenando ese nombre en una variable llamada nombre_de_interseccion_actual. Seguirá buscando y leyendo los avisos hasta encontrar la calle de destino, en ese momento, las instrucciones de giro restantes serán ejecutadas. Las instrucciones de conducción en pseudocódigo pueden ahora ser cambiadas para usar esta función de giro. ------------------------------------------------------------------------------------------------------Comienza yendo hacia el este en la calle principal; While (no haya una iglesia a la derecha) Conduce por la calle principal; If (la calle está bloqueada) { Cruzar(Derecha, Calle 15); Cruzar (Izquierda, Pine Street); Cruzar (Derecha, Calle 16); }



Else Cruzar(Derecha, Calle 16); Cruzar (Izquierda, Destination Road); For (i=0; i<5; i++) Sigue derecho 1 milla; Para en Destination Road 743; ------------------------------------------------------------------------------------------------------Las funciones que no son de uso general en pseudo-código, ya que pseudocódigo se utiliza sobre todo como una manera para que los programadores esbocen conceptos de los programas antes de escribir código compilable. Ya que el pseudo-código en realidad no tiene que funcionar, las funciones completas no necesitan ser escritas - hacer cosas complejas aquí será suficiente. Pero en un lenguaje de programación como C, las funciones se utilizan en exceso. La mayor parte de la utilidad real de C proviene de las colecciones de funciones existentes llamadas bibliotecas.


El Arte de La Explotacion Vista Previa

Recommend Documents