Linux Basics For Hackers

Machine Translated by Google
FUNDAMENTOS BÁSICOS DE LINUX
PARA HACKERS
PRIMEROS PASOS CON LA RED ,
ESCRITURA G , Y SEGURIDAD EN KALI
OCUPAR LA WEB
¡GUAU! Libro
electrónico www.wowebook.org
¡GUAU! Libro
Conceptos básicos de Linux para piratas informáticos
¡GUAU! Libro
¡GUAU! Libro
Conceptos básicos de
Linux para hackers
Empezar con
Redes, scripting y seguridad en
Kali
Por OccupyTheWeb
San Francisco
¡GUAU! Libro
CONCEPTOS BÁSICOS DE LINUX PARA HACKERS. Copyright © 2019 por OccupyTheWeb.
Reservados todos los derechos. Ninguna parte de este trabajo puede reproducirse o transmitirse de ninguna forma ni por ningún medio,
electrónico o mecánico, incluidas fotocopias, grabaciones o cualquier sistema de almacenamiento o recuperación de información, sin
el permiso previo por escrito del propietario de los derechos de autor y del editor.
ISBN10: 1593278551
ISBN13: 9781593278557
Editorial: William Pollock

Editores de producción: Serena Yang y Meg Sneeringer
Ilustración de portada: Josh Ellingson
Diseño de interiores: Estudios Octopod
Editora de desarrollo: Liz Chadwick
Revisor técnico: Cliff Janzen
Editor: Barton D. Reed
Compositores: Serena Yang y Meg Sneeringer
Correctora: Paula L. Fleming Indexadora:
JoAnne Burek
Para obtener información sobre distribución, traducciones o ventas al por mayor, comuníquese directamente con No Starch Press, Inc.:
Sin almidón Press, Inc.
245 Calle 8, San Francisco, CA 94103
teléfono: 1.415.863.9900; info@nostarch.com
www.nostarch.com
Datos de catalogación en publicación de la Biblioteca del Congreso
Nombres: OccupyTheWeb, autor.

Título: Conceptos básicos de Linux para piratas informáticos: introducción a las redes, las secuencias de
comandos y la seguridad en Kali/OccupyTheWeb.
Descripción: Primera edición. | San Francisco: No Starch Press, Inc., [2018].
Identificadores: LCCN 2018030544 (imprimir) | LCCN 2018032646 (libro electrónico) | ISBN
9781593278564 (epub) | ISBN 159327856X (publicación electrónica) | ISBN 9781593278557 (imprimir)
| ISBN 1593278551 (impreso) | ISBN 9781593278564 (libro electrónico) | ISBN 159327856X (libro
electrónico)
Temas: LCSH: Pruebas de penetración (Seguridad informática) | KaliLinux. |
Hackers. | Sistemas operativos (computadoras)
Clasificación: LCC QA76.9.A25 (libro electrónico) | LCC QA76.9.A25 O325 2018 (imprimir) | DDC 005.8
dc23
Registro LC disponible en https://lccn.loc.gov/2018030544
No Starch Press y el logotipo de No Starch Press son marcas comerciales registradas de No Starch Press, Inc. Otros nombres de
productos y empresas mencionados aquí pueden ser marcas comerciales de sus respectivos propietarios. En lugar de utilizar un símbolo
de marca registrada cada vez que aparece un nombre de marca registrada, utilizamos los nombres solo de manera editorial y para
beneficio del propietario de la marca, sin intención de infringir la marca.
La información contenida en este libro se distribuye "tal cual", sin garantía. Si bien se han tomado todas las precauciones en la
preparación de este trabajo, ni el autor ni No Starch Press, Inc. tendrán responsabilidad alguna ante ninguna persona o entidad con
respecto a cualquier pérdida o daño causado o presuntamente causado directa o indirectamente por el información contenida en el mismo.
¡GUAU! Libro
Dedico este libro a mis tres increíbles hijas.

Para mi significas el mundo.
¡GUAU! Libro
¡GUAU! Libro
Sobre el Autor
OccupyTheWeb (OTW) es el seudónimo del fundador y escritor principal del sitio
web de capacitación para hackers y pentester, https://www.hackers rise.com/. Es ex
profesor universitario y tiene más de 20 años de experiencia en la industria de la
tecnología de la información. Ha entrenado a piratas informáticos en todo Estados
Unidos, incluidas ramas del ejército estadounidense (Ejército, Fuerza Aérea y Armada)
y de la comunidad de inteligencia estadounidense (CIA, NSA y DNI). También es un
ávido ciclista de montaña y practicante de snowboard.
Acerca del revisor técnico

Desde los primeros días de Commodore PET y VIC20, la tecnología ha sido una
compañera constante (¡y a veces una obsesión!) para Cliff Janzen. Cliff descubrió la
pasión de su carrera cuando pasó a la seguridad de la información en 2008, después
de una década de operaciones de TI. Desde entonces, Cliff ha tenido la gran fortuna
de trabajar y aprender de algunas de las mejores personas de la industria, incluidos
OccupyTheWeb y la excelente gente de No Starch, durante la producción de este
libro. Trabaja felizmente como consultor de seguridad, haciendo de todo, desde
revisión de políticas hasta pruebas de penetración. Se siente afortunado de tener una
carrera que también es su pasatiempo favorito y una esposa que lo apoya.
¡GUAU! Libro
¡GUAU! Libro
Contenidos breves
Agradecimientos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xix
Introducción . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xxi
Capítulo 1: Introducción a los conceptos básicos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
Capítulo 2: Manipulación de texto. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
Capítulo 3: Análisis y gestión de redes. . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
Capítulo 4: Agregar y eliminar software. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
Capítulo 5: Control de permisos de archivos y directorios. . . . . . . . . . . . . . . . . . . . . . . . . 49
Capítulo 6: Gestión de procesos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
Capítulo 7: Gestión de variables de entorno de usuario. . . . . . . . . . . . . . . . . . . . . . . . . . . 71
Capítulo 8: Secuencias de comandos Bash. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
Capítulo 9: Compresión y Archivado. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
Capítulo 10: Gestión de sistemas de archivos y dispositivos de almacenamiento. . . . . . . . . . . . . . . . . . . . . 101
Capítulo 11: El sistema de registro. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
Capítulo 12: Uso y abuso de los servicios. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
Capítulo 13: Volverse seguro y anónimo. . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
Capítulo 14: Comprensión e inspección de redes inalámbricas. . . . . . . . . . . . . . . . . 153
Capítulo 15: Gestión del kernel de Linux y de los módulos cargables del kernel. . . . . . . . . . . 165
Capítulo 16: Automatización de tareas con programación de trabajos. . . . . . . . . . . . . . . . . . . . . . . . . 173
Capítulo 17: Conceptos básicos de secuencias de comandos Python para piratas informáticos. . . . . . . . . . . . . . . . . . . . . . . . . . . 183
Índice. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205
¡GUAU! Libro
¡GUAU! Libro
Contenido en detalle
Expresiones de gratitud xix
Introducción xxi
¿Qué hay en este libro? . . . . . . . . . . . . .. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . XXII
¿Qué es el hacking ético? . . . .. .. .. .. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . xxiii
Pruebas de penetración . . . . . . . .. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . xxiii
Militar y Espionaje. . .. .. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . xxiii
Por qué los piratas informáticos utilizan Linux . . . . . . . . . . .. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . XXIV
Linux es de código abierto. . . . . . .. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . XXIV
Linux es transparente. . . . . . . .. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . XXIV
Linux ofrece control granular. . .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . XXIV
La mayoría de las herramientas de piratería están .. .. .. . .. .. .. .. .. . .. .. .. . XXIV
. ..
escritas para Linux. El futuro pertenece a Linux/Unix. .. .. .. .. . .. .. .. .. .. . .. .. .. . XXIV
Descarga de máquinas . .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . . xxvi
virtuales Kali Linux. . . . . . . . . . . . . . . . . . . . . . .. .. .. .. . .. .. .. .. .. . .. .. .. . xxvi
Instalando VirtualBox. . . . . . . . . . . . . . .. .. .. .. . .. .. .. .. .. . .. .. .. . xxvi
Configurando su máquina virtual. . . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . xxvii
Instalación de Kali en la VM. . . . . . . . . . .. .. .. .. . .. .. .. .. .. . .. .. .. . xxxx
Configurando Kali. . . . . . . . . . . . . . . . . . . . . . . .. .. .. .. . .. .. .. .. .. . .. .. .. . xxxi
1
Comenzando con lo básico 1
Términos y conceptos introductorios. . .. .. .. .. . .. .. .. .. . .. .. .. .. .. . .. .. .. .. . 1

.. .. .. .. . .. ..
Un recorrido por Kali. . .. .. .. .. . .. .. .. .. . .. .. .. .. .. . .. .. .. .. .3
La terminal . . . . . . . . . . .. .. .. .. . .. .. .. .. . .. .. .. .. .. . .. .. .. .. . 4
El sistema de archivos Linux. . . . . .. .. .. .. . .. .. .. .. . .. .. .. .. .. . .. .. .. .. . 4
Comandos básicos en Linux. . . . . . . .. .. .. .. . .. .. .. .. . .. .. .. .. .. . .. .. .. .. .5
Encontrarse con pwd. . .. .. .. . .. .. .. .. . .. .. .. .. .. . .. .. .. .. .6
Comprobando su inicio de sesión con whoami. . . .. .. .. .. . .. .. .. .. .. . .. .. .. .. .6
Navegando por el sistema de archivos de Linux. . . . . .. .. .. .. . .. .. .. .. .. . .. .. .. .. .6
Obteniendo ayuda . . . . . . . . . . . . . . . . . . . .. .. .. .. . .. .. .. .. .. . .. .. .. .. .8
Hacer referencia a páginas del manual con man. . .. .. .. .. . .. .. .. .. .. . .. .. .. .. .9
Encontrar cosas. . . . . . . . . . . . . . . . . . . . . . . . . .. .. .. .. . .. .. .. .. .. . .. .. .. .. .9
Buscando con localizar. . . . . . . . . . . . .. .. .. .. . .. .. .. .. .. . .. .. .. . . 10
Encontrar binarios con Whereis. . . . . . . .. .. .. .. . .. .. .. .. .. . .. .. .. . . 10
Encontrar binarios en la variable PATH con la que . . .. .. .. .. .. . .. .. .. . . 10
Realizar búsquedas más potentes con find. . .. . .. .. .. .. .. . .. .. .. . . 11
Filtrado con grep. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . . 12
Modificación de archivos y directorios. . . . . . . . . . . . . . . . . . .. . .. .. .. .. .. . .. .. .. . . 13
Creando archivos. . . . . . . . . . . . . . . . . . . . . . . . .. . .. .. .. .. .. . .. .. .. . . 13
Creando un directorio. . . . . . . . . . . . . . . . . . . .. . .. .. .. .. .. . .. .. .. . . 15
Copiar un archivo. . . . . . . . . . . . . . . . . . . . . . . .. . .. .. .. .. .. . .. .. .. . . 15
¡GUAU! Libro
. .. ..
Cambiar el nombre de un archivo. . .. .. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. . . . . 15
Eliminación de un archivo. . . . . . . .. .. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. . . . . dieciséis
Eliminación de un directorio. . . .. .. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. . . . . dieciséis
¡Ve a jugar ahora! . . . . . . . . . . . . . . . .. .. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. . . . . 17
Ejercicios . . . . . . . . . . . . . . . . . . . .. .. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. . . . . 17
2
Manipulación de texto 19
.. .. .. .. .. . .. .. .. .. .. . .. ..
Visualización de archivos. .. .. .. . .. .. .. .. .. . .. .. .. . . 20
Tomando la cabeza. . . . . . . . . . . . . . . . . . .. .. .. . .. .. .. .. .. . .. .. .. . . 20
Agarrando esa cola. . . . . . . . . . . . . . . . .. .. .. . .. .. .. .. .. . .. .. .. . . 21
Numeración de las líneas. . . . . . . . . . . . . . . .. .. .. . .. .. .. .. .. . .. .. .. . . 22
Filtrado de texto con grep. . . . . . . . . . . . . . . . . . . . .. .. .. . .. .. .. .. .. . .. .. .. . . 22
Desafío hacker: uso de grep, nl, tail y head. . .. .. .. .. .. . .. .. .. . . 23
Usando sed para buscar y reemplazar. . . . . . . . . . . . . . . .. .. .. . .. .. .. .. .. . .. .. .. . . 23
Ver archivos con más y menos. . .. .. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . . 24
Controlar la pantalla con más. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . . 25
Mostrar y filtrar con menos. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . . 25
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. .. .. . .. .. .. .. .. . .. .. .. . . 26
Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. .. .. . .. .. .. .. .. . .. .. .. . . 27
3
Análisis y gestión de redes Análisis de redes con ifconfig. . . . 29
29 .. .. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. ..
Comprobación de dispositivos de red inalámbrica con iwconfig. .. .. . .30
. . .. .. .. .. .. . .. .. ..
Cambiar la información de su red. . . 31 . . . . . . . . . . . . . . . . . . . . . . .. .. . .. .. ..
Cambiar su dirección IP. . . . 31 . . . . . . . . . . . . . . . . . . . . . . .. .. . .. .. ..
Cambiar su máscara de red y dirección de transmisión. . . . 32 . . .. .. . .. .. ..
.. . .. .. .. .. .. . .. .. ..
Falsificando su dirección MAC. . . . 32 .. .. . .. .. ..
Asignación de nuevas direcciones IP desde el servidor DHCP. . .. .. 32 .. .. .. . .. .. ..
. . .
Manipulación del sistema de nombres de dominio. . . 33. . . . . . . . . . . . . . . . . .. .. . .. .. ..
Examinando DNS con dig . . ..33 . .. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. ..
Cambiar su servidor DNS ................................. 34
Mapeo de sus propias direcciones IP. . .. .36 . .. .. .. .. . .. .. .. .. .. . .. .. ..
Resumen . . . 37 . . . . . . . . . . . . . . . . . . . . . . . . . . .. .. .. .. . .. .. .. .. .. . .. .. ..
Ejercicios . . . 37
.. .. .. .. .. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. ..
4
Agregar y eliminar software Uso de apt to Handle 39
Software. . .. .. .. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . . 40
Buscando un paquete. .. .. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . . 40
Agregar software. . . . . .. .. .. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . . 40
Eliminación de software. . . .. .. .. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . . 41
Actualización de paquetes. . . .. .. .. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . . 42
Paquetes de actualización. . . . . . . . .
. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . . 42
Agregar repositorios a su archivo sources.list. .. .. .. .. .. . .. .. .. .. .. . .. .. .. . . 43
Usando un instalador basado en GUI. . . . . . . . . . . . . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . . 45
Instalación de software con git. . . . . . . . . . . . . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . . 46
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . . 47
Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . . 47
xiii Contenido en detalle

¡GUAU! Libro
5
Controlar los permisos de archivos y directorios 49
Diferentes tipos de usuarios. . . . . . . . . . . . . . . . . . .

.. .. .. . .. ..
.. .. .. . .. .. .. . . 50
Concesión de permisos. . . . . . . . . . . . . . . . . . . . ... .. .. . .. ..
.. .. .. . .. .. .. . . 50
Otorgar propiedad a un usuario individual. . .. .. . .. ..
.. .. .. . .. .. .. . . 50
Otorgar propiedad a un grupo. . . .. ..
.. .. .. . .. ..
.. .. .. . .. .. .. . . 51
Comprobación de permisos. . . . . . . . . . . . . . . . . . . . .
.. .. .. . .. ..
.. .. .. . .. .. .. . . 51
Cambiar permisos. .. .. . .. .. .. .. .. . .. .. .. .. .. . .. ..
.. .. .. . .. .. .. . . 52
Cambiar permisos con notación decimal. . .. . .. ..
.. .. .. . .. .. .. . . 52
Cambiando Permisos con UGO. . .. .. .. .. .. . .. ..
.. .. .. . .. .. .. . . 54
Otorgar permiso de ejecución a Root en una nueva herramienta. . . .. ..
.. .. .. . .. .. .. . . 55
Configuración de permisos predeterminados más seguros con máscaras. . . . . . .. ..
.. .. .. . .. .. .. . . 56
Permisos especiales. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. ..
.. .. .. . .. .. .. . . 57
Otorgar permisos de root temporales con SUID. . . .. ..
.. .. .. . .. .. .. . . 57
Otorgar permisos de grupo al usuario raíz SGID. . .. ..
.. .. .. . .. .. .. . . 58
"Los permisos especiales . . . . . . . . . . . . . . . . . . . .. ..
.. .. .. . .. .. .. . . 58
anticuados de Sticky Bit, la escalada de privilegios y el hacker". . . . .. . .. .. .. . . 58
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . .. .. .. . . 60
Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . .. .. .. . . 60
6
Gestión de proceso 61
Visualización de procesos. .. .. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . . 62
Filtrado por nombre de proceso. . . . . . . . . . . .. .. .. . .. .. .. .. .. . .. .. .. . . 63
Encontrar los procesos más codiciosos con top . .. .. .. . .. .. .. .. .. . .. .. .. . . 64
Gestión de Procesos. .. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . . 64
Cambiar la prioridad del proceso con nice. . . . . .. .. .. . .. .. .. .. .. . .. .. .. . . sesenta y cinco
Procesos de matanza. . . . . . . . . . . . . . . . . . .. .. .. . .. .. .. .. .. . .. .. .. . . 66
Ejecución de procesos en segundo plano. . . .. .. .. . .. .. .. .. .. . .. .. .. . . 68
Mover un proceso al primer plano. . .. .. .. .. . .. .. .. .. .. . .. .. .. . . 68
Procesos de programación. . . . . . . . . . . . . . . . . . . . . .. .. .. . .. .. .. .. .. . .. .. .. . . 69
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. .. .. . .. .. .. .. .. . .. .. .. . . 70
Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. .. .. . .. .. .. .. .. . .. .. .. . . 70
7
Gestión de variables de entorno de usuario 71
Visualización y modificación de variables de entorno. . . . . .. .. . .. .. .. .. .. . .. .. .. . . 72

Visualización de todas las variables de entorno. . . . . . . .. .. . .. .. .. .. .. . .. .. .. . . 72
Filtrado por variables particulares. . . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . . 73
Cambiar valores de variables para una sesión. . . .. .. . .. .. .. .. .. . .. .. .. . . 73
Hacer permanentes los cambios de valores de variables. .. .. . .. .. .. .. .. . .. .. .. . . 74
Cambiar el mensaje de Shell. .. .. .. .. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . . 75
Cambiar su RUTA . .. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . . 76
Agregar a la variable PATH. . .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . . 76
Cómo no agregar a la variable PATH. . .. .. .. . .. .. .. .. .. . .. .. .. . . 77
Crear una variable definida por el usuario. . . . . . . . . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . . 77
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . . 78
Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . . 79
¡GUAU! Libro
Contenido en detalle xiii
8
Secuencias de comandos bash 81
Un curso intensivo en Bash. . . . . . . . . . . . . . . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . . 82
Su primer guión: "¡Hola, hackers, levántense!" . . . . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . . 82
Configuración de permisos de ejecución. . . . . . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . . 83
Ejecutando HelloHackersArise. . . . . . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . . 84
Agregar funcionalidad con variables y entrada del usuario. .. .. .. .. .. . .. .. .. . . 84
Su primer script de hacker: busque puertos abiertos. .. .. .. . .. .. .. .. .. . .. .. .. . . 86
Nuestra tarea . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. .. .. .. .. . .. .. .. . . 86
Un escáner sencillo. . . . . . . . . . . . . . . . . . . . . . . . .. .. .. .. .. . .. .. .. . . 87
Mejora del escáner MySQL. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . . 88
Comandos Bash integrados comunes. . . . . . . . . . . . . . . . . . . .. .. .. .. .. . .. .. .. . . 90
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. .. .. .. .. . .. .. .. . . 91
Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. .. .. .. .. . .. .. .. . . 91
9
Comprimir y archivar 93
¿Qué es la compresión? . . . . . . . . . . . .. .. . .. .. .. ... .. .. .. .. .. .. . .. .. .. . . 93
Tarrar archivos juntos. .. .. . .. .. .. .. .. . .. .. .. ... .. .. .. .. .. .. . .. .. .. . . 94
Comprimir archivos. . . . . . . . . . . . . . .. .. . .. .. .. ... .. .. .. .. .. .. . .. .. .. . . 96
Comprimiendo con gzip. . .. .. .. . .. .. .. ... .. .. .. .. .. .. . .. .. .. . . 96
Comprimiendo con bzip2. .. .. .. . .. .. .. ... .. .. .. .. .. .. . .. .. .. . . 97
Comprimir con compresa. .. .. . .. .. .. ... .. .. .. .. .. .. . .. .. .. . . 97
Creación de copias físicas o bit a bit de dispositivos de almacenamiento. . . .. .. .. .. .. . .. .. .. . . 98
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. .. .. .. .. . .. .. .. . . 99
Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. .. .. .. .. . .. .. .. . . 99
10
Gestión de sistemas de archivos y dispositivos de almacenamiento 101
El directorio de dispositivos /dev. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
Cómo Linux representa los dispositivos de almacenamiento. .. .. 103
.. .. . .. .. .. .. .. . .. .. ..
Particiones de unidades ................................................ 103
Dispositivos de caracteres y bloques. .. ..105 . .. .. .. .. .. . .. .. .. .. .. . .. .. ..
Enumere información y dispositivos de bloque con lsblk.. .. 105 .. . .. .. .. .. .. . .. .. ..
Montaje y Desmontaje. . 106 . .. .. .. .. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. ..
. .. 106
Montaje de dispositivos de almacenamiento usted mismo. .. .. .. .. . .. .. .. .. .. . .. .. ..
Desmontar con umount. . 107 . . . . . . . . . . . .. .. .. . .. .. .. .. .. . .. .. ..
Monitoreo de sistemas de archivos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. .. .. .. . .. .. .. . 107
Obtención de información sobre discos montados. . . . . . . . . . . . .. .. .. .. . .. .. .. . 107
Comprobando errores. . . . . . . . . . . . . . . . . . . . . . . . . .. .. .. .. . .. .. .. . 108
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. .. .. .. . .. .. .. . 109
Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. .. .. .. . .. .. .. . 109
11
El sistema de registro 111
El demonio de registro rsyslog. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
El archivo de configuración rsyslog. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
Las reglas de registro de rsyslog. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
xiv Contenido en detalle

¡GUAU! Libro
Limpieza automática de registros con logrotate. .. .. .. .. . .. .. .. .. .. . .. .. .. . 115

Permanecer sigiloso. . . . . . . . . . . . . . . . . . . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . 117
Eliminación de pruebas. . . . . . . . . . . . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . 117
Deshabilitar el registro. . . . . . . . . . . . . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . 118
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . 119
Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . 119
12
Uso y abuso de servicios Inicio, detención y 121
reinicio de servicios ................................. 122
Creación de un servidor web HTTP con el servidor web Apache. .. .. .. .. .. . .. .. .. . 122
Empezando por Apache. . . . . . . . . . . . . . . . . . . . . . .. .. .. .. .. . .. .. .. . 123
Editando el archivo index.html. . . . . . . . . . . . . . . . . . .. .. .. .. .. . .. .. .. . 124
Agregar algo de HTML. . . . . . . . . . . . . . . . . . . . . . .. .. .. .. .. . .. .. .. . 124
Ver lo que pasa. . .. .. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . 125
OpenSSH y Raspberry Spy Pi .. .. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . 125
Configurando Raspberry Pi . .. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . 126
Construyendo Raspberry Spy . . . . . . . . . . . . . . . . .. .. .. .. .. . .. .. .. . 126
Pi Configurando la cámara. . . . . . . . . . . . . . . . . . . .. .. .. .. .. . .. .. .. . 127
Empezando a espiar. . . . . . . . . . . . . . . . . . . . . . . . . . .. .. .. .. .. . .. .. .. . 129
Extrayendo información de MySQL. . .. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . 130
Iniciando MySQL. . . . . . . . . .. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . 130
Interactuando con MySQL. . . . . . . . . . . . . . . . . . . . .. .. .. .. .. . .. .. .. . 131
Establecer una contraseña MySQL. . . . . . . . . . . . . . . . . .. .. .. .. .. . .. .. .. . 131
Accediendo a una base de datos remota. . . . . . . . . . . . . . . .. .. .. .. .. . .. .. .. . 132
Conexión a una base de datos. . . . . . . . . . . . . . . . . . .. .. .. .. .. . .. .. .. . 133
Tablas de bases de datos. . . . . . . . . . . . . . . . . . . . . . . . . .. .. .. .. .. . .. .. .. . 134
Examinando los datos. . . . . . . . . . . . . . . . . . . . . . . .. .. .. .. .. . .. .. .. . 135
PostgreSQL con Metasploit. .. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . 135
Resumen . . . . . . . . . . . . . . . . . . . . . . .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . 137
Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. .. .. .. .. . .. .. .. . 138
13
Volverse seguros y anónimos Cómo nos delata Internet. . 139
.. .. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . 140
El sistema de enrutador cebolla. . . . . . . .. .. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . 141
Cómo funciona Tor. . . . . . . .. .. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . 141
. .. ..
Preocupaciones de seguridad . .. .. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . 142
Servidores proxy. . . . . . . . . . . . . . . . .. .. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . 143
Configuración de servidores proxy en el archivo de configuración. . . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . 144
Algunas opciones más interesantes. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . 146
Preocupaciones de seguridad . . . . . . . . . . .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . 148
Redes Privadas Virtuales. . . . . . . . . . . . .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . 148
Correo electrónico cifrado. . . . . . . . . . . . . . . . . . .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . 150
Resumen . . . . . . . . . . . . . . . . . . . . . . .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . 151
Ejercicios . . . . . . . . . . . . . . . . . . . . . . . .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . 151
Contenido en detalle xv
¡GUAU! Libro
14
Comprender e inspeccionar
Conexiones inalámbricas 153
Redes Wifi. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154
Comandos inalámbricos básicos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154
WiFi Recon con aircrackng. . .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . 157
Detección y conexión a Bluetooth. . .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . 159
Cómo funciona Bluetooth. . . . . . . . . . . . . . . . . . .. . .. .. .. .. .. . .. .. .. . 160
Escaneo y reconocimiento de Bluetooth. .. .. .. . .. .. .. .. .. . .. .. .. . 160
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. .. . .. .. .. .. .. . .. .. .. . 164
Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. . .. .. .. .. .. . .. .. .. . 164
15
Administrar el kernel de Linux y los módulos
del kernel cargables 165
¿Qué es un módulo de kernel? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
Comprobando la versión del kernel. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167
Ajuste del kernel con sysctl. . . . . . . . . . . . . . . . . .. .. .. .. . .. .. .. .. .. . .. .. .. . 167
Gestión de módulos del kernel. . . . . . . . . . . . . . . .. .. .. .. . .. .. .. .. .. . .. .. .. . 169
Encontrar más información con modinfo. . .. .. .. . .. .. .. .. .. . .. .. .. . 170
Agregar y quitar módulos con modprobe. . . .. .. .. .. .. . .. .. .. . 170
Insertar y quitar un módulo del kernel. .. .. .. . .. .. .. .. .. . .. .. .. . 171
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . .. .. .. .. . .. .. .. .. .. . .. .. .. . 171
Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. .. .. .. . .. .. .. .. .. . .. .. .. . 172
dieciséis
Automatización de tareas con programación de trabajos 173
Programar un evento o trabajo para que se ejecute de forma automática. . . . . . . . . . . . . . . . . . . . 174

. .. . 176
Programación de una tarea de copia de seguridad. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. ..
Usando crontab para programar su escáner MySQL. . . 177 . .. .. .. .. .. . .. .. ..
Atajos de crontab. . 178 . .. .. .. .. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. ..
Uso de scripts rc para ejecutar trabajos al inicio. .. ..178. .. .. .. .. .. . .. .. .. .. .. . .. .. ..
. . . 179
Niveles de ejecución de Linux. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. ..
Agregar servicios a rc.d ........................................ 179
Agregar servicios a su inicio a través de una GUI. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180
Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181
Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181
17
Conceptos básicos de secuencias de comandos Python para piratas informáticos 183
Agregar módulos de Python. . . . . . . . . . . . . . . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . 184

Usando pepita. . . . . . . . . . . . . . . . . . . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . 184
Instalación de módulos de terceros. . . . . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . 185
Introducción a las secuencias de comandos con Python. . . . . . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . 186
Variables. . . . . . . . . . . . . . . . . . . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . 187
Comentarios. . . . . . . . . . . . . . . . . . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . 190
Funciones. . . . . . . . . . . . . . . . . . . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . 190
xvi Contenido en detalle

¡GUAU! Libro
Listas. . . . . . . . . . . . . . . . . . . . . . . . . . .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . 191
Módulos. . . . . . . . . . . . . . . . . . . . . . . .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . 192
Programación Orientada a Objetos (POO). . . .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . 192
Comunicaciones de red en Python. . .. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . 194
Construyendo un cliente TCP. . . . . . . . .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . 194
Creando un oyente TCP. . . . . . .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . 195
Diccionarios, bucles y declaraciones de control. .. .. .. .. .. . .. .. .. .. .. . .. .. .. . 197
Diccionarios. . . . . . . . . . . . . . . . . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . 197
Declaraciones de control. . . . . . . . . . . . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . 197
Bucles. . . . . . . . . . . . . . . . . . . . . . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . 198
Mejorando nuestros scripts de piratería. . . . . . . . . . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . 199
Resumen de excepciones y descifradores .. .. .. . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . 201
de contraseñas.. . . . . . . . . . . . . . . . . . . . . . . . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . 203
Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . 203
Índice 205
Contenido en detalle xvii

¡GUAU! Libro
¡GUAU! Libro
Expresiones de gratitud
Este libro no podría haberse escrito sin la colaboración de varias personas clave.
Primero, quiero agradecer y reconocer a Liz Chadwick por proponer este libro y ser la
editora principal de su contenido. Su persistencia y dedicación han hecho posible este
libro.
En segundo lugar, quiero agradecer a Bill Pollock, editor de No Starch Press,
por creer y respaldar este libro.
En tercer lugar, quiero reconocer los diligentes esfuerzos de mi revisor técnico,
Cliff Janzen, por garantizar que el contenido técnico de este libro sea preciso.
Cualquier error u omisión restante es únicamente culpa mía.

Finalmente, quiero agradecer y reconocer a todos los profesionales dedicados.
a No Starch Press por sus esfuerzos para completar el libro y comercializarlo. Gracias.
¡GUAU! Libro
¡GUAU! Libro
Introducción
¡El hacking es el conjunto de habilidades más

importante del siglo XXI! No hago esa afirmación a
la ligera. Los acontecimientos de los últimos años
parecen reafirmar esta afirmación con el titular de cada
mañana. Las naciones se espían entre sí para obtener secretos,
los ciberdelincuentes roban miles de millones de dólares, se liberan
gusanos digitales que exigen rescates, los adversarios influyen
mutuamente en las elecciones y los combatientes destruyen los servicios públicos d
Todo esto es obra de piratas informáticos, y su influencia en nuestro mundo cada vez más digital apenas
comienza a sentirse.
Decidí escribir este libro después de trabajar con decenas de miles de aspirantes a piratas
informáticos a través de NullByte, https://www.hackersarise.com/ y casi todas las ramas de las agencias
militares y de inteligencia de EE. UU. (NSA, DIA, CIA y FBI). Estas experiencias me han enseñado
que muchos aspirantes a hackers han tenido poca o ninguna experiencia con Linux, y esta falta de
experiencia es la principal barrera para iniciar el viaje hacia convertirse en hackers profesionales.
Casi todas las mejores herramientas para hackers están escritas en Linux, por lo que algunos
conocimientos básicos de Linux son un requisito previo para convertirse en un hacker profesional. He
escrito este libro para ayudar a los aspirantes a hackers a superar esta barrera.
¡GUAU! Libro
El hacking es una profesión de élite dentro del campo de las tecnologías de la información. Como tal, requiere una
Comprensión amplia y detallada de los conceptos y tecnologías de TI. En el nivel más
fundamental, Linux es un requisito. Le recomiendo encarecidamente que invierta tiempo y
energía en usarlo y comprenderlo si desea hacer de la piratería y la seguridad de la información
su carrera.
Este libro no está destinado a piratas informáticos experimentados ni a administradores de
Linux experimentados. Más bien, está destinado a aquellos que quieran iniciarse en el apasionante
camino del hacking, la ciberseguridad y el pentesting. Tampoco pretende ser un tratado completo
sobre Linux o piratería, sino más bien un punto de partida hacia estos mundos. Comienza con
lo esencial de Linux y se extiende a algunas secuencias de comandos básicas tanto en bash
como en Python. Siempre que fue apropiado, intenté utilizar ejemplos del mundo del hacking
para enseñar los principios de Linux.
En esta introducción, veremos el crecimiento del hacking ético para la seguridad de la
información y lo guiaremos a través del proceso de instalación de una máquina virtual para que
pueda instalar Kali Linux en su sistema sin alterar el sistema operativo que ya tiene. correr.
¿Qué hay en este libro?

En la primera serie de capítulos se sentirá cómodo con los fundamentos de Linux; El Capítulo 1
lo acostumbrará al sistema de archivos y al terminal, y le brindará algunos comandos básicos. El
Capítulo 2 le muestra cómo manipular texto para buscar, examinar y modificar software y
archivos.
En el Capítulo 3 administrará redes. Buscará redes, encontrará información sobre conexiones
y se disfrazará enmascarando su red y su información DNS.
El Capítulo 4 le enseña a agregar, eliminar y actualizar software y cómo mantener su

sistema optimizado. En el Capítulo 5, manipulará los permisos de archivos y directorios para
controlar quién puede acceder a qué. También aprenderá algunas técnicas de escalada de
privilegios.
El Capítulo 6 le enseña cómo administrar servicios, incluido iniciar y detener procesos y
asignar recursos para brindarle un mayor control. En el Capítulo 7 administrará las variables de
entorno para lograr un rendimiento óptimo, comodidad e incluso sigilo. Encontrará y filtrará
variables, cambiará su variable PATH y creará nuevas variables de entorno.
El Capítulo 8 le presenta el scripting bash, un elemento básico para cualquier hacker

serio. Aprenderá los conceptos básicos de bash y creará un script para buscar puertos de
destino en los que podría infiltrarse más adelante.
Los capítulos 9 y 10 le brindan algunas habilidades esenciales de administración de sistemas de archivos,
que le muestra cómo comprimir y archivar archivos para mantener su sistema limpio, copiar
dispositivos de almacenamiento completos y obtener información sobre archivos y discos conectados.
Los últimos capítulos profundizan en los temas de piratería. En el Capítulo 11 usarás y
manipularás el sistema de registro para obtener información sobre la actividad de un objetivo y
cubrir tus propias huellas. El Capítulo 12 le muestra cómo usar y abusar de tres servicios
principales de Linux: el servidor web Apache, OpenSSH y MySQL. Creará un servidor web,
creará un video espía remoto y aprenderá sobre las bases de datos y sus vulnerabilidades. El
Capítulo 13 le mostrará cómo mantenerse seguro y anónimo con servidores proxy, la red Tor,
VPN y correo electrónico cifrado.
XXII Introducción
¡GUAU! Libro
El capítulo 14 trata de las redes inalámbricas. Aprenderás redes básicas

comandos, luego descifra puntos de acceso WiFi y detecta y se conecta a señales de Bluetooth.
El Capítulo 15 profundiza en Linux con una visión de alto nivel de cómo

cómo funciona el kernel y cómo se puede abusar de sus controladores para generar software
malicioso. En el Capítulo 16 aprenderá habilidades de programación esenciales para automatizar

sus scripts de piratería. El Capítulo 17 le enseñará los conceptos básicos de Python y creará scripts
para dos herramientas de piratería: un escáner para espiar las conexiones TCP/IP y un sencillo
descifrador de contraseñas.
¿Qué es el hacking ético?

Con el crecimiento del campo de la seguridad de la información en los últimos años se ha producido
un crecimiento espectacular en el campo del hacking ético, también conocido como sombrero blanco.
(buen chico) piratear. El hacking ético es la práctica de intentar infiltrarse y explotar un sistema para
descubrir sus debilidades y protegerlo mejor. Segmento el campo del hacking ético en dos
componentes principales: pruebas de penetración para una empresa legítima de seguridad de la
información y trabajo para las agencias militares o de inteligencia de su país. Ambas son áreas de
rápido crecimiento y la demanda es fuerte.
Pruebas de penetración
A medida que las organizaciones se vuelven cada vez más conscientes de la seguridad y el costo
de las violaciones de seguridad aumenta exponencialmente, muchas organizaciones grandes están
comenzando a subcontratar servicios de seguridad. Uno de estos servicios de seguridad clave son
las pruebas de penetración. Una prueba de penetración es esencialmente un hack legal encargado
para demostrar la vulnerabilidad de la red y los sistemas de una empresa.
Generalmente, las organizaciones realizan primero una evaluación de vulnerabilidades para
encontrar vulnerabilidades potenciales en su red, sistemas operativos y servicios. Hago hincapié en el
potencial, ya que este escaneo de vulnerabilidades incluye una cantidad significativa de falsos positivos
(cosas identificadas como vulnerabilidades que en realidad no lo son). La función del evaluador de
penetración es intentar piratear o penetrar estas vulnerabilidades. Sólo entonces la organización podrá
saber si la vulnerabilidad es real y decidir invertir tiempo y dinero para cerrarla.
Militar y espionaje
Casi todas las naciones del planeta se dedican ahora al ciberespionaje y la ciberguerra. Basta leer los
titulares para ver que las actividades cibernéticas son el método elegido para espiar y atacar los
sistemas militares e industriales.
La piratería informática desempeña un papel crucial en estas actividades militares y de
recopilación de inteligencia, y eso será más cierto a medida que pase el tiempo. Imagine una guerra
del futuro en la que los piratas informáticos puedan obtener acceso a los planes de guerra de su
adversario y destruir su red eléctrica, sus refinerías de petróleo y sus sistemas de agua. Estas actividades
se llevan a cabo todos los días ahora. El hacker se convierte así en un componente clave de la defensa
de su nación.
¡GUAU! Libro Introducción xxiii

Por qué los piratas informáticos utilizan Linux
Entonces, ¿por qué los piratas informáticos utilizan Linux en lugar de otros sistemas operativos?
Principalmente porque Linux ofrece un nivel de control mucho mayor a través de algunos métodos diferentes.
Linux es de código abierto
A diferencia de Windows, Linux es de código abierto, lo que significa que el código fuente del sistema
operativo está disponible para usted. Como tal, puedes cambiarlo y manipularlo como quieras. Si está
intentando hacer que un sistema funcione de una manera para la que no estaba previsto, es esencial
poder manipular el código fuente.
Linux es transparente
Para hackear eficazmente, debes conocer y comprender tu sistema operativo y, en gran medida, el
sistema operativo que estás atacando. Linux es totalmente transparente, lo que significa que podemos ver y
manipular todas sus partes funcionales.
No es así con Windows. Microsoft se esfuerza por hacer que sea lo más difícil posible conocer
el funcionamiento interno de sus sistemas operativos, por lo que nunca se sabe realmente lo que sucede
"debajo del capó", mientras que en Linux, tiene un foco brillando directamente sobre todos y cada uno de
los componentes de su sistema operativo. El sistema operativo. Esto hace que trabajar con Linux sea más
efectivo.
Linux ofrece control granular
Linux es granular. Eso significa que tienes un control casi infinito sobre el sistema. En Windows, sólo
puedes controlar lo que Microsoft te permite controlar. En Linux, todo puede ser controlado por la terminal,
al nivel más minúsculo o al nivel más macro. Además, Linux hace que las secuencias de comandos en
cualquiera de los lenguajes de secuencias de comandos sean simples y efectivas.
La mayoría de las herramientas de piratería están escritas para Linux
Más del 90 por ciento de todas las herramientas de piratería están escritas para Linux. Por supuesto, hay
excepciones, como Caín, Abel y Wikto, pero esas excepciones confirman la regla. Incluso cuando las
herramientas de piratería como Metasploit o nmap se adaptan a Windows, no todas las capacidades se
transfieren desde Linux.
El futuro pertenece a Linux/Unix
Esto puede parecer una afirmación radical, pero creo firmemente que el futuro de la tecnología de la
información pertenece a los sistemas Linux y Unix. Microsoft tuvo su época en las décadas de 1980 y
1990, pero su crecimiento se está desacelerando y estancando.
Desde que comenzó Internet, Linux/Unix ha sido el sistema operativo elegido para los servidores
web debido a su estabilidad, confiabilidad y robustez. Incluso hoy en día, Linux/Unix se utiliza en dos tercios
de los servidores web y domina el mercado. Los sistemas integrados en enrutadores, conmutadores y
otros dispositivos casi siempre utilizan un kernel de Linux, y el mundo de la virtualización está dominado
por Linux, con VMware y Citrix basados en el kernel de Linux.
Más del 80 por ciento de los dispositivos móviles ejecutan Unix o Linux (iOS es Unix y Android es
Linux), por lo que si cree que el futuro de la informática está en
XXIV Introducción ¡GUAU! Libro
dispositivos móviles como tabletas y teléfonos (sería difícil argumentar lo contrario), entonces el
futuro es Unix/Linux. Microsoft Windows tiene sólo el 7 por ciento del mercado de dispositivos
móviles. ¿Es ese el carro al que quieres que te enganchen?
Descargando Kali Linux

Antes de comenzar, debe descargar e instalar Kali Linux en su computadora. Esta es la distribución
de Linux con la que trabajaremos a lo largo de este libro. Linux fue desarrollado por primera vez por
Linus Torvalds en 1991 como una alternativa de código abierto a Unix. Dado que es de código
abierto, los desarrolladores voluntarios codifican el kernel, las utilidades y las aplicaciones. Esto
significa que no existe una entidad corporativa primordial que supervise el desarrollo y, como
resultado, a menudo faltan convenciones y estandarización.
Kali Linux fue desarrollado por Offensive Security como un sistema operativo de piratería
basado en una distribución de Linux llamada Debian. Hay muchas distribuciones de Linux y Debian
es una de las mejores. Probablemente esté más familiarizado con Ubuntu como una distribución
de escritorio popular de Linux. Ubuntu también se basa en Debian. Otras distribuciones incluyen
Red Hat, CentOS, Mint, Arch y SUSE. Aunque todos comparten el mismo kernel de Linux (el
corazón del sistema operativo que controla la CPU, la RAM, etc.), cada uno tiene sus propias
utilidades, aplicaciones y opciones de interfaz gráfica (GNOME, KDE y otras) para diferentes
propósitos. Como resultado, cada una de estas distribuciones de Linux se ve y se siente ligeramente
diferente. Kali fue diseñado para probadores de penetración y piratas informáticos y viene con un
importante complemento de herramientas de piratería.
Le recomiendo encarecidamente que utilice Kali para este libro. Aunque puedes
Si utiliza otra distribución, probablemente tendrá que descargar e instalar las diversas herramientas
que usaremos, lo que podría significar muchas horas descargando e instalando herramientas.
Además, si esa distribución no está basada en Debian, puede haber otras diferencias menores.
Puede descargar e instalar Kali desde https://www.kali.org/.
Desde la página de inicio, haga clic en el enlace Descargas en la parte superior de la página.
En la página de Descargas, encontrarás múltiples opciones de descarga.
Es importante elegir la descarga correcta. En el lado izquierdo de la tabla, verá el nombre de
la imagen, que es el nombre de la versión que descarga el enlace. Por ejemplo, la primera lista
de nombres de imágenes que veo es Kali Linux 64 Bit, lo que significa que es Kali Linux completo y
es adecuado para sistemas de 64 bits; la mayoría de los sistemas modernos usan una CPU
Intel o AMD de 64 bits. Para determinar qué tipo de CPU hay en su sistema, vaya a Panel de
control4System y Security4System, y debería aparecer en la lista. Si su sistema es de 64 bits,
descargue e instale la versión de 64 bits de Kali completa (no Light o Lxde, ni ninguna de las
otras alternativas).
Si está ejecutando una computadora antigua con una CPU de 32 bits, necesitará
para instalar la versión de 32 bits, que aparece más abajo en la página.
Tiene la opción de descargar a través de HTTP o Torrent. Si elige HTTP, Kali se descargará
directamente a su sistema como cualquier descarga y se colocará en su carpeta de Descargas. La
descarga de torrent es la descarga de igual a igual utilizada por muchos sitios para compartir
archivos. Necesitarás un torrent
¡GUAU! Libro Introducción xxvi
aplicación como BitTorrent para hacer esto. Luego, el archivo Kali se descargará en la carpeta en
la que la aplicación de torrents almacena sus descargas.
Existen otras versiones para otros tipos de CPU, como la arquitectura ARM comúnmente
utilizada que se encuentra en tantos dispositivos móviles. Si está utilizando una Raspberry Pi, una
tableta u otro dispositivo móvil (los usuarios de teléfonos probablemente prefieran Kali NetHunter),
asegúrese de descargar e instalar la versión de arquitectura ARM de Kali desplazándose hacia
abajo hasta Descargar imágenes ARM y haciendo clic en Kali ARM Images . .
Tienes Kali descargado, pero antes de instalar nada, quiero hablar un poco sobre las
máquinas virtuales. Generalmente, para los principiantes, instalar Kali en una máquina virtual
es la mejor solución para aprender y practicar.
Maquinas virtuales
La tecnología de máquina virtual (VM) le permite ejecutar múltiples sistemas operativos desde
una sola pieza de hardware, como su computadora portátil o de escritorio. Esto significa que puede
continuar ejecutando el sistema operativo Windows o MacOS con el que está familiarizado y
ejecutar una máquina virtual de Kali Linux dentro de ese sistema operativo. No necesita sobrescribir
su sistema operativo existente para aprender Linux.
Hay numerosas aplicaciones de máquinas virtuales disponibles de VMware, Oracle,
Microsoft y otros proveedores. Todos son excelentes, pero aquí les mostraré cómo descargar e
instalar VirtualBox gratuito de Oracle.
Instalación de VirtualBox
Puede descargar VirtualBox en https://www.virtualbox.org/, como se muestra en la Figura 1.
Haga clic en el enlace Descargas en el menú de la izquierda y seleccione el paquete de
VirtualBox para el sistema operativo actual de su computadora, que alojará VirtualBox VM.
Asegúrese de descargar la última versión.
Figura 1: página de inicio de VirtualBox
Cuando se haya completado la descarga, haga clic en el archivo de instalación y será recibido
por un asistente de configuración familiar, que se muestra en la Figura 2.
xxvi Introducción ¡GUAU! Libro

Figura 2: El cuadro de diálogo del Asistente de configuración
Haga clic en Siguiente y aparecerá la pantalla Configuración personalizada, como en la Figura

3.
Figura 3: El cuadro de diálogo Configuración personalizada
Desde esta pantalla, simplemente haga clic en Siguiente. Continúe haciendo clic en Siguiente
hasta llegar a la pantalla de advertencia de Interfaces de red y luego haga clic en Sí.
Haga clic en Instalar para comenzar el proceso. Durante este proceso, es probable que se le
solicite varias veces acerca de la instalación del software del dispositivo. Estos son los dispositivos de
red virtuales necesarios para que sus máquinas virtuales se comuniquen.
Haga clic en Instalar para cada uno.
Cuando se complete la instalación, haga clic en Finalizar.
Configurando su máquina virtual

Ahora comencemos con su máquina virtual. VirtualBox debería abrirse una vez que se haya instalado
(si no, ábralo) y el VirtualBox Manager debería saludarlo, como se ve en la Figura 4.
¡GUAU! Libro Introducción xxvii
Figura 4: El Administrador de VirtualBox
Como crearemos una nueva máquina virtual con Kali Linux, haga clic en Nuevo en la
esquina superior izquierda. Esto abre el cuadro de diálogo Crear máquina virtual que se muestra
en la Figura 5.
Dale un nombre a tu máquina (cualquier nombre está bien, pero yo simplemente usé Kali) y
luego seleccione Linux en el menú desplegable Tipo . Finalmente, seleccione Debian (64
bits) en el tercer menú desplegable (a menos que esté utilizando la versión de Kali de 32
bits, en cuyo caso seleccione la versión de Debian de 32 bits). Haga clic en Siguiente y verá
una pantalla como la Figura 6. Aquí debe seleccionar cuánta RAM desea asignar a esta
nueva máquina virtual.
Figura 5: El cuadro de diálogo Crear máquina virtual Figura 6: Asignación de memoria
Como regla general, no recomiendo utilizar más del 25 por ciento de la RAM total del
sistema. Eso significa que si has instalado 4 GB en tu
xxviii Introducción
¡GUAU! Libro
sistema físico o host, luego seleccione solo 1 GB para su máquina virtual, y si tiene 16
GB en su sistema físico, seleccione 4 GB. Cuanta más RAM le dé a su máquina virtual,
mejor y más rápido se ejecutará, pero también debe dejar suficiente RAM para su sistema
operativo host y cualquier otra máquina virtual que desee ejecutar simultáneamente. Sus
máquinas virtuales no utilizarán RAM cuando usted no las esté utilizando, pero sí utilizarán
espacio en el disco duro.
Haga clic en Siguiente y accederá a la pantalla Disco duro. Elija Crear disco duro
virtual y haga clic en Crear.
En la siguiente pantalla, puede decidir si desea que el disco duro que está
creando se asigne dinámicamente o tenga un tamaño fijo. Si elige Asignado
dinámicamente, el sistema no ocupará todo el tamaño máximo que asigne para el disco
duro virtual hasta que lo necesite, lo que ahorrará más espacio no utilizado en el disco
duro para su sistema host. Le sugiero que seleccione asignado dinámicamente.
Haga clic en Siguiente y elegirá la cantidad de espacio en el disco duro que desea asignar.
cate a la VM y la ubicación de la VM (consulte la Figura 7).
Figura 7: Asignación de espacio en el disco duro
El valor predeterminado es 8 GB. Normalmente encuentro que es un poco

pequeño y recomiendo que asigne entre 20 y 25 GB como mínimo. Recuerde, si elige
asignar dinámicamente espacio en el disco duro, no utilizará el espacio hasta que lo
necesite, y expandir su disco duro después de haberlo asignado puede ser complicado,
por lo que es mejor pecar de excesivo.
Haga clic en Crear y ¡listo!
Instalación de Kali en la VM
En este punto, debería ver una pantalla como la Figura 8. Ahora necesitará instalar
Kali. Tenga en cuenta que a la izquierda de VirtualBox Manager, debería ver una
indicación de que Kali VM está apagado. Haga clic en el botón Inicio (icono de
flecha verde).
¡GUAU! Libro Introducción xxix
Figura 8: La pantalla de bienvenida de VirtualBox
Luego, VirtualBox Manager le preguntará dónde encontrar el disco de inicio.

Ya descargaste una imagen de disco con la extensión .iso, que debería estar en tu carpeta de
Descargas (si usaste un torrent para descargar Kali, el .iso
El archivo estará en la carpeta Descargas de su aplicación de torrents). Haga clic en el icono
de la carpeta a la derecha, navegue hasta la carpeta Descargas y seleccione el archivo de
imagen de Kali (consulte la Figura 9).
Figura 9: Selección de su disco de inicio
xxx Introducción ¡GUAU! Libro

Luego haga clic en Iniciar. ¡Felicitaciones, acaba de instalar Kali Linux en una máquina
virtual!
Configurando Kali
Kali ahora abrirá una pantalla como la Figura 10, que le ofrece varias opciones de inicio.
Sugiero utilizar la instalación gráfica para principiantes. Utilice las teclas del teclado para
navegar por el menú.
Si recibes un error al instalar Kali en tu VirtualBox, es
probablemente porque no tiene la virtualización habilitada en el BIOS de su sistema. Cada
sistema y su BIOS son ligeramente diferentes, así que consulte con su fabricante o busque
en línea soluciones para su sistema y BIOS. Además, en los sistemas Windows, es probable
que deba desactivar cualquier software de virtualización de la competencia, como HyperV.
Nuevamente, una búsqueda en Internet de su sistema debería guiarlo para hacerlo.
Figura 10: Selección del método de instalación
A continuación se le pedirá que seleccione su idioma. Asegúrese de seleccionar el idioma

en el que se siente más cómodo trabajando y luego haga clic en Continuar.
Luego, seleccione su ubicación, haga clic en Continuar y luego seleccione la distribución de
su teclado.
Cuando haces clic en Continuar, VirtualBox pasará por un proceso de detección
ing su hardware y adaptadores de red. Espere pacientemente mientras lo hace.
Finalmente, aparecerá una pantalla que le pedirá que configure su red, como en la Figura 11.
¡GUAU! Libro Introducción xxxi
Figura 11: Ingresando un nombre de host
El primer elemento que solicita es el nombre de su anfitrión. Puedes nombrarlo

como quieras, pero dejé el mío con el "kali" predeterminado.
A continuación, se le pedirá el nombre de dominio. No es necesario introducir
nada aquí. Haga clic en Continuar. La siguiente pantalla, que se muestra en la Figura 12,
es muy importante. Aquí se le solicita la contraseña que desea utilizar para el usuario
root .
Figura 12: Elegir una contraseña
xxxiii Introducción ¡GUAU! Libro

El usuario root en Linux es el todopoderoso administrador del sistema. Puede

utilizar cualquier contraseña con la que se sienta seguro. Si este fuera un sistema físico
que estuviéramos usando en Internet, sugeriría que usara una contraseña muy larga y
compleja para limitar la capacidad de un atacante de descifrarla. Dado que se trata de
una máquina virtual a la que las personas no pueden acceder sin acceder primero a su
sistema operativo host, la autenticación de contraseña en esta máquina virtual es
menos importante, pero aun así debe elegir sabiamente.
Haga clic en Continuar y se le pedirá que configure su zona horaria. Hazlo y luego
continúa.
La siguiente pantalla pregunta acerca de los discos de partición (una partición
es exactamente lo que parece: una parte o segmento de su disco duro). Elija Guiado:
use todo el disco y Kali detectará sus discos duros y configurará un particionador
automáticamente.
Luego, Kali le advertirá que se borrarán todos los datos del disco que
seleccione. . . ¡pero no te preocupes! Este es un disco virtual y el disco es nuevo y
está vacío, por lo que en realidad no hará nada. Haga clic en Continuar.
Kali ahora le preguntará si desea todos los archivos en una partición o si desea
tener particiones separadas. Si este fuera un sistema de producción, probablemente
seleccionaría particiones separadas para /home, /var y /tmp, pero considerando que
usaremos esto como un sistema de aprendizaje en un entorno virtual, es seguro para
usted simplemente seleccione Todos los archivos en una partición.
Ahora se le preguntará si desea escribir los cambios en el disco. Seleccione Finalizar
la partición y escriba los cambios en el disco. Kali le preguntará una vez más si desea
escribir los cambios en el disco; seleccione Sí y haga clic en Continuar (consulte la
Figura 13).
Figura 13: Escritura de cambios en el disco
¡GUAU! Libro Introducción xxxiii
Kali ahora comenzará a instalar el sistema operativo. Esto podría llevar un tiempo,
así que tenga paciencia. Ahora es el momento de tomarte un descanso para ir al baño y
tomar tu bebida favorita.
Una vez que se complete la instalación, se le preguntará si desea utilizar un espejo
de red. Esto realmente no es necesario, así que haga clic en No.
Luego, Kali le preguntará si desea instalar GRUB (Grand Unified Bootloader),
como se muestra en la Figura 14. Un gestor de arranque le permite seleccionar diferentes
sistemas operativos para iniciar, lo que significa que cuando inicia su máquina, puede
iniciar en cualquiera de ellos. Kali u otro sistema operativo. Seleccione Sí y haga clic
en Continuar.
Figura 14: Instalación de GRUB
En la siguiente pantalla, se le preguntará si desea instalar el gestor de arranque

GRUB de forma automática o manual. Por razones aún no claras, si elige la segunda
opción, Kali tenderá a colgarse y mostrar una pantalla en blanco después de la instalación.
Seleccione Ingresar dispositivo manualmente, como se muestra en la Figura 15.
xxxv Introducción ¡GUAU! Libro

Figura 15: Ingresando su dispositivo manualmente
En la siguiente pantalla, seleccione la unidad donde se debe instalar el gestor de

arranque GRUB (probablemente será algo como /dev/sda). Haga clic en la siguiente
pantalla, que debería indicarle que la instalación está completa.
¡Felicidades! Has instalado Kali. Haga clic en Continuar. Kali intentará
reiniciarse y verá varias líneas de código en una pantalla negra y en blanco antes de
que finalmente aparezca la pantalla de inicio de sesión de Kali 2018, como se muestra
en la Figura 16.
Figura 16: La pantalla de inicio de sesión de Kali
¡GUAU! Libro Introducción xxxv
Inicie sesión como root y se le pedirá su contraseña. Ingrese la contraseña que

seleccionó para su usuario root.
Después de iniciar sesión como root, aparecerá el escritorio de Kali Linux, como se
muestra en la Figura 17.
Figura 17: La pantalla de inicio de Kali
¡Ahora estás listo para comenzar tu viaje hacia el apasionante campo de la piratería!
¡Bienvenido!
xxxvi Introducción ¡GUAU! Libro

1
Primeros pasos con los conceptos básicos
Por nuestra propia naturaleza, los hackers son

hacedores. Queremos tocar y jugar con las
cosas. También queremos crear y, a veces, romper
cosas. Pocos de nosotros queremos leer largos tomos
de teoría de la tecnología de la información antes de poder hacer
lo que más amamos: piratear. Con eso en mente, este capítulo
está diseñado para brindarle algunas habilidades fundamentales
que le ayudarán a comenzar a utilizar Kali. . . ¡ahora!
En este capítulo, no entraremos en ningún concepto en detalle; cubriremos solo lo
suficiente para permitirle jugar y explorar en el sistema operativo de los piratas informáticos:
Linux. Guardaremos discusiones más profundas para capítulos posteriores.
Términos y conceptos introductorios

Antes de comenzar nuestro viaje por el maravilloso mundo de los conceptos básicos de Linux
para hackers, quiero presentar algunos términos que deberían aclarar algunos conceptos
que se analizan más adelante en este capítulo.
¡GUAU! Libro
Binarios Este término se refiere a archivos que se pueden ejecutar, similares a los
ejecutables de Windows. Los binarios generalmente residen en el directorio /usr/bin o
usr/sbin e incluyen utilidades como ps, cat, ls y cd (abordaremos las cuatro en este
capítulo), así como aplicaciones como la red inalámbrica. la herramienta de hacking
aircrackng y el sistema de detección de intrusos (IDS) Snort.
Distinción entre mayúsculas y minúsculas A diferencia de Windows, Linux distingue entre mayúsculas y
minúsculas. Esto significa que Desktop es diferente de Desktop, que a su vez es diferente de DeskTop.
Cada uno de estos representaría un nombre de archivo o directorio diferente. Muchas
personas que vienen de un entorno Windows pueden encontrar esto frustrante.
Si recibe el mensaje de error "archivo o directorio no encontrado" y está seguro de que
el archivo o directorio existe, probablemente necesite verificar su caso.
Directorio Esto es lo mismo que una carpeta en Windows. Un directorio proporciona

una forma de organizar archivos, normalmente de forma jerárquica.
Inicio Cada usuario tiene su propio directorio /home , y aquí es generalmente donde los
archivos que cree se guardarán de forma predeterminada.
Kali Kali Linux es una distribución de Linux diseñada específicamente para pruebas
de penetración. Tiene cientos de herramientas preinstaladas, lo que le ahorrará las
horas que le llevaría descargarlas e instalarlas usted mismo. Usaré la última versión de
Kali al momento de escribir este artículo: Kali 2018.2, lanzada por primera vez en abril
de 2018.
root Como casi todos los sistemas operativos, Linux tiene una cuenta de administrador
o superusuario, diseñada para que la utilice una persona de confianza que puede hacer
casi cualquier cosa en el sistema. Esto incluiría cosas como reconfigurar el sistema,
agregar usuarios y cambiar contraseñas. En Linux, esa cuenta se llama root. Como
hacker o pentester, a menudo utilizará la cuenta raíz para tener control sobre el sistema.
De hecho, muchas herramientas de piratas informáticos requieren que utilice la cuenta
raíz.
Script Se trata de una serie de comandos ejecutados en un entorno interpretativo que

convierte cada línea en código fuente. Muchas herramientas de piratería son
simplemente scripts. Los scripts se pueden ejecutar con el intérprete bash o cualquiera
de los otros intérpretes de lenguajes de scripting, como Python, Perl o Ruby.
Python es actualmente el intérprete más popular entre los hackers.
Shell Este es un entorno e intérprete para ejecutar comandos en Linux. El shell más
utilizado es bash, que significa Bourne nuevamente shell, pero otros shells populares
incluyen el shell C y el shell Z. Usaré el shell bash exclusivamente en este libro.
Terminal Esta es una interfaz de línea de comandos (CLI).
Una vez superados esos conceptos básicos, intentaremos desarrollar metódicamente

las habilidades esenciales de Linux que necesitará para convertirse en un hacker o un probador
de penetración. En este primer capítulo, lo guiaré para comenzar con Kali Linux.
2 Capítulo 1 ¡GUAU! Libro

Un recorrido por Kali
Una vez que inicie Kali, aparecerá una pantalla de inicio de sesión, como se muestra en la
Figura 11. Inicie sesión con el nombre de usuario de la cuenta raíz root y la contraseña
predeterminada también.
Figura 11: Iniciar sesión en Kali usando la cuenta raíz
Ahora debería tener acceso a su escritorio Kali (consulte la Figura 12). Bien
Observe rápidamente dos de los aspectos más básicos del escritorio: la interfaz del terminal y
la estructura de archivos.
Figura 12: El escritorio Kali
Comenzando con los conceptos básicos 3

¡GUAU! Libro
La terminal
El primer paso para usar Kali es abrir la terminal, que es la interfaz de línea de
comandos que usaremos en este libro. En Kali Linux, encontrarás el ícono de la
terminal en la parte inferior del escritorio. Haga doble clic en este icono para abrir la
terminal o presione ctrlaltT. Su nueva terminal debería verse como la que se muestra
en la Figura 13.
Figura 13: La terminal Kali
Esta terminal abre el entorno de línea de comandos, conocido como shell, que le
permite ejecutar comandos en los sistemas operativos subyacentes y escribir scripts.
Aunque Linux tiene muchos entornos de shell diferentes, el más popular es el shell
bash, que también es el shell predeterminado en Kali y muchas otras distribuciones de
Linux.
Para cambiar su contraseña, puede usar el comando passwd.
El sistema de archivos Linux
La estructura del sistema de archivos de Linux es algo diferente a la de Windows.

Linux no tiene una unidad física (como la unidad C:) en la base del sistema de archivos,
sino que utiliza un sistema de archivos lógico. En la parte superior de la estructura del
sistema de archivos está /, que a menudo se conoce como la raíz del sistema de
archivos, como si fuera un árbol al revés (consulte la Figura 14). Tenga en cuenta que
esto es diferente del usuario root. Estos términos pueden parecer confusos al principio,
pero serán más fáciles de diferenciar una vez que se acostumbre a Linux.

/bota /hogar /proceso /desarrollador /sbin /usr

Núcleo Usuario Vista de Especial binarios
imagen directorios datos archivos del dispositivo
internos del kernel /sbin

Más
binarios
/raíz /etc /mnt /sistema /papelera /lib /papelera /lib

Superusuario General Vista del binarios Bibliotecas Más Más
hogar Configuración del sistemaobjetivo kernel del binarios bibliotecas
directorio archivos
punto de montaje hardware.
Figura 14: El sistema de archivos de Linux
La raíz (/) del sistema de archivos está en la parte superior del árbol, y lo siguiente
son los subdirectorios más importantes que debe conocer:
/root El directorio de inicio del todopoderoso usuario root
/etc Generalmente contiene los archivos de configuración de Linux: archivos que controlan cuándo y
cómo se inician los programas.
/home El directorio de inicio del usuario
/mnt Donde otros sistemas de archivos están conectados o montados en el sistema de

archivos
/media Donde normalmente se conectan o montan CD y dispositivos USB en el sistema de archivos
/bin Donde los binarios de la aplicación (el equivalente de los ejecutables en

Microsoft Windows) residen
/lib Donde encontrará bibliotecas (programas compartidos similares a

DLL de Windows)
Dedicaremos más tiempo a estos directorios clave a lo largo de este libro.

Comprender estos directorios de primer nivel es importante para navegar por el sistema de archivos desde la
línea de comandos.
También es importante saber antes de comenzar que no debes iniciar sesión.
como root cuando realiza tareas rutinarias, porque cualquiera que hackee su sistema (sí, los hackers a
veces son hackeados) cuando usted inicia sesión como root inmediatamente obtendrá privilegios de root y
por lo tanto será “dueño” de su sistema. Inicie sesión como usuario normal cuando inicie aplicaciones normales,
navegue por la web, ejecute herramientas como Wireshark, etc.
Comandos básicos en Linux
Para comenzar, veamos algunos comandos básicos que le ayudarán a empezar a utilizar Linux.

¡GUAU! Libro
Encontrarse con personas con discapacidad
A diferencia de cuando trabaja en un entorno de interfaz gráfica de usuario (GUI) como Windows
o macOS, la línea de comando en Linux no siempre deja claro en qué directorio se encuentra
actualmente. Para navegar a un nuevo directorio, generalmente necesita para saber dónde estás
actualmente. El comando del directorio de trabajo actual, pwd, devuelve su ubicación dentro de la
estructura del directorio.
Ingresa pwd en tu terminal para ver dónde estás:
kali >pwd
/raíz
En este caso, Linux devolvió /root, diciéndome que estoy en el directorio del usuario raíz.
Y debido a que inició sesión como root cuando inició Linux, también debería estar en el directorio del
usuario root, que está un nivel por debajo de la parte superior de la estructura del sistema de archivos
(/).
Si está en otro directorio, pwd devolverá el nombre de ese directorio.
Comprobando su inicio de sesión con whoami
En Linux, el superusuario o administrador del sistema “todopoderoso” se llama root y tiene todos los
privilegios del sistema necesarios para agregar usuarios, cambiar contraseñas, cambiar privilegios,
etc. Obviamente, no desea que cualquiera tenga la capacidad de realizar dichos cambios; Quiere a
alguien en quien se pueda confiar y que tenga el conocimiento adecuado del sistema operativo.
Como hacker, normalmente necesitas tener todos esos privilegios para ejecutar los programas y
comandos que necesitas (muchas herramientas de hacker no funcionarán a menos que tengas
privilegios de root), por lo que querrás iniciar sesión como root.
Si ha olvidado si ha iniciado sesión como root o como otro usuario,

Puedes usar el comando whoami para ver con qué usuario has iniciado sesión:
kali > whoami

raíz
Si hubiera iniciado sesión como otro usuario, como mi cuenta personal,

whoami habría devuelto mi nombre de usuario, como se muestra aquí:
kali > whoami

OTW
Navegando por el sistema de archivos de Linux
Navegar por el sistema de archivos desde la terminal es una habilidad esencial en Linux. Para hacer
cualquier cosa, necesita poder moverse para buscar aplicaciones, archivos y directorios ubicados en
otros directorios. En un sistema basado en GUI,
6 Capítulo 1
¡GUAU! Libro
puedes ver visualmente los directorios, pero cuando usas la interfaz de línea de
comandos, la estructura está completamente basada en texto y navegar por el sistema
de archivos significa usar algunos comandos.
Cambiar directorios con cd
Para cambiar directorios desde la terminal, use el comando cambiar directorio, cd. Por
ejemplo, aquí se explica cómo cambiar al directorio /etc utilizado para almacenar archivos de
configuración:
kali >cd/etc.
raíz@kali:/etc#
El mensaje cambia a root@kali:/etc, indicando que estamos en el directorio /etc.

directorio. Podemos confirmar esto ingresando pwd:
root@kali:/etc# contraseña
/etc
Para subir un nivel en la estructura del archivo (hacia la raíz del archivo
estructura, o /), usamos cd seguido de puntos dobles (..), como se muestra aquí:
raíz@kali:/etc# cd ..
root@kali:/#contraseña
/
raíz@kali:/#
Esto nos sube un nivel desde /etc al directorio /raíz, pero puedes
sube tantos niveles como necesites. Simplemente use la misma cantidad de pares de
puntos dobles que la cantidad de niveles que desea mover:
•Usarías .. para subir un nivel.

•Usarías... .. para subir dos niveles.
•Usarías .. .. .. para subir tres niveles, y así sucesivamente.
Entonces, por ejemplo, para subir dos niveles, ingrese cd seguido de dos conjuntos de
puntos dobles con un espacio entre ellos:
kali >cd .. ..
También puede subir al nivel raíz en la estructura de archivos desde cualquier

donde ingresando cd /, donde / representa la raíz del sistema de archivos.
Listar el contenido de un directorio con ls
Para ver el contenido de un directorio (los archivos y subdirectorios), podemos usar el

comando ls (lista). Esto es muy similar al comando dir en Windows.

¡GUAU! Libro
kali >ls
bin initrd.img medios de var
boot initrd.img.old dev lib etc comunicación ejecutar sbin vmlinuz
lib64 inicio optar
srv vmlinuz.viejo
perdido+encontrado por la raíz tmp
del proceso usr
Este comando enumera tanto los archivos como los directorios contenidos en el directorio.
También puede usar este comando en cualquier directorio en particular, no solo en el que se encuentra
actualmente, enumerando el nombre del directorio después del comando; por ejemplo, ls /etc muestra
lo que hay en el directorio /etc.
Para obtener más información sobre los archivos y directorios, como sus permisos, propietario,
tamaño y cuándo se modificaron por última vez, puede agregar el modificador l después de ls (la l
significa largo). A esto se le suele denominar lista larga. Probémoslo aquí:
kali >ls l
total 84
drwrr drw 1 raíz raíz 4096 diciembre raíz 5 11:15 papelera
rr drwr 2 raíz 4096 diciembre raíz 4096 5 11:15 bota

r drwrr raíz diciembre raíz 4096 9 13:10 desarrollador
snip 3 18 raíz diciembre 9 13:43 etc.
drwrr 1 raíz raíz 4096 diciembre 5 11:15 var
Como puede ver, ls l nos proporciona mucha más información,

como si un objeto es un archivo o directorio, la cantidad de enlaces, el propietario, el grupo, su
tamaño, cuándo fue creado o modificado y su nombre.
Normalmente agrego el modificador l cada vez que hago un listado en Linux, pero para cada
uno lo suyo. Hablaremos más sobre ls l en el Capítulo 5.
Algunos archivos en Linux están ocultos y no se revelarán con un simple ls o
Comando ls l. Para mostrar archivos ocultos, agregue un modificador –a en minúscula, así:
kali >ls la
Si no ve el archivo que espera ver, vale la pena intentarlo con ls con la opción a.
Obteniendo ayuda
Casi todos los comandos, aplicaciones o utilidades tienen un archivo de ayuda dedicado en Linux que
brinda orientación para su uso. Por ejemplo, si necesitara ayuda para usar la mejor herramienta de
craqueo inalámbrico, aircrackng, simplemente podría escribir el comando aircrackng seguido del
comando help:
kali >aircrackng ayuda
Tenga en cuenta el doble guión aquí. La convención en Linux es utilizar un doble
guión () antes de opciones de palabras, como ayuda, y un solo guión () antes de opciones de una
sola letra, como –h.
8 Capítulo 1
¡GUAU! Libro
Cuando ingresa este comando, debería ver una breve descripción de la herramienta y
orientación sobre cómo usarla. En algunos casos, puedes usar h
o ? para acceder al archivo de ayuda. Por ejemplo, si necesitara ayuda para usar la mejor herramienta
de escaneo de puertos de los piratas informáticos, nmap, ingresaría lo siguiente:
kali >nmap h
Desafortunadamente, aunque muchas aplicaciones admiten las tres opciones (help, h y ?),
no hay garantía de que la aplicación que estás utilizando lo haga.
Entonces, si una opción no funciona, prueba con otra.
Hacer referencia a páginas del manual con man
Además del interruptor de ayuda, la mayoría de los comandos y aplicaciones tienen una página
de manual (man) con más información, como una descripción y una sinopsis del comando o
aplicación. Puede ver una página de manual simplemente escribiendo man antes del comando, utilidad
o aplicación. Para ver la página de manual de aircrackng, por ejemplo, ingresaría lo siguiente:
kali > hombre aircrackng

NOMBRE
aircrackng: un descifrador de claves 802.11 WEP/WPAPSK

SINOPSIS
aircrackng [opciones] <archivo(s) .cap / .ivs>
DESCRIPCIÓN
aircrackng es un programa para descifrar claves 802.11 WEP y WPA/WPA2PSK.

Puede recuperar la clave WEP una vez que se hayan capturado suficientes paquetes
cifrados con airodumpng. Esta parte de la suite aircrackng determina la clave WEP
utilizando dos métodos fundamentales. El primer método es el de los PTW (Pyshkin, Tews,
Weinmann). La principal ventaja del enfoque PTW es que se requieren muy pocos
paquetes de datos para descifrar la clave WEP. El segundo método es el método FMS/
KoreK. El método FMS/KoreK incorpora varios ataques estadísticos para descubrir la
clave WEP y los utiliza en combinación con fuerza bruta.
Además, el programa ofrece un método de diccionario para determinar la clave WEP. Para
descifrar claves precompartidas WPA/WPA2, se debe utilizar una lista de palabras (archivo
o stdin) o un airolibng.
Esto abre el manual de aircrackng, que le proporciona información más detallada.

más información que la pantalla de ayuda. Puede desplazarse por este archivo de manual usando
la tecla Intro, o puede avanzar y retroceder página usando pg dn y pg up.
claves, respectivamente. Para salir, simplemente ingrese q (para salir) y regresará al símbolo del
sistema.
Encontrar cosas
Hasta que se familiarice con Linux, puede resultar frustrante orientarse, pero el conocimiento de algunos
comandos y técnicas básicos contribuirá en gran medida a que la línea de comandos sea mucho
más amigable. Los siguientes comandos le ayudarán a localizar cosas desde la terminal.

¡GUAU! Libro
Buscando con localizar
Probablemente el comando más fácil de usar sea localizar. Seguido de una palabra clave que indica
qué es lo que desea encontrar, este comando recorrerá todo su sistema de archivos y localizará
cada aparición de esa palabra.
Para buscar aircrackng, por ejemplo, ingrese lo siguiente:
kali > localizar aircrackng

/usr/bin/aircrackng
/usr/share/applications/kaliaircrackng.desktop
/usr/share/desktopdirectories/05101aircrackng.directorio
recorte
/var/lib/dpkg/info/aircrackng.mg5sums
Sin embargo, el comando de localización no es perfecto. A veces, los resultados de la

localización pueden ser abrumadores y brindarle demasiada información. Además, localice
utiliza una base de datos que generalmente solo se actualiza una vez al día, por lo que si acaba de
crear un archivo hace unos minutos o unas horas, es posible que no aparezca en esta lista hasta el
día siguiente. Vale la pena conocer las desventajas de estos comandos básicos para que puedas
decidir mejor cuándo usar cada uno.
Encontrar binarios con Whereis
Si está buscando un archivo binario, puede usar el comando Whereis para localizarlo. Este
comando devuelve no solo la ubicación del binario sino también su fuente y página de manual si
están disponibles. He aquí un ejemplo:
kali >dónde está aircrackng

aircarckng: /usr/bin/aircarckng /usr/share/man/man1/aircarckng.1.gz
En este caso, se devuelven solo los binarios de aircrackng y la página de manual, en lugar de
cada aparición de la palabra aircrackng. Mucho más eficiente y esclarecedor, ¿no crees?
Encontrar binarios en la variable PATH con la que
El comando which es aún más específico: solo devuelve la ubicación de los binarios en la variable
PATH en Linux. Examinaremos más de cerca la variable PATH en el Capítulo 7, pero por ahora
es suficiente saber que PATH contiene los directorios en los que el sistema operativo busca los
comandos que ejecuta en la línea de comandos. Por ejemplo, cuando ingreso aircrackng en la línea
de comando, el sistema operativo busca en la variable PATH para ver en qué directorios debe
buscar aircrackng:
kali > cual aircrackng

/usr/bin/aircrackng
Aquí, pude encontrar un único archivo binario en los directorios enumerados en la variable
PATH. Como mínimo, estos directorios suelen incluir /usr/bin, pero pueden incluir /usr/sbin y quizás
algunos más.
10 Capítulo 1
¡GUAU! Libro
Realizar búsquedas más potentes con find
El comando de búsqueda es el más potente y flexible de las utilidades de búsqueda. Es capaz de

comenzar su búsqueda en cualquier directorio designado y buscar una serie de parámetros diferentes,
incluido, por supuesto, el nombre del archivo pero también la fecha de creación o modificación, el
propietario, el grupo, los permisos y el tamaño.
Aquí está la sintaxis básica para buscar:
encontrar expresión de opciones de directorio
Entonces, si quisiera buscar un archivo con el nombre apache2 (el código abierto
servidor web) comenzando en el directorio raíz, ingresaría lo siguiente:
kali >buscar / tipo f nombre apache2w
Primero indico el directorio en el que iniciar la búsqueda, en este caso / .

Luego especifico qué tipo de archivo buscar, en este caso f para un archivo ordinario . Por último,
pongo el nombre del archivo que estoy buscando, en este caso apache2 .
Mis resultados para esta búsqueda se muestran aquí:
kali > buscar / escribir f nombre apache2

/usr/lib/apache2/mpmitk/apache2
/usr/lib/apache2/mpmevent/apache2
/usr/lib/apache2/mpmworker/apache2
/usr/lib/apache2/mpmprefork/apache2
/etc/cron.daily/apache2
/etc/logrotate.d/apache2
/etc/init.d/apache2
/etc/default/apache2
El comando de búsqueda comenzó en la parte superior del sistema de archivos (/), pasó por
cada directorio busca apache2 en el nombre del archivo y luego enumera todas las instancias
encontradas.
Como puede imaginar, una búsqueda que busque en todos los directorios puede resultar lenta.
Una forma de acelerarlo es buscar sólo en el directorio donde esperaría encontrar los archivos que necesita.
En este caso estamos buscando un archivo de configuración, por lo que podríamos iniciar la
búsqueda en el directorio /etc, y Linux solo buscaría hasta sus subdirectorios. Vamos a intentarlo:
kali > buscar /etc tipo f nombre apache2

/etc/init.d/apache2
/etc/logrotate.d/apache2
/etc/cron.daily/apache2
Esta búsqueda mucho más rápida solo encontró apariciones de apache2 en el directorio /etc y
sus subdirectorios. También es importante tener en cuenta que, a diferencia de otros comandos de
búsqueda, buscar solo muestra coincidencias exactas de nombres. Si el
Comenzando con lo básico 11

¡GUAU! Libro
El archivo apache2 tiene una extensión, como apache2.conf, la búsqueda no encontrará una coincidencia.
Podemos solucionar esta limitación utilizando comodines, que nos permiten hacer coincidir varios caracteres.
Los comodines vienen en diferentes formas: * y []. ., ?
Busquemos en el directorio /etc todos los archivos que comiencen con apache2 y tengan cualquier
extensión. Para esto, podríamos escribir un comando de búsqueda usando el siguiente comodín:
kali > buscar /etc tipo f nombre apache2.*

/etc/apache2/apache2.conf
Cuando ejecutamos este comando, encontramos que hay un archivo en /etc

directorio que se ajuste al patrón apache2.*. Cuando usamos un punto seguido del comodín *, el
terminal busca cualquier extensión después del nombre de archivo apache2. Esta puede ser una técnica
muy útil para encontrar archivos cuya extensión no conoce.
Cuando ejecuto este comando, encuentro dos archivos que comienzan con apache2 en el directorio /
etc, incluido el archivo apache2.conf.
Una mirada rápida a los comodines
Digamos que estamos haciendo una búsqueda en un directorio que tiene los archivos cat,
hat, what y bat. El ? El comodín se utiliza para representar un solo carácter, por lo que una
búsqueda de ?at encontraría sombrero, gato y murciélago, pero no qué, porque en este nombre
de archivo está precedido por dos letras. El comodín [] se utiliza para hacer coincidir los
caracteres que aparecen dentro de los corchetes. Por ejemplo, una búsqueda de [c,b]at
coincidiría con gato y murciélago, pero no con sombrero o qué. Entre los comodines más
utilizados se encuentra el asterisco (*), que coincide con cualquier carácter de cualquier
longitud, desde ninguno hasta un número ilimitado de caracteres. Una búsqueda de *at, por
ejemplo, encontraría gato, sombrero, qué y murciélago.
Filtrando con grep
Muy a menudo, cuando utilice la línea de comando, querrá buscar una palabra clave en particular. Para
ello, puede utilizar el comando grep como filtro para buscar palabras clave.
El comando grep se utiliza a menudo cuando la salida se canaliza de un comando a otro. Cubro la
tubería en el Capítulo 2, pero por ahora, basta con decir que Linux (y Windows, de hecho) nos permite
tomar la salida de un comando y enviarla como entrada a otro comando. Esto se llama tubería y usamos el |
comando para hacerlo (la tecla | generalmente está encima de la tecla Intro en su teclado).
El comando ps se utiliza para mostrar información sobre los procesos que se ejecutan en la
máquina. Cubrimos esto con más detalle en el Capítulo 6, pero para esto
12 Capítulo 1
¡GUAU! Libro
Por ejemplo, supongamos que quiero ver todos los procesos que se ejecutan en mi sistema
Linux. En este caso, puedo usar el comando ps (procesos) seguido del comando aux
cambia para especificar qué información de proceso mostrar, así:
kali > ps aux
Esto me proporciona una lista de todos los procesos que se ejecutan en este
sistema, pero ¿qué pasa si solo quiero encontrar un proceso para ver si se está ejecutando?
Puedo hacer esto canalizando la salida de ps a grep y buscando una palabra clave. Por
ejemplo, para saber si el servicio apache2 se está ejecutando, ingresaría lo siguiente.
kali >ps auxiliar | grep apache2

raíz 4851 0,2 0,7 37548 7668? SS 10:14 0:00 /usr/sbin/apache2 k inicio
raíz 4906 0,0 0,4 37572 4228? S 10:14 0:00 /usr/sbin/apache2 k inicio
raíz 4910 0,0 0,4 37572 4228? SS 10:14 0:00 /usr/sbin/apache2 k inicio
recorte
Este comando le dice a Linux que muestre todos mis servicios y luego envíe esa salida
a grep, que buscará en la salida la palabra clave apache2 y luego mostrará solo la salida
relevante, ahorrándome así una cantidad considerable de tiempo y vista.
Modificar archivos y directorios

Una vez que haya encontrado sus archivos y directorios, querrá poder realizar acciones en
ellos. En esta sección, veremos cómo crear archivos y directorios, copiar archivos,
cambiarles el nombre y eliminar archivos y directorios.
Creando archivos
Hay muchas formas de crear archivos en Linux, pero por ahora solo veremos dos métodos
simples. El primero es gato, que es la abreviatura de concatenar, que significa combinar piezas
(no es una referencia a tu felino domesticado favorito). El comando cat se usa generalmente
para mostrar el contenido de un archivo, pero también se puede usar para crear archivos
pequeños. Para crear archivos más grandes, es mejor ingresar el código en un editor de texto
como vim, emacs, leafpad, gedit o kate y luego guardarlo como un archivo.
Concatenación con gato
El comando cat seguido de un nombre de archivo mostrará el contenido de ese archivo, pero
para crear un archivo, seguimos el comando cat con una redirección, indicada con el símbolo
> , y un nombre para el archivo que queremos crear. He aquí un ejemplo:
kali > gato > hackingskills

¡El hacking es el conjunto de habilidades más valioso del siglo XXI!

¡GUAU! Libro
Cuando presiona Enter, Linux entrará en modo interactivo y esperará

para comenzar a ingresar contenido para el archivo. Esto puede resultar desconcertante
porque el mensaje desaparece, pero si simplemente comienza a escribir, todo lo que ingrese
irá al archivo (en este caso, hackingskills). Aquí entré ¡La piratería es el conjunto de
habilidades más valioso del siglo XXI! Para salir y volver al mensaje, presiono CtrlD. Luego,
cuando quiero ver qué hay en el archivo hackingskills, ingreso lo siguiente:
kali > habilidades para hackear gatos

¡El hacking es el conjunto de habilidades más valioso del siglo XXI!
Si no utiliza el símbolo de redireccionamiento, Linux devolverá el contenido de su archivo.
Para agregar o agregar más contenido a un archivo, puede usar el comando cat con una
doble redirección (>>), seguido de lo que desee agregar al final del archivo. He aquí un ejemplo:
kali >gato >> habilidades de hacking

Todo el mundo debería aprender a hackear
Linux vuelve a entrar en modo interactivo, esperando que se agregue contenido al

archivo. Cuando entro Todos deberían aprender a piratear y presiono CtrlD, vuelvo al
mensaje. Ahora, cuando muestro el contenido de ese archivo con cat, puedo ver que al archivo
se le ha agregado " Todos deberían aprender a hackear", como se muestra aquí:

¡El hacking es el conjunto de habilidades más valioso del siglo XXI! Todo el mundo debería aprender a hackear
Si quiero sobrescribir el archivo con nueva información, simplemente puedo usar el

comando cat con una sola redirección nuevamente, de la siguiente manera:
kali > gato > hackingskills

Todos los que trabajan en seguridad de TI sin habilidades de piratería están en la oscuridad
Todos los que trabajan en seguridad de TI sin habilidades de piratería están en la oscuridad
Como puede ver aquí, Linux entra en modo interactivo, ingreso el nuevo texto y luego
salgo al mensaje. Cuando vuelvo a utilizar cat para ver el contenido del archivo, veo que mis
palabras anteriores se han sobrescrito con el texto más reciente.
Creación de archivos con toque
El segundo comando para la creación de archivos es tocar. Este comando se desarrolló

originalmente para que un usuario pudiera simplemente tocar un archivo para cambiar
algunos de sus detalles, como la fecha en que fue creado o modificado. Sin embargo, si el
archivo aún no existe, este comando crea ese archivo de forma predeterminada.

Creemos un nuevo archivo con toque:
kali >tocar nuevo archivo
Ahora, cuando uso ls –l para ver la lista larga del directorio, veo que se ha creado un nuevo
archivo llamado newfile. Tenga en cuenta que su tamaño es 0 porque no hay contenido en el
archivo nuevo.
Creando un directorio
El comando para crear un directorio en Linux es mkdir, una contracción de make directorio.
Para crear un directorio llamado nuevodirectorio, ingrese el siguiente comando:
kali >mkdir nuevodirectorio
Para navegar a este directorio recién creado, simplemente ingrese esto:
kali >cd nuevodirectorio
Copiar un archivo
Para copiar archivos, usamos el comando cp . Esto crea un duplicado del archivo en la nueva
ubicación y deja el anterior en su lugar.
Aquí, crearemos el archivo oldfile en el directorio raíz con touch y lo copiaremos a /root/
newdirectory, renombrándolo en el proceso y dejando el oldfile original en su lugar:
kali >tocar archivo antiguo

kali >cp archivo antiguo /raíz/nuevodirectorio/nuevo archivo
Cambiar el nombre del archivo es opcional y se realiza simplemente agregando el nombre

que desea darle al final de la ruta del directorio. Si no cambia el nombre del archivo cuando lo
copia, el archivo conservará el nombre original de forma predeterminada.
Cuando navegamos al directorio nuevo, vemos que hay una copia exacta del archivo
antiguo llamado archivo nuevo:
kali >cd nuevodirectorio

kali >ls
archivo nuevo archivo antiguo
Cambiar el nombre de un archivo
Desafortunadamente, Linux no tiene un comando destinado únicamente a cambiar el nombre de

un archivo, como lo hacen Windows y algunos otros sistemas operativos, pero sí tiene el
comando mv (mover).

¡GUAU! Libro
El comando mv se puede utilizar para mover un archivo o directorio a una nueva ubicación
ción o simplemente para darle un nuevo nombre a un archivo existente. Para cambiar el nombre de
nuevo archivo a nuevo archivo2, deberá ingresar lo siguiente:
kali >mv nuevo archivo nuevo archivo2

kali >ls
archivo antiguo archivo nuevo2
Ahora, cuando enumera (ls) ese directorio, ve nuevoarchivo2 pero no nuevoarchivo,

porque ha sido renombrado. Puedes hacer lo mismo con los directorios.
Eliminar un archivo
Para eliminar un archivo, simplemente puedes usar el comando rm , así:
kali >rm nuevoarchivo2
Si ahora hace una lista larga en el directorio, puede confirmar que el archivo se ha eliminado.
Eliminar un directorio
El comando para eliminar un directorio es similar al comando rm para eliminar archivos pero con
dir (para directorio) agregado, así:
kali >rmdir nuevodirectorio

rmdir: no se pudo eliminar 'nuevo directorio': el directorio no está vacío
Es importante tener en cuenta que rmdir no eliminará un directorio que no esté vacío, pero
le dará un mensaje de advertencia que indica que "el directorio no está vacío", como puede ver en
este ejemplo. Primero debe eliminar todo el contenido del directorio antes de eliminarlo. Esto es
para evitar que borre accidentalmente objetos que no tenía intención de borrar.
Si desea eliminar un directorio y su contenido de una sola vez, debe

Puede usar el modificador r después de rm, así:
kali >rm r nuevodirectorio
Sin embargo, sólo una advertencia: tenga cuidado al usar la opción r con rm, al menos al
principio, porque es muy fácil eliminar archivos y directorios valiosos por error. Usar rm r en su
directorio de inicio, por ejemplo, eliminaría todos los archivos y directorios allí, probablemente no
lo que pretendía.
dieciséis
Capítulo 1
¡GUAU! Libro
¡Ve a jugar ahora!

Ahora que tiene algunas habilidades básicas para navegar por el sistema de archivos,
puede jugar un poco con su sistema Linux antes de continuar. La mejor manera de
sentirse cómodo con el uso del terminal es probar sus nuevas habilidades ahora mismo.
En los capítulos siguientes, exploraremos más y más profundamente nuestro campo de
juego de hackers.
Ejercicios
Antes de pasar al Capítulo 2, pruebe las habilidades que aprendió en este capítulo completando los
siguientes ejercicios:
1. Utilice el comando ls desde el directorio raíz (/) para explorar la estructura de directorios de Linux.
Vaya a cada uno de los directorios con el comando cd y ejecute pwd para verificar dónde se
encuentra en la estructura del directorio.
2. Utilice el comando whoami para verificar con qué usuario inició sesión.
3. Utilice el comando de localización para buscar listas de palabras que puedan usarse como contraseña.
agrietamiento.
4. Utilice el comando cat para crear un nuevo archivo y luego agréguelo a ese archivo.
Tenga en cuenta que > redirige la entrada a un archivo y >> agrega a un archivo.
5. Cree un nuevo directorio llamado hackerdirectory y cree un nuevo archivo en

ese directorio llamado hackedfile. Ahora copie ese archivo a su directorio /root y cámbiele el nombre
a secretfile.
¡GUAU! Libro Comenzando con los conceptos básicos 17
¡GUAU! Libro
2
Manipulación de texto
En Linux, casi todo lo que maneja directamente es un

archivo, y la mayoría de las veces serán archivos de
texto; por ejemplo, todos los archivos de configuración
en Linux son archivos de texto. Entonces para reconfigurar
una aplicación, simplemente abre el archivo de configuración,
cambia el texto, guarda el archivo y luego reinicia la aplicación;
tu reconfiguración está completa.
Con tantos archivos de texto, la manipulación del texto se vuelve crucial en la
administración de Linux y aplicaciones Linux. En este capítulo, utilizará varios comandos y
técnicas para manipular texto en Linux.
Con fines ilustrativos, utilizaré archivos del mejor sistema de detección de intrusos en
la red (NIDS) del mundo, Snort, que fue desarrollado por primera vez por Marty Roesch y
ahora es propiedad de Cisco. Los NIDS se utilizan comúnmente para detectar intrusiones
por parte de piratas informáticos, por lo que si desea ser un hacker exitoso, debe estar
familiarizado con las formas en que los NIDS pueden disuadir los ataques y las formas en
que puede abusar de ellos para evitar la detección.
¡GUAU! Libro
NOTA Si la versión de Kali Linux que estás usando no viene con Snort preinstalado, puedes descargar los
archivos del repositorio de Kali ingresando aptget install snort.
Ver archivos
Como se demostró en el Capítulo 1, el comando de visualización de texto más básico
probablemente sea cat, pero tiene sus limitaciones. Utilice cat para mostrar el archivo de
configuración de Snort (snort.conf ) que se encuentra en/etc/snort (consulte el Listado 21).
kali >gato /etc/snort/snort.conf
Listado 21: Mostrando snort.conf en la ventana de terminal
Su pantalla ahora debería mostrar el archivo snort.conf completo , que se transmitirá hasta
llegar al final del archivo, como se muestra aquí. Esta no es la forma más conveniente ni práctica
de ver y trabajar con este archivo.
# incluir $SO_RULE_PATH/exploit.rules
recorte
# comandos de umbralización o supresión de eventos...

kali >
En las siguientes dos secciones, le mostraré los comandos head y tail , que son dos
métodos para mostrar solo una parte del contenido de un archivo para poder ver más fácilmente el
contenido clave.
tomando la cabeza
Si solo desea ver el comienzo de un archivo, puede usar el comando head . De forma
predeterminada, este comando muestra las primeras 10 líneas de un archivo. El siguiente comando,
por ejemplo, muestra las primeras 10 líneas de snort.conf:
kali >cabeza /etc/snort/snort.conf

#
# Paquetes de reglas VRT Snort.conf
#
# Para más información visítenos en:
recorte
#Bichos Snort:bugs@snort.org
Si desea ver más o menos de las 10 líneas predeterminadas, ingrese la cantidad que desea
con el interruptor de guión () después de la llamada al encabezado y antes

el nombre del archivo. Por ejemplo, si desea ver las primeras 20 líneas del archivo,
deberá ingresar el comando que se muestra en la parte superior del Listado 22.
kali >cabeza 20 /etc/snort/snort.conf
#
#Paquetes de reglas VRT Snort.conf
#
#Para más información visítanos en:
#.
#.
#.
#Opciones: enablegre enablempls enabletargetbased
enableppm enableperfprofiling enablezlib enableact
respuestaen vivo enablenormalizer enablereload enablereact
Listado 22: Mostrando las primeras 20 líneas de snort.conf en la ventana de terminal
Deberías ver solo las primeras 20 líneas de snort.conf en la ventana de tu terminal.
Agarrando esa cola

El comando tail es similar al comando head , pero se usa para ver las últimas líneas de un
archivo. Usémoslo en snort.conf:
kali >cola /etc/snort/snort.conf

#incluir $SO_RULE_PATH/smtp.rules
#incluir $SO_RULE_PATH/amenazasespecíficas.rules
#incluir $SO_RULE_PATH/webactivex.rules
#incluir $SO_RULE_PATH/webclient.rules
#incluir $SO_RULE_PATH/webiis.rules
#incluir $SO_RULE_PATH/webmiscp.rules
#Comandos de supresión y umbralización de eventos. Ver umbral.conf
Observe que este comando muestra algunas de las últimas líneas de inclusión del
archivos de reglas , pero no todos, porque similar a head, el valor predeterminado para tail
es mostrar 10 líneas. Puede mostrar más líneas tomando las últimas 20 líneas de snort.conf.
Al igual que con el comando head , puede indicarle a tail cuántas líneas mostrar
ingresando un guión () y luego el número de líneas entre el comando y el nombre del
archivo, como se muestra en el Listado 23.
kali >cola 20 /etc/snort/snort.conf

#incluir $SO_RULE_PATH/chat.rules
recorte
#Comandos de supresión o umbral de eventos. Ver theshold.conf
Listado 23: Mostrando las últimas 20 líneas de snort.conf en la ventana de terminal
¡GUAU! Libro
Ahora podemos ver casi todas las líneas de inclusión de los archivos de reglas en una sola
pantalla.
Numerar las líneas

A veces, especialmente con archivos muy largos, es posible que deseemos que el archivo muestre
números de línea. Dado que snort.conf tiene más de 600 líneas, los números de línea serían útiles
aquí. Esto hace que sea más fácil hacer referencia a los cambios y volver al mismo lugar dentro del
archivo.
Para mostrar un archivo con números de línea, usamos el comando nl (líneas numéricas).
Simplemente ingrese el comando que se muestra en el Listado 24.
kali >nl /etc/snort/snort.conf

612 ################################################# ################
613 reglas de biblioteca #dinámica
614 #incluye $SO_RULE_PATH/maltraffic.rules
615 #incluye $SO_RULE_PATH/chat.rules
recorte
630 #incluye $SO_RULE_PATH/webiis.rules
631 #incluye $SO_RULE_PATH/webmisc.rules
Listado 24: Visualización de números de línea en la salida del terminal
Cada línea ahora tiene un número, lo que facilita mucho la referencia.
Filtrar texto con grep

El comando grep es probablemente el comando de manipulación de texto más utilizado. Le permite
filtrar el contenido de un archivo para su visualización. Si, por ejemplo, desea ver todas las líneas
que incluyen la palabra salida en su archivo snort.conf , puede usar cat y pedirle que muestre solo
esas líneas (consulte el Listado 25).
kali >gato /etc/snort/snort.conf | salida grep

# 6) Configurar complementos de salida
# Paso #6: Configurar complementos de salida
# salida unificada2: nombre de archivo fusionado.log, límite 128, nostamp, mpls_event_types,
vlan_event_types
salida unificada2: nombre de archivo fusionado.log, límite 128, nostamp, mpls_event_types,
vlan_event_types
# salida alert_unified2: nombre de archivo fusionado.log, límite 128, nostamp
# salida log_unified2: nombre de archivo fusionado.log, límite 128, nostamp
# salida alert_syslog: LOG_AUTH LOG_ALERT
# salida log_tcpdump: tcpdump.log
Listado 25: Mostrando líneas con instancias de la palabra clave o frase especificada por grep
Este comando primero verá snort.conf y luego usará una barra vertical (|) para enviarlo a grep,
que tomará el archivo como entrada, buscará líneas con apariciones de la palabra salida y mostrará
solo esas líneas. El comando grep es un comando muy poderoso y esencial para trabajar en Linux,
porque puede ahorrarle horas de búsqueda de cada aparición de una palabra o comando en un
archivo.

Desafío hacker: uso de grep, nl, tail y head

Digamos que desea mostrar las cinco líneas inmediatamente antes de una línea que dice #
Paso #6: Configure los complementos de salida usando al menos cuatro de los comandos que
acaba de aprender. ¿Como lo harias? (Sugerencia: hay muchas más opciones para estos comandos
que los que hemos analizado. Puede aprender más comandos usando el comando man
integrado de Linux . Por ejemplo, man tail mostrará el archivo de ayuda para el comando tail ).
Hay muchas maneras de resolver este desafío; aquí te muestro qué líneas cambiar para
hacerlo de una manera, y tu trabajo es encontrar otro método.
Paso 1
kali >nl/etc/snort.conf | salida grep

34 # 6) Configurar complementos de salida
512 # Paso #6: Configurar complementos de salida
518 # salida unificada2: nombre de archivo fusionado.log, límite 128, nostamp,
mpls_event_types, vlan_event_types
521 # salida alert_unified2: nombre de archivo snort.alert, límite 128, nostamp
522 # salida log_unified2: nombre de archivo snort.log, límite 128, nostamp
525 # salida alert_syslog: LOG_AUTH LOG_ALERT
528 # salida log_tcpdump: tcpdump.log
Podemos ver que la línea # Paso #6: Configurar complementos de salida es la línea 512,
y sabemos que queremos las cinco líneas que preceden a la línea 512, así como la propia línea
512 (es decir, las líneas 507 a 512).
Paso 2
kali >cola n+507 /etc/snort/snort.conf | cabeza n 6

ip_anidada interna, \
lista blanca $WHITE_LIST_PATH/white_list.rules, \
lista negra $BLACK_LIST_PATH/lista_negra.rules
################################################## #
Aquí, usamos tail para comenzar en la línea 507 y luego enviarla a head, y
devuelve solo las seis líneas superiores, lo que nos da las cinco líneas que preceden al Paso #6
línea, con esa línea incluida.
Usando sed para buscar y reemplazar

El comando sed le permite buscar apariciones de una palabra o un patrón de texto y luego
realizar alguna acción sobre él. El nombre del comando es una contracción de editor de
secuencias, porque sigue el mismo concepto que un editor de secuencias. En su forma más
básica, sed funciona como la función Buscar y reemplazar en Windows.
¡GUAU! Libro
Busque la palabra mysql en el archivo snort.conf usando grep, así:
kali >gato /etc/snort/snort.conf | grep mysql

incluir $RULE_PATH/mysql.rules
#incluir $RULE_PATH/servidormysql.rules
Deberías ver que el comando grep encontró dos apariciones de mysql.

Digamos que desea que sed reemplace cada aparición de mysql con MySQL
(recuerde, Linux distingue entre mayúsculas y minúsculas) y luego guarde el nuevo archivo en snort2.conf.
Puede hacer esto ingresando el comando que se muestra en el Listado 26.
kali >sed s/mysql/MySQL/g /etc/snort/snort.conf > snort2.conf
Listado 26: Uso de sed para buscar y reemplazar palabras clave o frases
El comando s realiza la búsqueda: primero das el término que estás buscando

(mysql ) y luego el término por el que quieres reemplazarlo (MySQL), separados por
una barra (/). El comando g le dice a Linux que desea que el reemplazo se realice
globalmente. Luego, el resultado se guarda en un nuevo archivo llamado snort2.conf.
Ahora, cuando usas grep con snort2.conf para buscar mysql, verás que no se
encontraron instancias, pero cuando buscas MySQL, verás dos apariciones.
kali >gato snort2.conf | grep MySQL

incluir $RULE_PATH/MySQL.rules
#incluir $RULE_PATH/servidorMySQL.rules
Si quisiera reemplazar solo la primera aparición del término mysql, omitiría el comando
g final.
kali >sed s/mysql/MySQL/ snort.conf > snort2.conf
También puede utilizar el comando sed para buscar y reemplazar cualquier aparición
específica de una palabra en lugar de todas las apariciones o solo la primera aparición.
Por ejemplo, si desea reemplazar solo la segunda aparición de la palabra mysql,
simplemente coloque el número de la aparición (en este caso, 2) al final del comando:
kali >sed s/mysql/MySQL/2 snort.conf > snort2.conf
Este comando afecta sólo a la segunda aparición de mysql.
Ver archivos con más y menos

Aunque cat es una buena utilidad para mostrar archivos y crear archivos pequeños,
ciertamente tiene sus limitaciones a la hora de mostrar archivos grandes. Cuando usas gato

con snort.conf, el archivo se desplaza por cada página hasta llegar al final, lo cual no es muy
práctico si desea obtener información de él.
Para trabajar con archivos más grandes, tenemos otras dos utilidades de visualización: más
y menos.
Controlar la pantalla con más

El comando more muestra una página de un archivo a la vez y le permite avanzar hacia abajo
usando la tecla Intro . Es la utilidad que utilizan las páginas man, así que veámosla primero. Abra
snort.conf con el comando more , como se muestra en el Listado 27.
kali >más /etc/snort/snort.conf

recorte
# Opciones de construcción de Snort:
# Opciones: enablegre enablempls enabletargetbased
enableppm enableperfprofiling enablezlib enableactive
respuesta enablenormalizer enablereload enablereact
enableflexresp3
#
Más(2%)
Listado 27: Usar más para mostrar la salida del terminal una página a la vez
Observe que más muestra solo la primera página y luego se detiene, y nos dice en la esquina
inferior izquierda qué parte del archivo se muestra (2 por ciento en este caso).
Para ver líneas o páginas adicionales, presione Intro. Para salir más, ingrese q (para salir).
Mostrar y filtrar con menos

El comando less es muy similar a more, pero con funcionalidad adicional; de ahí la broma común
de los aficionados a Linux: "Menos es más". Con menos, no sólo puede desplazarse por un archivo
a su gusto, sino que también puede filtrarlo por términos. Como en el Listado 28, abra snort.conf
con menos.
kali >menos /etc/snort/snort.conf

recorte
/etc/snort/snort.conf
Listado 28: Usar less para que el terminal de visualización genere una página a la vez y filtre los resultados
Observe en la parte inferior izquierda de la pantalla que menos ha resaltado el

ruta al archivo. Si presiona la tecla de barra diagonal (/) , menos le permitirá buscar términos
en el archivo. Por ejemplo, cuando configura Snort por primera vez, debe determinar cómo y
dónde desea enviar su alerta de intrusión.
¡GUAU! Libro
producción. Para encontrar esa sección del archivo de configuración, simplemente

puede buscar el resultado, así:

/producción
Esto lo llevará inmediatamente a la primera aparición del resultado y lo resaltará.

Luego puede buscar la siguiente aparición de salida escribiendo n (para siguiente).

# Para obtener más información, consulte el Manual de Snort, Configuración de Snort Módulos de salida
################################################## ###################
#unificado2
# Recomendado para la mayoría de las instalaciones
# salida unificada2: nombre de archivo fusionado.log, límite 128, nostamp, mpls_event_types,

vlan_event_types
salida unificada2: nombre de archivo snort.log, límite 128, nostamp, mpls_event_types, vlan_event_types
# Configuración adicional para tipos específicos de instalaciones

# salida alert_unified2: nombre de archivo snort.alert, límite 128, nostamp
# salida log_unified2: nombre de archivo snort.log, límite 128, nostamp
#syslog
# salida alert_syslog: LOG_AUTH LOG_ALERT
:
Como puedes ver, menos te llevó a la siguiente aparición de la palabra salida .

y resaltó todos los términos de búsqueda. En este caso, fue directamente a la sección de
salida de Snort. ¡Que conveniente!
Resumen
Linux tiene numerosas formas de manipular texto, y cada forma tiene sus propias
fortalezas y debilidades. Hemos abordado algunos de los métodos más útiles en este
capítulo, pero le sugiero que pruebe cada uno de ellos y desarrolle sus propios
sentimientos y preferencias. Por ejemplo, creo que grep es indispensable y lo uso
menos , pero es posible que usted lo sienta diferente.

Ejercicios
Antes de pasar al Capítulo 3, pruebe las habilidades que aprendió en este capítulo
completando los siguientes ejercicios:
1. Navegue hasta /usr/share/wordlists/metasploit. Este es un directorio de múltiples listas de

palabras que se pueden usar para forzar contraseñas de fuerza bruta en varios
dispositivos protegidos con contraseña usando Metasploit, el marco de pentesting y
piratería más popular.
2. Utilice el comando cat para ver el contenido del archivo contraseñas.lst.
3. Utilice el comando más para mostrar el archivo contraseñas.lst.
4. Utilice el comando less para ver el archivo contraseñas.lst.
5. Ahora use el comando nl para colocar números de línea en las contraseñas en

contraseñas.lst. Debería haber 88.396 contraseñas.
6. Utilice el comando tail para ver las últimas 20 contraseñas en contraseñas.lst.
7. Utilice el comando cat para mostrar contraseñas.lst y canalícelo para encontrar todas las
contraseñas que contengan 123.
¡GUAU! Libro Manipulación de texto 27
¡GUAU! Libro
Análisis y gestión
3
N e trabajos
Comprender las redes es crucial para cualquier

aspirante a hacker. En muchas situaciones, estarás
pirateando algo a través de una red, y un buen hacker
necesita saber cómo conectarse e interactuar con esa red.
Por ejemplo, es posible que necesite conectarse a una computadora
con su dirección de Protocolo de Internet (IP) oculta a la vista, o
puede que necesite redirigir las consultas del Sistema de nombres de
dominio (DNS) de un objetivo a su sistema; Este tipo de tareas son
relativamente simples pero requieren un poco de conocimientos sobre
redes Linux. Este capítulo le muestra algunas herramientas esenciales
de Linux para analizar y administrar redes durante sus aventuras de piratería de redes
Analizando redes con ifconfig

El comando ifconfig es una de las herramientas más básicas para examinar e
interactuar con interfaces de red activas. Puede usarlo para consultar sus conexiones
de red activas simplemente ingresando ifconfig en la terminal.
Pruébelo usted mismo y debería ver un resultado similar al Listado 31.
¡GUAU! Libro
Kali >ifconfig
ueth0Linkencap:EthernetHWaddr 00:0c:29:ba:82:0f
dirección vinet:192.168.181.131 Bcast:192.168.181.255 Máscara:255.255.255.0
recorte
ylo Linkencap: bucle invertido local
Dirección Internet: 127.0.0.1 Máscara: 255.0.0.0
recorte
zwlan0 Encapsulación de enlace:EthernetHWaddr 00:c0:ca:3f:ee:02
Listado 31: Usando ifconfig para obtener información de la red
Como puede ver, el comando ifconfig muestra información útil sobre las interfaces de red activas
en el sistema. En la parte superior del resultado está el nombre de la primera interfaz detectada, eth0
, que es la abreviatura de Ethernet0 (Linux comienza a contar en 0 en lugar de 1). Esta es la primera
conexión de red por cable. Si hubiera más interfaces Ethernet cableadas, aparecerían en la salida usando el
mismo formato (eth1, eth2, etc.).
A continuación se enumera el tipo de red que se utiliza (Ethernet) , seguido de HWaddr

y una dirección; esta es la dirección global única estampada en cada pieza de hardware de
red; en este caso, la tarjeta de interfaz de red (NIC), generalmente denominada dirección de
control de acceso a medios (MAC).
La segunda línea contiene información sobre la dirección IP actualmente asignada
a esa interfaz de red (en este caso, 192.168.181.131 ); el Bcast , o dirección de
difusión, que es la dirección utilizada para enviar información a todas las IP de la subred; y
finalmente la máscara de red (Máscara ), que se utiliza para determinar qué parte de la
dirección IP está conectada a la red local. También encontrará más información técnica en
esta sección del resultado, pero está más allá del alcance de este capítulo sobre conceptos
básicos de redes de Linux.
La siguiente sección del resultado muestra otra conexión de red llamada lo , que
es la abreviatura de dirección de bucle invertido y, a veces, se denomina localhost. Esta
es una dirección de software especial que lo conecta a su propio sistema. El software y los
servicios que no se ejecutan en su sistema no pueden usarlo. Usaría lo para probar algo en
su sistema, como su propio servidor web.
El host local generalmente se representa con la dirección IP 127.0.0.1.
La tercera conexión es la interfaz wlan0 . Esto aparece sólo si tienes una interfaz o adaptador
inalámbrico, como lo hago yo aquí. Tenga en cuenta que también muestra la dirección MAC de ese
dispositivo (HWaddr).
Esta información de ifconfig le permite conectarse y manipular la configuración de su red
de área local (LAN), una habilidad esencial para la piratería.
Comprobación de dispositivos de red inalámbrica con iwconfig

Si tiene un adaptador inalámbrico, puede usar el comando iwconfig para recopilar información
crucial para la piratería inalámbrica, como la dirección IP del adaptador, su dirección MAC, en
qué modo se encuentra y más. La información que puedes obtener de este comando es
particularmente importante cuando usas herramientas de piratería inalámbrica como
aircrackng.
Usando la terminal, echemos un vistazo a algunos dispositivos inalámbricos con
iwconfig (consulte el Listado 32).

Kali >iwconfig
wlan0 IEEE 802.11bg ESSID: apagado/cualquiera
Modo:Punto de acceso gestionado: No asociado TxPower=20 dBm
recorte
no hay extensiones inalámbricas
eth0 sin extensiones inalámbricas
Listado 32: Usando iwconfig para obtener información sobre adaptadores inalámbricos
El resultado aquí nos dice que la única interfaz de red con extensiones inalámbricas es
wlan0, que es lo que esperaríamos. Ni lo ni eth0 tienen extensiones inalámbricas.
Para wlan0, aprendemos de qué estándares inalámbricos 802.11 IEEE es capaz nuestro
dispositivo: b y g, dos de los primeros estándares de comunicación inalámbrica. La mayoría de los
dispositivos inalámbricos ahora también incluyen n (n es el último estándar).
También aprendemos de iwconfig el modo de la extensión inalámbrica (en este caso, Modo:
Administrado, en contraste con el modo monitor o promiscuo). Necesitaremos un modo promiscuo
para descifrar contraseñas inalámbricas.
A continuación, podemos ver que el adaptador inalámbrico no está conectado (No Asociado)
a un punto de acceso (AP) y que su potencia sea de 20 dBm, lo que representa la intensidad
de la señal. Dedicaremos más tiempo a esta información en el Capítulo 14.
Cambiar la información de su red

Poder cambiar su dirección IP y otra información de red es una habilidad útil porque le ayudará
a acceder a otras redes mientras aparece como un dispositivo confiable en esas redes. Por
ejemplo, en un ataque de denegación de servicio (DoS), puede falsificar su IP para que el
ataque parezca provenir de otra fuente, lo que le ayudará a evadir la captura de IP durante el
análisis forense. Esta es una tarea relativamente simple en Linux y se realiza con el comando
ifconfig .
Cambiar su dirección IP
Para cambiar su dirección IP, ingrese ifconfig seguido de la interfaz que desea reasignar y la
nueva dirección IP que desea asignar a esa interfaz. Por ejemplo, para asignar la dirección IP
192.168.181.115 a la interfaz eth0, ingresaría lo siguiente:
Kali >ifconfig eth0 192.168.181.115

kali >
Cuando haces esto correctamente, Linux simplemente devolverá el comando

avisar y no decir nada. ¡Ésto es una cosa buena!
Luego, cuando vuelva a verificar sus conexiones de red con ifconfig, debería ver que su
dirección IP ha cambiado a la nueva dirección IP que acaba de asignar.
¡GUAU! Libro
Análisis y gestión de redes 31
Cambiar su máscara de red y dirección de transmisión
También puede cambiar su máscara de red (netmask) y dirección de transmisión con el

comando ifconfig . Por ejemplo, si desea asignar esa misma interfaz eth0 con una máscara
de red de 255.255.0.0 y una dirección de transmisión de 192.168.1.255, deberá ingresar
lo siguiente:
kali >ifconfig eth0 192.168.181.115 máscara de red 255.255.0.0 transmisión 192.168.1.255

kali >
Una vez más, si ha hecho todo correctamente, Linux responde con un nuevo símbolo del
sistema. Ahora ingrese ifconfig nuevamente para verificar que cada uno de los parámetros
se haya cambiado en consecuencia.
Falsificar su dirección MAC
También puede usar ifconfig para cambiar su dirección MAC (o HWaddr). La dirección MAC
es única a nivel mundial y a menudo se utiliza como medida de seguridad para mantener
a los piratas informáticos fuera de las redes o para rastrearlas. Cambiar su dirección MAC
para falsificar una dirección MAC diferente es casi trivial y neutraliza esas medidas de
seguridad. Por tanto, es una técnica muy útil para eludir los controles de acceso a la red.
Para falsificar su dirección MAC, simplemente use el botón abajo del comando ifconfig
opción para eliminar la interfaz (eth0 en este caso). Luego ingrese el comando ifconfig
seguido del nombre de la interfaz (hw para hardware, ether
para Ethernet) y la nueva dirección MAC falsificada. Finalmente, vuelva a abrir la interfaz
con la opción arriba para que se realice el cambio. He aquí un ejemplo:
kali >ifconfig eth0 abajo

kali > ifconfig eth0 hw éter 00:11:22:33:44:55
kali >ifconfig eth0 arriba
Ahora, cuando verifique su configuración con ifconfig, debería ver que HWaddr ha
cambiado a su nueva dirección IP falsificada.
Asignación de nuevas direcciones IP desde el servidor DHCP
Linux tiene un servidor de Protocolo de configuración dinámica de host (DHCP) que ejecuta
un demonio (un proceso que se ejecuta en segundo plano) llamado dhcpd o demonio dhcp. El
servidor DHCP asigna direcciones IP a todos los sistemas de la subred y mantiene archivos de
registro de qué dirección IP se asigna a qué máquina en un momento dado. Esto lo convierte
en un gran recurso para que los analistas forenses rastreen a los piratas informáticos después
de un ataque. Por ese motivo, resulta útil comprender cómo funciona el servidor DHCP.
Por lo general, para conectarse a Internet desde una LAN, debe tener una IP asignada
por DHCP. Por lo tanto, después de configurar una dirección IP estática, debe regresar y
obtener una nueva dirección IP asignada por DHCP. Para hacer esto, siempre puedes reiniciar tu

sistema, pero le mostraré cómo recuperar un nuevo DHCP sin tener que apagar su sistema y
reiniciarlo.
Para solicitar una dirección IP de DHCP, simplemente llame al servidor DHCP con
el comando dhclient seguido de la interfaz a la que desea asignar la dirección. Las diferentes
distribuciones de Linux utilizan diferentes clientes DHCP, pero Kali se basa en Debian, que
utiliza dhclient. Por lo tanto, puedes asignar una nueva dirección como esta:
kali > dhclient eth0
El comando dhclient envía una solicitud DHCPDISCOVER desde la interfaz de red

especificada (aquí, eth0). Luego recibe una oferta (DHCPOFFER) del servidor DHCP
(192.168.181.131 en este caso) y confirma la asignación de IP al servidor DHCP con una
solicitud dhcp.
Kali >ifconfig
eth0Linkencap:EthernetHWaddr 00:0c:29:ba:82:0f
Dirección de Internet: 192.168.181.131 Bcast: 192.168.181.131 Máscara: 255.255.255.0
Dependiendo de la configuración del servidor DHCP, la dirección IP asignada en

cada caso puede ser diferente.
Ahora, cuando ingrese ifconfig, debería ver que el servidor DHCP tiene
asignó una nueva dirección IP, una nueva dirección de transmisión y una nueva máscara
de red a su interfaz de red eth0.
Manipulación del sistema de nombres de dominio

Los piratas informáticos pueden encontrar un tesoro de información sobre un objetivo en su
sistema de nombres de dominio (DNS). DNS es un componente crítico de Internet y,
aunque está diseñado para traducir nombres de dominio a direcciones IP, un pirata
informático puede usarlo para recopilar información sobre el objetivo.
Examinando DNS con excavación
DNS es el servicio que traduce un nombre de dominio como hackersarise.com a la

dirección IP adecuada; de esa manera, su sistema sabrá cómo llegar a él.
Sin DNS, todos tendríamos que recordar miles de direcciones IP de nuestros sitios web
favoritos, una tarea nada fácil incluso para un experto.
Uno de los comandos más útiles para el aspirante a hacker es dig, que ofrece una
forma de recopilar información DNS sobre un dominio de destino. La información DNS
almacenada puede ser una pieza clave de reconocimiento temprano antes de atacar. Esta
información podría incluir la dirección IP del servidor de nombres del objetivo (el servidor
que traduce el nombre del objetivo a una dirección IP), el servidor de correo electrónico del
objetivo y, potencialmente, cualquier subdominio y dirección IP.
Por ejemplo, ingrese dig hackersarise.com y agregue la opción ns (corto
para servidor de nombres). El servidor de nombres de hackersarise.com se muestra en la
SECCIÓN DE RESPUESTAS del Listado 33.
¡GUAU! Libro Análisis y gestión de redes 33

kali > excavar hackersarise.com ns

recorte
;; SECCIÓN DE PREGUNTAS:
;hackersarise.com. EN NS
;; SECCIÓN DE RESPUESTAS:
hackersarise.com. 5 EN NS ns7.wixdns.net.
hackersarise.com. 5 EN NS ns6.wixdns.net.
;; SECCIÓN ADICIONAL:
ns6.wixdns.net. 5 EN UN 216.239.32.100
recorte
Listado 33: Usando dig y su opción ns para obtener información sobre un servidor de nombres de dominio
Tenga en cuenta también en la SECCIÓN ADICIONAL que esta consulta de excavación revela la IP
dirección (216.239.32.100) del servidor DNS que sirve a hackersarise.com.
También puede utilizar el comando dig para obtener información sobre los servidores de
correo electrónico conectados a un dominio agregando la opción mx (mx es la abreviatura de servidor
de intercambio de correo). Esta información es crítica para los ataques a los sistemas de correo
electrónico. Por ejemplo, la información sobre los servidores de correo electrónico www.hackersarise.com
se muestra en la SECCIÓN DE AUTORIDAD del Listado 34.
kali > excavar hackersarise.com mx

recorte
;; SECCIÓN DE PREGUNTAS:
;hackersarise.com. EN MX
;; SECCIÓN DE AUTORIDAD:
hackersarise.com. 5 EN SOA ns6.wixdns.net. soporte.wix.com 2016052216 10800 3600 604 800 3600
recorte
Listado 34: Usando dig y su opción mx para obtener información sobre un intercambio de correo de dominio
servidor
El servidor DNS de Linux más común es el dominio de nombres de Internet de Berkeley (BIND).
En algunos casos, los usuarios de Linux se referirán a DNS como BIND, pero no se confunda: DNS y BIND
asignan nombres de dominio individuales a direcciones IP.
Cambiar su servidor DNS

En algunos casos, es posible que desee utilizar otro servidor DNS. Para hacerlo, editará un archivo de texto
sin formato llamado /etc/resolv.conf en el sistema. Abra ese archivo en un editor de texto; estoy usando
Leafpad. Luego, en su línea de comando, ingrese el nombre exacto de su editor seguido de la ubicación del
archivo y el nombre del archivo.
Por ejemplo,
kali >leafpad /etc/resolv.conf
Abrirá el archivo resolv.conf en el directorio /etc en mi editor de texto gráfico especificado,

Leafpad. El archivo debería parecerse a la Figura 31.
Figura 31: Un archivo resolv.conf típico en un editor de texto
Como puede ver en la línea 3, mi servidor de nombres está configurado en un servidor

DNS local en 192.168.181.2. Eso funciona bien, pero si quiero agregar o reemplazar ese
servidor DNS con, digamos, el servidor DNS público de Google en 8.8.8.8, agregaría la siguiente
línea en el archivo /etc/resolv.conf para especificar el servidor de nombres:
servidor de nombres 8.8.8.8
Entonces solo necesitaría guardar el archivo. Sin embargo, también puedes lograr el
mismo resultado exclusivamente desde la línea de comando ingresando lo siguiente:
kali >echo "servidor de nombres 8.8.8.8"> /etc/resolv.conf
Este comando repite la cadena del servidor de nombres 8.8.8.8 y la redirige (>) al archivo /
etc/resolv.conf, reemplazando el contenido actual. Tu /etc/resolv.conf
El archivo ahora debería verse como en la Figura 32.
Figura 32: Cambiar el archivo resolv.conf para especificar el servidor DNS de Google
Si abre el archivo /etc/resolv.conf ahora, debería ver que apunta al

Solicitudes de DNS al servidor DNS de Google en lugar de a su servidor DNS local.
Su sistema ahora irá al servidor DNS público de Google para resolver los nombres de
dominio en direcciones IP. Esto puede significar que los nombres de dominio tardan un poco
más en resolverse (probablemente milisegundos). Por lo tanto, para mantener la velocidad pero
conservar la opción de utilizar un servidor público, es posible que desee conservar el servidor
DNS local en el archivo resolv.conf y seguirlo con un servidor DNS público. El sistema operativo
consulta cada servidor DNS listado en el orden en que aparece en /etc/resolv.conf, por lo que
el sistema solo hará referencia al servidor DNS público si el nombre de dominio no se puede
encontrar en el servidor DNS local.
NOTA Si está utilizando una dirección DHCP y el servidor DHCP proporciona una configuración DNS, el
servidor DHCP reemplazará el contenido del archivo cuando renueve la dirección DHCP.

Mapeo de sus propias direcciones IP
Un archivo especial en su sistema llamado archivo de hosts también realiza el nombre de dominio:
Traducción de direcciones IP. El archivo de hosts se encuentra en /etc/hosts y, al igual que con DNS,
puede usarlo para especificar su propia asignación de dirección IP y nombre de dominio.
En otras palabras, puede determinar a qué dirección IP accede su navegador cuando ingresa
www.microsoft.com (o cualquier otro dominio) en el navegador, en lugar de dejar que el servidor DNS
decida. Como hacker, esto puede resultar útil para secuestrar una conexión TCP en su red de área
local para dirigir el tráfico a un servidor web malicioso con una herramienta como dnsspoof.
Desde la línea de comando, escriba el siguiente comando (puede sustituir el editor de texto
preferido por leafpad):
kali >leafpad /etc/hosts
Ahora debería ver su archivo de hosts , que se parecerá a la Figura 33.
Figura 33: Un archivo de hosts predeterminado de Kali Linux
De forma predeterminada, el archivo de hosts contiene solo una asignación para su host local,
en 127.0.0.1, y el nombre de host de su sistema (en este caso, Kali, en 127.0.1.1). Pero puedes agregar
cualquier dirección IP asignada a cualquier dominio que desees. Como ejemplo de cómo se podría
utilizar esto, puede asignar www.bankofamerica.com a su sitio web local, en 192.168.181.131.
127.0.0.1 servidor local

127.0.1.1 Kali
192.168.181.131 bancoofamerica.com
# Las siguientes líneas son deseables para hosts con capacidad IPv6
::1 localhost ip6localhost ip6loopback
ff02::1 ip6todos los nodos
ff02::2 ip6todos los enrutadores
Asegúrese de presionar el tabulador entre la dirección IP y la clave de dominio, no la barra

espaciadora.
A medida que se involucre más en sus esfuerzos de piratería y aprenda sobre herramientas
como dnsspoof y Ettercap, podrá usar el archivo de hosts para dirigir cualquier tráfico en su LAN que
visite www.bankofamerica.com a su servidor web en 192.168.181.131. .
Bastante fácil, ¿verdad?

Resumen
Cualquier hacker necesita algunas habilidades básicas de redes Linux para conectarse,
analizar y administrar redes. A medida que progreses, estas habilidades serán cada vez
más útiles para realizar reconocimientos, suplantaciones de identidad y conexiones a
sistemas de destino.
Ejercicios
Antes de pasar al Capítulo 4, pruebe las habilidades que aprendió en este capítulo completando
los siguientes ejercicios:
1. Encuentre información sobre sus interfaces de red activas.
2. Cambie la dirección IP en eth0 a 192.168.1.1.
3. Cambie su dirección de hardware en eth0.
4. Compruebe si tiene alguna interfaz inalámbrica disponible activa.
5. Restablezca su dirección IP a una dirección asignada por DHCP.
6. Busque el servidor de nombres y el servidor de correo electrónico de su sitio web favorito.
7. Agregue el servidor DNS de Google a su archivo /etc/resolv.conf para que su sistema haga
referencia a ese servidor cuando no pueda resolver una consulta de nombre de
dominio con su servidor DNS local.
¡GUAU! Libro
4
Agregar y eliminar
Software
Una de las tareas más fundamentales en

Linux (o cualquier sistema operativo) agrega
y elimina software. A menudo necesitarás
instalar software que no viene con
su distribución o elimine el software no deseado para
que no ocupe espacio en el disco duro.
Algunos programas requieren otro software para ejecutarse y, a veces, encontrará
que puede descargar todo lo que necesita a la vez en un paquete de software, que es un
grupo de archivos (normalmente bibliotecas y otras dependencias) que necesita para
que un software funcione. ejecutar con éxito. Cuando instala un paquete, todos los
archivos que contiene se instalan juntos, junto con un script para simplificar la carga
del software.
En este capítulo, examinamos tres métodos clave para agregar nuevo software:
administrador de paquetes apt, administradores de instalación basados en GUI y git.
¡GUAU! Libro
Uso de software apto para manejar

En las distribuciones de Linux basadas en Debian, que incluyen Kali y Ubuntu, el administrador de
software predeterminado es la herramienta de empaquetado avanzado, o apt, cuyo comando
principal es aptget. En su forma más simple y común, puede usar aptget para descargar e
instalar nuevos paquetes de software, pero también puede actualizar y mejorar el software con él.
Buscando un paquete
Antes de descargar un paquete de software, puede verificar si el paquete que necesita está
disponible en su repositorio, que es un lugar donde su sistema operativo almacena información.
La herramienta apt tiene una función de búsqueda que puede comprobar si el paquete está disponible.
La sintaxis es sencilla:
palabra clave de búsqueda de aptcache
Tenga en cuenta que usamos el comando aptcache para buscar en el caché de apt, o el lugar
donde almacena los nombres de los paquetes. Entonces, si estuviera buscando el sistema de
detección de intrusiones Snort, por ejemplo, ingresaría el comando que se muestra en el Listado
41.
kali > bufido de búsqueda aptcache

fwsnort Traductor de reglas de Snort a iptables
ippl registrador de protocolos IP
recorte
snort Sistema flexible de detección de intrusiones en la red
snortcommon Sistema flexible de detección de intrusiones en la red archivos comunes
recorte
Listado 41: Buscando en el sistema con aptcache para Snort
Como puede ver, numerosos archivos tienen la palabra clave snort , pero cerca de la mitad del
resultado vemos snort: sistema flexible de detección de intrusiones en la red. ¡Eso es lo que estamos
buscando!
Agregar software
Ahora que sabes que el paquete snort existe en tu repositorio, puedes usar aptget para descargar
el software.
Para instalar una pieza de software desde el repositorio predeterminado de su sistema
operativo en la terminal, use el comando aptget , seguido de la palabra clave install y luego el
nombre del paquete que desea instalar. La sintaxis se ve así:
aptget nombre del paquete de instalación
Probemos esto instalando Snort en su sistema. Ingrese aptget

Instale snort como una instrucción de comando, como se muestra en el Listado 42.

kali >aptget instalar bufido

Leyendo listas de paquetes... Listo
Construyendo árbol de dependencias
Leyendo información de estado... Listo
Paquetes sugeridos:
snortdoc
Se instalarán los siguientes paquetes NUEVOS:
bufido
recorte
¿Instalar estos paquetes sin verificación [S/n]?
Listado 42: Instalando Snort con aptget install
El resultado que ve le indica lo que se está instalando. si todo parece

correcto, continúe e ingrese y cuando se le solicite, y la instalación del software continuará.
Eliminación de software
Al eliminar software, utilice aptget con la opción eliminar , seguido del nombre del software a
eliminar (consulte el Listado 43).
kali >aptget eliminar bufido

Los siguientes paquetes se instalaron automáticamente y ya no son necesarios:
libdaq0 libprelude2 oinkmaster bibliotecascomunessnort reglaspredeterminadasdesnort

recorte
¿Quieres continuar [T/n]?
Listado 43: Eliminando Snort con aptget remove
Nuevamente, verás las tareas realizadas en tiempo real y se te preguntará si deseas

continuar. Puede ingresar y para desinstalar, pero es posible que desee conservar Snort ya
que lo usaremos nuevamente. El comando eliminar no elimina los archivos de configuración, lo
que significa que puede reinstalar el mismo paquete en el futuro sin reconfigurarlo.
Si desea eliminar los archivos de configuración al mismo tiempo que el

paquete, puede utilizar la opción de purga , como se muestra en el Listado 44.
kali >aptget purga resoplido

libdaq0 libprelude2 oinkmaster bibliotecascomunessnort reglaspredeterminadasdesnort
recorte
¿Quieres continuar [T/n]?
Listado 44: Eliminación de Snort y los archivos de configuración que lo acompañan con aptget purge
¡GUAU! Libro Agregar y quitar software 41
Simplemente ingrese Y cuando se le solicite para continuar con la eliminación del

paquete de software y los archivos de configuración.
Es posible que haya notado la línea Los siguientes paquetes se instalaron automáticamente
y ya no son necesarios en el resultado. Para mantener las cosas pequeñas y modulares, muchos
paquetes de Linux se dividen en unidades de software que podrían usar muchos programas
diferentes. Cuando instaló Snort, instaló varias dependencias o bibliotecas que Snort requiere
para ejecutarse.
Ahora que estás eliminando Snort, esas otras bibliotecas o dependencias ya no son necesarias,
por lo que también se eliminan.
Actualización de paquetes
Los repositorios de software se actualizarán periódicamente con nuevo software o nuevas versiones
de software existente. Estas actualizaciones no le llegan automáticamente, por lo que debe
solicitarlas para poder aplicarlas a su propio sistema. Actualizar no es lo mismo que actualizar:
actualizar simplemente actualiza la lista de paquetes disponibles para descargar desde el
repositorio, mientras que actualizar actualizará el paquete a la última versión en el repositorio.
Puede actualizar su sistema individual ingresando el comando aptget seguido de la palabra

clave update. Esto buscará en todos los paquetes de su sistema y comprobará si hay actualizaciones
disponibles. Si es así, las actualizaciones se descargan (consulte el Listado 45).
kali >aptobtener actualización

Obtener: 1 http://mirrors.ocf.berkeley.edu/kali kalirolling InRelease [30.5kb]
Obtener:2 http://mirrors.ocf.berkeley.edu/kali kalirolling/main Paquetes amd64 [14,9 MB]
Obtenga: 3 http://mirrors.ocf.berkeley.edu/kali kalirolling Paquetes amd64 no gratuitos [163kb]
Obtener:4 http://mirrors.ocf.berkeley.edu/kali kalirolling/contrib Paquetes amd64 [107 kB]
Obtuvo 15,2 MB en 1 min 4 s (236 kB/s)
Listado 45: Actualizando todos los paquetes obsoletos con aptget update
Se actualizará la lista de software disponible en el repositorio de su sistema. Si la

actualización es exitosa, su terminal indicará Leyendo listas de paquetes... Listo, como puede ver
en el Listado 45. Tenga en cuenta que el nombre del repositorio y los valores (hora, tamaño, etc.)
pueden ser diferentes en su sistema.
Paquetes de actualización
Para actualizar los paquetes existentes en su sistema, utilice aptget update.

Debido a que la actualización de sus paquetes puede generar cambios en su software, debe
iniciar sesión como root o usar el comando sudo antes de ingresar a aptget Upgrade. Este
comando actualizará todos los paquetes en su sistema que apt conoce, es decir, solo aquellos
almacenados en el repositorio (consulte el Listado 46). La actualización puede llevar mucho
tiempo, por lo que es posible que no puedas utilizar tu sistema durante un tiempo.

kali >aptobtener actualización

Construyendo árbol de dependencias... Listo
Calculando actualización... Listo
recorte
Se actualizarán los siguientes paquetes:
recorte
1101 actualizados, 0 recién instalados, 0 para eliminar y 318 no actualizados.
Necesita obtener 827 MB de archivos.
Después de esta operación, se liberarán 408 MB de espacio en disco.
¿Quieres continuar? [T/n]
Listado 46: Actualizando todos los paquetes obsoletos con aptget Upgrade
Debería ver en el resultado que su sistema estima la cantidad de espacio en el disco duro necesario
para el paquete de software. Continúe e ingrese Y
si desea continuar y tener suficiente espacio en el disco duro para la actualización.
Agregar repositorios a su archivo sources.list

Los servidores que contienen el software para distribuciones particulares de Linux se
conocen como repositorios. Casi todas las distribuciones tienen sus propios repositorios
de software (desarrollados y configurados para esa distribución) que podrían no funcionar
bien, o no funcionar en absoluto, con otras distribuciones. Aunque estos repositorios
suelen contener software igual o similar, no son idénticos y, a veces, tienen versiones
diferentes del mismo software o software completamente diferente.
Por supuesto, utilizará el repositorio de Kali, que tiene una gran cantidad de
software de seguridad y piratería. Pero debido a que Kali se especializa en seguridad
y piratería, no incluye algún software y herramientas especiales, ni siquiera algún
software común y corriente. Vale la pena agregar uno o dos repositorios de respaldo en
los que su sistema pueda buscar en caso de que no encuentre un software específico
en el repositorio de Kali.
Los repositorios que su sistema buscará software se almacenan en el archivo
sources.list , y puede modificar este archivo para definir desde qué repositorios desea
descargar el software. A menudo agrego los repositorios de Ubuntu después de los
repositorios de Kali en mi archivo sources.list ; De esa manera, cuando solicito descargar
un nuevo paquete de software, mi sistema primero buscará en el repositorio de Kali y, si el
paquete de software no está allí, buscará en el repositorio de Ubuntu.
Puede encontrar el archivo fuentes.list en /etc/apt/sources.list y abrirlo con cualquier
editor de texto. Volveré a usar Leafpad. Para abrir el archivo sources.list , ingrese lo
siguiente en su terminal, reemplazando leafpad con el nombre de su editor:
kali >leafpad /etc/apt/sources.list
Después de ingresar este comando, debería ver una ventana como la de

Figura 41, con una lista de los repositorios predeterminados de Kali.
Figura 41: Repositorios predeterminados de Kali en sources.list
Muchas distribuciones de Linux dividen los repositorios en categorías separadas.

Por ejemplo, Ubuntu divide sus categorías de repositorio de la siguiente manera:
principal Contiene software de código abierto compatible
Universe Contiene software de código abierto mantenido por la comunidad.
multiverse Contiene software restringido por derechos de autor u otras cuestiones legales
restringido Contiene controladores de dispositivos propietarios
backports Contiene paquetes de versiones posteriores
No recomiendo utilizar repositorios de prueba, experimentales o inestables en su lista de

fuentes porque pueden descargar software problemático a su sistema. El software que no esté
completamente probado podría dañar su sistema.
Cuando solicita descargar un nuevo paquete de software, el sistema busca secuencialmente
en sus repositorios enumerados en sources.list y se detiene cuando encuentra el paquete deseado.
Primero verifique que el repositorio sea compatible con su sistema. Kali, al igual que Ubuntu, está
construido sobre Debian, por lo que estos repositorios funcionan bastante bien con cada uno de estos
sistemas.
Para agregar un repositorio, simplemente edite el archivo sources.list agregando el nombre del
repositorio a la lista y luego guarde el archivo. Digamos, por ejemplo, que desea instalar Oracle Java
8 en Kali. No hay ningún paquete apt para Oracle Java 8 disponible como parte de las fuentes
predeterminadas de Kali, pero una búsqueda rápida en línea muestra que la excelente gente de
WebUpd8 ha creado uno. Si agrega su repositorio a las fuentes, puede instalar Oracle Java 8 con apt
get install oracle
comando java8installer . Al momento de escribir este artículo, necesitaría agregar las siguientes
ubicaciones de repositorio a sources.list para poder agregar los repositorios necesarios:
deb http://ppa.launchpad.net/webupd8team/java/ubuntu confiable principal

debsrc http://ppa.launchpad.net/webupd8team/java/ubuntu principal preciso

Usando un instalador basado en GUI

Las versiones más nuevas de Kali ya no incluyen una herramienta de instalación de
software basada en GUI, pero siempre puedes instalar una con el comando aptget . Las
dos herramientas de instalación basadas en GUI más comunes son Synaptic y Gdebi.
Instalemos Synaptic y usémoslo para instalar nuestro paquete Snort:
kali >aptget instalar sináptico

recorte
Activadores de procesamiento para el menú (2.1.47)...
kali >
Una vez que haya instalado Synaptic, puede iniciarlo desde Configuración4
Administrador de paquetes Synaptic, que debería abrir una ventana como la de la Figura
42.
Figura 42: La interfaz del Administrador de paquetes Synaptic
Ahora puedes buscar el paquete que estás buscando. Simplemente haga clic en
la pestaña Buscar para abrir una ventana de búsqueda. Como está buscando Snort
nuevamente, ingrese snort en la ventana de búsqueda y haga clic en Buscar. Desplácese
hacia abajo en los resultados de la búsqueda para encontrar el paquete que está buscando.
Marque la casilla junto a Snort y luego haga clic en la pestaña Aplicar , como se muestra en
la Figura 43. Synaptic ahora descargará e instalará Snort desde el repositorio junto con
las dependencias necesarias.
Figura 43: Descarga de Snort desde el Administrador de paquetes Synaptic
Instalación de software con git

A veces, el software que desea no está disponible en ninguno de los repositorios.
especialmente si es nuevo, pero puede estar disponible en github (https://www
.github.com/), un sitio que permite a los desarrolladores compartir su software con otros
para descargarlo, usarlo y proporcionar comentarios. Por ejemplo, si desea bluediv ing,
una suite de piratería y pentesting de Bluetooth, y no puede encontrarlo en el repositorio
de Kali, puede buscar el software en github ingresando bluediving .
en la barra de búsqueda. Si existe en github, debería ver el repositorio en los resultados
de búsqueda.
Una vez que haya encontrado el software en github, puede instalarlo desde la
terminal ingresando el comando git clone seguido de su URL de github.
Por ejemplo, bluediving se encuentra en https://www.github.com/balle/bluediving
.git. Para clonarlo en su sistema, ingrese el comando que se muestra en el Listado 47.
kali > clon de git https://www.github.com/balle/bluediving.git

Clonando en 'bluediving'...
remoto: Contando objetos: 131, Listo.
remoto: Total 131 (delta 0), reutilizado 0 (delta 0), paquete reutilizado 131
Recepción de objetos: 100% (131/131), 900,81 KiB | 646,00 KiB/s, listo.
Resolución de deltas: 100% (9/9), listo.
Comprobando conectividad... Listo.
Listado 47: Clonación de bluediving con git clone

El comando git clone copia todos los datos y archivos de esa ubicación en su
sistema. Puede verificar que se hayan descargado exitosamente usando el comando de
lista larga ls –l en el directorio de destino, así:
kali >ls l
Si ha clonado bluediving con éxito en su sistema, debería ver el siguiente resultado:
total 80
drwxrxrx 7 raíz raíz 4096 10 de enero 22:19 bluediving
drwxrxrx 2 raíz raíz 4096 5 de diciembre 11:17 Escritorio
drwxrxrx 2 raíz raíz 4096 5 de diciembre 11:17 Documentos
drwxrxrx 2 raíz raíz 4096 5 de diciembre 11:17 Descargas
drwxrxrx 2 raíz raíz 4096 5 de diciembre 11:17 Música
recorte
Como puedes ver, bluediving ha sido clonado exitosamente en el sistema,

y se ha creado un nuevo directorio llamado bluediving para sus archivos.
Resumen
En este capítulo, aprendió algunas de las muchas formas de descargar e instalar nuevo
software en su sistema Linux. Los administradores de paquetes de software (como apt),
los instaladores basados en GUI y los clones de git son los métodos más comunes y
cruciales que debe conocer un aspirante a hacker. Pronto se familiarizará con cada
uno de ellos.
Ejercicios
1. Instale un nuevo paquete de software desde el repositorio de Kali.
2. Elimine ese mismo paquete de software.
3. Actualiza tu repositorio.
4. Actualice sus paquetes de software.
5. Seleccione una nueva pieza de software de github y clónela en su sistema.

¡GUAU! Libro
5
Control de archivos
Permisos del directorio
No todos los usuarios de un mismo sistema operativo deberían

tener el mismo nivel de acceso a los archivos
y directorios. Como cualquier sistema operativo profesional

o de nivel empresarial, Linux tiene métodos para proteger el
acceso a archivos y directorios. Este sistema de seguridad permite al
administrador del sistema (el usuario raíz ) o al propietario del archivo
proteger sus archivos contra accesos no deseados o manipulación al otorgar
permisos a usuarios seleccionados para leer, escribir o ejecutar archivos.
Para cada archivo y directorio, podemos especificar el estado del permiso
para el propietario del archivo, para grupos particulares de usuarios y para
todos los demás usuarios. Esto es una necesidad en un sistema operativo
multiusuario de nivel empresarial. La alternativa sería bastante caótica.
En este capítulo, le mostraré cómo verificar y cambiar permisos en archivos y
directorios para usuarios seleccionados, cómo configurar permisos predeterminados para
archivos y directorios, y cómo configurar permisos especiales. Finalmente, verá cómo la
comprensión de los permisos por parte de un hacker podría ayudarle a explotar un sistema.
¡GUAU! Libro
Diferentes tipos de usuarios

Como sabes, en Linux el usuario root es todopoderoso. El usuario root puede hacer
básicamente cualquier cosa en el sistema. Otros usuarios del sistema tienen capacidades
y permisos más limitados y casi nunca tienen el acceso que tiene el usuario root.
Estos otros usuarios suelen agruparse en grupos que generalmente comparten una
función similar. En una entidad comercial, estos grupos podrían ser finanzas, ingeniería,
ventas, etc. En un entorno de TI, estos grupos pueden incluir desarrolladores,
administradores de red y administradores de bases de datos.
La idea es colocar a personas con necesidades similares en un grupo al que se le
concedan permisos relevantes; entonces cada miembro del grupo hereda los permisos
del grupo. Esto se debe principalmente a la facilidad de administración de permisos y,
por tanto, a la seguridad.
El usuario raíz es parte del grupo raíz de forma predeterminada. Cada nuevo usuario
del sistema debe agregarse a un grupo para poder heredar los permisos de ese grupo.
Conceder permisos
A todos y cada uno de los archivos y directorios se les debe asignar un nivel particular de
permiso para las diferentes identidades que lo utilizan. Los tres niveles de permiso son
los siguientes:
r Permiso para leer. Esto otorga permiso solo para abrir y ver un archivo.
w Permiso para escribir. Esto permite a los usuarios ver y editar un archivo.
x Permiso para ejecutar. Esto permite a los usuarios ejecutar un archivo (pero no
necesariamente verlo o editarlo).
De esta forma, el usuario root puede otorgar a los usuarios un nivel de permiso
dependiendo de para qué necesitan los archivos. Cuando se crea un archivo, normalmente
el usuario que lo creó es el propietario del archivo y el grupo propietario es el grupo
actual del usuario. El propietario del archivo puede otorgarle varios privilegios de acceso.
Veamos cómo cambiar los permisos para pasar la propiedad a usuarios individuales y a
grupos.
Otorgar propiedad a un usuario individual

Para transferir la propiedad de un archivo a un usuario diferente para que tenga la
capacidad de controlar los permisos, podemos usar el comando chown (o cambiar propietario):
kali >chown ubob v/tmp/bobsfile
Aquí, damos el comando, el nombre del usuario al que le estamos dando propiedad
y luego la ubicación y el nombre del archivo relevante. Este comando otorga a la cuenta
de usuario de Bob u la propiedad de bobsfile v.

Otorgar propiedad a un grupo

Para transferir la propiedad de un archivo de un grupo a otro, podemos usar el comando
chgrp (o cambiar grupo).
A menudo es más probable que los hackers trabajen solos que en grupos, pero no es
raro que varios hackers o pentesters trabajen juntos en un proyecto y, en ese caso, es
necesario utilizar grupos. Por ejemplo, es posible que tenga un grupo de pentesters y un
grupo de miembros del equipo de seguridad trabajando en el mismo proyecto. Los
pentesters en este ejemplo son el grupo raíz, lo que significa que tienen todos los
permisos y accesos. El grupo raíz necesita acceso a las herramientas de piratería,
mientras que el personal de seguridad sólo necesita acceso a herramientas defensivas,
como un sistema de detección de intrusos (IDS). Digamos que el grupo raíz descarga e
instala un programa llamado newIDS; el grupo raíz deberá cambiar la propiedad al grupo
de seguridad para que el grupo de seguridad pueda usarlo a voluntad.
Para hacerlo, el grupo raíz simplemente ingresaría el siguiente comando:
kali >chgrp useguridad vnewIDS
Este comando transfiere al grupo de seguridad u la propiedad de newIDS v.

Ahora necesita saber cómo comprobar si estas asignaciones han funcionado. Lo
harás verificando los permisos de un archivo.
Comprobando permisos
Cuando desee saber qué permisos se otorgan a qué usuarios para un archivo o directorio,
use el comando ls con el parámetro –l (largo) para mostrar el contenido de un directorio
en formato largo; esta lista contendrá los permisos. En el Listado 51, uso el comando ls –
l en el archivo /usr/share/hashcat
(una de mis herramientas favoritas para descifrar contraseñas) para ver qué podemos
aprender sobre los archivos allí.
kali >ls –l /usr/share/hashcat

total 32952
uvwx drwxrxrx 5 y z5 {
raíz raíz 4096 rwrr 1 raíz raíz rw de diciembre 10:47 conjuntos de caracteres
rr 1 raíz raíz drwxr xrx 2 33685504 28 de junio de 2018 hashcat.hcstat

raíz raíz 4096 drwxr xrx 2 33685504 28 de junio de 2018 hashcat.hctune
raíz raíz 4096 drwxr xrx 3 raíz raíz 5 de diciembre 10:47 mascarillas
4096 5 de diciembre 10:47 OpenCL

5 de diciembre 10:47 reglas
Listado 51: Verificando los permisos de un archivo con el comando de listado largo
En cada línea, obtenemos información sobre:
u El tipo de archivo
v Los permisos del archivo para propietario, grupos y usuarios, respectivamente
w El número de enlaces (este tema está más allá del alcance del libro).
x El propietario del archivo

¡GUAU! Libro
y El tamaño del archivo en bytes.

z Cuándo se creó o modificó por última vez el archivo
{ El nombre del archivo
Por ahora, centrémonos en las cadenas de letras aparentemente incomprensibles.

y guiones en el borde izquierdo de cada línea. Nos dicen si un elemento es un archivo o directorio y
qué permisos, si los hay, tiene.
El primer carácter indica el tipo de archivo, donde d representa un directorio y un guión (–) indica
un archivo. Estos son los dos tipos de archivos más comunes.
La siguiente sección define los permisos del archivo. Hay tres conjuntos
de tres caracteres, formado por alguna combinación de lectura (r), escritura (w) y ejecución (x), en
ese orden. El primer conjunto representa los permisos del propietario; el segundo, los del grupo; y
el último, los de todos los demás usuarios.
Independientemente del conjunto de tres letras que estés mirando, si ves una r
Primero, ese usuario o grupo de usuarios tiene permiso para abrir y leer ese archivo o directorio. Una
w como letra del medio significa que pueden escribir (modificar) el archivo o directorio, y una x al
final significa que pueden ejecutar (o ejecutar) el archivo o directorio. Si alguna r, w o x se reemplaza
con un guión (), entonces no se ha otorgado el permiso respectivo. Tenga en cuenta que los
usuarios pueden tener permiso para ejecutar sólo archivos binarios o scripts.
Usemos la tercera línea de salida del Listado 51 como ejemplo:
rwrr 1 raíz raíz 33685504 28 de junio de 2018 hashcat.hcstat
El archivo se llama, como sabemos por el extremo derecho de la línea, hashcat.hcstat.

Después de la inicial – (que indica que es un archivo), los permisos rw nos dicen que el propietario
tiene permisos de lectura y escritura, pero no de ejecución.
El siguiente conjunto de permisos (r) representa los del grupo y muestra que el grupo tiene
permisos de lectura pero no de escritura ni de ejecución. Y, finalmente, vemos que el resto de
usuarios también tienen solo lectura por misión (r).
Estos permisos no están escritos en piedra. Como usuario root o propietario de archivos, puede
cambiarlos. A continuación, haremos precisamente eso.
Cambiar permisos
Podemos usar el comando de Linux chmod (o cambiar modo) para cambiar las misiones. Sólo un
usuario root o el propietario del archivo pueden cambiar los permisos.
En esta sección, usamos chmod para cambiar los permisos en hashcat.hcstat
utilizando dos métodos diferentes. Primero usamos una representación numérica de permisos y
luego usamos una representación simbólica.
Cambiar permisos con notación decimal

Podemos usar un atajo para referirnos a los permisos usando un solo número para representar un
conjunto de permisos rwx . Como todo lo que subyace al sistema operativo, los permisos se representan
en binario, por lo que ON y OFF se activan y desactivan.

están representados por 1 y 0, respectivamente. Puede pensar en los permisos rwx como tres
interruptores ON/OFF, de modo que cuando se conceden todos los permisos, esto equivale a 111
en binario.
Un conjunto binario como este se representa fácilmente como un dígito mediante convert
convirtiéndolo en octal, un sistema numérico de ocho dígitos que comienza con 0 y termina con
7. Un dígito octal representa un conjunto de tres dígitos binarios, lo que significa que podemos
representar un conjunto rwx completo con un dígito. La Tabla 51 contiene todas las combinaciones
de permisos posibles y sus representantes octales y binarios.
Tabla 51: Octal y Binario

Representaciones de permisos
Binario octal rwx
000 0
001 1 X
010 2 w
011 3 wx
100 4 r
101 5 RX
110 6 rw
111 7 rwx
Usando esta información, veamos algunos ejemplos. Primero, si queremos configurar

solo el permiso de lectura, podemos consultar la Tabla 51 y ubicar el valor de lectura:
rwx
4
A continuación, si queremos establecer el permiso en wx, podríamos usar el mismo

metodología y busque qué establece la w y qué establece la x:
rwx
21
Observe en la Tabla 51 que la representación octal para wx es 3, que no es coincidencia
que sea el mismo valor que obtenemos cuando sumamos los dos valores para establecer w y x
individualmente: 2 + 1 = 3.
Finalmente, cuando los tres permisos están activados, se ve así:
rwx
421
Y 4 + 2 + 1 = 7. Aquí vemos que en Linux, cuando todos los permisos

Los interruptores están encendidos, están representados por el equivalente octal de 7.
¡GUAU! Libro Controlar los permisos de archivos y directorios 53
Entonces, si quisiéramos representar todos los permisos para el propietario, grupo y

todos los usuarios, podríamos escribirlo de la siguiente manera:
777
Aquí es donde entra en juego el atajo. Al pasarle a chmod tres dígitos octales (uno
para cada conjunto de rwx ), seguidos de un nombre de archivo, podemos cambiar los
permisos de ese archivo para cada tipo de usuario. Ingrese lo siguiente en su línea de comando:
kali >chmod 774 hashcat.hcstat
Al observar la Tabla 51, podemos ver que esta declaración le otorga al propietario
todos los permisos, al grupo todos los permisos y a todos los demás (otros) solo el permiso
de lectura.
Ahora podemos ver si esos permisos han cambiado ejecutando ls l en el directorio
y mirando la línea hashcat.hcstat . Navegue hasta el directorio y ejecute ese comando
ahora:
kali >ls l
total 32952
drwxrxrx 5 u raíz raíz raíz 4096 5 de diciembre 10:47 conjuntos de caracteres
rwxrwxr 1 raíz 33685504 28 de junio de 2018 hashcat.hcstat
rwrr 1 raíz raíz raíz 33685504 28 de junio de 2018 hashcat.hctune
drwxr xrx 2 raíz 4096 5 de diciembre 10:47 mascarillas
drwxr xrx 2 raíz raíz raíz 4096 5 de diciembre 10:47 OpenCL
drwxr xrx 3 raíz 4096 5 de diciembre 10:47 reglas
Deberías ver rwxrwxr en el lado izquierdo de la línea u de hashcat.hcstat .

Esto confirma que la llamada chmod cambió exitosamente los permisos en el archivo para
darle tanto al propietario como al grupo la capacidad de ejecutar el archivo.
Cambiar permisos con UGO

Aunque el método numérico es probablemente el método más común para cambiar
permisos en Linux, algunas personas encuentran el método simbólico de chmod más
intuitivo; ambos métodos funcionan igual de bien, así que busque el que más le convenga.
El método simbólico a menudo se denomina sintaxis UGO , que significa usuario (o
propietario), grupo y otros.
La sintaxis de UGO es muy simple. Ingrese el comando chmod y luego los usuarios
para los que desea cambiar los permisos, proporcionando u para usuario, g para grupo u o
para otros, seguido de uno de tres operadores:
Elimina un permiso
+ Agrega un permiso
= Establece un permiso
Después del operador, incluya el permiso que desea agregar o eliminar (rwx) y,
finalmente, el nombre del archivo al que aplicarlo.
54 Capítulo 5
¡GUAU! Libro
Entonces, si desea eliminar el permiso de escritura del usuario que

pertenece el archivo hashcat.hcstat , puede ingresar lo siguiente:
kali >chmod uw hashcat.hcstat
Este comando dice que se elimine () el permiso de escritura (w) de hashcat
.hcstat para el usuario (u).
Ahora, cuando verifiques los permisos con ls –l nuevamente, deberías ver
que el archivo hashcat.hcstat ya no tiene permiso de escritura para el usuario:
kali >ls l
total 32952
drwxrxrx 5 raíz raíz raíz 4096 5 de diciembre 10:47
rxrxr 1 raíz 33685504 28 de junio de 2018 hashcat.hcstat
rwrr 1 raíz raíz raíz 33685504 28 de junio de 2018 hashcat.hctune
drwxr xrx 2 raíz 4096 5 de diciembre 10:47 mascarillas
drwxr xrx 2 raíz raíz raíz 4096 5 de diciembre 10:47 OpenCL
drwxr xrx 3 raíz 4096 5 de diciembre 10:47 reglas
También puedes cambiar varios permisos con un solo comando. Si desea otorgar
permiso de ejecución tanto al usuario como a otros usuarios (sin incluir el grupo), puede
ingresar lo siguiente:
chmod u+x, o+x hashcat.hcstat
Este comando le dice a Linux que agregue el permiso de ejecución para el usuario.
así como el permiso de ejecución para otros para el archivo hashcat.hcstat .
Otorgar permiso de ejecución a Root en una nueva herramienta
Como hacker, a menudo necesitarás descargar nuevas herramientas de hacking, pero

Linux asigna automáticamente a todos los archivos y directorios permisos predeterminados
de 666 y 777, respectivamente. Esto significa que, de forma predeterminada, no podrá
ejecutar un archivo inmediatamente después de descargarlo. Si lo intentas, normalmente
recibirás un mensaje que dice algo como "Permiso denegado". Para estos casos,
necesitará otorgarse permisos de root y de ejecución usando chmod para poder ejecutar
el archivo.
Por ejemplo, digamos que descargamos una nueva herramienta de piratería llamada newhackertool.
y colóquelo en el directorio del usuario raíz (/).
kali >ls l
total 80
drwxrxrx 7 raíz raíz 4096 5 de diciembre 11.17 Escritorio
drwxrxrx 7 root root 4096 5 de diciembre 11.17 Documentos
drwxrxrx 7 root root 4096 5 de diciembre 11.17 Descargas
drwxrxrx 7 raíz raíz 4096 5 de diciembre 11.17 Música
rwrr 1 raíz raíz 1072 5 de diciembre 11.17 newhackertoolu
drwxrxrx 7 root root 4096 5 de diciembre 11.17 Imágenes

¡GUAU! Libro
drwxrxrx 7 raíz raíz 4096 5 de diciembre 11.17 Público

drwxrxrx 7 root root 4096 5 de diciembre 11.17 Plantillas
drwxrxrx 7 raíz raíz 4096 5 de diciembre 11.17 Vídeos
Podemos ver newhackertool en u, junto con el resto de contenidos de la

directorio raíz. Podemos ver que nuestra nueva herramienta hacker no tiene permisos de
ejecución para nadie. Esto hace que sea imposible de usar. Puede parecer extraño que, de
forma predeterminada, Linux no le permita ejecutar un archivo que haya descargado, pero
sobre todo esta configuración hace que su sistema sea más seguro.
Podemos darnos permiso para ejecutar newhackertool ingresando lo siguiente:
kali >chmod 766 nuevahackertool
Ahora, cuando realizamos un listado largo en el directorio, podemos ver que nuestra
nueva herramienta hacker tiene permiso de ejecución para el propietario:
kali >chmod 766 nuevahackertool

kali >ls l
total 80
recorte
drwxrxrx 7 raíz raíz 4096 5 de diciembre 11.17 Música
rwxrwrw 1 raíz raíz 1072 5 de diciembre 11.17 newhackertool
drwxrxrx 7 root root 4096 5 de diciembre 11.17 Imágenes
recorte
Como ahora comprende, esto nos otorga (como propietario) todos los permisos, incluido
el de ejecución, y otorga al grupo y a todos los demás solo permisos de lectura y escritura (4
+ 2 = 6).
Configuración de permisos predeterminados más seguros con máscaras

Como ha visto, Linux asigna automáticamente permisos básicos, normalmente 666 para
archivos y 777 para directorios. Puede cambiar los permisos predeterminados asignados a
archivos y directorios creados por cada usuario con el método umask (o desenmascarar).
El método umask representa los permisos que desea eliminar de los permisos base en un
archivo o directorio para hacerlos
más seguro.
La umask es un número decimal de tres dígitos que corresponde a los tres dígitos de
los permisos, pero el número de la umask se resta del número de permisos para proporcionar
el nuevo estado de los permisos. Esto significa que cuando se crea un nuevo archivo o
directorio, sus permisos se establecen en el valor predeterminado menos el valor en umask,
como se muestra en la Figura 51.

Nuevos archivos Nuevos directorios
666 777 Permisos básicos de Linux

− 022 − 022
máscara
644 755 Permisos resultantes
Figura 51: Cómo un valor de umask de 022 afecta los permisos

en nuevos archivos y directorios
Por ejemplo, si la umask está configurada en 022, se creará un nuevo archivo con el valor predeterminado original.
Los permisos de 666 ahora tendrán los permisos 644, lo que significa que el propietario tiene permisos de
lectura y escritura, y el grupo y todos los demás usuarios solo tienen permiso de lectura.
En Kali, como ocurre con la mayoría de los sistemas Debian, la umask está preconfigurada en 022,
lo que significa que el valor predeterminado de Kali es 644 para archivos y 755 para directorios.
El valor de umask no es universal para todos los usuarios del sistema. Cada usuario puede establecer
un valor de máscara de usuario predeterminado personal para los archivos y directorios en su archivo .profile
personal . Para ver el valor actual cuando inicia sesión como usuario, simplemente ingrese el comando
umask y observe lo que se devuelve. Para cambiar el valor de umask para un usuario, edite el archivo /home/
username/.profile y, por ejemplo, agregue umask 007 para configurarlo de modo que solo el usuario y los
miembros del grupo de usuarios tengan permisos.
Permisos especiales
Además de los tres permisos de propósito general, rwx, Linux tiene tres permisos especiales que son un poco
más complicados. Estos permisos especiales son configurar ID de usuario (o SUID), configurar ID de grupo
(o SGID) y bit fijo. Discutiré cada uno de ellos por separado en las siguientes tres secciones.
Concesión de permisos de root temporales con SUID
Como ya debería saber, un usuario puede ejecutar un archivo sólo si tiene permiso para ejecutar ese archivo
en particular. Si el usuario solo tiene permisos de lectura y/o escritura, no puede ejecutar. Esto puede parecer
sencillo, pero existen excepciones a esta regla.
Es posible que se haya encontrado con un caso en el que un archivo requiere los permisos del usuario
root durante la ejecución para todos los usuarios, incluso aquellos que no son root. Por ejemplo, un archivo que
permite a los usuarios cambiar su contraseña necesitaría acceso al archivo /etc/shadow (el archivo que
contiene las contraseñas de los usuarios en Linux) que requiere privilegios de usuario root para poder ejecutarse.
En tal caso, puede otorgar temporalmente privilegios de propietario para ejecutar el archivo configurando el bit
SUID en el programa.
Básicamente, el bit SUID dice que cualquier usuario puede ejecutar el archivo con los permisos del
propietario, pero esos permisos no se extienden más allá del uso de ese archivo.

¡GUAU! Libro
Para configurar el bit SUID , ingrese un 4 antes de los permisos regulares, de modo
que un archivo con un nuevo permiso resultante de 644 se represente como 4644 cuando el SUID
El bit está configurado.
Establecer el SUID en un archivo no es algo que haría un usuario típico, pero si

Si desea hacerlo, utilizará el comando chmod , como en el nombre de archivo chmod 4644 .
Otorgar permisos de grupo al usuario raíz SGID

SGID también otorga permisos elevados temporales, pero otorga los permisos del grupo del
propietario del archivo, en lugar de los del propietario del archivo. Esto significa que, con un bit
SGID establecido, alguien sin permiso de ejecución puede ejecutar un archivo si el propietario
pertenece al grupo que tiene permiso para ejecutar ese archivo.
El bit SGID funciona ligeramente diferente cuando se aplica a un directorio: cuando el bit se
establece en un directorio, la propiedad de los nuevos archivos creados en ese directorio pasa
al grupo del creador del directorio, en lugar del grupo del creador del archivo.
Esto es muy útil cuando varios usuarios comparten un directorio. Todos los usuarios de ese
grupo pueden ejecutar los archivos, no solo un usuario.
El bit SGID se representa como 2 antes de los permisos regulares, por lo que un nuevo
El archivo con los permisos resultantes 644 se representaría como 2644 cuando el bit
SGID esté configurado. Nuevamente, usaría el comando chmod para esto; por ejemplo,
nombre de archivo chmod 2644 .
El bit pegajoso anticuado

El bit adhesivo es un bit de permiso que puede configurar en un directorio para permitir que
un usuario elimine o cambie el nombre de archivos dentro de ese directorio. Sin embargo, la
parte adhesiva es un legado de los sistemas Unix más antiguos y los sistemas modernos
(como Linux) la ignoran. Como tal, no lo discutiré más aquí, pero deberías estar familiarizado con
el término porque es posible que lo escuches en el mundo Linux.
Permisos especiales, escalada de privilegios y el hacker

Como hacker, estos permisos especiales se pueden utilizar para explotar los sistemas Linux
mediante la escalada de privilegios, mediante la cual un usuario normal obtiene privilegios de
root o administrador de sistemas y los permisos asociados. Con privilegios de root, puedes
hacer cualquier cosa en el sistema.
Una forma de hacerlo es explotar el bit SUID . Un administrador del sistema o
El desarrollador de software puede configurar el bit SUID en un programa para permitirle
acceder a archivos con privilegios de root. Por ejemplo, los scripts que necesitan cambiar
contraseñas a menudo tienen el bit SUID configurado. Usted, el hacker, puede usar ese
permiso para obtener privilegios de root temporales y hacer algo malicioso, como obtener
acceso a las contraseñas en /etc/shadow.
Busquemos archivos con el bit SUID configurado en nuestro sistema Kali para probar
esto. En el Capítulo 1, les presenté el comando de búsqueda . Usaremos su poder para
buscar archivos con el bit SUID configurado.
Como recordará, el comando de búsqueda es potente, pero la sintaxis es un poco más
complicada que la de algunos de los otros comandos de ubicación, como localizar y cuál.
Tómese un momento para revisar la sintaxis de búsqueda en el Capítulo 1, si es necesario.

En este caso, queremos buscar archivos en cualquier parte del sistema de archivos, para el
usuario root u otro administrador de sistemas, con los permisos 4000. Para hacer esto, podemos
usar el siguiente comando de búsqueda :
kali > buscar / usuario raíz perm 4000
Con este comando le pedimos a Kali que comience a buscar en la parte superior del sistema
de archivos con la sintaxis / . Luego busca en todas partes debajo de / archivos que son propiedad
de root, especificados con el usuario root y que tienen el bit de permiso SUID establecido (perm
4000).
Cuando ejecutamos este comando, obtenemos el resultado que se muestra en el Listado 52.
/usr/bin/chsh
/usr/bin/gpasswd
/usr/bin/pkexec
/usr/bin/sudo
/usr/bin/contraseña
/usr/bin/kismet_capture
recorte
Listado 52: Búsqueda de archivos con el bit SUID configurado
El resultado revela numerosos archivos que tienen el bit SUID configurado. Naveguemos
hasta el directorio /usr/bin , donde residen muchos de estos archivos, y luego ejecutemos un listado
largo en ese directorio y desplácese hacia abajo hasta el archivo sudo , como se muestra en el Listado
53.
kali >cd /usr/bin

kali >ls l
recorte
rwxrxrx 1 raíz raíz 176272 rwxrxrx 1 raíz 18 de julio de 2018 stunel4
raíz 26696 17 de marzo de 2018 u rwsrxrx 1 raíz raíz 140944 chupar
5 de julio de sudo
2018 snip
Listado 53: Identificando archivos con el bit SUID configurado
Tenga en cuenta que en u, el primer conjunto de permisos (para el propietario) tiene una s
en lugar de la x. Así es como Linux representa que el bit SUID está configurado. Esto significa que
cualquiera que ejecute el archivo sudo tiene privilegios de usuario root, lo que puede ser un problema
de seguridad para el administrador del sistema y un posible vector de ataque para el hacker. Por
ejemplo, algunas aplicaciones necesitan acceder al directorio /etc/
archivo sombra para completar con éxito sus tareas. Si el atacante puede obtener el control de esa
aplicación, puede utilizar el acceso de esa aplicación a las contraseñas en un sistema Linux.
Linux tiene un sistema de seguridad bien desarrollado que protege archivos y directorios del
acceso no autorizado. El aspirante a hacker debe tener un conocimiento básico de este sistema no
sólo para proteger sus archivos sino también para ejecutar nuevas herramientas y archivos. En
algunos casos, los piratas informáticos pueden aprovechar los permisos SUID y SGID para escalar
privilegios de un usuario normal a un usuario root.

¡GUAU! Libro
Resumen
El uso de permisos por parte de Linux para proteger los archivos y directorios de un usuario
o grupo de otros usuarios en el sistema puede usarse con fines ofensivos y defensivos.
Ahora debería saber cómo administrar estos permisos y cómo explotar los puntos débiles
de este sistema de seguridad, en particular, los bits SUID y SGID .
Ejercicios
Antes de pasar al Capítulo 6, ponga a prueba los conocimientos adquiridos en este capítulo
1. Seleccione un directorio y ejecute un listado largo en él. Tenga en cuenta los permisos sobre
los archivos y directorios.
2. Seleccione un archivo para el que no tenga permiso de ejecución y concédase permisos de

ejecución utilizando el comando chmod . Intente utilizar tanto el método numérico (777)
como el método UGO.
3. Elija otro archivo y cambie su propiedad usando chown.

4. Utilice el comando de búsqueda para buscar todos los archivos con el bit SGID configurado.

Gestión de proceso
6
En un momento dado, un sistema Linux
normalmente tiene cientos, o incluso miles,
de procesos ejecutándose simultáneamente.
Un proceso es simplemente un programa que se
ejecuta y utiliza recursos. Incluye una terminal, un servidor
web, cualquier comando en ejecución, cualquier base
de datos, la interfaz GUI y mucho más. Cualquier buen linux
El administrador, y en particular un hacker, necesita comprender cómo gestionar sus
procesos para optimizar sus sistemas. Por ejemplo, una vez que un pirata informático
toma el control de un sistema objetivo, es posible que desee encontrar y detener un
determinado proceso, como una aplicación antivirus o un firewall. Para hacerlo, el
hacker primero necesitaría saber cómo encontrar el proceso. Es posible que el hacker
también desee configurar un script de escaneo para que se ejecute periódicamente
para encontrar sistemas vulnerables, por lo que también veremos cómo programar dicho script.
En este capítulo, aprenderá a gestionar esos procesos. Primero,
aprenda a ver y encontrar procesos y a descubrir qué procesos utilizan la mayor
cantidad de recursos. Luego, aprenderá a gestionar procesos mediante
¡GUAU! Libro
ejecutarlos en segundo plano, priorizarlos y eliminarlos si es necesario (sin sangre

involucrada). Finalmente, aprenderá a programar procesos para que se ejecuten en días, fechas
y horas específicas.
Visualización de procesos
En la mayoría de los casos, el primer paso en la gestión de procesos es ver qué procesos se
están ejecutando en su sistema. La herramienta principal para ver procesos (y una de las
mejores amigas del administrador de Linux) es el comando ps . Ejecútelo en su línea de comando
para ver qué procesos están activos:
kali >ps
PID TTY TIEMPO CMD
39659 puntos/0 00:00:01 fiesta

39665 puntos/0 00:00:00 p.d.
El kernel de Linux, el núcleo interno del sistema operativo que controla casi todo,
asigna un ID de proceso único (PID) a cada proceso de forma secuencial, a medida que se
crean. Cuando se trabaja con estos procesos en Linux, a menudo es necesario especificar sus
PID, por lo que es mucho más importante anotar el PID del proceso que el nombre del proceso.
Por sí solo, el comando ps no proporciona mucha información. Ejecutar el comando

ps sin ninguna opción enumera los procesos iniciados (que se dice que son invocados) por el
usuario actualmente conectado (en nuestro caso, root) y qué procesos se están ejecutando
en esa terminal. Aquí, simplemente dice que el shell bash está abierto y ejecutándose y que
ejecutamos el comando ps .
Queremos y necesitamos mucha más información que eso, particularmente sobre aquellos
procesos ejecutados por otros usuarios y por el sistema en segundo plano. Sin esta información,
sabemos muy poco de lo que realmente está sucediendo en nuestro sistema.
Al ejecutar el comando ps con las opciones aux se mostrarán todos los procesos que se
ejecutan en el sistema para todos los usuarios, como se muestra en el Listado 61. Tenga en
cuenta que no antepone un guión () a estas opciones y que todo está en minúsculas; Debido
a que Linux distingue entre mayúsculas y minúsculas, el uso de opciones en mayúsculas le
daría resultados significativamente diferentes.
kali > ps aux

USUARIO PID %CPU %MEM ¿VZZ RSS TTY COMANDO DE HORA DE INICIO ESTADÍSTICO
Raíz 1 0,0 0,4 202540 6396? 0 ? 24 de abril 0:46 /sbin/inicio

Raíz 2 0.0 0.0 0 0? S 24 de abril 0:00 [kthreadd]
Raíz 3 0.0 0.0 0 S 24 de abril 0:26 [ksoftirqd/0]
snip
raíz 39706 0,0 0,2 36096 3204 puntos/0 R+ 15:05 0:00 ps auxiliar
Listado 61: Usando las opciones auxiliares para ver los procesos de todos los usuarios
Como puede ver, este comando ahora enumera tantos procesos que probablemente se
ejecuten en la parte inferior de la pantalla. El primer proceso es init, que aparece en la
columna final, y el último proceso es el comando que ejecutamos para mostrar, ps aux.

Muchos de los detalles (PID, %CPU, TIEMPO, COMANDO, etc.) pueden ser diferentes
en su sistema, pero deben tener el mismo formato. Para nuestros propósitos, estas
son las columnas más importantes de este resultado:
USUARIO El usuario que invocó el proceso.

PID El ID del proceso
%CPU El porcentaje de CPU que utiliza este proceso.
%MEM El porcentaje de memoria que utiliza este proceso.
COMANDO El nombre del comando que inició el proceso.
En general, para realizar cualquier acción sobre un proceso, debemos especificar su PID.
Veamos cómo utilizar este identificador a nuestro favor.
Filtrar por nombre de proceso
Cuando consultamos o realizamos una acción sobre procesos, generalmente no queremos que
todos los procesos se muestren en la pantalla. Es simplemente un problema de demasiada
información. La mayoría de las veces queremos encontrar información sobre un solo
proceso. Para hacerlo, podemos usar el comando de filtrado grep, que presenté en el
Capítulo 1.
Para demostrarlo, usaremos el marco de explotación Metasploit, el marco de
explotación más utilizado y el buen amigo de casi todos los piratas informáticos. Esto viene
instalado en su sistema Kali, así que inicie Metasploit con lo siguiente:
kali > msfconsole
Una vez iniciado el framework de explotación, veamos si podemos encontrarlo en la

lista de procesos. Para hacerlo, use el comando ps aux y luego canalícelo (|) para buscar la
cadena msfconsole, como en el Listado 62.
kali >ps auxiliar | grep msfconsole

raíz 39756 0.0 0.0 4304 716 pts/2 Ss+ 15:13 0:00 sh c servicio postgresql
inicio && msfdb init & msfconsole
raíz 39759 35.1 15.2 4304 227888 pts/2 Sl+ 15:13 1:36 rubí /usr/bin/
msfconsola
raíz 39892 0,0 0,0 4304 940 pts/2 S+ 15:18 0:00 grep msfconsole
Listado 62: Filtrar una búsqueda ps para encontrar un proceso en particular
De la salida filtrada en este listado, deberías ver todos los procesos.

que coinciden con el término msfconsole. Primero se muestra la base de datos PostgreSQL,
que es la base de datos que utiliza Metasploit, luego el programa msfconsole en sí desde /
usr/bin/msfconsole. Finalmente, debería ver el comando grep que utilizó para buscar msfconsole.
Observe que el resultado no incluyó la lista de encabezados de columna de ps. Dado que
la palabra clave msfconsole no está en el encabezado, no se muestra. Aun así, los resultados
se muestran en el mismo formato.
A partir de esto, puede obtener información importante. Si por ejemplo necesitas saber
cuántos recursos está utilizando Metasploit, puedes consultar
¡GUAU! Libro Gestión de procesos 63
la tercera columna (la columna de CPU), para ver que está usando el 35,1 por ciento de su CPU,
y consulte la cuarta columna para ver que está usando el 15,2 por ciento de la memoria de su
sistema. Eso es bastante. ¡Es una bestia exigente!
Encontrar los procesos más codiciosos con top
Cuando ingresa el comando ps , los procesos se muestran en el orden en que se iniciaron y, dado
que el kernel asigna PID en el orden en que se iniciaron, lo que ve son procesos ordenados por
número de PID.
En muchos casos, queremos saber qué procesos utilizan más
recursos. Aquí es donde el comando top resulta útil porque muestra los procesos ordenados por
recursos utilizados, comenzando por el más grande.
A diferencia del comando ps , que nos proporciona una instantánea única de los procesos, top
actualiza la lista dinámicamente (de forma predeterminada, cada 10 segundos).
Puede observar y monitorear esos procesos que consumen muchos recursos, como se muestra
en el Listado 63.
kali >arriba
arriba 15:31:17 hasta 2 días, ^;50, 4 usuarios, carga promedio: 0,00, 0,04, 0,09
Tareas: 176 en total, 1 en ejecución, 175 durmiendo, 0 detenido, 0 zombie
%Cpu(s): 1,3 us, 0,7 sy,).) ni, 97,4 id, 0,0 wa, 0,0 hi 0,0 si 0,0
KiB Mem: 1491220 en total, 64848 gratis, 488272 usados, 938100 buff/caché
KiB Swap: 1046524 en total, 1044356 gratis, 2168 usados. 784476 disponible MEM
PID USUARIO PR NI VIRT RES SHR S %CPU %TIEMPO MEM+ DOMINIO

39759 raíz 20 0 893180 247232 11488 S 0,7 16,6 1:47,88 rubí
39859 raíz 20 0 27308 16796 14272 S 0,3 1,2 1:47,88 postgres
39933 raíz 20 0 293936 61500 29108 S 0,7 4,1 1:47,88 Xorg
recorte
Listado 63: Encontrar los procesos más codiciosos con top
Los administradores de sistemas a menudo mantienen la parte superior en ejecución en una terminal para monitorear
uso de los recursos del proceso. Como hacker, es posible que quieras hacer lo mismo,
especialmente si tienes varias tareas ejecutándose en tu sistema. Mientras tienes la parte
superior en ejecución, presiona H o ? Aparecerá una lista de comandos interactivos y al presionar
Q saldrá de la parte superior. Pronto volverá a utilizar top para administrar sus procesos en
“Cambiar la prioridad de los procesos con nice” en la página 65 y “Eliminar procesos” en la
página 66.
Gestión de procesos
Los piratas informáticos a menudo necesitan realizar multiprocesamiento y un sistema operativo
como Kali es ideal para ello. El pirata informático puede tener un escáner de puertos ejecutándose
mientras ejecuta un escáner de vulnerabilidades y un exploit simultáneamente. Esto requiere que
el pirata informático administre estos procesos de manera eficiente para utilizar mejor los recursos
del sistema y completar la tarea. En esta sección, le mostraré cómo administrar múltiples procesos.

Cambiar la prioridad del proceso con nice
No es frecuente escuchar la palabra agradable en el contexto de los piratas informáticos, pero

aquí sí la escucharás. El comando nice se utiliza para influir en la prioridad de un proceso para
el núcleo. Como vio cuando ejecutamos el comando ps , numerosos procesos se ejecutan
en el sistema a la vez y todos compiten por los recursos disponibles. El kernel tendrá la última
palabra sobre la prioridad de un proceso, pero puedes usar nice para sugerir que un proceso
debe tener mayor prioridad.
La idea detrás del uso del término agradable es que, cuando lo utilizas, estás
determinando qué tan "amable" serás con otros usuarios: si tu proceso utiliza la mayoría de los
recursos del sistema, no estás siendo muy amable. lindo.
Los valores de nice varían de −20 a +19, siendo cero el valor predeterminado (consulte
la Figura 61). Un valor agradable alto se traduce en una prioridad baja, y un valor agradable
bajo se traduce en una prioridad alta (cuando no estás siendo tan amable con otros
usuarios y procesos). Cuando se inicia un proceso, hereda el agradable
valor de su proceso padre. El propietario del proceso puede reducir la prioridad del proceso
pero no puede aumentarla. Por supuesto, el superusuario o el usuario root pueden establecer
arbitrariamente el valor agradable como quieran.
−20 0 +19
Más probable Por defecto Es menos probable que
recibir prioridad buen valor recibir prioridad
Figura 61: Valores de prioridad de amabilidad
Cuando inicias un proceso, puedes establecer el nivel de prioridad con el agradable

comando y luego modifique la prioridad después de que el proceso haya comenzado a
ejecutarse con el comando renice . La sintaxis de estos dos comandos es ligeramente
diferente y puede resultar confusa. El comando nice requiere que incremente el valor nice,
mientras que el comando renice quiere un valor absoluto para la amabilidad. Veamos un
ejemplo para demostrarlo.
Establecer la prioridad al iniciar un proceso
Para fines de demostración, supongamos que tenemos un proceso llamado

slowprocess que se encuentra en /bin/slowprocess. Si quisiéramos acelerar su
finalización podríamos iniciar el proceso con el comando nice :
kali >nice n 10 /bin/proceso lento
Este comando incrementaría el valor nice en 10, aumentando su prioridad y

asignándole más recursos.
Por otro lado, si queremos ser amables con nuestros compañeros usuarios y procesos
y darle una prioridad más baja al proceso lento , podríamos incrementar su valor agradable
positivamente en 10:
kali >nice n 10 /bin/proceso lento
¡GUAU! Libro Gestión de Procesos 65
Pruebe esto en un proceso que esté ejecutando actualmente y luego ejecute ps

para ver cómo cambia, si es que cambia.
Cambiar la prioridad de un proceso en ejecución con renice
El comando renice toma valores absolutos entre –20 y 19 y establece la prioridad en ese nivel
particular, en lugar de aumentar o disminuir desde el nivel en el que comenzó. Además, Renice
requiere el PID del proceso al que se dirige en lugar del nombre. Entonces, si el proceso lento está
usando una cantidad excesiva de recursos en su sistema y desea darle una prioridad más baja,
permitiendo así que otros procesos tengan una prioridad más alta y más recursos, puede cambiar el
proceso lento (que tiene un PID de 6996) y darle es un valor agradable mucho más alto , así:
kali >renice 20 6996
Al igual que con nice, solo el usuario root puede cambiar un proceso a un valor negativo para
darle mayor prioridad, pero cualquier usuario puede ser amable y reducir la prioridad con renice.
También puede utilizar la utilidad superior para cambiar el valor agradable . con la cima
utilidad en ejecución, simplemente presione la tecla R y luego proporcione el PID y el bonito
valor. El Listado 64 muestra la utilidad superior ejecutándose. Cuando presiono la tecla R y proporciono
el PID y el valor agradable , obtengo el siguiente resultado:
arriba 21:36:56 hasta 21:41, 2 usuarios, carga promedio: 0,60, 0,22, 0,11
Tareas: 128 en total, 1 en ejecución, 127 durmiendo, 0 detenido, 0 zombie
%Cpu(s): 1,5 us, 0,7 sy, 0,0 ni, 96,7 id, 1,1 wa, 0,0 hi, 0,0 si, 0,0 st
KiB Mem: 511864 en total, 500780 usados, 11084 libres, 152308 buffers
Intercambio de KiB: 901116 en total, 14444 usados, 886672 gratuitos, 171376 en caché
u PID para Renice
|
PID USUARIO PR NI VIRT RES SHR S %CPU %MEM TIEMPO DOMINIO
5451 raíz 20 0 1577m 19m 14m S 5.3 3.9 42:46.26 0LLYDBG.EXE
2766 raíz 20 0 55800 20m 5480 S 2,6 4,0 1:01,42 Xorg
5456 raíz 20 0 6356 4272 1780 S 1.3 0.8 13:21.69 servidor de vino
7 raíz 20 0 0 0 0 S 0.3 0.0 0:30.12 rcu_sched
5762 raíz 20 0 174m 20m 17m S 0.3 4.1 0:04.74 gnometerminal
Listado 64: Cambiando un valor agradable cuando top está en uso
Cuando presiono la tecla R, me pide el PID u con el texto renice

PID [valor] a valor. El resultado debería entonces cambiar para reflejar las nuevas prioridades.
Procesos de matanza
En ocasiones, un proceso consumirá demasiados recursos del sistema, mostrará un comportamiento

inusual o, en el peor de los casos, se congelará. Un proceso que exhibe este tipo de comportamiento a
menudo se denomina proceso zombie. Para usted, probablemente el síntoma más problemático será
el desperdicio de recursos utilizados por el zombi que podrían asignarse mejor a procesos útiles.

Cuando identifique un proceso problemático, es posible que desee detenerlo con el

comando kill . Hay muchas formas diferentes de finalizar un programa y cada una tiene
su propio número de finalización.
El comando matar tiene 64 señales de matar diferentes, y cada una hace algo
ligeramente diferente. Aquí, nos centramos en algunos que probablemente le resulten
más útiles. La sintaxis del comando Kill es KillSignal PID, donde el interruptor de señal es
opcional. Si no proporciona un indicador de señal, el valor predeterminado es SIGTERM.
La Tabla 61 enumera las señales de muerte comunes.
Tabla 61: Señales de muerte comúnmente utilizadas
Nombre de señal Número de Descripción

opción
Suspiro 1 Esto se conoce como señal de colgar (HUP) . Detiene el proceso

designado y lo reinicia con el mismo PID.
FIRMA 2 Esta es la señal de interrupción (INT) . Es una señal de muerte débil que no
se garantiza que funcione, pero funciona en la mayoría de los casos.
SIGQUITAR 3 Esto se conoce como volcado de memoria. Finaliza el proceso y

guarda la información del proceso en la memoria, y luego guarda esta
información en el directorio de trabajo actual en un archivo llamado
core. (Las razones para hacer esto están fuera del alcance de este
libro).
SIGNO 15 Esta es la señal de Terminación (TERM) . Es la señal de muerte
predeterminada del comando de matar .
SIGKILL 9 Esta es la señal de muerte absoluta. Obliga al proceso a
detenerse enviando los recursos del proceso a un dispositivo
especial, /dev/null.
Con el comando superior , puede identificar qué procesos están utilizando demasiados
recursos; A menudo, esos procesos serán legítimos, pero puede haber procesos
maliciosos que consumen recursos y usted querrá eliminarlos.
Si solo desea reiniciar un proceso con la señal HUP, ingrese 1
opción con matar, así:
kali > matar 1 6996
En el caso de un zombie o un proceso malicioso, es probable que desees enviar la

señal kill 9 , la señal de muerte absoluta, al proceso. Esto garantiza que el proceso
finalice.
kali > matar 9 6996
Si no conoce el PID de un proceso, puede usar el comando killall para finalizar el

proceso. Este comando toma el nombre del proceso, en lugar del PID, como argumento.
Gestión de procesos 67
¡GUAU! Libro
Por ejemplo, podrías terminar un proceso zombie hipotético como este:
kali >killall 9 proceso zombie
Finalmente, también puedes finalizar un proceso en el comando superior . Simplemente

presione la tecla K y luego ingrese el PID del proceso infractor.
Ejecución de procesos en segundo plano
En Linux, ya sea que esté trabajando desde la línea de comandos o la GUI, está
trabajando dentro de un shell. Todos los comandos que se ejecutan se ejecutan desde ese
shell, incluso si se ejecutan desde la interfaz gráfica. Cuando ejecuta un comando, el shell
espera hasta que se complete el comando antes de ofrecer otro símbolo del sistema.
En ocasiones, es posible que desees que un proceso se ejecute en segundo plano, en

lugar de tener que esperar a que se complete en esa terminal. Por ejemplo, digamos que
queremos trabajar en un script en un editor de texto y por eso hemos llamado a nuestro
editor de texto (leaf pad) ingresando lo siguiente:
kali >newscript de hoja de hoja
En este caso, el shell bash abrirá el editor de texto leafpad para crear un nuevo script.
Mientras trabajamos en el editor de texto, la terminal se ocupa ejecutando el editor de texto.
Si regresamos a la terminal, deberíamos ver que está ejecutando nuestro editor de texto y
que no tenemos ningún mensaje nuevo que nos permita ingresar más comandos.
Por supuesto, podríamos abrir otra terminal para ejecutar más comandos, pero una
mejor opción para ahorrar recursos y espacio en la pantalla es iniciar el editor de texto
ejecutándose en segundo plano. Ejecutar un proceso en segundo plano simplemente
significa que continuará ejecutándose sin necesidad del terminal. De esta forma, el terminal
queda libre para otras tareas.
Para iniciar el editor de texto en segundo plano, simplemente agregue un signo (&) al
final del comando, así:
kali >newscript de hoja de hoja &
Ahora, cuando se abre el editor de texto, la terminal devuelve un nuevo símbolo del
sistema para que podamos ingresar otros comandos en nuestro sistema mientras editamos
nuestro nuevo script. Esto es efectivo para cualquier proceso que pueda ejecutarse durante un
período de tiempo significativo cuando desee utilizar el terminal. Como hacker, esto le resultará
útil para ejecutar múltiples terminales con múltiples tareas, para ahorrar recursos y espacio en
la pantalla.
Mover un proceso al primer plano
Si desea mover un proceso que se ejecuta en segundo plano al primer plano, puede
utilizar el comando fg (primer plano). El comando fg requiere el PID del proceso que desea
volver al primer plano, como se muestra a continuación.

kali >fg 1234
Si no conoce el PID, puede usar el comando ps para encontrarlo.
Procesos de programación
Tanto los administradores de sistemas Linux como los piratas informáticos a menudo necesitan
programar procesos para que se ejecuten a una hora determinada del día. Un administrador del
sistema podría querer programar una copia de seguridad del sistema para que se ejecute todos los
sábados por la noche a las 2 a.m., por ejemplo. Un pirata informático podría querer configurar un
script para que se ejecute y realice reconocimientos de forma regular, encontrando puertos abiertos
o vulnerabilidades. En Linux, puedes lograr esto al menos de dos maneras: con at y crond.
El comando at es un demonio (un proceso en segundo plano) útil para programar un trabajo para
que se ejecute una vez en algún momento en el futuro. El crond es más adecuado para programar
tareas para que se realicen todos los días, semanas o meses, y cubriremos esto en detalle en el
Capítulo 16.
Usamos el demonio at para programar la ejecución de un comando o conjunto de comandos en
el futuro. La sintaxis es simplemente el comando at seguido de la hora para ejecutar el proceso. El

argumento de tiempo se puede proporcionar en varios formatos. La Tabla 62 contiene los formatos
de hora más comunes .
Tabla 62: Formatos de hora aceptados por el comando at
Formato de tiempo Significado
a las 19:20 Programado para ejecutarse a las 7:20 pm del día actual.
a las 19:20 horas del 25 de junio Programado para ejecutarse a las 7:20 pm el 25 de junio
al mediodía Programado para ejecutarse al mediodía del día actual.
al mediodía del 25 de junio Programado para ejecutarse al mediodía del 25 de junio.
mañana Programado para ejecutarse mañana
en este momento + 20 minutos Programado para ejecutarse en 20 minutos a partir de la hora actual.
en este momento + 10 horas Programado para ejecutarse en 10 horas a partir de la hora actual.
en este momento + 5 días Programado para ejecutarse en cinco días a partir de la fecha actual.
en este momento + 3 semanas Programado para ejecutarse en tres semanas a partir de la fecha actual.
a las 19:20 25/06/2019 Programado para ejecutarse a las 7:20 p.m. el 25 de junio de 2019
Cuando ingresa al demonio at con la hora especificada, entra en modo interactivo y recibe
un mensaje at> . Aquí es donde ingresa el comando que desea ejecutar en el momento especificado:
kali >a las 7:20am
en >/root/myscanningscript
Este fragmento de código programará myscanningscript para que se ejecute hoy a las 7:20
a. m.
¡GUAU! Libro Gestión de procesos 69
Resumen
Gestionar procesos en Linux es una habilidad clave para todo usuario y hacker de Linux.
Debe poder ver, buscar, eliminar, priorizar y programar procesos para administrar su
instancia de Linux de manera óptima. Un pirata informático a menudo necesitará
encontrar procesos en el objetivo que desea eliminar, como el software antivirus o un
firewall. También necesitarán gestionar múltiples procesos en un ataque y priorizarlos.
Ejercicios
1. Ejecute el comando ps con las opciones auxiliares de su sistema y observe qué proceso es
el primero y cuál el último.
2. Ejecute el comando superior y observe los dos procesos que utilizan la mayor cantidad
de recursos.
3. Utilice el comando kill para finalizar el proceso que utiliza la mayor cantidad de recursos.
4. Utilice el comando renice para reducir la prioridad de un proceso en ejecución.

a +19.
5. Cree un script llamado myscanning (el contenido no es importante) con un editor de texto y
luego prográmelo para que se ejecute el próximo miércoles a la 1 am.

Gestión de usuarios
7
Variables de entorno
Para aprovechar al máximo su sistema de

piratería Linux, necesita comprender las
variables del entorno y ser experto en
gestionarlas para obtener un rendimiento óptimo,
comodidad e incluso sigilo. Sin embargo, entre las áreas
que los recién llegados a Linux encuentran problemáticas, la
gestión de las variables de entorno del usuario puede ser la
más difícil de dominar. Técnicamente, existen dos tipos de variables: she
Las variables de entorno son variables de todo el sistema integradas en su sistema y
su interfaz que controlan la forma en que su sistema se ve, actúa y "siente" para el
usuario, y son heredadas por cualquier shell o proceso secundario. Las variables de
Shell, por otro lado, generalmente se enumeran en minúsculas y solo son válidas en el
shell en el que están configuradas. Para evitar explicaciones excesivas, en este capítulo
solo cubro algunas de las habilidades más básicas y útiles para las variables de entorno
y de shell. y no profundices demasiado en las diferencias entre ellos.
¡GUAU! Libro
Las variables son simplemente cadenas en pares clavevalor. Generalmente, cada

par tendrá el aspecto CLAVE=valor. En los casos en que haya varios valores, se verán
como CLAVE=valor1:valor2. Como ocurre con la mayoría de las cosas en Linux, si hay
espacios en el valor, debe estar entre comillas. En Kali Linux, su entorno es su shell bash.
Cada usuario, incluido el root, tiene un conjunto predeterminado de variables de entorno
que determinan cómo se ve, actúa y se siente el sistema.
Puede cambiar los valores de estas variables para que su sistema funcione de manera
más eficiente, adaptar su entorno de trabajo para satisfacer mejor sus necesidades
individuales y, potencialmente, cubrir sus pistas si es necesario.
Ver y modificar variables de entorno

Puede ver todas sus variables de entorno predeterminadas ingresando env en su
terminal desde cualquier directorio, así:
kali >env
XDG_VTNR=7
SSHAGENT_PID=922
XDG_SESSION_ID=2
XDG_GREETER_DATA_DIR=/var/lib/lightdm/data/root
GLADE_PIXMAP_PATH=:eco
TÉRMINO=xtérmino
SHELL=/bin/bash
recorte
USUARIO=raíz
recorte
RUTA=/usr/local/sbin :usr/local/bin:/usr/sbin:/sbin/bin
recorte
INICIO=/raíz
recorte
Las variables de entorno siempre están en mayúsculas, como en INICIO, RUTA, SHELL, etc. Estas son
sólo las variables de entorno predeterminadas que vienen en su sistema. Un usuario también puede crear sus
propias variables y, como verá, necesitamos un comando diferente para incluirlas en la salida.
Ver todas las variables de entorno

Para ver todas las variables de entorno, incluidas las variables de shell, las variables
locales y las funciones de shell, como las variables definidas por el usuario y los alias de
comandos, utilice el comando set . Este comando enumerará todas las variables de
entorno exclusivas de su sistema, lo que en la mayoría de los casos le dará un resultado
durante tanto tiempo que no podrá verlo todo en una sola pantalla. Puede solicitar ver
cada variable, línea por línea, de una manera más accesible usando set y canalizándola
al comando more , de la siguiente manera:
kali >conjunto | más

BASH=/bin/bash
BASHOPTS=checkwinsize:cmdlist:complete_fullquote:expand_aliases:extglob.....

BASH_ALIASES=()
BASH_ARGC=()
BASH_ARGV=()
recorte
Ahora la lista de variables ocupará una pantalla, línea por línea, y luego se detendrá.
Cuando presiona Intro, el terminal avanza a la siguiente línea, llevándolo a la siguiente variable,
para que pueda desplazarse presionando o manteniendo presionado Intro.
Como recordará del Capítulo 2, siempre que utilice el comando more para la salida, puede
ingresar q para salir (o salir) y regresar al símbolo del sistema.
Filtrado por variables particulares
Aunque usar set con more da resultados más manejables que revisar la gran cantidad de
nombres de variables que obtienes solo con set , aún puede ser bastante tedioso si estás
buscando una variable en particular. En su lugar, puede utilizar el comando de filtrado grep para
encontrar la variable de interés.
Usemos la variable HISTSIZE como ejemplo. Esta variable contiene la cantidad
máxima de comandos que almacenará su archivo de historial de comandos.
Estos comandos son los que haya escrito previamente en el símbolo del sistema en esta sesión
y se pueden recuperar con las teclas de flecha hacia arriba y hacia abajo. Tenga en cuenta
que HISTSIZE no almacena los comandos en sí, solo el número de ellos que se pueden
almacenar.
Canalice la salida de su conjunto con grep para encontrar la variable HISTSIZE , así:
kali >conjunto | grep HISTSIZE

TAMAÑOHIST=1000
Como puede ver, este comando encuentra la variable HISTSIZE y muestra su valor. El
valor predeterminado de esta variable probablemente esté establecido en 1000 en su sistema.
Esto indica que la terminal almacenará sus últimos 1000 comandos de forma predeterminada.
Cambiar valores de variables para una sesión
Ahora veamos cómo cambiar el valor de una variable. Como se señaló, la variable HISTSIZE
contiene el valor de la cantidad de comandos para almacenar en el archivo de historial.
A veces, no querrá que su sistema guarde comandos anteriores, tal vez porque no quiere dejar ninguna
evidencia de su actividad en su propio sistema o en un sistema de destino. En ese caso, puede establecer
la variable HISTSIZE en 0
por lo que el sistema no almacenará ninguno de sus comandos anteriores. Debido a que esta
variable tiene un valor único, para cambiarla, le asigna un nuevo valor en la forma familiar que
se muestra en el Listado 71.
Kali >HISTSIZE=0
Listado 71: Cambiando el valor de HISTSIZE

¡GUAU! Libro
Ahora, cuando intenta utilizar las teclas de flecha hacia arriba y hacia abajo para
recuperar sus comandos, no sucede nada porque el sistema ya no los almacena.
Esto es sigiloso, aunque puede resultar inconveniente.
Hacer permanentes los cambios de valores de variables
Cuando cambia una variable de entorno, ese cambio sólo ocurre en ese entorno en particular;
en este caso, ese entorno es la sesión de bash shell. Esto significa que cuando cierra la
terminal, todos los cambios realizados se pierden y los valores se restablecen a sus
valores predeterminados. Si desea que los cambios sean permanentes, debe utilizar el
comando exportar . Este comando exportará el nuevo valor de su entorno actual (el shell
bash) al resto del sistema, haciéndolo disponible en todos los entornos hasta que lo cambie
y lo exporte nuevamente.
Las variables son cadenas, por lo que si ejecuta con cautela, no es mala idea
guardar el contenido de una variable en un archivo de texto antes de modificarla. Por
ejemplo, dado que estamos a punto de cambiar la variable PS1 , que controla la
información que muestra en el mensaje, primero ejecute el siguiente comando para guardar
los valores existentes en un archivo de texto en el directorio de inicio del usuario actual:
kali >echo $HISTSIZE> ~/valueofHISTSIZE.txt
De esta manera, siempre podrás deshacer los cambios. Si desea ser aún más
cauteloso y crear un archivo de texto con todas las configuraciones actuales, puede
guardar el resultado del comando set en un archivo de texto con un comando como
este:
kali >establecer> ~/valueofALLon01012017.txt
Después de haber cambiado una variable, como lo hicimos en el Listado 71, puede
hacer que el cambio sea permanente ingresando export y luego el nombre de la variable que
cambió, como se muestra aquí:
kali > exportar HISTSIZE
Ahora la variable HISTSIZE seguirá establecida en 0 cuando abandone este entorno

y entre en otro entorno. Si desea restablecer el HISTSIZE
variable a 1000, simplemente ingrese esto:
Kali >HISTSIZE=1000
kali > exportar HISTSIZE
Este fragmento de código establecerá el valor de la variable HISTSIZE en 1000 y

expórtalo a todos tus entornos.

Cambiar el mensaje de Shell

Su indicador de shell, otra variable de entorno, le proporciona información útil, como el
usuario con el que está operando y el directorio en el que está trabajando actualmente. El
indicador de shell predeterminado en Kali toma el siguiente formato:
nombre de usuario@nombre de host:directorio_actual
Si trabaja como usuario root, esto se traduce en el siguiente mensaje

predeterminado:
raíz@kali:directorio_actual
Puede cambiar el nombre en el indicador de shell predeterminado estableciendo el

valor de la variable PS1 . La variable PS1 tiene un conjunto de marcadores de posición
para la información que desea mostrar en el mensaje, incluidos los siguientes:
\u El nombre del usuario actual
\h El nombre del host
\W El nombre base del directorio de trabajo actual.
Esto es muy útil si tiene shells en varios sistemas o si ha iniciado sesión con varias
cuentas. Al establecer diferentes valores \u y \h para diferentes shells o cuentas, puede
saber de un vistazo quién es usted y cuál es su sistema actual.
Divirtámonos un poco y cambiemos el mensaje en tu terminal. Por ejemplo, podría

ingresar lo siguiente:
kali >PS1="Mejor hacker del mundo: #"

El mejor hacker del mundo: #
Ahora, cada vez que utilices este terminal, se te recordará que eres el "Mejor hacker
del mundo". Pero cualquier terminal posterior que abra seguirá teniendo el símbolo del
sistema predeterminado, porque la variable PS1 solo contiene valores para su sesión de
terminal. Recuerde, hasta que exporte una variable, solo es válida para esa sesión. Si
realmente te gusta este nuevo símbolo del sistema y quieres verlo en cada terminal, debes
exportarlo, así:
kali >exportar PS1
Esto hará que el cambio sea permanente en todas las sesiones.

¿Qué tal un poco más de diversión? Supongamos que realmente desea que su terminal
se vea como un indicador cmd de Windows . En este caso, puede cambiar el nombre del
mensaje a C: y mantener \w para que el mensaje muestre su directorio actual, como
se muestra en el Listado 72.

¡GUAU! Libro
kali >exportar PS1='C:\w> '

C:/tmp>
Listado 72: Cambiando el mensaje y mostrando el directorio actual
Hacer que su mensaje muestre su directorio actual puede ser generalmente útil,
particularmente para un principiante, por lo que es algo a considerar cuando cambia su variable
PS1 .
Cambiando tu RUTA
Una de las variables más importantes en su entorno es su variable PATH , que controla en qué
parte de su sistema buscará su shell los comandos que ingrese, como cd, ls y echo. La mayoría de
los comandos se encuentran en el subdirectorio sbin o bin , como /usr/local/sbin o usr/local/bin. Si
el shell bash no encuentra el comando en uno de los directorios de su variable PATH , devolverá
el error comando no encontrado, incluso si ese comando existe en un directorio que no está
en su PATH.
Puede averiguar qué directorios están almacenados en su variable PATH haciendo clic en
usando echo en su contenido, así:
kali >echo $PATH

/usr/local/sbin:usr/local/bin:/usr/sbin:/sbin/bin
Estos son los directorios donde tu terminal buscará cualquier comando. Cuando ingresa ls,
por ejemplo, el sistema sabe que debe buscar en cada uno de estos directorios el comando ls ,
y cuando encuentra ls, el sistema lo ejecuta.
Cada directorio está separado por dos puntos (:), y no olvide agregar el $
símbolo de contenido a RUTA.
Agregar a la variable PATH

Probablemente puedas ver por qué es importante saber qué hay en tu variable PATH: si descargaste
e instalaste una nueva herramienta, digamos newhackingtool,
en el directorio /root/newhackingtool , solo puede usar comandos de esa herramienta cuando esté
en ese directorio porque ese directorio no está en la variable PATH . Cada vez que quisieras usar
esa herramienta, primero tendrías que navegar a /root/newhackingtool, lo cual es un poco
inconveniente si quieres usar la herramienta con frecuencia.
Para poder utilizar esta nueva herramienta desde cualquier directorio, es necesario agregar el
directorio que contiene esta herramienta en su variable PATH .
Para agregar newhackingtool a su variable PATH , ingrese lo siguiente:
kali >RUTA=$RUTA:/root/newhackingtool

Esto asigna la variable PATH original más /root/newhackingtool

directorio a la nueva variable PATH , por lo que la variable contiene todo lo que hacía antes,
más el nuevo directorio de herramientas.
Si examina el contenido de la variable PATH nuevamente, debería ver que este
directorio se agregó al final de PATH, como se muestra aquí:
kali >echo $PATH

/usr/local/sbin:usr/local/bin:/usr/sbin:/sbin/bin:/root/newhackingtool
Ahora puede ejecutar nuevas aplicaciones de hackingtool desde cualquier lugar de

su sistema, en lugar de tener que navegar a su directorio. ¡El shell bash buscará en todos los
directorios enumerados su nueva herramienta!
N ota Agregar a PATH puede ser una técnica útil para los directorios que usa con frecuencia, pero tenga
cuidado de no agregar demasiados directorios a su variable PATH . Debido a que el sistema
tendrá que buscar en todos y cada uno de los directorios de PATH para encontrar comandos,
agregar muchos directorios podría ralentizar su terminal y su piratería.
Cómo no agregar a la variable PATH
Un error común cometido por los nuevos usuarios de Linux es asignar un nuevo directorio,
como /root/newhackingtool, directamente a la variable PATH de esta manera:
kali >PATH=/root/newhackingtool
kali >echo $PATH
/root/nuevaherramientadehacking
Si usa este comando, su variable PATH solo contendrá el /root/

newhackingtool y ya no contiene los directorios binarios del sistema como /bin, /sbin y otros
que contienen comandos críticos. Cuando vaya a utilizar cualquiera de los comandos del
sistema, recibirá el comando de error no encontrado, como se muestra a continuación, a
menos que primero navegue al directorio de archivos binarios del sistema cuando ejecute
el comando:
kali >cd
bash: cd: comando no encontrado
Recuerde que desea agregarla a la variable PATH , no reemplazarla.

Si tiene dudas, guarde el contenido de la variable en algún lugar antes de modificarla.
Crear una variable definida por el usuario

Puede crear sus propias variables personalizadas definidas por el usuario en Linux simplemente
asignando un valor a una nueva variable que usted nombre. Esto puede resultar útil cuando
realiza secuencias de comandos de shell más avanzadas o descubre que utiliza a menudo un
comando largo que se cansa de escribir una y otra vez.

¡GUAU! Libro
La sintaxis es sencilla: ingrese el nombre de su variable, seguido

por el símbolo de asignación (=), y luego el valor a poner en la variable, como se muestra aquí:
kali >MYNEWVARIABLE="El hackeo es la habilidad más valiosa del siglo XXI"
Esto asigna una cadena a la variable MYNEWVARIABLE. Para ver el valor de esa variable,
use el comando echo y el símbolo $ content con el nombre de la variable, como hicimos antes:
kali >echo $MYNEWVARIABLE

El hacking es la habilidad más valiosa del siglo XXI
Al igual que las variables de entorno de nuestro sistema, las variables definidas por el usuario
deben exportarse para persistir en nuevas sesiones.
Si desea eliminar esta nueva variable, o cualquier variable, utilice el comando unset
dominio. Sin embargo, piense siempre antes de eliminar una variable del sistema, porque su sistema
probablemente funcionará de manera muy diferente después.
kali >desarmar MINEWVARIABLE

kali >echo $MYNEWVARIABLE
kali >
Como puede ver, cuando ingresa MYNEWVARIABLE sin establecer, elimina la variable junto
con su valor. Si usa echo en esa misma variable, Linux ahora devolverá una línea en blanco.
Resumen
Es posible que las variables de entorno le parezcan extrañas, pero vale la pena conocerlas. Controlan
cómo se ve, actúa y se siente su entorno de trabajo en Linux. Puede gestionar estas variables
para adaptar su entorno a sus necesidades cambiándolas, exportándolas e incluso creando las
suyas propias.
En algunos casos, pueden resultar útiles para cubrir sus huellas como hacker.

Ejercicios
1. Vea todas sus variables de entorno con el comando más .
2. Utilice el comando echo para ver la variable HOSTNAME .
3. Encuentre un método para cambiar la barra diagonal (/) por una barra invertida (\) en el
ejemplo falso de Microsoft cmd PS1 (consulte el Listado 72).
4. Crea una variable llamada MYNEWVARIABLE y pon tu nombre en ella.
5. Utilice echo para ver el contenido de MYNEWVARIABLE.
6. Exporte MYNEWVARIABLE para que esté disponible en todos los entornos.
7. Utilice el comando echo para ver el contenido de la variable PATH .
8. Agregue su directorio de inicio a la variable PATH para que cualquier binario en su directorio de
inicio pueda usarse en cualquier directorio.
9. Cambie su variable PS1 a "El hacker más grande del mundo:".
¡GUAU! Libro Gestión de variables de entorno de usuario 79
¡GUAU! Libro
Escritura de Bash
8
Cualquier hacker que se precie debe poder
escribir guiones. De hecho, cualquier
administrador de Linux que se precie debe poder
escribir scripts. Los piratas informáticos a menudo necesitan automa
comandos, a veces desde múltiples herramientas, y esto se
hace de manera más eficiente a través de programas cortos que
ellos mismos escriben.
En este capítulo, crearemos algunos scripts de shell bash simples para comenzar con los scripts.
Agregaremos capacidades y características a medida que avancemos y eventualmente crearemos un
script capaz de encontrar posibles objetivos de ataque en un rango de direcciones IP.
Para convertirse en un hacker de élite , también necesita la capacidad de crear secuencias de

comandos en uno de los lenguajes de secuencias de comandos más utilizados, como Ruby (los exploits
de Metasploit están escritos en Ruby), Python (muchas herramientas de piratería son secuencias de
comandos de Python) o Perl (Perl es el mejor lenguaje de scripting para manipulación de texto). En el
Capítulo 17 doy una breve introducción a los scripts de Python.
¡GUAU! Libro
Un curso intensivo en Bash

Un shell es una interfaz entre el usuario y el sistema operativo que le permite manipular
archivos y ejecutar comandos, utilidades, programas y mucho más. La ventaja de un shell
es que usted realiza estas tareas inmediatamente desde la computadora y no a través de
una abstracción, como una GUI, que le permite personalizar su tarea según sus
necesidades. Hay varios shells diferentes disponibles para Linux, incluido el shell Korn,
el shell Z, el shell C y el shell Bourneagain , más conocido como bash.
Debido a que el shell bash está disponible en casi todas las distribuciones de
Linux y UNIX (incluidos macOS y Kali), usaremos el shell bash exclusivamente.
El shell bash puede ejecutar cualquier comando, utilidad o aplicación del sistema que
su línea de comandos habitual pueda ejecutar, pero también incluye algunos de sus propios
comandos integrados. La Tabla 81 más adelante en el capítulo le brinda una referencia
a algunos comandos útiles que residen dentro del shell bash.
En capítulos anteriores, utilizó los comandos cd, pwd, set y umask . En esta
sección, usará dos comandos más: el comando echo , usado por primera vez en el Capítulo
7, que muestra mensajes en la pantalla, y el comando read , que lee datos y los almacena
en otro lugar. Simplemente aprender estos dos comandos le permitirá crear una herramienta
simple pero poderosa.
Necesitará un editor de texto para crear scripts de shell. Puede utilizar el editor de
texto de Linux que más le guste, incluidos vi, vim, emacs, gedit, kate, etc. Usaré Leafpad
en estos tutoriales, como lo hice en capítulos anteriores.
El uso de un editor diferente no debería suponer ninguna diferencia en el script ni en su
funcionalidad.
Su primer guión: "¡Hola, hackers, levántense!"

Para su primer script, comenzaremos con un programa simple que devuelve un
mensaje en la pantalla que dice "¡Hola, HackersArise!" Abre tu editor de texto y
vámonos.
Para comenzar, debe indicarle a su sistema operativo qué intérprete desea utilizar
para el script. Para hacer esto, ingrese un shebang, que es una combinación de un
signo de almohadilla y un signo de exclamación, así:
#!
Luego sigues el shebang (#!) con /bin/bash para indicar que quieres
el sistema operativo para utilizar el intérprete de shell bash. Como verá en capítulos
posteriores, también puede utilizar el shebang para utilizar otros intérpretes, como Perl
o Python. Aquí desea utilizar el intérprete de bash, así que ingrese lo siguiente:
#! /bin/bash

Luego, ingrese el comando echo, que le indica al sistema que simplemente repita
(o eco) de regreso a su monitor lo que siga al comando.
En este caso, queremos que el sistema nos responda "¡Hola, HackersArise!", como se hace en el
Listado 81. Tenga en cuenta que el texto o mensaje que queremos repetir debe estar entre comillas dobles.
#! /bin/bash
# Este es mi primer script bash. Deséame suerte.
echo "¡Hola, hackers, levántate!"
Listado 81: Su mensaje "¡Hola, hackers, levántense!" guion
Aquí también verá una línea precedida por una almohadilla (#). Este es un comentario, que es una
nota que te dejas a ti mismo o a cualquier otra persona que lea el código para explicar lo que estás
haciendo en el script. Los programadores utilizan comentarios en todos los lenguajes de codificación. El
intérprete no lee ni ejecuta estos comentarios, por lo que no necesita preocuparse por estropear su código.
Son visibles sólo para los humanos. El shell bash sabe que una línea es un comentario si comienza con el
carácter #.
Ahora, guarde este archivo como HelloHackersArise sin extensión y salga de su

editor de texto.
Configuración de permisos de ejecución
De forma predeterminada, un script bash recién creado no es ejecutable ni siquiera por usted, el
propietario. Veamos los permisos de nuestro nuevo archivo en la línea de comando usando cd para movernos
al directorio y luego ingresando ls l. Debería verse así:
kali >ls l
recorte
rwrr 1 raíz raíz 42 22 de octubre 14:32 HelloHackersArise
recorte
Como puede ver, nuestro nuevo archivo tiene permisos rwrr (644). Como aprendió en el Capítulo
5, esto significa que el propietario de este archivo sólo tiene permisos de lectura (r) y escritura (w), pero no
permisos de ejecución (x). El grupo y todos los demás usuarios sólo tienen permisos de lectura. Necesitamos
darnos lindos permisos exe para poder ejecutar este script. Cambiamos los permisos con el comando chmod,
como vio en el Capítulo 5. Para otorgar permisos de ejecución al propietario, al grupo y a todos los demás,
ingrese lo siguiente:
kali >chmod 755 HolaHackersArise
Secuencias de comandos Bash 83

¡GUAU! Libro
Ahora, cuando hacemos un listado largo en el archivo, así, podemos ver que
tener permisos de ejecución:
kali >ls l
recorte
rwx rx rx 1 raíz raíz 42 22 de octubre 14:32 HelloHackersArise
recorte
¡El script ya está listo para ejecutarse!
Ejecutando HelloHackersArise
Para ejecutar nuestro script simple, ingrese lo siguiente:
kali >./HelloHackersArise
El ./ antes del nombre del archivo le dice al sistema que queremos ejecutar este script en
el archivo HelloHackersArise del directorio actual. También le dice al sistema que si hay otro
archivo en otro directorio llamado HelloHackersArise, ignórelo y ejecute HelloHackersArise solo
en el directorio actual. Puede parecer poco probable que haya otro archivo con este nombre en su
sistema, pero es una buena práctica utilizar ./ al ejecutar archivos, ya que esto localiza la ejecución
del archivo en el directorio actual y muchos directorios tendrán nombres de archivo duplicados, como
inicio. y configuración.
Cuando presionamos Enter, nuestro script muy simple devuelve nuestro mensaje al monitor:
¡Hola, HackersArise!
¡Éxito! ¡Acabas de completar tu primer script de shell!
Agregar funcionalidad con variables y entrada del usuario
Entonces, ahora tenemos un guión simple. Todo lo que hace es devolver un mensaje a la salida
estándar. Si queremos crear scripts más avanzados, probablemente necesitaremos agregar algunas
variables.
Una variable es un área de almacenamiento que puede contener algo en la memoria.

Ese “algo” podrían ser algunas letras, palabras (cadenas) o números. Se la conoce como variable
porque los valores que contiene son modificables; esta es una característica extremadamente útil para
agregar funcionalidad a un script.
En nuestro próximo script, agregaremos funcionalidad para solicitar al usuario su
nombre, coloque lo que haya ingresado en una variable, luego solicite al usuario el capítulo en el
que se encuentra en este libro y coloque esa entrada del teclado en una variable. Después de
eso, enviaremos un mensaje de bienvenida al usuario que incluye su nombre y el capítulo.
Abra un nuevo archivo en su editor de texto e ingrese el script que se muestra en el

Listado 82.
84 Capítulo 8
¡GUAU! Libro
tú#! /bin/bash
v # Este es su segundo script bash. En este, solicita /

# el usuario para la entrada, coloca la entrada en una variable y /
# mostrar el contenido de la variable en una cadena.
w echo "¿Cuál es tu nombre?"
leer nombre
x echo "¿En qué capítulo estás en Conceptos básicos de Linux para hackers?"
leer capitulo
y echo "Bienvenido" $nombre "al Capítulo" $capítulo "de Conceptos básicos de Linux para hackers!"
Listado 82: Un script simple que utiliza variables
¡Abrimos con #! /bin/bash para decirle al sistema que queremos usar el intérprete bash para este script u.
Luego agregamos un comentario que describe el script y su funcionalidad v. Después de eso, le solicitamos al
usuario su nombre y le pedimos al intérprete que lea la entrada y la coloque en una variable que llamamos
nombre w.
Luego solicitamos al usuario que ingrese el capítulo en el que está trabajando actualmente en este libro, y
nuevamente leemos la entrada del teclado en una variable, esta vez llamada capítulo x.
En la línea final, construimos una línea de salida que da la bienvenida al lector por su nombre al capítulo
en el que se encuentra. Usamos el comando echo y proporcionamos el texto que queremos mostrar en la
pantalla entre comillas dobles. Luego, para completar el nombre y número de capítulo que ingresó el usuario,
agregamos las variables donde deberían aparecer en el mensaje. Como se señaló en el Capítulo 7, para utilizar
los valores contenidos en las variables, debe preceder el nombre de la variable con el símbolo $.
Guarde este archivo como WelcomeScript.sh. La extensión .sh es la convención para archivos de script.
Es posible que hayas notado que no incluimos la extensión antes; no es estrictamente necesario y, si deja la
extensión desactivada, el archivo se guardará como un archivo de script de shell de forma predeterminada.
Ahora, ejecutemos este script. No olvide darse permiso de ejecución con chmod primero; de lo
contrario, el sistema operativo le regañará con un mensaje de Permiso denegado.
kali >./WelcomeScript.sh
¿Cómo te llamas?
Ocupar la Web
¿En qué capítulo estás en Conceptos básicos de Linux para hackers?
8
¡Bienvenido a OccupytheWeb al Capítulo 8 de Conceptos básicos de Linux para hackers!
Como puede ver, su secuencia de comandos tomó información del usuario, la colocó en vari
ables, y luego usó esas entradas para hacer un saludo para el usuario.

¡GUAU! Libro
Este es un script simple, pero le enseñó cómo usar variables y recibir entradas desde el teclado.
Ambos son conceptos cruciales en secuencias de comandos que necesitará utilizar en secuencias de
comandos más complejas en el futuro.
Su primer script de hacker: busque puertos abiertos
Ahora que tiene algunas habilidades básicas de secuencias de comandos, pasemos a algunas
secuencias de comandos un poco más avanzadas que tienen aplicaciones en el mundo real para la
piratería. Usaremos un ejemplo del mundo del black hat hacking. Los hackers de sombrero negro son
aquellos con intenciones maliciosas, como robar números de tarjetas de crédito o desfigurar sitios
web. Los hackers de sombrero blanco son aquellos con buenas intenciones, como ayudar a los
desarrolladores de software o administradores de sistemas a hacer que sus sistemas sean más seguros.
Los hackers de sombrero gris son aquellos que tienden a moverse entre estos dos extremos.
Antes de continuar, debe familiarizarse con una herramienta sencilla pero esencial llamada nmap
que viene instalada en Kali de forma predeterminada. Probablemente hayas escuchado el nombre; nmap
se utiliza para sondear un sistema para ver si está conectado a la red y averiguar qué puertos están
abiertos. A partir de los puertos abiertos descubiertos, puede suponer qué servicios se están ejecutando
en el sistema de destino. Esta es una habilidad crucial para cualquier hacker o administrador de sistemas.
En su forma más simple, la sintaxis para ejecutar un escaneo de nmap se ve así:
nmap <tipo de escaneo><IP de destino><opcionalmente, puerto de destino>
No es muy difícil. El escaneo de nmap más simple y confiable es el escaneo de conexión TCP,
designado con el modificador sT en nmap. Entonces, si quisieras escanear la dirección IP 192.168.181.1
con un escaneo TCP, ingresarías lo siguiente:
mapa n st 192.168.181.1
Para ir un paso más allá, si desea realizar un escaneo TCP de la dirección 192.168.181.1, para ver
si el puerto 3306 (el puerto predeterminado para MySQL) está abierto, puede ingresar esto:
mapa n st 192.168.181.1 p 3306
Aquí, p designa el puerto que desea buscar. Continúe y pruébelo ahora en su sistema Kali.
Nuestra tarea
En el momento de escribir este artículo, hay un hacker que cumple condena en una prisión federal de EE.
UU. con el nombre de Max Butler, también conocido como Max Vision en todo el mundo hacker. Max era
una especie de hacker de sombrero gris. De día era un profesional de seguridad informática en Silicon
Valley y de noche robaba y vendía números de tarjetas de crédito en el mercado negro. Hubo un tiempo
en que dirigió el mercado negro de tarjetas de crédito más grande del mundo, CardersMarket. Ahora, Max
cumple una condena de 13 años de prisión.
86 Capítulo 8
¡GUAU! Libro
y al mismo tiempo ayuda al Equipo de Respuesta a Emergencias Informáticas (CERT) en

Pittsburgh a defenderse contra los piratas informáticos.
Unos años antes de que atraparan a Max, se dio cuenta de que el sistema de punto de venta
(POS) Aloha utilizado por muchos restaurantes pequeños tenía una puerta trasera de soporte
técnico incorporada. En este caso, la puerta trasera permitió que el soporte técnico ayudara a
sus clientes. El soporte técnico de Aloha podría acceder al sistema del usuario final a través del
puerto 5505 para brindar asistencia cuando el usuario pidiera ayuda. Max se dio cuenta de que si
encontraba un sistema conectado a Internet con el sistema POS Aloha, podía acceder al sistema
con privilegios de administrador de sistemas a través del puerto 5505. Max pudo ingresar a
muchos de estos sistemas y robar decenas de miles de números de tarjetas de crédito.
Al final, Max quería encontrar todos los sistemas que tuvieran el puerto 5505 abierto para
poder pasar de robar miles de números de tarjetas de crédito a robar millones. Max decidió
escribir un script que escanearía millones de direcciones IP en busca de sistemas con el puerto
5505 abierto. Por supuesto, la mayoría de los sistemas no tienen el puerto 5505 abierto, por lo
que, si lo tuvieran, es probable que estuvieran ejecutando el condenado Aloha POS. Podría ejecutar
este script mientras estaba en el trabajo durante el día y luego, por la noche, piratear aquellos
sistemas identificados con el puerto 5505 abierto.
Nuestra tarea es escribir un script que será casi idéntico al script de Max, pero en lugar de
buscar el puerto 5505 como lo hizo Max, nuestro script buscará sistemas conectados a la
omnipresente base de datos en línea MySQL. MySQL es una base de datos de código abierto
utilizada detrás de millones de sitios web; Trabajaremos con MySQL en el Capítulo 12. De forma
predeterminada, MySQL usa el puerto 3306. Las bases de datos son el "vellón de oro" que casi todo
hacker de sombrero negro busca, ya que a menudo contienen números de tarjetas de crédito e
información de identificación personal (PII) que Es muy valioso en el mercado negro.
Un escáner sencillo
Antes de escribir el script para escanear IP públicas en Internet, asumamos una tarea mucho más
pequeña. En lugar de escanear el mundo, primero escribamos un script para buscar el puerto 3306
en una red de área local para ver si nuestro script realmente funciona. Si es así, podemos editarlo
fácilmente para realizar una tarea mucho más grande.
En su editor de texto, ingrese el script que se muestra en el Listado 83.
tú#! /bin/bash
v # Este script está diseñado para encontrar hosts con MySQL instalado
nmap wsT 192.168.181.0/24 xp 3306 y>/dev/null zoG MySQLscan
{ gato MySQLscan | grep abierto > MySQLscan2 |
gato MySQLscan2
Listado 83: El script del escáner simplificado
Comenzamos con el shebang y el intérprete para usarte. sigamos esto

con un comentario para explicar qué hace el script v.

¡GUAU! Libro
Ahora usemos el comando nmap para solicitar un escaneo TCP w en nuestra LAN,
buscando el puerto 3306 x. (Tenga en cuenta que sus direcciones IP pueden diferir; en su
terminal, use el comando ifconfig en Linux o el comando ipconfig en Windows para determinar
su dirección IP). Para permanecer sigiloso, también enviamos la salida estándar de nmap
que normalmente aparecería en la pantalla. a un lugar especial en Linux, donde desaparece y.
Estamos haciendo esto en una máquina local, por lo que no importa mucho, pero si usaras el
script de forma remota, querrás ocultar la salida de nmap. Luego enviamos el resultado del
escaneo a un archivo llamado MySQLscan en un formato z compatible con grep, es decir, un
formato en el que grep puede funcionar.
La siguiente línea muestra el archivo MySQLscan en el que almacenamos la salida y

luego canaliza esa salida a grep para filtrar las líneas que incluyen la palabra clave open {.
Luego colocamos esas líneas en un archivo llamado MySQLscan2 |.
Finalmente, muestra el contenido del archivo MySQLscan2. Este archivo final solo debe
incluir líneas de salida de nmap con hosts que tengan el puerto 3306 abierto. Guarde este
archivo como MySQLscanner.sh y concédase permisos de ejecución con chmod 755.
Ejecute el script, así:
Kali >./MySQLscanner.sh
host: 192.168.181.69 () Puertos: 3306/open/tcp//mysql///
Como podemos ver, este script pudo identificar la única dirección IP en mi LAN con
MySQL ejecutándose. Sus resultados pueden diferir, dependiendo de si algún puerto ejecuta
instalaciones de MySQL en su red local, por supuesto.
Mejorando el escáner MySQL
Ahora queremos adaptar este script para que sea aplicable a algo más que su propia red
local. Este script sería mucho más fácil de usar si pudiera solicitarle al usuario el rango de
direcciones IP que desea escanear y el puerto a buscar, y luego usar esa entrada. Recuerde,
aprendió cómo solicitarle al usuario y poner su entrada de teclado en una variable en
“Agregar funcionalidad con variables y entrada de usuario” en la página 84.
Echemos un vistazo a cómo podría utilizar variables para hacer que este script sea más
flexible y eficiente.
Agregar indicaciones y variables a nuestro script de hacker
En su editor de texto, ingrese el script que se muestra en el Listado 84.
#! /bin/bash
"
u echo "Ingrese la dirección IP inicial: v lea FirstIP
"
w echo "Ingrese el último octeto de la última dirección IP:
leer LastOctetIP
88 Capítulo 8
¡GUAU! Libro
"
x echo "Ingrese el número de puerto que desea escanear: leer puerto
y nmap sT $PrimeraIP$LastOctetIP p $puerto >/dev/null oG MySQLscan
z gato MySQLscan | grep abierto > MySQLscan2
{ gato MySQLscan2
Listado 84: Su escáner de puertos MySQL avanzado
Lo primero que debemos hacer es reemplazar la subred especificada con un rango de

direcciones IP. Crearemos una variable llamada FirstIP y una segunda variable llamada LastOctetIP
para crear el rango, así como una variable llamada puerto para el número de puerto (el último octeto
es el último grupo de dígitos después del tercer punto en la dirección IP. En el Dirección IP
192.168.1.101, el último octeto es 101).
NOTA El nombre de la variable es irrelevante, pero la mejor práctica es utilizar un nombre de variable que
le ayuda a recordar lo que contiene la variable.
También debemos solicitar al usuario estos valores. Podemos hacer esto usando el
comando echo que usamos en el Listado 81.
Para obtener un valor para la variable FirstIP, haga eco "Ingrese la dirección IP inicial:
"
en la pantalla, solicitando al usuario la primera dirección IP que desea escanear. Al ver este mensaje
en la pantalla, el usuario ingresará la primera dirección IP dirección, por lo que necesitamos

capturar esa entrada del usuario.
Podemos hacer esto con el comando de lectura seguido del nombre de la variable en la
que queremos almacenar la entrada v. Este comando colocará la dirección IP ingresada por el
usuario en la variable FirstIP. Luego podemos usar ese valor en FirstIP en todo nuestro script.
Haremos lo mismo para las variables LastOctetIP w y puerto x mediante el mensaje

pedirle al usuario que ingrese la información y luego usar un comando de lectura para capturarla.
A continuación, necesitamos editar el comando nmap en nuestro script para usar las
variables que acabamos de crear y completar. Para utilizar el valor almacenado en la variable,
simplemente anteponemos el nombre de la variable con $, como en $port, por ejemplo. Entonces,
en y, escaneamos un rango de direcciones IP, comenzando con la primera IP ingresada por el usuario
hasta la segunda IP ingresada por el usuario, y buscamos el puerto particular ingresado por el usuario.
Hemos utilizado las variables en lugar de la subred para escanear y el puerto para determinar qué
escanear. El símbolo de redirección > le indica a la salida estándar de nmap, que generalmente va
a la pantalla, que vaya a /dev/null (/dev/null
es simplemente un lugar para enviar la salida para que desaparezca). Luego, enviamos el
resultado en un formato compatible con grep a un archivo al que llamamos MySQLscan.
La siguiente línea sigue siendo la misma que en nuestro escáner simple: genera el
contenido del archivo MySQLscan, lo canaliza a grep, donde se filtra por líneas que incluyen la
palabra clave open, y luego envía esa salida a un nuevo archivo llamado MySQLscan2 z. Finalmente,
mostramos el contenido del archivo MySQLscan2 {.
Si todo funciona como se esperaba, este script escaneará las direcciones IP desde la primera
dirección de entrada hasta la última dirección de entrada, buscando el puerto de entrada.

¡GUAU! Libro
y luego informar solo con las direcciones IP que tienen el puerto designado abierto. Guarde su archivo de script
como MySQLscannerAdvanced y recuerde darse permiso de ejecución.
Una ejecución de muestra
Ahora podemos ejecutar nuestro script de escaneo simple con las variables que determinan qué rango de
direcciones IP y puerto escanear sin tener que editar el script cada vez que queramos ejecutar un escaneo:
kali >./MySQLscannerAdvanced.sh
Introduzca la dirección IP inicial:
192.168.181.0
Introduzca la última dirección IP:
192.168.181.255
Ingrese el número de puerto que desea escanear:
3306
Anfitrión: 192.168.181.254 ()Puertos:3306/open/tcp//mysql//
El script solicita al usuario la primera dirección IP, la última dirección IP y luego el puerto que desea
buscar. Después de recopilar esta información, el script realiza el escaneo de nmap y produce un informe de
todas las direcciones IP en el rango que tienen abierto el puerto especificado. Como puede ver, incluso el
script más simple puede crear una herramienta poderosa. Aprenderá aún más sobre la creación de scripts
en el Capítulo 17.
Comandos Bash integrados comunes
Como prometimos, la Tabla 81 le brinda una lista de algunos comandos útiles integrados en bash.
Tabla 81: Comandos Bash integrados
Dominio Función
: Devuelve 0 o verdadero
. Ejecuta un script de shell
bg Pone un trabajo en segundo plano

romper Sale del bucle actual
cd Directorio de cambios
continuar Reanuda el bucle actual
eco Muestra los argumentos del comando.
evaluar
Evalúa la siguiente expresión
ejecutivo
Ejecuta el siguiente comando sin crear un nuevo proceso.
salida sale del caparazón
exportar Hace que una variable o función esté disponible para otros programas.
fg Pone un trabajo en primer plano
90 Capítulo 8
¡GUAU! Libro
Dominio Función
getopts Analiza los argumentos del script de shell.
trabajos Enumera trabajos en segundo plano (bg)
pwd Muestra el directorio actual

leer Lee una línea de la entrada estándar
solo lectura Declara como variable como de solo lectura

colocar Enumera todas las variables
cambio Mueve los parámetros a la izquierda.

prueba
Evalúa argumentos
[ Realiza una prueba condicional
veces Imprime los tiempos del usuario y del sistema.
trampa Atrapa una señal
tipo Muestra cómo se interpretaría cada argumento como un comando.

máscara
Cambia los permisos predeterminados para un archivo nuevo
desarmado Elimina valores de una variable o función.
esperar
Espera a que se complete un proceso en segundo plano
Resumen
La creación de secuencias de comandos es una habilidad esencial para cualquier hacker o administrador de sistemas.
Le permite automatizar tareas que normalmente le llevarían horas de su tiempo y, una vez guardado el script, puede utilizarlo
una y otra vez. La creación de scripts en Bash es la forma más básica de scripting y avanzará al scripting en Python con aún
más capacidades en el Capítulo 17.
Ejercicios
Antes de pasar al Capítulo 9, pruebe las habilidades que aprendió en este capítulo completando los siguientes
ejercicios:
1. Cree su propio script de saludo similar a nuestro script HelloHackersArise.
2. Cree un script similar a MySQLscanner.sh pero diséñelo para buscar sistemas con la base de datos SQL
Server de Microsoft en el puerto 1433. Llámelo MSSQLscanner.
3. Modifique el script MSSQLscanner para solicitar al usuario un inicio y un final.
ing dirección IP y el puerto a buscar. Luego filtre todas las direcciones IP donde esos puertos están
cerrados y muestre solo aquellas que están abiertas.
Secuencias de comandos bash

91
¡GUAU! Libro electrónico
www.wowebook.org
¡GUAU! Libro
9
Comprimir y archivar
Los piratas informáticos a menudo necesitan descargar y
instalar nuevo software, así como enviar y descargar múltiples
scripts y archivos de gran tamaño.

Estas tareas son más fáciles si estos archivos están com
prensados y combinados en una sola lima. Si vienes del mundo Windows,
probablemente reconocerás este concepto por el formato .zip , que combina y comprime
archivos para hacerlos más pequeños y poder transferirlos a través de Internet o a
medios extraíbles.
Hay muchas formas de hacer esto en Linux y en este capítulo analizamos algunas de
las herramientas más comunes para hacerlo. También analizamos el comando dd , que le
permite copiar unidades enteras, incluidos los archivos eliminados en esas unidades.
¿Qué es la compresión?
El interesante tema de la compresión podría llenar un libro entero por sí solo, pero
para este libro sólo necesitamos una comprensión rudimentaria del proceso.
La compresión, como su nombre lo indica, hace que los datos sean más pequeños, por lo que requiere menos
¡GUAU! Libro
capacidad de almacenamiento y facilitando la transmisión de datos. Para sus propósitos como

hacker principiante, será suficiente clasificar la compresión como con pérdida o sin pérdida.
La compresión con pérdida es muy eficaz para reducir el tamaño de los archivos, pero
se pierde la integridad de la información. En otras palabras, el archivo después de la
compresión no es exactamente igual al original. Este tipo de compresión funciona muy bien
para archivos de gráficos, vídeo y audio, donde apenas se nota una pequeña diferencia en
el archivo: mp3, .mp4, .png y .jpg son algoritmos de compresión con pérdida. Si se cambia un
píxel en un archivo .png o una sola nota en un archivo .mp3 , es poco probable que su ojo o
su oído noten la diferencia; aunque, por supuesto, los aficionados a la música dirán que
definitivamente pueden notar la diferencia entre un archivo .png . mp3 y un archivo .flac sin
comprimir. Los puntos fuertes de la compresión con pérdidas son su eficiencia y eficacia. La
relación de compresión es muy alta, lo que significa que el archivo resultante es significativamente
más pequeño que el original.
Sin embargo, la compresión con pérdida es inaceptable cuando se envían archivos o
software y la integridad de los datos es crucial. Por ejemplo, si envía un script o un documento,
se debe conservar la integridad del archivo original cuando se descomprime. Este capítulo se
centra en este tipo de compresión sin pérdidas , que está disponible en varias utilidades y
algoritmos. Desafortunadamente, la compresión sin pérdidas no es tan eficiente como la
compresión con pérdidas, como se podría imaginar, pero para el hacker, la integridad suele
ser mucho más importante que el índice de compresión.
Tarrar archivos juntos

Normalmente, lo primero que se hace al comprimir archivos es combinarlos en un archivo. En la
mayoría de los casos, al archivar archivos, utilizará el comando tar .
Tar significa archivo en cinta, una referencia a los días prehistóricos de la informática, cuando
los sistemas utilizaban cintas para almacenar datos. El comando tar crea un único archivo a
partir de muchos archivos, que luego se denomina archivo comprimido, archivo tar o tarball.
Por ejemplo, digamos que tiene tres archivos de script como los que usamos en el
Capítulo 8, llamados hackersarise1, hackersarise2 y hackersarise3. Si navega hasta el
directorio que los contiene y realiza una lista larga, podrá ver claramente los archivos y los
detalles que esperaría, incluido el tamaño de los archivos, como se muestra aquí:
kali >ls l
rwxrxrx 1 raíz raíz 22311 27 de noviembre de 2018 13:00 hackersarise1.sh
rwxrxrx 1 raíz raíz rwxr 8791 27 de noviembre de 2018 13:00 hackersarise2.sh
xrx 1 raíz raíz 3992 27 de noviembre de 2018 13:00 hackersarise3.sh
Supongamos que desea enviar estos tres archivos a otro hacker con el que está trabajando
en un proyecto. Puede combinarlos y crear un único archivo usando el comando del Listado 91.
kali >tar cvf HackersArise.tar hackersarise1 hackersarise2 hackersarise3

hackersarise1

hackersarise2
hackersarise3
Listado 91: Creando un tarball de tres archivos
Analicemos este comando para comprenderlo mejor. el archivo

El comando es tar y lo estamos usando aquí con tres opciones. La opción c significa crear, v (que
significa detallado y es opcional) enumera los archivos con los que trata tar y f significa escribir en el
siguiente archivo. Esta última opción también funcionará para leer archivos. Luego le damos al nuevo
archivo el nombre de archivo que desea crear a partir de los tres scripts: HackersArise.tar.
En su totalidad, este comando tomará los tres archivos y creará un solo archivo,
HackersArise.tar, a partir de ellos. Cuando hagas otra lista larga del directorio, verás que también
contiene el nuevo archivo .tar , como se muestra a continuación:
kali >ls l
recorte
rwrr 1 raíz raíz 40960 27 de noviembre de 2018 13:32 HackersArise.tar
recorte
kali >
Tenga en cuenta el tamaño del tarball aquí: 40.960 bytes. Cuando se archivan los tres archivos,
tar utiliza una sobrecarga significativa para realizar esta operación: mientras que la suma de los tres
archivos antes del archivado era de 35.094 bytes, después del archivado, el tarball había crecido a
40.960 bytes. En otras palabras, el proceso de archivado ha añadido más de 5.000 bytes. Aunque
esta sobrecarga puede ser significativa con archivos pequeños, se vuelve cada vez menos significativa
con archivos cada vez más grandes.
Podemos mostrar esos archivos desde el tarball, sin extraerlos, al
usando el comando tar con el modificador t content list, como se muestra a continuación:
kali >tar tvf HackersArise.tar

rwxrxrx 1 raíz raíz 22311 27 de noviembre de 2018 13:00 hackersarise1.sh
rwxrxrx 1 raíz raíz rwxrxr 8791 27 de noviembre de 2018 13:00 hackersarise2.sh
x 1 raíz raíz 3992 27 de noviembre de 2018 13:00 hackersarise3.sh
Aquí vemos nuestros tres archivos originales y sus tamaños originales. Luego puede extraer
esos archivos del tarball usando el comando tar con x
(extraer), como se muestra a continuación:
kali >tar xvf HackersArise.tar

hackersarise1.sh
hackersarise2.sh
hackersarise3.sh
Debido a que todavía estás usando el modificador –v , este comando mostrará qué
Los archivos se extraen en la salida. Si desea extraer los archivos y hacerlo “silenciosamente”,
es decir, sin mostrar ningún resultado, simplemente puede eliminar el modificador v (detallado),
como se muestra aquí:
kali >tar xf HackersArise.tar
¡GUAU! Libro Comprimir y archivar 95

Los archivos se han extraído al directorio actual; puede hacer una lista larga en el
directorio para verificarlo. Tenga en cuenta que, de forma predeterminada, si ya existe un archivo
extraído, tar eliminará el archivo existente y lo reemplazará con el archivo extraído.
Comprimir archivos
Ahora tenemos un archivo archivado, pero ese archivo es más grande que la suma de los
archivos originales. ¿Qué sucede si desea comprimir esos archivos para facilitar su transporte?
Linux tiene varios comandos capaces de crear archivos comprimidos. Miraremos estos:
• gzip, que utiliza la extensión .tar.gz o .tgz

• bzip2, que utiliza la extensión .tar.bz2
• comprimir, que utiliza la extensión .tar.z
Todos ellos son capaces de comprimir nuestros archivos, pero utilizan diferentes algoritmos
de compresión y tienen diferentes ratios de compresión. Por lo tanto, veremos cada uno y de qué
es capaz.
En general, comprimir es lo más rápido, pero los archivos resultantes son más grandes; bzip2
es el más lento, pero los archivos resultantes son los más pequeños; y gzip cae en algún
punto intermedio. La razón principal por la que usted, como hacker en ciernes, debería conocer los
tres métodos es que al acceder a otras herramientas, se encontrará con varios tipos de
compresión. Por lo tanto, esta sección le muestra cómo lidiar con los principales métodos de
compresión.
Comprimiendo con gzip
Probemos primero con gzip (GNU zip), ya que es la utilidad de compresión más utilizada en Linux.
Puede comprimir su archivo HackersArise.tar ingresando lo siguiente (asegurándose de estar en
el directorio que contiene el archivo archivado):
kali >gzip HackersArise.*
Observe que utilizamos el comodín * para la extensión del archivo; esto le dice a linux
que el comando debe aplicarse a cualquier archivo que comience con HackersArise con cualquier
extensión de archivo. Utilizará notación similar para los siguientes ejemplos.
Cuando hacemos un listado largo en el directorio, podemos ver que HackersArise.tar ha sido
reemplazado por HackersArise.tar.gz, ¡y el tamaño del archivo se ha comprimido a solo 3299
bytes!
kali >ls l
recorte
rwrr 1 raíz raíz 3299 27 de noviembre de 2018 13:32 HackersArise.tar.gz
recorte
Luego podemos descomprimir ese mismo archivo usando el comando gunzip , abreviatura
de GNU unzip.

kali >gunzip HackersArise.*
Una vez descomprimido, el archivo ya no se guarda con la extensión .tar.gz sino con la
extensión .tar . Además, observe que ha vuelto a su tamaño original de 40.960 bytes. Intente
hacer una lista larga para confirmar esto. Vale la pena señalar que gzip también se puede
utilizar para extraer archivos .zip .
Comprimiendo con bzip2
Otra de las utilidades de compresión más utilizadas en Linux es bzip2, que funciona de
manera similar a gzip pero tiene mejores relaciones de compresión, lo que significa que
el archivo resultante será aún más pequeño. Puede comprimir su archivo HackersArise.tar
ingresando lo siguiente:
kali >bzip2 HackersArise.*
Cuando haces una lista larga, puedes ver que bzip2 ha comprimido el archivo a solo 2081
bytes. También tenga en cuenta que la extensión del archivo ahora es .tar.bz2.
Para descomprimir el archivo comprimido, use bunzip2, así:
kali >bunzip2 HackersArise.*

kali >
Cuando lo haga, el archivo volverá a su tamaño original y su extensión

vuelve a .tar.
Comprimir con compresa
Finalmente, puedes usar el comando comprimir para comprimir el archivo. Esta es

probablemente la utilidad de compresión menos utilizada, pero es fácil de recordar. Para
usarlo, simplemente ingrese el comando comprimir seguido del nombre del archivo, así:
kali >comprimir HackersArise.*

kali >ls l
recorte
rwrr 1 raíz raíz 5476 27 de noviembre de 2018 13:32 HackersArise.tar.Z
Tenga en cuenta que la utilidad de compresión redujo el tamaño del archivo a 5476 bytes,
más del doble del tamaño de bzip2. También tenga en cuenta que la extensión del archivo
ahora es .tar.Z (con una Z mayúscula).
Para descomprimir el mismo archivo, use descomprimir:
kali >descomprimir HackersArise.*
También puedes usar el comando gunzip con archivos que han sido comprimidos con
compress.

Creación de copias físicas o bit a bit de dispositivos de almacenamiento

Dentro del mundo de la seguridad de la información y la piratería, un comando de archivado de
Linux destaca sobre el resto en su utilidad. El comando dd realiza una copia bit a bit de un archivo,
un sistema de archivos o incluso un disco duro completo. Esto significa que incluso los archivos
eliminados se copian (sí, es importante saber que sus archivos eliminados pueden ser
recuperables), lo que facilita su descubrimiento y recuperación. Los archivos eliminados no
se copiarán con la mayoría de las utilidades de copia lógica, como cp.
Una vez que un hacker ha adquirido un sistema de destino, el comando dd le permitirá

copiar todo el disco duro o un dispositivo de almacenamiento a su sistema. Además, aquellas
personas cuyo trabajo es atrapar a los piratas informáticos (es decir, los investigadores
forenses) probablemente utilizarán este comando para hacer una copia física del disco duro con
archivos eliminados y otros artefactos que podrían ser útiles para encontrar pruebas contra el
pirata informático.
Es fundamental tener en cuenta que el comando dd no debe usarse para la copia diaria
típica de archivos y dispositivos de almacenamiento porque es muy lento; otros comandos hacen
el trabajo más rápido y más eficientemente. Sin embargo, es excelente cuando se necesita una
copia de un dispositivo de almacenamiento sin el sistema de archivos u otras estructuras
lógicas, como en una investigación forense.
La sintaxis básica del comando dd es la siguiente:
dd if=archivo de entrada de=archivo de salida
Entonces, si quisieras hacer una copia física de tu unidad flash, asumiendo

Si la unidad flash es sdb (analizaremos más esta designación en el Capítulo 10), deberá ingresar
lo siguiente:
kali >dd if=/dev/sdb of=/root/flashcopy

1257441=0 registros en
1257440+0 registros eliminados
7643809280 bytes (7,6 GB) copiados, 1220,729 s, 5,2 MB/s
Analicemos este comando: dd es su comando físico de "copiar"; if designa su archivo de

entrada, donde /dev/sdb representa su unidad flash en el directorio /dev ; de designa su archivo
de salida; y /root/flashcopy es el nombre del archivo al que desea copiar la copia física. (Para
obtener una explicación más completa de la designación de unidades del sistema Linux dentro
del archivo /dev
directorio, consulte el Capítulo 10.)
Hay numerosas opciones disponibles para usar con el comando dd , y puedes investigar un
poco sobre ellas, pero entre las más útiles se encuentra la opción noerror.
y la opción bs (tamaño de bloque). Como su nombre lo indica, la opción noerror continúa copiando
incluso si se encuentran errores. La opción bs le permite determinar el tamaño del bloque (el
número de bytes leídos/escritos por bloque) de los datos que se copian. De forma predeterminada,
está configurado en 512 bytes, pero se puede cambiar para acelerar el proceso. Normalmente,
esto se establecería según el tamaño del sector de la

dispositivo, normalmente 4 KB (4096 bytes). Con estas opciones, tu comando se

vería así:
kali >dd if=/dev/media of=/root/flashcopy bs=4096 conv:noerror
Como se mencionó, vale la pena investigar un poco más por tu cuenta, pero
Esta es una buena introducción al comando y sus usos comunes.
Resumen
Linux tiene una serie de comandos que le permiten combinar y comprimir sus archivos
para facilitar su transferencia. Para combinar archivos, tar es el comando preferido y
tiene al menos tres utilidades para comprimir archivos (gzip, bzip2 y compress), todas
con diferentes relaciones de compresión. El comando dd va más allá. Le permite realizar
una copia física de dispositivos de almacenamiento sin estructuras lógicas, como un
sistema de archivos, lo que le permite recuperar artefactos como archivos eliminados.
Ejercicios
Antes de pasar al Capítulo 10, pruebe las habilidades que aprendió en este
capítulo completando los siguientes ejercicios:
1. Cree tres scripts para combinar, similar a lo que hicimos en el Capítulo 8.

Nómbrelos Linux4Hackers1, Linux4Hackers2 y Linux4Hackers3.
2. Cree un tarball a partir de estos tres archivos. Nombra el tarball L4H. Observe cómo
cambia el tamaño de la suma de los tres archivos cuando se guardan juntos.
3. Comprima el tarball L4H con gzip. Observe cómo cambia el tamaño del archivo.
Investigue cómo puede controlar la sobrescritura de archivos existentes. Ahora descomprime
el archivo L4H.
4. Repita el Ejercicio 3 usando bzip2 y compress.

5. Haga una copia física, bit a bit, de una de sus unidades flash usando el dd
dominio.
¡GUAU! Libro
10
Sistema de archivos y almacenamiento
Gestión de dispositivos
Si proviene de un entorno Windows, la forma

en que Linux representa y administra los
dispositivos de almacenamiento le resultará
bastante diferente. Ya ha visto que el sistema de
archivos no tiene una representación física de la unidad,
como el sistema C:, D: o E: en Windows, sino que tiene
una estructura de árbol de archivos con / en la parte superior
o raíz de la misma. Este capítulo analiza cómo Linux
representa los dispositivos de almacenamiento, como discos
duros, unidades flash y otros dispositivos de almacenamiento.
Primero observamos cómo se montan unidades adicionales y otros dispositivos
de almacenamiento en ese sistema de archivos, lo que lleva al directorio / (raíz).
Montar en este contexto simplemente significa conectar unidades o discos al sistema
de archivos para que sean accesibles al sistema operativo (SO). Para usted, como
hacker, es necesario comprender el sistema de gestión de archivos y dispositivos de
almacenamiento, tanto en su propio sistema como, a menudo, en el sistema de su objetivo.
¡GUAU! Libro
Los piratas informáticos suelen utilizar medios externos para cargar datos, herramientas de
piratería o incluso su sistema operativo. Una vez que esté en su sistema de destino, debe
comprender con qué está trabajando, dónde encontrar archivos confidenciales u otros archivos
críticos, cómo montar una unidad en el sistema de destino y si puede colocar esos archivos en
su sistema y dónde. . En este capítulo cubrimos todos estos temas, además de cómo
administrar y monitorear dispositivos de almacenamiento.
Comenzamos con el directorio conocido como /dev, que probablemente ya habrás
notado en la estructura del directorio: dev es la abreviatura de dispositivo, y cada dispositivo
en Linux está representado por su propio archivo dentro del directorio /dev . Comencemos
trabajando con /dev.
El directorio de dispositivos /dev

Linux tiene un directorio especial que contiene archivos que representan cada dispositivo
conectado: el directorio /dev con el nombre apropiado . Como primera introducción, navegue
hasta el directorio /dev y luego realice un listado largo en él. Debería ver algo como el
Listado 101.
kali >cd/dev
kali >ls l
total 0
crw 1 raíz raíz 10,175 16 de mayo 12:44 agpgart
crw 1 raíz raíz 10,235 16 de mayo 12:44 autofs
drwxrxrx 1 raíz raíz 160 16 de mayo 12:44 bloque
recorte
lrwxrwxrwx 1 raíz raíz 3 16 mayo 12:44 cdrom > sr0
recorte
drwxrxrx 2 raíz raíz 60 16 de mayo 12:44 CPU
recorte
Listado 101: Un listado largo del directorio /dev
Los dispositivos se muestran en orden alfabético de forma predeterminada. Puedes

Reconoce algunos de los dispositivos, como un cdrom y una CPU, pero otros tienen
nombres bastante crípticos. Cada dispositivo en su sistema está representado por un archivo
en el directorio /dev , incluidos los dispositivos que probablemente nunca haya usado o que ni
siquiera haya sabido que existían. En caso de que lo haga, hay un archivo de dispositivo
esperando a ser utilizado.
Si se desplaza un poco hacia abajo en esta pantalla, debería ver más listados de
dispositivos. De particular interés son los dispositivos sda1, sda2, sda3, sdb y sdb1, que
son el disco duro y sus particiones y una unidad flash USB y sus particiones.
recorte
brwrw 1 raíz raíz brwrw 8, 0 16 de mayo 12:44 sda
1 raíz raíz brwrw 1 raíz raíz 8, 1 16 mayo 12:44 sda1
brwrw 1 raíz raíz 8, 2 16 de mayo 12:44 sda2
8, 5 16 de mayo 12:44 sda5

brwrw 1 raíz raíz brwrw 1 raíz 8, 16 16 de mayo 12:44 sdb

raíz 8, 17 16 mayo 12:44 sdb1
recorte
Echemos un vistazo más de cerca a estos.
Cómo Linux representa los dispositivos de almacenamiento
Linux utiliza etiquetas lógicas para las unidades que luego se montan en el sistema de archivos.
Estas etiquetas lógicas variarán dependiendo de dónde estén montadas las unidades, lo que significa
que el mismo disco duro puede tener diferentes etiquetas en diferentes momentos, dependiendo de
dónde y cuándo esté montado.
Originalmente, Linux representaba las unidades de disquete (¿las recuerdas?) como fd0
y discos duros como hda. De vez en cuando todavía verás estas representaciones de unidades
en sistemas Linux heredados, pero hoy en día la mayoría de las unidades de disquete ya no existen
(gracias a Dios). Aun así, los discos duros antiguos que utilizaban una interfaz IDE o EIDE
todavía se representan en el formato hda. Las unidades de interfaz Serial ATA (SATA) y los discos
duros de interfaz de sistema pequeño (SCSI) más nuevos se representan como sda. Las unidades a
veces se dividen en secciones conocidas como particiones, que se representan en el sistema de
etiquetado con números, como verá a continuación.
Cuando los sistemas tienen más de un disco duro, Linux simplemente los nombra en serie
incrementando la última letra en orden alfabético, de modo que la primera unidad es sda, la segunda
es sdb, la tercera es sdc, y así sucesivamente (consulte la Tabla 10). 1). La letra de serie después
de sd a menudo se denomina letra mayor .
número.
Tabla 101: Sistema de denominación de dispositivos
Archivo de dispositivo
Descripción
sda Primer disco duro SATA
sdb Segundo disco duro SATA
COSUDE Tercer disco duro SATA
SDD Cuarto disco duro SATA
Particiones de unidad
Algunas unidades se pueden dividir en particiones para administrar y separar información. Por
ejemplo, es posible que desee separar su disco duro para que su archivo de intercambio ,
directorio de inicio y directorio / estén todos en particiones separadas; es posible que desee
hacer esto por varias razones, incluido compartir recursos y relajar el valor predeterminado.
permisos. Linux etiqueta cada partición con un número menor que aparece después de la
designación de la unidad. De esta forma, la primera partición de la primera unidad SATA sería
sda1. La segunda partición sería entonces sda2, la tercera sda3, y así sucesivamente, como se
ilustra en la Tabla 102.

¡GUAU! Libro
Tabla 102: Sistema de etiquetado de particiones
Dividir Descripción
sda1 La primera partición (1) en la primera (a) unidad SATA
sda2 La segunda (2) partición en la primera (a) unidad
sda3 La tercera (3) partición en la primera (a) unidad
sda4 La cuarta (4) partición en la primera (a) unidad
En ocasiones, es posible que desee ver las particiones de su sistema Linux para
ver cuáles tiene y cuánta capacidad hay disponible en cada una. Puedes hacer esto
usando la utilidad fdisk . Al usar el modificador l con fdisk se enumeran todas las
particiones de todas las unidades, como se muestra en el Listado 102.
kali >fdisk l
Disco /dev/sda: 20GiB, 21474836480 bytes, 41943040 sectores
Unidades: sectores de 1 * 512 = 512 bytes
Tamaño del sector (lógico/físico): 512 bytes / 512 bytes
Tamaño de E/S (mínimo/óptimo): 512 bytes/512 bytes
Tipo de etiqueta de disco: dos
Identificador de disco: 0x7c06cd70
Bota Inicio Sectores finales Tamaño Id Tipo

Dispositivo / * 2048 39174143 39172096 18.7G 83 Linux
dev/sda1 / 39176190 41940991 2764802 1.3G 5 extendido
dev/sda2 /dev/sda5 39176192 41940991 2764800 1.3G 82 Intercambio de Linux/Solaris
Disco /dev/sdb: 29,8 GiB, 31999393792 bytes, 62498816 sectores

Unidades: sectores de 1 * 512 = 512 bytes
Tamaño del sector (lógico/físico): 512 bytes / 512 bytes
Tamaño de E/S (mínimo/óptimo): 512 bytes/512 bytes
Tipo de etiqueta de disco: dos
Identificador de disco: 0xc3072e18
Inicio de arranque Sectores finales Tamaño Id Tipo

Dispositivo /dev/sdb1 32 62498815 62498784 29,8G 7HPFS/NTFS/exFAT
Listado 102: Listado de particiones con fdisk
Como puede ver en el Listado 102, los dispositivos sda1, sda2 y sda5 se
enumeran en la primera estrofa. Estos tres dispositivos forman el disco virtual de mi
máquina virtual, que es una unidad de 20 GB con tres particiones, incluida la partición de
intercambio (sda5), que actúa como RAM virtual (similar a los archivos de paginación
en Windows) cuando se excede la capacidad de la RAM.
Si explora el Listado 102 hasta la tercera estrofa, verá una segunda salida de
dispositivo designada sdb1; la etiqueta b nos indica que esta unidad está separada de
los primeros tres dispositivos. Esta es mi unidad flash de 64 GB. Tenga en cuenta
que fdisk indica que es un tipo de sistema de archivos HPFS/NTFS/ExFAT. Estos tipos
de archivos (sistema de archivos de alto rendimiento (HPFS), sistema de archivos de
nueva tecnología (NTFS) y tabla de asignación de archivos extendida (exFAT) no son
nativos de los sistemas Linux, sino de los sistemas macOS y Windows. vale la pena ser

capaz de reconocer tipos de archivos nativos de diferentes sistemas cuando investiga.

El sistema de archivos puede indicar en qué tipo de máquina se formateó la unidad, lo que
puede ser información valiosa. Kali puede utilizar unidades flash USB creadas en muchos
sistemas operativos diferentes.
Como vio en el Capítulo 1, el sistema de archivos de Linux está estructurado de manera
significativamente diferente a la de Windows y otros sistemas operativos propietarios. Además
de esto, la forma en que se almacenan y administran los archivos también es diferente en Linux.
Las nuevas versiones de Windows utilizan un sistema de archivos NTFS, mientras que los
sistemas Windows más antiguos utilizan sistemas de tabla de asignación de archivos (FAT).
Linux utiliza varios tipos diferentes de sistemas de archivos, pero los más comunes son
ext2, ext3 y ext4. Todas estas son iteraciones del sistema de archivos ext (o extendido) ,
siendo ext4 la última.
Dispositivos de caracteres y bloques
Otra cosa a tener en cuenta sobre el nombre de los archivos de dispositivo en el directorio /
dev es que la primera posición contiene c o b. Puede ver esto en el Listado 101 al comienzo
de la mayoría de las entradas, y se parece a esto:
crw 1 raíz raíz 10,175 16 de mayo 12:44 agpgart
Estas letras representan las dos formas en que los dispositivos transfieren datos hacia
adentro y hacia afuera. La c significa carácter y estos dispositivos se conocen, como es de
esperar, como dispositivos de caracteres . Los dispositivos externos que interactúan con el
sistema enviando y recibiendo datos carácter por carácter, como ratones o teclados, son
dispositivos de caracteres.
La b representa el segundo tipo: dispositivos de bloque . Se comunican en bloques de
datos (varios bytes a la vez) e incluyen dispositivos como discos duros y unidades de DVD. Estos
dispositivos requieren un rendimiento de datos de mayor velocidad y, por lo tanto, envían y
reciben datos en bloques (muchos caracteres o bytes a la vez). Una vez que sepas si un
dispositivo es un personaje o un dispositivo de bloque, podrás obtener fácilmente más
información sobre él, como verás a continuación.
Enumere información y dispositivos de bloqueo con lsblk
El comando de Linux lsblk, abreviatura de bloque de lista, enumera información básica sobre
cada dispositivo de bloque enumerado en /dev. El resultado es similar a la salida de fdisk l,
pero también mostrará los dispositivos con múltiples particiones en una especie de árbol,
mostrando cada dispositivo con sus particiones como ramas, y no requiere privilegios de root
para ejecutarse. En el Listado 103, por ejemplo, vemos sda, con sus ramas sda1, sda2 y sda5.
kali >lsblk
MAJ:MIN RM TAMAÑO RO TIPO PUNTO DE MONTAJE
2:0 1 disco 4K 0
8:0 0 20G 0 disco
Nombre 8:1 0 18.7G 0 parte /
fd0 8:2 0 1K 0 parte
8:5|sda5
sda1 |sda1 |sda2 0 1.3G 0 parte [SWAP]

¡GUAU! Libro
sdb 8:16 1 disco 29,8G 0

|sdb1 8.17 1 disco/medio 29,8G 0
sr0 11:0 1 2.7G 0 ROM
Listado 103: Listado de información del dispositivo de bloque con lsblk
La salida incluye la unidad de disquete como fd0 y la unidad de DVD como sr0, incluso
aunque ninguno de los dos está en mi sistema; esto es simplemente un vestigio de los sistemas
heredados. También podemos ver información sobre el punto de montaje de la unidad: esta es la
posición en la que se conectó la unidad al sistema de archivos. Tenga en cuenta que el disco duro sda1
está montado en / y la unidad flash está montada en /media.
Verá más sobre el significado de esto en la siguiente sección.
Montaje y desmontaje
La mayoría de los sistemas operativos modernos, incluidas la mayoría de las versiones nuevas de
Linux, montan automáticamente los dispositivos de almacenamiento cuando están conectados, lo
que significa que la nueva unidad flash o disco duro se conecta automáticamente al sistema de
archivos. Para aquellos nuevos en Linux, el montaje puede ser un tema extraño.
Primero se debe conectar físicamente un dispositivo de almacenamiento al sistema de archivos y
luego se adjunta lógicamente al sistema de archivos para que los datos estén disponibles para el
sistema operativo. En otras palabras, incluso si el dispositivo está conectado físicamente al sistema, no
necesariamente está conectado lógicamente ni disponible para el sistema operativo. El término montaje
es un legado de los primeros días de la informática, cuando las cintas de almacenamiento (antes de los
discos duros) tenían que montarse físicamente en el sistema informático; piense en esas computadoras
grandes con unidades de cinta giratoria que quizás haya visto en viejas películas de ciencia ficción.
Como se mencionó, el punto en el árbol de directorios donde están conectados los dispositivos se
conoce como punto de montaje. Los dos puntos de montaje principales en Linux son /mnt
y /medios. Como regla general, los discos duros internos se montan en /mnt y los dispositivos USB
externos, como unidades flash y discos duros USB externos, se montan en /media, aunque técnicamente
se puede utilizar cualquier directorio.
Montaje de dispositivos de almacenamiento usted mismo
En algunas versiones de Linux, es necesario montar una unidad manualmente para poder acceder a su
contenido, por lo que vale la pena aprender esta habilidad. Para montar una unidad en el sistema de
archivos, use el comando de montaje . El punto de montaje del dispositivo debe ser un directorio vacío;
Si monta un dispositivo en un directorio que tiene subdirectorios y archivos, el dispositivo montado
cubrirá el contenido del directorio, haciéndolo invisible y no disponible. Entonces, para montar el nuevo
disco duro sdb1 en el directorio /mnt , deberá ingresar lo siguiente:
kali >montar /dev/sdb1 /mnt
Entonces ese disco duro debería estar disponible para acceder. Si desea montar la unidad
flash sdc1 en el directorio /media , deberá ingresar esto:
kali >montar /dev/sdc1 /media

Los sistemas de archivos que están montados en un sistema se guardan en un archivo en /etc/
fstab (abreviatura de tabla del sistema de archivos), que el sistema lee en cada inicio.
Desmontar con desmontar
Si tienes experiencia en Mac o Windows, probablemente hayas desmontado una unidad sin
saberlo. Antes de retirar una unidad flash de su sistema, debe “expulsarla” para evitar dañar los
archivos almacenados en el dispositivo. Expulsar es sólo otra palabra para desmontar.
De manera similar al comando mount , puede desmontar un segundo disco duro ingresando el
comando umount seguido de la entrada del archivo del dispositivo en el directorio /dev , como /dev/
sdb. Tenga en cuenta que el comando no se escribe desmontar sino desmontar (sin n).
kali >desmontar /dev/sdb1
No puede desmontar un dispositivo que está ocupado, por lo que si el sistema está leyendo o
Al escribir en el dispositivo, solo recibirá un error.
Monitoreo de sistemas de archivos
En esta sección, analizamos algunos comandos para monitorear el estado del sistema de archivos,
una habilidad necesaria para cualquier hacker o administrador del sistema. Obtendremos información
sobre los discos montados y luego buscaremos y corregiremos errores. Los dispositivos de
almacenamiento son particularmente propensos a errores, por lo que vale la pena aprender esta habilidad.
Obtener información sobre discos montados
El comando df (para liberar disco) nos proporcionará información básica sobre cualquier disco duro
o dispositivo montado, como CD, DVD y unidades flash, incluido cuánto espacio se está utilizando
y cuánto hay disponible (consulte el Listado 104). ). Sin ninguna opción, df utiliza de forma
predeterminada la primera unidad de su sistema (en este caso, sda). Si desea verificar una unidad
diferente, simplemente siga el comando df con la representación de la unidad que desea verificar
(por ejemplo, df sdb).
kali >df
Sistema de Bloques 1K Usado Disponible Uso% Montado en
archivos 19620732 17096196 1504788 92% /
rootfs udev 10240 0 10240 0% /desarrollador
recorte
/dev/sdb1 29823024 29712544 110480 99% /medios/USB3.0
Listado 104: Obteniendo información sobre discos y dispositivos montados con df
La primera línea de salida aquí muestra los encabezados de las categorías y luego obtenemos
la información. El espacio en disco se proporciona en bloques de 1 KB. En la segunda línea, vemos que
rootfs tiene 19.620.732 bloques de un kilobyte, de los cuales está usando

¡GUAU! Libro
17.096.196 (o alrededor del 92 por ciento), dejando 1.504.788 disponibles. El comando df también
nos dice que este sistema de archivos está montado en la parte superior del sistema de archivos /.
En la última línea, puedes ver mi unidad flash USB. Tenga en cuenta que está designado
/dev/sdb1, está casi 100 por ciento lleno y está montado en /media/USB3.0.
En resumen, mi disco virtual en este sistema se denomina sda1, que
se descompone de la siguiente manera:
disco duro sd sata
un primer disco duro
1 Primera partición en esa unidad
Mi unidad flash de 64 GB está designada como sdb1 y mi unidad externa como sdc1.
Comprobando errores
El comando fsck (abreviatura de verificación del sistema de archivos) verifica el sistema de archivos en
busca de errores y repara el daño, si es posible, o coloca el área defectuosa en bloques defectuosos.
tabla para marcarlo como malo. Para ejecutar el comando fsck , debe especificar el tipo de sistema
de archivos (el valor predeterminado es ext2) y el archivo del dispositivo a verificar. Es importante
tener en cuenta que debe desmontar la unidad antes de ejecutar una verificación del sistema de
archivos. Si no puede desmontar el dispositivo montado, recibirá el mensaje de error que se muestra en
el Listado 105.
kali >fsck
fsck de utillinux 2.20.1
e2fsck 1.42.5 (29 de julio de 2012)
/dev/sda1 está montado
e2fsck: No se puede continuar, abortando.
Listado 105: Intentando (y fallando) ejecutar una verificación de errores en una unidad montada
Entonces, el primer paso al realizar una verificación del sistema de archivos es desmontar el
dispositivo. En este caso, desmontaré mi unidad flash para realizar una verificación del sistema de archivos:
kali >desmontar /dev/sdb1
Puedo agregar la opción p para que fsck repare automáticamente cualquier problema
con el dispositivo, así:
kali >fsck p /dev/sdb1
Con el dispositivo desmontado, ahora puedo verificar si hay sectores defectuosos u otros
problemas con el dispositivo, de la siguiente manera:
kali >fsck p /dev/sdb1

fsck de utillinux 2.30.2
exfatfsck 1.2.7
Comprobando el sistema de archivos en /dev/sdb1.

Versión del sistema de archivos 1.0

Tamaño del sector 512 bytes
Tamaño de cluster 32 KB
Tamaño del volumen 7648 megas
Espacio utilizado 1265 MB

Espacio disponible 6383 MB
Totalmente 20 directorios y 111 archivos.
Comprobación del sistema de archivos finalizada. No se encontraron errores.
Resumen
Comprender cómo Linux designa y administra sus dispositivos es crucial para cualquier
usuario y hacker de Linux. Los piratas informáticos necesitarán saber qué dispositivos
están conectados a un sistema y cuánto espacio hay disponible. Debido a que los
dispositivos de almacenamiento a menudo desarrollan errores, podemos verificar y
reparar esos errores con fsck. El comando dd es capaz de realizar una copia física de
un dispositivo, incluidos los archivos eliminados.
Ejercicios
Antes de pasar al Capítulo 11, pruebe las habilidades que aprendió en este capítulo completando los siguientes
ejercicios:
1. Utilice los comandos mount y umount para montar y desmontar su flash

conducir.
2. Verifique la cantidad de espacio libre en su disco duro principal.
3. Verifique si hay errores en su unidad flash con fsck.
4. Utilice el comando dd para copiar todo el contenido de una unidad flash a otra, incluidos los archivos
eliminados.
5. Utilice el comando lsblk para determinar las características básicas de su bloque.

dispositivos.
¡GUAU! Libro Gestión de sistemas de archivos y dispositivos de almacenamiento 109
¡GUAU! Libro
11
El sistema de registro
Para cualquier usuario de Linux, es fundamental tener

conocimientos sobre el uso de los archivos de registro. Registro
Los archivos almacenan información sobre eventos que
ocurren cuando se ejecutan el sistema operativo y las aplicaciones,

incluidos los errores y las alertas de seguridad.
Su sistema registrará información automáticamente según la serie de reglas
que le mostraré cómo configurar en este capítulo.
Como hacker, los archivos de registro pueden ser un rastro de las actividades y
la identidad de su objetivo. Pero también puede ser un rastro de sus propias actividades
en el sistema de otra persona. Por lo tanto, un pirata informático necesita saber qué
información puede recopilar, así como qué puede recopilar sobre sus propias acciones
y métodos para ocultar esa evidencia.
Por otro lado, cualquiera que proteja sistemas Linux necesita saber cómo administrar
las funciones de registro para determinar si un sistema ha sido atacado y luego descifrar
qué sucedió realmente y quién lo hizo.
¡GUAU! Libro
Este capítulo le muestra cómo examinar y configurar archivos de registro, así como
como cómo eliminar evidencia de su actividad e incluso desactivar el registro por
completo. Primero, veremos el demonio que realiza el registro.
El demonio de registro rsyslog

Linux utiliza un demonio llamado syslogd para registrar automáticamente eventos en su
computadora. Se utilizan varias variaciones de syslog, incluidos rsyslog y syslogng, en
diferentes distribuciones de Linux y, aunque funcionan de manera muy similar, existen
algunas diferencias menores. Dado que Kali Linux está construido sobre Debian, y Debian
viene con rsyslog de forma predeterminada, en este capítulo nos centraremos en esa
utilidad. Si desea utilizar otras distribuciones, vale la pena investigar un poco sobre sus
sistemas de registro.
Echemos un vistazo a rsyslog en su sistema. Buscaremos todos los archivos
relacionados con rsyslog. Primero, abra una terminal en Kali e ingrese lo siguiente:
kali > localizar rsyslog

/etc/rsyslog.conf
/etc/rsyslog.d
/etc/default/rsyslog
/etc/init.d/rsyslog
/etc/logcheck/ignore.d.server/rsyslog
/etc/logrotate.d/rsyslog
/etc/rc0.d/K04rsyslog
recorte
Como puede ver, numerosos archivos contienen la palabra clave rsyslog, algunos
de los cuales son más útiles que otros. El que queremos examinar es el archivo de
configuración rsyslog.conf.
El archivo de configuración rsyslog
Como casi todas las aplicaciones en Linux, rsyslog se administra y configura mediante
un archivo de configuración de texto plano ubicado, como suele ser el caso en Linux, en el
directorio /etc . En el caso de rsyslog, el archivo de configuración se encuentra en /etc/
rsyslog.conf. Abra ese archivo con cualquier editor de texto y exploraremos lo que hay
dentro (aquí uso Leafpad):
kali >leafpad /etc/rsyslog.conf
Debería ver algo como el Listado 111.
/etc/rsyslog.conf Archivo de configuración para rsyslog.
# Para más información, ver

# /usr/share/doc/rsyslogdoc/html/rsyslog_conf.html
#################
#### MÓDULOS ####
#################

module(load="imuxsock") # proporciona soporte para el registro del sistema local

module(load="imklog") # proporciona soporte de registro del kernel
#module(load="immark") # proporciona capacidad de mensaje MARK
# proporciona recepción de syslog UDP

#modulo(carga="imudp")
#entrada(tipo="imudp" puerto="514")
# proporciona recepción de syslog TCP

#módulo(carga="imtcp")
#entrada(tipo="imtcp" puerto="514")
###########################
#### DIRECTIVAS GLOBALES ####
###########################
Listado 111: Una instantánea del archivo rsyslog.conf
Como puede ver, el archivo rsyslog.conf viene bien documentado con numerosos
comentarios que explican su uso. Gran parte de esta información no le será útil en este
momento, pero si navega hasta la línea 50, encontrará la sección Reglas . Aquí es donde
puede establecer las reglas sobre lo que su sistema Linux registrará automáticamente.
Las reglas de registro de rsyslog
Las reglas de rsyslog determinan qué tipo de información se registra, qué programas
registran sus mensajes y dónde se almacena ese registro. Como hacker, esto le permite
descubrir qué se está registrando y dónde están escritos esos registros para poder
eliminarlos u ocultarlos. Desplácese hasta la línea 50 y debería ver algo como el Listado
112.
###############
#### NORMAS ####
###############
#
# Primero, algunos archivos de registro estándar. Registre por instalación.
#
auth,authpriv.* /var/log/auth.log
*.*;auth,authpriv.none #cron.* /var/log/syslog
daemon.* /var/log/cron.log
kern.* 1pr.* /var/log/daemon.log
correo.* /var/log/kern.log
/var/log/lpr.log
usuario.* /var/log/mail.log
/var/log/usuario.log
#
# Registro para el sistema de correo. Dividirlo para que
# es fácil escribir scripts para analizar estos archivos.
#

¡GUAU! Libro
correo.info /var/log/mail.info
correo.advertir /var/log/mail.warn
correo.err /var/log/mail.err
Listado 112: Buscando las reglas de registro en rsyslog.conf
Cada línea es una regla de registro independiente que indica qué mensajes se registran y
dónde se registran. El formato básico de estas reglas es el siguiente:
prioridad.de.instalaciones acción
La palabra clave facility hace referencia al programa, como mail, kernel o lpr,
cuyos mensajes se están registrando. La palabra clave de prioridad determina qué
tipo de mensajes registrar para ese programa. La palabra clave de acción , en el
extremo derecho, hace referencia a la ubicación donde se enviará el registro. Veamos
cada sección más de cerca, comenzando con la palabra clave facility , que se refiere
a cualquier software que esté generando el registro, ya sea el kernel, el sistema de correo
o el usuario.
La siguiente es una lista de códigos válidos que se pueden utilizar en lugar del
Palabra clave de instalación en las reglas de nuestro archivo de configuración:
auth/authpriv Mensajes de seguridad/autorización

cron demonios del reloj
demonio Otros demonios
mensajes del kernel

sistema de impresión lpr
sistema de correo
usuario Mensajes genéricos a nivel de usuario
Un comodín de asterisco (*) en lugar de una palabra se refiere a todas las instalaciones.
Puede seleccionar más de una instalación enumerándolas separadas por una coma.
La prioridad le dice al sistema qué tipos de mensajes registrar. Los códigos se enumeran
desde la prioridad más baja, comenzando en la depuración, hasta la prioridad más alta, y
terminando en el pánico. Si la prioridad es *, se registran los mensajes de todas las prioridades.
Cuando especifica una prioridad, se registran los mensajes de esa prioridad y superiores. Por
ejemplo, si especifica un código de prioridad de alerta, el sistema registrará los mensajes
clasificados como alerta y de mayor prioridad, pero no registrará los mensajes marcados como
críticos ni con ninguna prioridad inferior a la alerta.
Aquí está la lista completa de códigos válidos para prioridad:
• depurar
• información
• aviso
• advertencia
• advertir
• error
• errar

• crítico
• alerta
• emerger
• pánico
Los códigos de advertencia, advertencia, error, err, emergencia y pánico han

quedado obsoletos y no deben usarse.
La acción suele ser un nombre de archivo y una ubicación a la que se deben enviar los
registros. Tenga en cuenta que, por lo general, los archivos de registro se envían al
directorio /var/log con un nombre de archivo que describe la instalación que los generó, como
auth. Esto significa, por ejemplo, que los registros generados por la función de autenticación se
enviarán a /var/log.auth.log.
Veamos algunos ejemplos de reglas de registro:
correo.* /var/log/correo
Este ejemplo registrará eventos de correo de todas las prioridades (*) en /var/log/mail.
kern.crit /var/log/kernel
Este ejemplo registrará eventos del kernel de prioridad crítica (crit) o superior en /var/log/
kernel.
*.emergente *
Este último ejemplo registrará todos los eventos de prioridad de emergencia (emerg) para
todos los usuarios registrados. Con estas reglas, el pirata informático puede determinar dónde se
encuentran los archivos de registro, cambiar las prioridades o incluso desactivar reglas de registro
específicas.
Limpiar registros automáticamente con logrotate

Los archivos de registro ocupan espacio, por lo que si no los elimina periódicamente,
acabarán llenando todo el disco duro. Por otro lado, si elimina sus archivos de registro con
demasiada frecuencia, no tendrá registros para investigar en algún momento futuro. Puede
utilizar logrotate para determinar el equilibrio entre estos requisitos opuestos rotando sus
registros.
La rotación de registros es el proceso de archivar archivos de registro periódicamente
moviéndolos a otra ubicación, dejándolo con un archivo de registro nuevo. Esa ubicación
archivada se limpiará después de un período de tiempo específico.
Su sistema ya está rotando archivos de registro usando un trabajo cron que emplea el
utilidad logrotate . Puede configurar la utilidad logrotate para elegir la regularidad de la
rotación de su registro con el archivo de texto /etc/logrotate.conf . Abrámoslo con un editor
de texto y echemos un vistazo:
kali >leafpad /etc/logrotate.conf

¡GUAU! Libro
Debería ver algo como el Listado 113.
# ver "man logrotate" para más detalles

# rotar archivos de registro semanalmente
tu semanalmente
# mantener 4 semanas de retrasos

rotar 4
w # crear archivos de registro nuevos (vacíos) después de rotar los antiguos

crear
x # descomente esto si desea que sus archivos de registro se compriman

#comprimir
# paquetes colocan información de rotación de registros en este directorio

incluir /etc/logrotate.d
# ningún paquete posee wtmp o btmp; los rotaremos aquí

/var/log/wtmp {
desaparecidook
mensual
crear 0664 raíz utmp
rotar 1
}
Listado 113: El archivo de configuración logrotate
Primero, puede configurar la unidad de tiempo que sus números de rotación se refieren a usted. El valor
predeterminado aquí es semanal, lo que significa que cualquier número después de la palabra clave rotar
siempre se refiere a semanas.
Más abajo, puede ver la configuración de la frecuencia con la que se rotan los registros:
La configuración predeterminada es rotar los registros cada cuatro semanas. Esta configuración
predeterminada funcionará para la mayoría de las personas, pero si desea conservar sus registros por
más tiempo con fines de investigación o por menos tiempo para borrarlos más rápido, esta es la
configuración que debe cambiar. Por ejemplo, si revisa sus archivos de registro todas las semanas y desea
ahorrar espacio de almacenamiento, puede cambiar esta configuración para rotar 1. Si tiene suficiente
espacio de almacenamiento para sus registros y desea mantener un registro semipermanente para análisis
forense más adelante, podrías cambiar esta configuración para rotar 26
para conservar sus registros durante seis meses o rotar 52 para conservarlos durante un año.
De forma predeterminada, se crea un nuevo archivo de registro vacío cuando se rotan los antiguos.
fuera w. Como indican los comentarios en el archivo de configuración, también puede optar por
comprimir sus archivos de registro rotados x.
Al final de cada período de rotación, se cambia el nombre de los archivos de registro y se empujan
hacia el final de la cadena de registros a medida que se crea un nuevo archivo de registro, que reemplaza
al archivo de registro actual. Por ejemplo, /var/log.auth se convertirá en /var/log.auth.1, luego en /var/
log.auth.2, y así sucesivamente. Si rota los registros cada cuatro semanas y mantiene cuatro conjuntos de
copias de seguridad, tendrá /var/log.auth.4, pero no /var/log.auth.5, es decir
que /var/log.auth.4 se eliminará en lugar de enviarse a /var/log/

aut.5. Puede ver esto usando el comando de localización para buscar /var/log/
archivos de registro auth.log con un comodín, como se muestra aquí:
kali > localizar /var/log/auth.log.*

/var/log/auth.log.1
/var/log/auth.log.2
/var/log/auth.log.3
/var/log/auth.log.4
Para obtener más detalles sobre las muchas formas de personalizar y utilizar logrotate
utilidad, consulte la página man logrotate . Este es un excelente recurso para aprender sobre las
funciones que puede usar y las variables que puede cambiar para personalizar cómo se manejan sus
registros. Una vez que se familiarice con Linux, tendrá una mejor idea de la frecuencia con la que necesita
iniciar sesión y qué opciones prefiere, por lo que vale la pena volver a visitar el archivo logrotate.conf .
Permanecer sigiloso
Una vez que haya comprometido un sistema Linux, es útil desactivar el registro y eliminar cualquier evidencia
de su intrusión en los archivos de registro para reducir las posibilidades de detección. Hay muchas formas de
hacer esto y cada una conlleva sus propios riesgos y nivel de confiabilidad.
Eliminación de pruebas
Primero, querrás eliminar cualquier registro de tu actividad. Simplemente podría abrir los archivos de registro
y eliminar con precisión cualquier registro que detalla su actividad, línea por línea, utilizando las técnicas
de eliminación de archivos que aprendió en el Capítulo 2. Sin embargo, esto podría llevar mucho tiempo y
dejar espacios de tiempo en los archivos de registro, lo que parece sospechoso. Además, los archivos
eliminados generalmente pueden ser recuperados por un investigador forense capacitado.
Una solución mejor y más segura es destruir los archivos de registro. Con otros sistemas de
eliminación de archivos, un investigador experto aún puede recuperar los archivos eliminados, pero
supongamos que hay una manera de eliminar el archivo y sobrescribirlo varias veces, lo que hace que su
recuperación sea mucho más difícil. Por suerte para nosotros, Linux tiene un comando incorporado,
apropiadamente llamado shred, precisamente para este propósito.
Para comprender cómo funciona el comando shred , eche un vistazo rápido a la
pantalla de ayuda ingresando el siguiente comando:
kali >triturar ayuda

Uso: triturar [OPCIÓN]...ARCHIVO...
Sobrescriba los ARCHIVOS especificados repetidamente para hacerlo más difícil
incluso para pruebas de hardware muy costosas para recuperar datos
recorte
¡GUAU! Libro El sistema de registro 117
Como puede ver en el resultado completo en su pantalla, el comando shred

tiene muchas opciones. En su forma más básica, la sintaxis es simple:
triturar <ARCHIVO>
Por sí solo, shred eliminará el archivo y lo sobrescribirá varias veces.

De forma predeterminada, triturar sobrescribe cuatro veces. Generalmente, cuantas más veces se
sobrescribe el archivo, más difícil será recuperarlo, pero tenga en cuenta que cada sobrescritura lleva
tiempo, por lo que, en el caso de archivos muy grandes, la destrucción puede llevar mucho tiempo.
Dos opciones útiles para incluir son la opción f , que cambia el valor por
misiones en los archivos para permitir la sobrescritura si es necesario un cambio de permiso, y
la opción –n , que le permite elegir cuántas veces sobrescribir los archivos. Como ejemplo,
trituraremos los archivos de registro en /var/log/auth.log 10 veces usando el siguiente comando:
kali >triturar f n 10 /var/log/auth.log.*
Necesitamos la opción –f para darnos permiso para destruir archivos de autenticación , y

siga la opción –n con la cantidad de veces deseada para sobrescribir. Después de la ruta del
archivo que queremos destruir, incluimos el asterisco comodín para destruir no solo el archivo
auth.log , sino también cualquier registro que se haya creado con logrotate, como auth.log.1,
auth. log.2, etc.
Ahora intenta abrir un archivo de registro:
kali >leafpad /var/log/auth.log.1
Una vez que haya triturado un archivo, verá que el contenido es un galimatías indescifrable,
como se muestra en la Figura 111.
Figura 111: Un archivo de registro triturado
Ahora bien, si el ingeniero de seguridad o el investigador forense examina el registro

archivos, no encontrarán nada útil porque nada de eso es recuperable.
Deshabilitar el registro
Otra opción para cubrir sus huellas es simplemente desactivar el registro. Cuando un pirata
informático toma el control de un sistema, podría desactivar inmediatamente el registro para evitar
que el sistema realice un seguimiento de sus actividades. Esto, por supuesto, requiere privilegios
de root.

Para desactivar todos los registros, el hacker podría simplemente detener el demonio rsyslog .
Detener cualquier servicio en Linux utiliza la misma sintaxis, que se muestra aquí (verá más sobre
esto en el Capítulo 12):
servicio nombre del servicio inicio|detener|reiniciar
Entonces, para detener el demonio de registro, simplemente puede ingresar lo siguiente

dominio:
kali > servicio rsyslog detener
Ahora Linux dejará de generar archivos de registro hasta que se reinicie el

servicio, lo que le permitirá operar sin dejar ninguna evidencia en los archivos de registro.
Resumen
Los archivos de registro rastrean casi todo lo que sucede en su sistema Linux. Pueden ser un
recurso invaluable al intentar analizar lo que ha ocurrido, ya sea un mal funcionamiento o un
ataque. Para el hacker, los archivos de registro pueden ser evidencia de sus actividades e
identidad. Sin embargo, un hacker astuto puede eliminar y destruir estos archivos y desactivar el
registro por completo, sin dejar evidencia alguna.
Ejercicios
1. Utilice el comando de localización para buscar todos los archivos rsyslog .
2. Abra el archivo rsyslog.conf y cambie la rotación de su registro a una semana.
3. Deshabilite el inicio de sesión en su sistema. Investigue qué se registra en el archivo /var/log/

syslog cuando deshabilita el registro.
4. Utilice el comando shred para triturar y eliminar todos sus archivos de registro de kern .

¡GUAU! Libro
¡GUAU! Libro
12
Uso y transporte de servicios
En la terminología de Linux, un servicio es

una aplicación que se ejecuta en segundo
plano esperando a que usted la utilice. Su
sistema Linux tiene docenas de servicios
preinstalados. De ellos, el más conocido es el
omnipresente servidor web Apache, que se utiliza
para crear, administrar e implementar servidores web, pero hay muc
Para los propósitos de este capítulo sobre servicios, he
seleccionado sólo cuatro que son de particular importancia
para el hacker: Apache Web Server, OpenSSH, MySQL
y PostgreSQL.
En este capítulo, aprenderá cómo configurar un servidor web con Apache, espiar
físicamente con OpenSSH, acceder a datos con MySQL y almacenar su información de
piratería con PostgreSQL.
¡GUAU! Libro
Iniciar, detener y reiniciar servicios

Antes de comenzar a trabajar con estos cuatro servicios cruciales, comencemos examinando
cómo iniciar, detener y reiniciar servicios en Linux.
Algunos servicios se pueden detener e iniciar a través de la GUI en Kali Linux, como
lo haría en un sistema operativo como Windows o Mac. Sin embargo, algunos servicios
requieren el uso de la línea de comando, que veremos aquí.
Aquí está la sintaxis básica para gestionar servicios:
servicio nombre del servicio inicio|detener|reiniciar
Para iniciar el servicio apache2 (servidor web o servicio HTTP), ingresaría lo siguiente:
kali > inicio del servicio apache2
Para detener el servidor web Apache, ingrese:
kali > parada del servicio apache2
Por lo general, cuando realiza un cambio de configuración en una aplicación o

servicio alterando su archivo de configuración de texto sin formato, debe reiniciar el
servicio para capturar la nueva configuración. Así, ingresarías lo siguiente:
kali > reinicio del servicio apache2
Ahora que comprende cómo iniciar, detener y reiniciar servicios desde la línea de
comandos, pasemos a los cuatro servicios de Linux más críticos para los piratas informáticos.
Crear un servidor web HTTP con el servidor web Apache

El servidor web Apache es probablemente el servicio más utilizado en sistemas Linux.
Apache se encuentra en más del 60 por ciento de los servidores web del mundo, por lo que
cualquier administrador de Linux que se precie debería estar familiarizado con él. Como
hacker que aspira a piratear sitios web, es fundamental comprender el funcionamiento
interno de Apache, los sitios web y las bases de datos backend de estos sitios. También
puede utilizar Apache para configurar su propio servidor web, desde el cual podría enviar
malware mediante secuencias de comandos entre sitios (XSS) a cualquiera que visite su
sitio, o podría clonar un sitio web y redirigir el tráfico a su sitio mediante el abuso de el
Sistema de Nombres de Dominio (DNS). En cualquiera de estos casos, se requieren
conocimientos básicos de Apache.

Comenzando con apache
Si tiene Kali ejecutándose en su sistema, Apache ya está instalado. Muchas otras distribuciones
de Linux también lo tienen instalado de forma predeterminada. Si no tienes instalado
Apache, puedes descargarlo e instalarlo desde los repositorios ingresando lo siguiente:
kali >aptget instalar apache2
El servidor web Apache suele estar asociado con la base de datos MySQL (que veremos
en la siguiente sección) y estos dos servicios suelen combinarse con un lenguaje de
programación como Perl o PHP para desarrollar aplicaciones web. Esta combinación de Linux,
Apache, MySQL y PHP o Perl forma una plataforma poderosa y robusta para el desarrollo e
implementación de aplicaciones basadas en web, conocidas colectivamente como LAMP. Estas
son las herramientas más utilizadas para desarrollar sitios web en el mundo de Linux, y también
son muy populares en el mundo de Microsoft, donde generalmente se las conoce como WAMP,
donde la W significa Windows.
El primer paso, por supuesto, es iniciar nuestro demonio Apache. En Kali, vaya a
Applications4Services4HTTPD y haga clic en Inicio de Apache. Puede lograr lo mismo desde
la línea de comando ingresando lo siguiente:
kali > servicios inicio apache2
Ahora que Apache se está ejecutando, debería poder mostrar su página web
predeterminada. Ingrese http://localhost/ en su navegador web favorito para abrir la página
web, que debería verse similar a la Figura 121.
Figura 121: La página predeterminada del servidor web Apache2
Como puede ver, Apache muestra "Funciona" como su página web predeterminada. Ahora
que sabes que tu Servidor Web Apache está funcionando, ¡personalicémoslo!
Uso y abuso de los servicios 123

¡GUAU! Libro
Editando el archivo index.html
La página web predeterminada de Apache está en /var/www/html/index.html. Puede editar el archivo

index.html para proporcionar la información que desee, así que creemos el nuestro propio. Para ello,
puede utilizar cualquier editor de texto que desee; Usaré Leafpad.
Abra /var/www/html/index.html y debería ver algo como el Listado 121.
<!DOCTYPE html PUBLIC "//W3C//DTD XHTML 1.0 Transicional//ES"

"http://www.w3.org/TR/xhtm11/DTD/xhtm11transiti
<html xmlns="http://www.w3.org/1999/xhtml>
<cabeza>
<meta httpequiv="Tipo de contenido" content="text/html; conjunto de caracteres=UTF8" I>

u <title>Página predeterminada de Apache2 Debian: funciona</title>
<tipo de estilo="texto/css" media="pantalla">
*{
margen: Opx Opx Opx Opx;
relleno: Opx Opx Opx Opx;
}
cuerpo, html {
relleno: 3px 3px 3px 3px;
color de fondo: #D8DBE2;
familia de fuentes: Verdana, sansserif;
tamaño de fuente: 11 puntos;
alineación de texto: centro;

}
div.página_principal {
posición: relativa;
pantalla: mesa;
Listado 121: El archivo index.html del servidor web Apache
Tenga en cuenta aquí que la página web predeterminada tiene exactamente el texto que se
mostró cuando abrimos nuestro navegador en localhost, pero en formato HTML u.
Todo lo que necesitamos hacer es editar o reemplazar este archivo para que nuestro servidor web
muestre la información que queremos.
Agregar algo de HTML
Ahora que tenemos el servidor web en funcionamiento y el archivo index.html abierto, podemos
agregar cualquier texto que queramos que proporcione el servidor web. Crearemos algunos bloques
HTML simples.
Creemos esta página. En un nuevo archivo en su editor de texto, ingrese el código que se
muestra en el Listado 122.
<html>
<cuerpo>
<h1>¡HackersArise es lo mejor! </h1>
<p> Si quieres aprender a hackear, HackersArise.com </p>

¡<p> es el mejor lugar para aprender a hackear!</p>

</cuerpo>
</html>
Listado 122: HTML simple para agregar al archivo index.html
Una vez que haya ingresado el texto exactamente como aparece en el Listado 122,
guarde este archivo como /var/www/html/index.html y cierre su editor de texto. Su editor
de texto le indicará que el archivo ya existe. Esta bien. Simplemente sobrescriba el archivo /
var/www/html/index.html existente .
Ver lo que sucede

Habiendo guardado nuestro archivo /var/www/html/index.html , podemos verificar qué
servirá Apache. Navegue su navegador una vez más a http://localhost y debería ver algo
como la Figura 122.
Figura 122: Nuevo sitio web HackersArise
¡Apache ha presentado nuestra página web tal como la creamos!
OpenSSH y Raspberry Spy Pi

SSH es un acrónimo de Secure Shell y es básicamente lo que nos permite conectarnos
de forma segura a una terminal en un sistema remoto, un reemplazo del inseguro
telnet que era tan común hace años. Cuando construimos un servidor web, SSH nos
permite crear una lista de acceso (una lista de usuarios que pueden usar este servicio),
autenticar usuarios con contraseñas cifradas y cifrar todas las comunicaciones. Esto reduce
la posibilidad de que usuarios no deseados utilicen el terminal remoto (debido al proceso
de autenticación agregado) o intercepten nuestra comunicación (debido al cifrado).
Probablemente el servicio SSH de Linux más utilizado sea OpenSSH, que se instala en
casi todas las distribuciones de Linux, incluida Kali.
Los administradores de sistemas suelen utilizar SSH para gestionar sistemas

remotos, y los piratas informáticos suelen utilizar SSH para conectarse a sistemas remotos
comprometidos, por lo que haremos lo mismo aquí. En este ejemplo, usamos SSH para
configurar un sistema Raspberry Pi remoto para espiar, algo que yo llamo "Raspberry Spy
Pi". Para ello, necesitará una Raspberry Pi y el correspondiente módulo de cámara Raspberry Pi.

¡GUAU! Libro
Sin embargo, antes de hacer eso, inicie OpenSSH en su sistema Kali con el
comando ahora familiar:
kali > inicio del servicio ssh
Usaremos SSH para construir y controlar una Raspberry Pi de espionaje remoto.

Si aún no está familiarizado con ella, la Raspberry Pi es una computadora pequeña pero
poderosa, del tamaño de una tarjeta de crédito, que funciona muy bien como herramienta de
espionaje remoto. Emplearemos una Raspberry Pi con un módulo de cámara para usarla como
dispositivo de espionaje remoto. Puedes comprar una Raspberry Pi en casi cualquier tienda de
electrónica, incluido Amazon, por menos de 50 dólares, y puedes conseguir el módulo de la
cámara por unos 15 dólares.
Aquí, usaremos Raspberry Spy Pi en la misma red que nuestro sistema Kali, lo que nos
permite usar direcciones IP internas privadas. Por supuesto, al hackear en el mundo real,
probablemente querrás configurarlo en otra red remota, pero eso sería un poco más difícil y
estaría fuera del alcance de este libro.
Configurando la Raspberry Pi
Asegúrese de que su Raspberry Pi esté ejecutando el sistema operativo Raspbian; Esta es

simplemente otra distribución de Linux adaptada específicamente a la CPU Raspberry Pi.
Puede encontrar instrucciones de descarga e instalación de Raspbian en https://
www.raspberrypi.org/downloads/raspbian/. Casi todo lo que ha aprendido en este libro se aplica
al sistema operativo Raspbian en Raspberry Pi, así como a Kali, Ubuntu y otras distribuciones
de Linux.
Una vez que haya descargado e instalado su sistema operativo Raspbian, deberá
conectar su Raspberry Pi a un monitor, mouse y teclado y luego conectarlo a Internet. Si
todo esto es nuevo para usted, consulte las instrucciones en https://www.raspberrypi.org/
learning/hardwareguide/. Con todo configurado, inicia sesión con el nombre de usuario pi y
la contraseña raspberry.
Construyendo la Raspberry Spy Pi
El primer paso es asegurarse de que SSH esté ejecutándose y habilitado en Raspberry Spy
Pi. SSH suele estar desactivado de forma predeterminada, por lo que para habilitarlo, vaya
al menú Preferencias e inicie la Configuración de Raspberry Pi. Luego vaya a la pestaña Interfaces
y, junto a SSH, haga clic en Habilitado (si aún no está marcado) y haga clic en Aceptar.
Cuando SSH está habilitado, puede iniciarlo en su Raspberry Spy Pi al

abriendo una terminal e ingresando lo siguiente:
kali > inicio del servicio ssh
A continuación, debe conectar el módulo de su cámara. Si estás usando una frambuesa

Placa Pi versión 3, solo hay un lugar para conectarla. Apague el Pi,
126 Capítulo 12
¡GUAU! Libro
conecte el módulo al puerto de la cámara y luego enciéndalo nuevamente. Tenga en cuenta que
la cámara es muy frágil y nunca debe entrar en contacto con los pines de entrada/salida de uso
general (GPIO); de lo contrario, podría acortarse y morir.
Ahora, con el servicio SSH en funcionamiento, coloque la Raspberry Spy Pi en algún
lugar de su casa, escuela o cualquier otro lugar que desee espiar. Por supuesto, debe estar
conectado a la red de área local, ya sea mediante cable Ethernet o, idealmente, mediante
WiFi. (Los nuevos Raspberry Pi 3 y Raspberry Pi Zero tienen WiFi incorporado).
Ahora necesitas obtener la dirección IP de tu Raspberry Pi. Como tu

Como aprendió en el Capítulo 3, puede obtener la dirección IP de un dispositivo Linux
usando ifconfig:
pi >ifconfig
La dirección IP de mi Pi es 192.168.1.101, pero asegúrese de utilizar la dirección IP de su

Raspberry Spy Pi siempre que aparezca mi dirección en este capítulo. Ahora, desde su sistema
Kali, debería poder conectarse directamente y controlar su Raspberry Spy Pi y usarlo como un
sistema de espionaje remoto.
En este ejemplo sencillo, su sistema deberá estar en la misma red que el Pi.
Para conectarse a la Raspberry Spy Pi remota a través de SSH desde su sistema Kali,
ingrese lo siguiente, recordando usar la dirección IP de su propia Pi:
kali >sshpi@192.168.1.101
Contraseña de pi@192.168.1.101:
Los programas incluidos con el sistema Debian GNU/Linux son software libre;
Los términos de distribución exactos para cada programa se describen en la
archivos individuales en /usr/share/doc/*/copyright.
Debian GNU/Linux viene SIN ABSOLUTAMENTE NINGUNA GARANTÍA, en la medida

permitido por la ley aplicable
último inicio de sesión: martes 1 de enero 12:01:01 2018
pi@raspberyypi:: $
Luego, el Spy Pi le pedirá una contraseña. En este caso, la contraseña predeterminada es

frambuesa, a menos que la hayas cambiado.
Configurando la cámara
A continuación, necesitamos configurar la cámara. Para hacerlo, inicie la herramienta de
configuración Raspberry Pi ingresando el siguiente comando:
pi >sudo raspiconfig
Esto debería iniciar un menú gráfico como el que se muestra en la Figura 123.

¡GUAU! Libro
Figura 123: La herramienta de configuración Raspberry Pi
Desplácese hacia abajo hasta 6 Habilitar cámara y presione Enter. Ahora, desplácese hasta la
parte inferior de este menú, seleccione Finalizar y presione Intro, como se muestra en la Figura 124.
Figura 124: Finalizando la configuración
Cuando la herramienta de configuración le pregunta si desea reiniciar, como se muestra en

Figura 125, seleccione Sí y presione Intro nuevamente.
Figura 125: Reinicie el Pi para habilitar los cambios.
¡Ahora tu cámara Raspberry Spy Pi debería estar habilitada y lista para espiar!

Empezando a espiar
Una vez que su Raspberry Spy Pi se haya reiniciado y haya iniciado sesión a través de SSH
desde su terminal Kali, estará listo para comenzar a usarlo para espiar tomando fotografías.
El sistema operativo Raspbian tiene una aplicación llamada raspistill

que usaremos para tomar fotografías desde nuestra pequeña Raspberry Spy Pi.
Ingrese raspistill en la terminal para ver la pantalla de ayuda de la herramienta y todas sus
opciones:
pi@raspberrypi: raspistill
Aplicación de cámara raspistill v1.3.8
Ejecuta la cámara durante un tiempo específico y realiza una captura JPG al final si se solicita
uso: raspistill [opciones]
Comandos de parámetros de imagen
recorte
¡Usemos ahora Raspberry Spy Pi para tomar algunas fotografías de espionaje remoto!
El comando raspistill tiene numerosas opciones que debes explorar, pero aquí simplemente
usaremos las predeterminadas. Para tomar una fotografía y guardarla como JPEG, ingrese lo
siguiente:
pi@raspberrypi: raspistill v o primera imagen.jpg

Aplicación de cámara raspistill v1.3.8
ancho 2592, alto 1944, calidad 85, nombre de archivo firstpicture.jpg
Retraso de tiempo 5000, sin formato
recorte
Usamos la opción –v para obtener una salida detallada y la opción –o para decirle a raspistill
que estamos a punto de darle un nombre de archivo para usar; luego le damos el nombre del archivo.
Cuando hacemos un listado largo de Raspberry Spy Pi, podemos ver el archivo firstpicture.jpg,
pi@raspberrypi: ls l
total 2452
drwxrxrx 2 pi pi drwxrxrx 2 pi 4096 18 de marzo de 2019 Escritorio
pi drwxrxrx 2 pi pi rwrr 1 4096 18 de marzo de 2019 Documentos
pi pi drwxrxrx 2 pi pi drwxrxr 4096 18 de marzo de 2019 Descargas
x 2 pi pi cortar 2472219 18 de marzo de 2019 primera imagen.jpg
4096 18 de marzo de 2019 Música
4096 18 de marzo de 2019 Imágenes
Hemos tomado nuestra primera foto espía en nuestro control remoto Raspberry Spy Pi
usando SSH! Siéntete libre de explorar más a fondo esta arma versátil.

¡GUAU! Libro
Extrayendo información de MySQL

MySQL es la base de datos más utilizada detrás de aplicaciones web basadas en bases
de datos. En nuestra era moderna de tecnologías Web 2.0, donde casi todos los sitios
web funcionan con bases de datos, esto significa que MySQL contiene los datos de la
mayor parte de la web.
Las bases de datos son el “vellón de oro” de los hackers. Contienen información
crítica sobre los usuarios, así como información confidencial, como números de tarjetas de
crédito. Por esta razón, los piratas informáticos suelen atacar las bases de datos.
Al igual que Linux, MySQL es de código abierto y tiene licencia pública general (GPL).
y lo encontrará preinstalado en casi todas las distribuciones de Linux.
Al ser gratuito, de código abierto y potente, MySQL se ha convertido en el
base de elección para muchas aplicaciones web, incluidos sitios web populares como
WordPress, Facebook, LinkedIn, Twitter, Kayak, Walmart.com, Wikipedia y YouTube.
Otros sistemas de gestión de contenidos (CMS) populares, como Joomla, Drupal y

Ruby on Rails, también utilizan MySQL. Entiendes la idea. Si desea desarrollar o atacar las
bases de datos backend de aplicaciones web, debe conocer MySQL. Empecemos.
Iniciando MySQL
Afortunadamente, Kali ya tiene MySQL instalado (si está utilizando otra distribución, puede
descargar e instalar MySQL desde el repositorio de software o directamente desde https://
www.mysql.com/downloads/).
Para iniciar su servicio MySQL, ingrese lo siguiente en la terminal:
kali > inicio del servicio mysql
A continuación, debe autenticarse iniciando sesión. Ingrese lo siguiente y, cuando se

le solicite una contraseña, simplemente presione Intro:
kali >mysql u raíz p

Introducir la contraseña:
Bienvenido al monitor MySQL. Los comandos terminan con ; o \g.
Su ID de conexión MySQL es 4
Versión del servidor: 5.6.301 (Debian)
Copyright (c) 2000, 2016, Oracle y/o sus filiales. Reservados todos los derechos
Oracle es una marca registrada de Oracle Corporation y/o sus

afiliados. Otros nombres pueden ser marcas comerciales de sus respectivos
propietarios
Escriba 'ayuda'; o '\h' para obtener ayuda. Escriba '\c' para borrar la declaración de entrada actual
mysql >
En la configuración predeterminada de MySQL, la contraseña del usuario root está vacía.

Obviamente, esta es una vulnerabilidad de seguridad importante y usted debe remediarla.

agregando una contraseña después de su primer inicio de sesión. Tenga en cuenta que los nombres
de usuario y las contraseñas para su sistema operativo y MySQL son separados y distintos. Cambiemos
la contraseña del usuario root de MySQL ahora para estar seguros.
Pasado y futuro de MySQL
MySQL fue desarrollado por primera vez por MySQL AB de Suecia en 1995 y luego fue
adquirido por Sun Microsystems en 2008, que a su vez fue adquirido por Oracle en
2009, por lo que MySQL ahora es propiedad de Oracle. Oracle es el editor de software
de bases de datos más grande del mundo, por lo que la comunidad de código
abierto tiene importantes inquietudes sobre el compromiso de Oracle de mantener
MySQL como código abierto. Como resultado, ahora existe una bifurcación del software de
base de datos MySQL llamada “Maria” que se compromete a mantener este software y
sus versiones posteriores de código abierto. Como administrador de Linux o hacker, debes vigilar a María.
Interactuando con MySQL
SQL es un lenguaje de programación interpretado para interactuar con una base de datos. La base de
datos suele ser una base de datos relacional , lo que significa que los datos se almacenan en varias
tablas que interactúan y cada tabla tiene valores en una o más columnas y filas.
Existen varias implementaciones de SQL, cada una con sus propios comandos.
y sintaxis, pero aquí hay algunos comandos comunes:
seleccione Usado para recuperar datos
unión Se utiliza para combinar los resultados de dos o más operaciones seleccionadas.
insertar Se utiliza para agregar nuevos datos.
actualizar Se utiliza para modificar datos existentes.

eliminar Se utiliza para eliminar datos.
Puedes proporcionar condiciones a cada comando para que sea más específico.
específico sobre lo que quieres hacer. Por ejemplo, la línea
seleccione usuario, contraseña de clientes donde usuario='admin';
devolverá los valores de los campos de usuario y contraseña para cualquier usuario cuyo valor de
usuario sea igual a "admin" en la tabla de clientes.
Establecer una contraseña MySQL
Veamos qué usuarios ya hay en nuestro sistema MySQL ingresando lo siguiente. (Tenga en
cuenta que los comandos en MySQL terminan con un punto y coma).
Uso y abuso de servicios 131

¡GUAU! Libro
mysql > seleccione usuario, host, contraseña de mysql.user;

+
| usuario | anfitrión | contraseña
+
|raíz | |localhost | |
raíz | afrodita.kali.org |127.0.0.1 |
raíz |
snip
Esto muestra que los usuarios root no tienen contraseña establecida. Asignemos una
contraseña a root. Para hacerlo, primero seleccionaremos una base de datos con la que trabajar.
MySQL en su sistema vendrá con algunas bases de datos ya configuradas. Utilice las bases
de datos del programa; comando para ver todas las bases de datos disponibles:
mysql >mostrar bases de datos;

++
| Base de datos |
++
| esquema_información | |
MySQL | |
esquema_rendimiento |
++
3 filas en conjunto (0,23 segundos)
MySQL viene con tres bases de datos por defecto, dos de las cuales (información_
esquema y esquema_rendimiento) son bases de datos administrativas que no usaremos aquí. Usaremos la
base de datos no administrativa, mysql, que se incluye para sus propios fines. Para comenzar a utilizar la base
de datos mysql , ingrese:
mysql > usar mysql;

Leer información de la tabla para completar los nombres de tablas y columnas
Puede desactivar esta función para obtener un inicio más rápido con A
Base de datos cambiada
Este comando nos conecta a mysql. Ahora, podemos establecer la contraseña para que el
usuario root surja hackers con el siguiente comando:
mysql >actualizar contraseña establecida por el usuario = CONTRASEÑA("hackersarise") donde usuario = 'raíz';
Este comando actualizará al usuario configurando la contraseña de root del usuario en

hackersarise.
Accediendo a una base de datos remota
Para acceder a una base de datos MySQL en el host local, utilizamos la siguiente sintaxis:
kali >mysql u <nombre de usuario> p

De forma predeterminada, este comando usa la instancia de MySQL en el host local si no se le proporciona
un nombre de host o una dirección IP. Entonces, para acceder a una base de datos remota, debemos proporcionar
el nombre de host o la dirección IP del sistema que aloja la base de datos MySQL. He aquí un ejemplo:
kali >mysql u raíz p 192.168.1.101
Esto nos conectará a la instancia de MySQL en 192.168.1.101 y nos solicitará una contraseña. Para fines
de demostración, me estoy conectando a una instancia de MySQL en mi red de área local (LAN). Si tiene un
sistema en su red con MySQL instalado, use su dirección IP aquí. Asumiré que logró omitir la contraseña e
inició sesión en el sistema como root (ya sabe que, de manera predeterminada, la base de datos MySQL no
tiene contraseña).
Esto abre la interfaz de línea de comandos de MySQL, que nos proporciona el indicador mysql >. Además
de esta interfaz de línea de comandos, MySQL tiene interfaces GUI, tanto nativas (MySQL Workbench) como de
terceros (Navicat y TOAD para MySQL). Para usted como hacker, la interfaz de línea de comandos puede ser la
mejor oportunidad para explotar la base de datos MySQL, así que nos centraremos en eso aquí. Es poco
probable que, como ingresante no autorizado a la base de datos, se le presente una GUI fácil de usar.
N ota Esta pantalla nos recuerda que todos los comandos deben terminar en punto y coma o \g (a diferencia de SQL
Server de Microsoft) y que podemos obtener ayuda ingresando ayuda; o \h.
Ahora que hemos iniciado sesión como administrador del sistema, podemos navegar unim
pedió a través de la base de datos. Si hubiésemos iniciado sesión como usuario normal, nuestra navegación
estaría limitada por los permisos proporcionados por el administrador del sistema para ese usuario.
Conexión a una base de datos
Con acceso al sistema, queremos husmear. Nuestro siguiente paso es descubrir si hay bases de datos a las que
valga la pena acceder. Aquí está el comando para encontrar qué bases de datos están en el sistema al que se
accede:
mysql >mostrar bases de datos;

++
| Base de datos |
++
| esquema de información | |
MySQL | |
números de tarjetas de |
crédito | esquema_rendimiento |
++
4 filas en conjunto (0,26 segundos)
¡Ajá! Hemos encontrado una base de datos que vale la pena explorar con números de tarjetas de crédito.
Conectémonos con él.

¡GUAU! Libro
En MySQL, como en otros sistemas gestores de bases de datos (DBMS), podemos conectarnos a la base
de datos que nos interese ingresando use nombre de base de datos;.
mysql > usar números de tarjetas de crédito;

Base de datos cambiada
La respuesta de Base de datos modificada indica que ahora estamos conectados a

la base de datos de números de tarjetas de crédito.
Por supuesto, no hace falta decir que es poco probable que un administrador de base de datos sea
tan complaciente como para nombrar una base de datos con algo tan fácilmente reconocible como
números de tarjetas de crédito, por lo que es posible que deba explorar un poco para encontrar una base de
datos de interés.
Tablas de base de datos
Ahora estamos conectados a la base de datos de números de tarjetas de crédito y podemos explorar un poco para
ver qué información podría contener. Los datos de una base de datos se organizan en tablas, y cada tabla puede
contener un conjunto diferente de datos relacionados.
Podemos saber qué tablas hay en esta base de datos ingresando el siguiente comando:
mysql >mostrar tablas;

++
| Tablas_en_números de tarjetas de crédito |
++
| números de tarjeta |
++
1 fila en conjunto (0,14 segundos)
Aquí podemos ver que esta base de datos tiene solo una tabla, llamada números de tarjeta.
Generalmente, las bases de datos tendrán numerosas tablas, por lo que es probable que tengas que espiar un
poco más. En esta base de datos de muestra, tenemos la suerte de poder centrar nuestra atención en esta única
tabla para extraer el vellocino de oro del hacker.
Ahora que tenemos una tabla que queremos examinar, necesitamos comprender la estructura de esa
tabla. Una vez que sabemos cómo está dispuesta la tabla, podemos extraer la información relevante.
Puede ver la estructura de la tabla usando la declaración describe, así:
mysql > describir números de tarjeta;

++++ +++
| Campo | Tipo | Nulo | Llave | Predeterminado | Adicional |
++++ +++
| clientes | | varchar(15) | SÍ | varchar(15) | | NULO | |
dirección | | SÍ | varchar(15) | SÍ | | | NULO | |
ciudad | varchar(15) | SÍ | entero(12) | | NULO | |
estado | | | NULO | |
cc | NO | |0 | |
++++ +++
134 Capítulo 12
¡GUAU! Libro
MySQL responde con la información crítica sobre la estructura de nuestra tabla de interés. Podemos
ver el nombre de cada campo, así como el tipo de datos que contiene (a menudo el tipo de texto varchar o
el tipo entero int). También podemos ver si aceptará valores NULL; la clave, si existe alguna (la clave
vincula las tablas); cualquier valor predeterminado que pueda tener un campo; y cualquier información
adicional al final, como notas.
Examinando los datos
Para ver realmente los datos en la tabla, usamos el comando SELECT. El SELECCIONAR
El comando requiere que conozca la siguiente información:
•La tabla que contiene los datos que desea ver
•Las columnas dentro de esa tabla que contienen los datos que desea ver
Lo exponemos en el siguiente formato:
SELECCIONAR columnas DE la tabla
Como un atajo útil para ver los datos de todas las columnas, podemos usar un
asterisco como comodín en lugar de escribir cada nombre de columna que queremos ver. Entonces, para
ver un volcado de todos los datos de la tabla de números de tarjetas, ingresamos lo siguiente:
mysql >SELECT * FROM números de tarjeta;

++++ ++
| clientes | DIRECCIÓN | ciudad | estado | cc |
++++ ++
| jones | 1 calle de la pared | Nueva York | Nueva York | 12345678 |
| Aserrador | 12 Picadilly | Londres | Reino Unido | 234567890 |
| Gama | 25 calle delantera | Los Ángeles | California | 4567898877 |
++++ ++
Como puede ver, MySQL ha mostrado toda la información de la tabla de números de tarjeta en
nuestra pantalla. ¡Hemos encontrado el vellocino de oro del hacker!
PostgreSQL con Metasploit
PostgreSQL, o simplemente Postgres, es otra base de datos relacional de código abierto que se utiliza
a menudo en aplicaciones muy grandes orientadas a Internet debido a su capacidad para escalar
fácilmente y manejar cargas de trabajo pesadas. Fue lanzado por primera vez en julio de 1996 y lo
mantiene un grupo importante de desarrolladores conocido como PostgreSQL Global Development
Group.
PostgreSQL también se instala de forma predeterminada en Kali, pero si está utilizando otra
distribución de Linux, probablemente estará en su repositorio y podrá instalarlo ingresando el siguiente
comando:
kali >aptobtener instalación de postgres

¡GUAU! Libro
Como hacker, PostgreSQL le resultará particularmente importante porque es la base de datos

predeterminada del marco de pruebas de penetración y piratería más utilizado, Metasploit. Metasploit utiliza
PostgreSQL para almacenar sus módulos, así como los resultados de escaneos y exploits, para facilitar
su uso en una prueba de penetración o pirateo. Por esa razón, usaremos PostgreSQL aquí en el contexto de
Metasploit.
Como ocurre con casi todos los servicios en Linux, podemos iniciar PostgreSQL ingresando al inicio
de la aplicación de servicio, así:
kali > inicio del servicio postgresql
Con PostgreSQL en funcionamiento, iniciemos Metasploit:
kali > msfconsole
Tenga en cuenta que cuando Metasploit haya completado el inicio, verá un mensaje msf >.
Enseñarle cómo usar Metasploit con fines de piratería y explotación está más allá del alcance de este
libro, pero aquí configuraremos la base de datos en la que Metasploit almacenará su información.
Con Metasploit en ejecución, podemos configurar PostgreSQL con el siguiente comando para que
almacene datos de cualquier actividad de Metasploit en su sistema:
msf > inicio de msfdb

[*] ejecutivo: inicio de msfdb
Crear base de datos utiliza 'msf'
Ingrese la contraseña para el nuevo rol
Ingrese nuevamente:
Creando bases de datos 'msf' y 'msf_test'
Creando el archivo de configuración /usr/share/metasploitframework/config/database.yml
Creando un esquema de base de datos inicial
A continuación, debemos iniciar sesión en Postgres como root. Aquí, precedemos a la com.
Mande con su, el comando “cambiar de usuario”, para obtener privilegios de root:
msf >su postgres

[*] en postgres
postgres@kali:/raíz$
Cuando inicie sesión en Postgres, verá que el mensaje ha cambiado

a postgres@kali:/root$, que representa la aplicación, el nombre de host y el usuario.
En el siguiente paso, necesitamos crear un usuario y una contraseña, así:
postgres@kali:/root$ crear usuario msf_user P

Ingrese la contraseña para el nuevo rol:
Ingrese nuevamente:
136 Capítulo 12
¡GUAU! Libro
Creamos el nombre de usuario msf_user usando la opción –P con createuser

dominio. Luego ingrese la contraseña deseada dos veces. A continuación, debe crear la base de
datos y otorgar permisos para msf_user. Nombra la base de datos hackers_arise_db, como se
muestra aquí:
postgres@kali:/root$ creadob owner=msf_user hackers_arise_db

postgres@kali:/root$ salir
Cuando salga de Postgres con el comando de salida, la terminal volverá al mensaje msf >.
A continuación, tenemos que conectar nuestra consola Metasploit, msfconsole, a nuestro

Base de datos PostgreSQL definiendo lo siguiente:
•El usuario
•La contraseña
•El anfitrión
•El nombre de la base de datos
En nuestro caso, podemos conectar msfconsole a nuestra base de datos con el siguiente
comando ing:
msf >db_connect msf_user:contraseña@127.0.0.1/hackers_arise_db
Por supuesto, deberá proporcionar la contraseña que utilizó anteriormente. La dirección IP

es la de su sistema local (localhost), por lo que puede usar 127.0.0.1 a menos que haya creado
esta base de datos en un sistema remoto.
Por último, podemos verificar el estado de la base de datos PostgreSQL para asegurarnos
de que esté conectada:
msf > estado_db

[*] postgresql conectado a msf
Como puede ver, Metasploit responde que la base de datos PostgreSQL está conectada
y lista para usar. Ahora, cuando hagamos un análisis del sistema o ejecutemos exploits con
Metasploit, los resultados se almacenarán en nuestra base de datos PostgreSQL. Además,
Metasploit ahora almacena sus módulos en nuestra base de datos Postgres, ¡lo que hace que la
búsqueda del módulo correcto sea mucho más fácil y rápida!
Resumen
Linux cuenta con numerosos servicios que se ejecutan en segundo plano hasta que el usuario
los necesita. El servidor web Apache es el más utilizado, pero un hacker también debe estar
familiarizado con MySQL, SSH y PostgreSQL para diversas tareas. En este capítulo, cubrimos
los conceptos básicos absolutos para comenzar a utilizar estos servicios. Una vez que se sienta
cómodo con su sistema Linux, le insto a que explore más a fondo cada uno de estos servicios.

¡GUAU! Libro
Ejercicios
1. Inicie su servicio apache2 a través de la línea de comando.
2. Utilizando el archivo index.html, cree un sitio web sencillo que anuncie su llegada al
apasionante mundo del hacking.
3. Inicie su servicio SSH a través de la línea de comando. Ahora conéctate a tu Kali

sistema desde otro sistema en su LAN.
4. Inicie su servicio de base de datos MySQL y cambie la contraseña del usuario root a
hackersarise. Cambie a la base de datos mysql.
5. Inicie su servicio de base de datos PostgreSQL. Configúrelo como se describe en

este capítulo para que Metasploit lo utilice.
138 Capítulo 12
¡GUAU! Libro
13
Convertirse en seguro y
Anónimo
Hoy en día, se realiza un seguimiento de casi

todo lo que hacemos en Internet. Quienquiera que
esté haciendo el seguimiento, ya sea Google rastreando nuestra
búsquedas en línea, visitas a sitios web y correo electrónico o el
La Agencia de Seguridad Nacional (NSA) cataloga todas nuestras
actividades; cada uno de nuestros movimientos en línea se registra,
indexados y luego extraídos para el beneficio de alguien. El individuo promedio
y el hacker, en particular, necesita entender cómo limitar este seguimiento
y permanecer relativamente anónimo en la web para limitar esta
vigilancia ubicua.
En este capítulo, analizamos cómo navegar por la World Wide Web.
de forma anónima (o lo más cerca posible) usando cuatro métodos:
•La Red Cebolla

•Servidores proxy
•Redes privadas virtuales
• Correo electrónico privado cifrado
¡GUAU! Libro
Ningún método garantiza que sus actividades estén a salvo de miradas indiscretas y, con
suficiente tiempo y recursos, se puede rastrear cualquier cosa. Sin embargo, es probable que
estos métodos dificulten mucho el trabajo del rastreador.
Cómo nos delata Internet
Para comenzar, analicemos a alto nivel algunas de las formas en que se rastrean nuestras
actividades en Internet. No entraremos en todos los métodos de seguimiento ni en demasiados
detalles sobre ninguno de ellos, ya que eso estaría fuera del alcance de este libro.
De hecho, una discusión así podría ocupar por sí sola un libro entero.
Primero, su dirección IP lo identifica cuando navega por Internet. Los datos enviados
desde su máquina generalmente están etiquetados con su dirección IP, lo que facilita el
seguimiento de sus actividades. En segundo lugar, Google y otros servicios de correo electrónico
“leerán” su correo electrónico en busca de palabras clave para ofrecerle anuncios de manera más eficiente.
Aunque hay muchos métodos más sofisticados que requieren mucho más tiempo y recursos,
estos son los que intentamos evitar en este capítulo. Comencemos echando un vistazo a
cómo las direcciones IP nos delatan en Internet.
Cuando envía un paquete de datos a través de Internet, contiene las direcciones IP del
origen y el destino de los datos. De esta forma, el paquete sabe adónde va y dónde devolver la
respuesta. Cada paquete salta a través de múltiples enrutadores de Internet hasta que encuentra
su destino y luego regresa al remitente. Para la navegación general por Internet, cada salto es
un enrutador por el que pasa el paquete para llegar a su destino. Puede haber entre 20 y 30 saltos
entre el remitente y el destino, pero normalmente cualquier paquete llegará al destino en menos de
15 saltos.
A medida que el paquete atraviesa Internet, cualquiera que lo intercepte puede ver quién lo
envió, dónde ha estado y hacia dónde se dirige. Esta es una forma en que los sitios web pueden
saber quién es usted cuando llega e iniciar sesión automáticamente, y también es la forma en
que alguien puede rastrear dónde ha estado en Internet.
Para ver qué saltos puede realizar un paquete entre usted y el destino, puede usar el
comando traceroute, como se muestra a continuación. Simplemente ingrese traceroute
y la dirección IP o dominio de destino, y el comando enviará paquetes al destino y rastreará la ruta
de esos paquetes.
kali >traceroruta google.com

traceroute a google.com (172.217.1.78), 30 saltos máximo, paquetes de 60 bytes
1 192.168.1.1 (192.168.1.1) 4,152 ms 3,834 ms 32,964 ms
2 10.0.0.1 (10.0.0.1) 5,797 ms 6,995 ms 7,679 ms
3 96.120.96.45 (96.120.96.45) 27.952 ms 30.377 ms 32.964 ms
recorte
18 lgal15s44inf14.le100.net (172.217.1.78) 94,666 ms 42,990 ms 41,564 ms
Como puede ver, www.google.com está a 18 saltos de distancia de mí en Internet.

Es probable que sus resultados sean diferentes porque su solicitud provendrá de una
ubicación diferente y porque Google tiene muchos servidores en todo el mundo. Además, los
paquetes no siempre toman la misma ruta a través del
140 Capítulo 13
¡GUAU! Libro
Internet, por lo que podrías enviar otro paquete desde tu dirección al

mismo sitio y recibir una ruta diferente. Veamos cómo podemos disfrazar
todo esto con la red Tor.
El sistema de enrutador de cebolla

En la década de 1990, la Oficina de Investigación Naval (ONR) de Estados Unidos se
propuso desarrollar un método para navegar anónimamente por Internet con fines de espionaje.
El plan era configurar una red de enrutadores que estuviera separada de los
enrutadores de Internet, que pudiera cifrar el tráfico y que solo almacenara la
dirección IP no cifrada del enrutador anterior, lo que significaba que todas las demás
direcciones de enrutador a lo largo del camino estaban cifradas. La idea era que
cualquiera que observara el tráfico no pudiera determinar el origen o destino de los
datos. Esta investigación se conoció como “El Proyecto Onion Router (Tor)” en 2002,
y ahora está disponible para que cualquiera pueda utilizarla para una navegación
relativamente segura y anónima en la Web.
Cómo funciona Tor
Los paquetes enviados a través de Tor no se envían a través de enrutadores

regulares tan estrechamente monitoreados por tanta gente, sino que se envían a
través de una red de más de 7.000 enrutadores en todo el mundo, gracias a los
voluntarios que permiten que Tor utilice sus computadoras. Además de utilizar una
red de enrutador totalmente separada, Tor cifra los datos, el destino y la dirección
IP del remitente de cada paquete. En cada salto, la información se cifra y luego
se descifra en el siguiente salto cuando se recibe. De esta manera, cada paquete
contiene información sólo sobre el salto anterior a lo largo de la ruta y no sobre la
dirección IP del origen. Si alguien intercepta el tráfico, solo podrá ver la dirección IP
del salto anterior y el propietario del sitio web solo podrá ver la dirección IP del
último enrutador que envió el tráfico (consulte la Figura 131). Esto garantiza un
relativo anonimato en Internet.
+ +
annie
++ +
+ Nodo Tor
Ruta cifrada
Paso libre Factura
Figura 131: Cómo utiliza Tor los datos de tráfico cifrados
Volverse seguro y anónimo 141

¡GUAU! Libro
Para habilitar el uso de Tor, simplemente instale el navegador Tor desde https://www
.torproject.org/. Una vez instalado, se verá como en la Figura 132 y podrá usarlo como
cualquier navegador de Internet antiguo. Al utilizar este navegador, navegará por Internet a
través de un conjunto separado de enrutadores y podrá visitar sitios sin que Big Brother lo
rastree. Desafortunadamente, la desventaja es que navegar a través del navegador Tor
puede ser mucho más lento; Debido a que no hay tantos enrutadores, el ancho de banda es
limitado en esta red.
Figura 132: La página de inicio del navegador Tor
Además de poder acceder a casi cualquier sitio web de la Internet tradicional, el

navegador Tor es capaz de acceder a la web oscura. Los sitios web que componen la web
oscura requieren anonimato, por lo que permiten el acceso únicamente a través del navegador
Tor y tienen direcciones que terminan en .onion para su dominio de nivel superior (TLD). La
web oscura es famosa por sus actividades ilegales, pero allí también se encuentran
disponibles varios servicios legítimos. Una advertencia, sin embargo: al acceder a la web
oscura, es posible que te encuentres con material que muchos encontrarán ofensivo.
Preocupaciones de seguridad
Los servicios de inteligencia y espionaje de Estados Unidos y otras naciones consideran la

red Tor una amenaza a la seguridad nacional, creyendo que una red tan anónima permite
a gobiernos extranjeros y terroristas comunicarse sin ser vigilados. Como resultado, una
serie de proyectos de investigación sólidos y ambiciosos están trabajando para romper el
anonimato de Tor.

Estas autoridades ya han roto el anonimato de Tor y probablemente lo volverán a

romper. La NSA, por ejemplo, ejecuta sus propios enrutadores Tor, lo que significa que
su tráfico puede estar atravesando los enrutadores de la NSA cuando usa Tor. Si su tráfico
sale de los enrutadores de la NSA, eso es aún peor, porque el enrutador de salida
siempre conoce su destino. La NSA también cuenta con un método conocido como
correlación de tráfico, que implica buscar patrones en el tráfico entrante y saliente, que
ha podido romper el anonimato de Tor. Aunque estos intentos de romper Tor no afectarán
la efectividad de Tor para ocultar su identidad de servicios comerciales, como Google,
pueden limitar la efectividad del navegador para mantener su anonimato ante las agencias
de espionaje.
Servidores proxy
Otra estrategia para lograr el anonimato en Internet es utilizar proxies, que son sistemas
intermedios que actúan como intermediarios para el tráfico: el usuario se conecta a un
proxy y al tráfico se le proporciona la dirección IP del proxy antes de pasar (consulte la
Figura 13). 3). Cuando el tráfico regresa del destino, el proxy lo envía de regreso al
origen. De esta manera, el tráfico parece provenir del proxy y no de la dirección IP
de origen.
172.23.26.8
Servidor
proxy
IP
Tu dirección IP
65.55.125.1289 Servidor proxy
Tu dirección IP
65.55.125.1289
Su ISP Servidor web
Figura 133: Ejecución de tráfico a través de un servidor proxy
Por supuesto, es probable que el proxy registre su tráfico, pero un investigador

tendría que obtener una citación o una orden de registro para obtener los registros. Para
que su tráfico sea aún más difícil de rastrear, puede utilizar más de un proxy, en una
estrategia conocida como cadena de proxy, que veremos más adelante en este capítulo.
Kali Linux tiene una excelente herramienta de proxy llamada proxychains que
puedes configurar para ocultar tu tráfico. La sintaxis del comando proxychains es sencilla,
kali >proxychains <el comando que desea representar> <argumentos>
¡GUAU! Libro Volverse seguro y anónimo 143
Los argumentos que proporcione pueden incluir una dirección IP. Por ejemplo,
Si quisieras usar proxychains para escanear un sitio con nmap de forma anónima, ingresarías lo siguiente:
kali >proxychains nmap sT Pn <dirección IP>
Esto enviaría el comando de escaneo oculto nmap –sS a la dirección IP proporcionada a través de
un proxy. Luego, la herramienta construye la cadena de servidores proxy, por lo que no tienes que
preocuparte por eso.
Configuración de servidores proxy en el archivo de configuración
En esta sección, configuramos un proxy para que lo utilice el comando proxychains . Como ocurre con casi
todas las aplicaciones en Linux/Unix, la configuración de las cadenas proxy se administra mediante el archivo
de configuración, específicamente /etc/proxychains.conf. Abra el archivo de configuración en el editor de
texto de su elección con el siguiente comando (reemplazando leafpad con el editor elegido si es necesario):
kali >leafpad /etc/proxychains.conf
Debería ver un archivo como el que se muestra en el Listado 131.
# proxychains.conf VER 3.1

# Proxificador de túnel HTTP, SOCKS4, SOCKS5 con DNS.
# La siguiente opción identifica cómo se trata ProxyList.

# solo se debe descomentar una opción a la vez,
# de lo contrario se aceptará la última opción que aparezca
#
# cadena_dinamica
#
# Dinámico: cada conexión se realizará a través de servidores proxy encadenados.
# todos los proxies encadenados en el orden en que aparecen en la lista
# al menos un proxy debe estar en línea para jugar en cadena
# (se omiten los proxies inactivos)
# de lo contrario, EINTR se devuelve a la cadena estricta de la aplicación
# Estricto: cada conexión se realizará a través de servidores proxy encadenados.
# todos los representantes deben estar en línea para jugar en cadena
# de lo contrario, se devuelve EINTR a la aplicación M
recorte
Listado 131: El archivo proxychains.conf
Desplácese hacia abajo en este archivo hasta la línea 61, y debería ver la sección ProxyList ,
como se muestra en el Listado 132.
[Lista de proxy]
# agregar proxy aquí...
# mientras tanto
# valores predeterminados establecidos en "tor"
calcetines4 127.0.0.1 9050
Listado 132: La sección del archivo de configuración para agregar servidores proxy
Podemos agregar proxies ingresando las direcciones IP y los puertos de los proxies que queremos
usar en esta lista. Por ahora, usaremos algunos servidores proxy gratuitos. Puede encontrar servidores
proxy gratuitos buscando en Google "proxies gratuitos" o utilizando el sitio http://www.hidemy.
.nombre, como se muestra en la Figura 134. Sin embargo, tenga en cuenta que utilizar servidores proxy
gratuitos en actividades de piratería en la vida real no es una buena idea. Cubriré esto con más detalle
más adelante en el capítulo. El ejemplo utilizado aquí es sólo para fines educativos.
Figura 134: Proxies gratuitos de http://www.hidemy.name
Complete los detalles en el formulario o simplemente haga clic en buscar; luego agregue uno de los
los servidores proxy resultantes a su archivo proxychains.conf usando el siguiente formato:
Tipo Dirección IP Puerto
He aquí un ejemplo:
[Lista de proxy]
calcetines4 114.134.186.12 22020
# mientras tanto
# valores predeterminados establecidos en "tor"
# calcetines4 127.0.0.1 9050
Es importante tener en cuenta que proxychains utiliza Tor de forma predeterminada

si no ingresa ningún proxy propio. La última línea del Listado 132 dirige las cadenas proxy
para que envíen tráfico primero a través del host en 127.0.0.1 en el puerto 9050 (la
configuración Tor predeterminada). Si no estás agregando tus propios servidores proxy y quieres
usar Tor, déjalo como está. Si no estás usando Tor, necesitarás comentar esta línea (agrega
un # antes).
Por mucho que me guste Tor, como ya he mencionado, suele ser muy lento. También porque
la NSA ha roto Tor, es mucho menos probable que dependa de él para mantener el anonimato.
Por lo tanto, comento esta línea y agrego mi propio conjunto de servidores proxy.
Probémoslo. En este ejemplo, abriré el navegador Firefox.
y haga que navegue a https://www.hackersarise.com/ de forma anónima enviando el tráfico a
través de un proxy.
El comando es el siguiente:
kali >proxychains firefox www.hackersarise.com
Esto abre con éxito https://www.hackersarise.com/ en Firefox a través del proxy elegido y
me devuelve los resultados. Para cualquiera que rastree este tráfico, parece que fue mi proxy el
que navegó a https://www.hackersarise.com/
en lugar de mi dirección IP.
Algunas opciones más interesantes
Ahora que tenemos proxychains funcionando, veamos algunas otras opciones que podemos
configurar a través del archivo proxychains.conf . Como ya lo tenemos configurado, simplemente
estamos usando un único proxy. Sin embargo, podemos instalar varios proxies y usarlos todos,
podemos usar un número limitado de la lista o podemos hacer que las cadenas de proxy
cambien el orden al azar. Probemos todas estas opciones.
Agregar más servidores proxy
Primero, agreguemos algunos servidores proxy más a nuestra lista. Volver a http://www.hidemy
.nombre y busque más direcciones IP proxy. Luego agregue algunos de estos proxies más
a su archivo proxychains.conf , así:
[Lista de proxy]
calcetines4 114.134.186.12 22020
calcetines4 188.187.190.59 8888
calcetines4 181.113.121.158 335551
Ahora guarde este archivo de configuración e intente ejecutar el siguiente comando:
kali >proxychains firefox www.hackersarise.com
No notarás ninguna diferencia, pero tu paquete ya está viajando.

a través de varios apoderados.

Encadenamiento dinámico
Con varias IP en nuestro archivo proxychain.conf , podemos configurar el encadenamiento

dinámico, que ejecuta nuestro tráfico a través de cada proxy de nuestra lista y, si uno de
los proxy está inactivo o no responde, pasa automáticamente al siguiente proxy de la lista sin
arrojando un error. Si no configuramos esto, un único proxy fallido interrumpiría nuestra
solicitud.
Vuelva a su archivo de configuración de proxychains , busque la cadena_dinámica
línea (línea 10) y descomente el comentario, como se muestra a continuación. También
asegúrese de comentar la línea estricto_chain si aún no lo está.
# cadena_dinamica
#
# Dinámico: cada conexión se realizará a través de servidores proxy encadenados

recorte
Esto permitirá el encadenamiento dinámico de nuestros servidores proxy, lo que

permitirá un mayor anonimato y una piratería sin problemas. Guarde el archivo de
configuración y no dude en probarlo.
Encadenamiento aleatorio
Nuestro último truco de proxy es la opción de encadenamiento aleatorio , donde las cadenas
de proxy elegirán aleatoriamente un conjunto de direcciones IP de nuestra lista y las usarán
para crear nuestra cadena de proxy. Esto significa que cada vez que usamos cadenas de
proxy, el proxy se verá diferente para el objetivo, lo que dificultará el seguimiento de nuestro
tráfico desde su origen. Esta opción también se considera “dinámica” porque si uno de los
proxies está inactivo, pasará al siguiente.
Vuelva al interior del archivo /etc/proxychains.conf y comente las líneasdynamic_chain y
estricto_chain agregando un # al comienzo de cada línea; luego descomente la línea
random_chain . Sólo podemos usar una de estas tres opciones a la vez, así que
asegúrese de comentar las otras opciones antes de usar proxychains.
A continuación, busque y descomente la línea con chain_len y luego asígnele un número

razonable. Esta línea determina cuántas de las direcciones IP de su cadena se utilizarán para
crear su cadena de proxy aleatoria.
# cadena_dinamica
#
# Dinámico: cada conexión se realizará a través de servidores proxy encadenados

#
# cadena_estricta
#
# Estricto: cada conexión se realizará a través de servidores proxy encadenados.

# todos los representantes deben estar en línea para jugar en cadena
# de lo contrario, se devuelve EINTR a la aplicación

#
cadena_aleatoria
# Aleatorio: cada conexión se realizará mediante un proxy aleatorio
# (o cadena de proxy, consulte chain_len) de la lista.
# esta opción es buena para probar tu IDS :)
# Tiene sentido sólo si random_chain

cadena_len = 3
Aquí, descomenté chain_len y le di un valor de 3, lo que significa que proxychains ahora usará tres
proxies de mi lista en /etc/proxychains.conf
archivo, eligiéndolos aleatoriamente y pasando al siguiente si un proxy no funciona. Tenga en cuenta
que, aunque este método ciertamente mejora su anonimato, también aumenta la latencia de sus
actividades en línea.
Ahora que sabes cómo usar cadenas proxy, puedes hackear con relativo anonimato. Digo
“relativo” porque no existe una forma segura de permanecer en el anonimato mientras la NSA y el FSB
espían nuestras actividades en línea.
pero podemos hacer que la detección sea mucho más difícil con la ayuda de proxychains.
Preocupaciones de seguridad
Como última nota sobre la seguridad del proxy, asegúrese de elegir sus servidores proxy con
prudencia: las cadenas de proxy son tan buenas como los servidores proxy que utiliza. Si tiene la
intención de permanecer en el anonimato, no utilice un proxy gratuito, como se mencionó anteriormente.
Los piratas informáticos utilizan servidores proxy pagados en los que se puede confiar. De hecho, es
probable que los servidores proxy gratuitos vendan su dirección IP y su historial de navegación. Como
dijo una vez Bruce Schneier, el famoso criptógrafo y experto en seguridad: “Si algo es gratis, tú no
eres el cliente; tú eres el producto”. En otras palabras, es probable que cualquier producto gratuito
recopile sus datos y los venda. ¿Por qué si no ofrecerían un proxy gratis?
Aunque la dirección IP de su tráfico que sale del proxy será anónima, existen otras formas para que
las agencias de vigilancia lo identifiquen. Por ejemplo, el propietario del proxy conocerá su identidad y,
si el espionaje o las agencias de aplicación de la ley con jurisdicción lo presionan lo suficiente, puede
ofrecer su identidad para proteger su negocio. Es importante ser consciente de las limitaciones de los
proxy como fuente de anonimato.
Redes Privadas Virtuales
El uso de una red privada virtual (VPN) puede ser una forma eficaz de mantener su tráfico web
relativamente anónimo y seguro. Una VPN se utiliza para conectarse a un dispositivo de Internet
intermediario, como un enrutador, que envía su tráfico a su destino final etiquetado con la dirección IP
del enrutador.
El uso de una VPN ciertamente puede mejorar su seguridad y privacidad, pero no es garantía de
anonimato. El dispositivo de Internet al que se conecta debe registrar o registrar su dirección IP para
poder enviarle los datos correctamente, de modo que cualquiera que pueda acceder a estos registros
pueda descubrir información sobre usted.

La belleza de las VPN es que son simples y fáciles de usar. Puede abrir una
cuenta con un proveedor de VPN y luego conectarse sin problemas a la VPN
cada vez que inicie sesión en su computadora. Utilizaría su navegador como de
costumbre para navegar por la web, pero cualquiera que esté mirando le parecerá
que su tráfico proviene de la dirección IP y la ubicación del dispositivo VPN de
Internet y no de la suya. Además, todo el tráfico entre usted y el dispositivo VPN
está cifrado, por lo que ni siquiera su proveedor de servicios de Internet puede ver su tráfico.
Entre otras cosas, una VPN puede ser eficaz para evadir contenidos
controlados por el gobierno y censuras de información. Por ejemplo, si su gobierno
nacional limita su acceso a sitios web con un mensaje político particular,
probablemente pueda usar una VPN ubicada fuera de su país para acceder a ese
contenido. Algunas corporaciones de medios, como Netflix, Hulu y HBO, limitan
el acceso a su contenido a direcciones IP que se originan en su propio país.
Usar una VPN basada en un país que esos servicios permitan a menudo puede
ayudarte a sortear esas limitaciones de acceso.
Algunos de los mejores y más populares servicios VPN comerciales, según
Según CNET, son los siguientes:
• IP desaparecer
•NordVPN
•VPN exprés
•Ciberfantasma
•VPN de rana dorada
•Esconde mi culo (HMA)
•Acceso privado a Internet
•PuroVPN
•TorGuard
•VPN con búfer
La mayoría de estos servicios VPN cobran entre 50 y 100 dólares al año y muchos
ofrecen una prueba gratuita de 30 días. Para obtener más información sobre cómo
configurar una VPN, elija una de la lista y visite el sitio web. Debería encontrar
instrucciones de descarga, instalación y uso que sean bastante fáciles de seguir.
La ventaja de una VPN es que todo su tráfico está encriptado cuando sale de
su computadora, lo que lo protege contra espionaje, y su dirección IP queda oculta
por la dirección IP de la VPN cuando visita un sitio. Al igual que con un servidor
proxy, el propietario de la VPN tiene su dirección IP de origen (de lo contrario,
no podrían enviarle su tráfico). Si son presionados por agencias de espionaje o
autoridades policiales, podrían revelar su identidad. Una forma de evitarlo es
utilizar sólo VPN que prometan no almacenar ni registrar esta información (y
esperar que sean veraces). De esta forma, si alguien insiste en que el proveedor
del servicio VPN entregue sus datos a sus usuarios, no hay datos.
Correo electrónico cifrado

Los servicios de correo electrónico comerciales gratuitos como Gmail, Yahoo! y Outlook Web Mail
(anteriormente Hotmail) son gratuitos por una razón: son vehículos para rastrear sus intereses y
mostrar anuncios. Como ya se mencionó, si un servicio es gratuito, usted es el producto, no el cliente.
Además, los servidores del proveedor de correo electrónico (Google, por ejemplo) tienen acceso al
contenido no cifrado de tu correo electrónico, incluso si utilizas HTTPS.
Una forma de evitar las escuchas ilegales en su correo electrónico es utilizar correo
electrónico cifrado. ProtonMail, que se muestra en la Figura 135, cifra su correo electrónico de
un extremo a otro o de un navegador a otro. Esto significa que su correo electrónico está
cifrado en los servidores de ProtonMail; ni siquiera los administradores de ProtonMail pueden leer
su correo electrónico.
ProtonMail fue fundado por un grupo de jóvenes científicos en las instalaciones del
supercolisionador CERN en Suiza. Los suizos tienen una larga historia de protección de secretos
(¿recuerdas esas cuentas bancarias suizas de las que tanto has oído hablar?), y los servidores de
ProtonMail están ubicados en la Unión Europea, que tiene leyes mucho más estrictas con respecto
al intercambio de datos personales que lo hace Estados Unidos. ProtonMail no cobra por una
cuenta básica, pero ofrece cuentas premium por una tarifa nominal. Es importante tener en cuenta
que al intercambiar correo electrónico con usuarios que no son de ProtonMail, existe la posibilidad
de que parte o la totalidad del correo electrónico no esté cifrado. Consulte la base de conocimientos
de soporte de ProtonMail para obtener todos los detalles.
Figura 135: La pantalla de inicio de sesión de ProtonMail

Resumen
Estamos constantemente vigilados por empresas comerciales y agencias de inteligencia
nacionales. Para mantener seguros sus datos y sus viajes web, debe implementar al
menos una de las medidas de seguridad analizadas en este capítulo.
Al emplearlos en combinación, puede minimizar su huella en la web y mantener sus
datos mucho más seguros.
Ejercicios
1. Ejecute traceroute a su sitio web favorito. ¿Cuántos saltos aparecen entre usted y su sitio
favorito?
2. Descargue e instale el navegador Tor. Ahora, navegue de forma anónima por la web como lo
haría con cualquier otro navegador y vea si nota alguna diferencia en la velocidad.
3. Intente usar cadenas proxy con el navegador Firefox para navegar a su favorito
sitio web.
4. Explore los servicios VPN comerciales de algunos de los proveedores enumerados en este
capítulo. Elija uno y pruebe una prueba gratuita.
5. Abra una cuenta gratuita de ProtonMail y envíe un saludo seguro a

ocupartheweb@protonmail.com.
¡GUAU! Libro
14
Comprensión y observación
Conexiones inalámbricas
La capacidad de buscar y conectarse a otros

dispositivos de red desde su sistema es crucial
para convertirse en un hacker exitoso, y con
tecnologías inalámbricas como WiFi (IEEE 802.1)
y Bluetooth convirtiéndose en el estándar, encontrar y
controlar conexiones WiFi y Bluetooth es cada vez más importante. llave
Si alguien puede piratear una conexión inalámbrica, puede acceder a un dispositivo y
acceder a información confidencial. El primer paso, por supuesto, es aprender a
encontrar estos dispositivos.
En el Capítulo 3, analizamos algunos comandos de red básicos en Linux, incluidos
algunos de los fundamentos de las redes inalámbricas, con la promesa de más redes
inalámbricas en el Capítulo 14. Como prometimos, aquí examinamos dos de las
tecnologías inalámbricas más comunes en Linux. Linux: WiFi y Bluetooth.
¡GUAU! Libro
Redes WiFi
Empezaremos con WiFi. En esta sección, le mostraré cómo encontrar, examinar y conectarse a puntos
de acceso WiFi. Antes de hacerlo, dediquemos un poco de tiempo a repasar algunos términos y
tecnologías básicos de WiFi para ayudarlo a comprender mejor el resultado de muchas de las consultas
que haremos en este capítulo:
AP (punto de acceso) Este es el dispositivo al que se conectan los usuarios inalámbricos

para acceder a Internet.
ESSID (identificador de conjunto de servicios extendidos) Es el mismo que el SSID, que analizamos
en el Capítulo 3, pero se puede utilizar para múltiples AP en una LAN inalámbrica.
BSSID (identificador de conjunto de servicios básicos) Este es el identificador único de cada AP

y es el mismo que la dirección MAC del dispositivo.
SSID (identificador de conjunto de servicios) Este es el nombre de la red.
Canales WiFi puede funcionar en cualquiera de los 14 canales (1–14). En Estados Unidos, la
conexión WiFi está limitada a los canales 1 a 11.
Energía Cuanto más cerca esté del AP WiFi, mayor será la potencia y más fácil será romper la
conexión.
Seguridad Este es el protocolo de seguridad utilizado en el AP WiFi desde el que se está

leyendo. Existen tres protocolos de seguridad principales para WiFi.
El original, Wired Equivalent Privacy (WEP), tenía graves fallos y era fácil de descifrar. Su
reemplazo, el acceso protegido WiFi (WPA), era un poco más seguro. Finalmente, WPA2PSK,
que es mucho más seguro y utiliza una clave precompartida (PSK) que todos los usuarios
comparten, ahora es utilizado por casi todos los AP WiFi (excepto WiFi empresarial).
Modos WiFi puede funcionar en uno de tres modos: administrado, maestro o monitor. Aprenderá
qué significan estos modos en la siguiente sección.
Alcance inalámbrico En los Estados Unidos, un AP WiFi debe transmitir legalmente su señal a un
límite superior de 0,5 vatios. A esta potencia, tiene un alcance normal de unos 100 metros (300
pies). Las antenas de alta ganancia pueden ampliar este alcance hasta 20 millas.
La frecuencia WiFi está diseñada para funcionar en 2,4 GHz y 5 GHz. Los AP WiFi modernos y
las tarjetas de red inalámbrica suelen utilizar ambos.
Comandos inalámbricos básicos
En el Capítulo 3, conoció el comando de red básico de Linux ifconfig, que enumera cada interfaz de red
activada en su sistema junto con algunas estadísticas básicas, incluida (lo más importante) la dirección
IP de cada interfaz. Echemos otro vistazo a los resultados al ejecutar ifconfig.
Y esta vez concéntrate en las conexiones inalámbricas.
Kali >ifconfig
eth0Linkencap:EthernetHWaddr 00:0c:29:ba:82:0f
Dirección Internet:192:168.181.131 Bcast:192.168.181.255 Máscara:255.255.255.0
recorte

Linkencap: bucle invertido local

Dirección Internet: 127.0.0.1 Máscara: 255.0.0.0
recorte
u wlan0 Encapsulación de enlace:EthernetHWaddr 00:c0:ca:3f:ee:02
La interfaz WiFi aquí se muestra como wlan0 . En Kali Linux, conexión WiFi
Las caras generalmente se designan como wlanX, donde X representa el número de
esa interfaz. En otras palabras, el primer adaptador WiFi de su sistema estaría etiquetado
como wlan0, el segundo wlan1, y así sucesivamente.
Si solo desea ver sus interfaces WiFi y sus estadísticas, Linux tiene un comando
específico similar a ifconfig pero dedicado a la conexión inalámbrica.
Ese comando es iwconfig. Cuando ingresa, solo se muestran sus interfaces inalámbricas
y sus datos clave:
Kali >iwconfig
wlan0 IEEE 802.11bg ESSID: apagado/cualquiera

Modo: Punto de acceso administrado: Potencia de transmisión no asociada = 20 dBm
Reintentar límite corto:7 RTS thr:off Fragment thr:off
Clave de cifrado: desactivada
Gestión de energía: apagado
Aquí, vemos sólo las interfaces inalámbricas, también conocidas como tarjetas de
red, y datos clave sobre ellas, incluido el estándar inalámbrico utilizado, si el ESSID está
apagado y el modo. El modo tiene tres configuraciones: administrado, lo que significa
que está listo para unirse o se ha unido a un AP; master, lo que significa que está listo
para actuar como AP o ya lo es; y monitorear, que discutiremos un poco más adelante en
el capítulo. También podremos ver si tiene algún cliente asociado y cuál es su potencia
de transmisión, entre otras cosas. A partir de este ejemplo, puede ver que wlan0 está en
el modo requerido para conectarse a una red WiFi pero aún no está conectado a ninguna.
Volveremos a revisar este comando una vez que la interfaz inalámbrica esté conectada a
una red WiFi.
Si no está seguro de a qué AP WiFi desea conectarse, puede
vea todos los puntos de acceso inalámbrico a los que puede llegar su tarjeta de red
usando el comando iwlist . La sintaxis de iwlist es la siguiente:
acción de interfaz iwlist
Puedes realizar múltiples acciones con iwlist. Para nuestros propósitos, haremos
use la acción de escaneo para ver todos los AP WiFi en su área. (Tenga en cuenta
que con una antena estándar, su alcance será de 300 a 500 pies, pero esto se
puede ampliar con una antena económica de alta ganancia).
kali > escaneo iwlist wlan0

wlan0 Escaneo completado:
Celda 01 Dirección:88:AD:43:75:B3:82
Canal 1
Comprensión e inspección de redes inalámbricas 155

¡GUAU! Libro
Frecuencia: 2.412GHz (Canal 1)

Calidad=70/70 Nivel de señal =38 dBm
ESSID: "HackersArise"
recorte
El resultado de este comando debe incluir todos los AP WiFi dentro del alcance
de su interfaz inalámbrica, junto con datos clave sobre cada AP, como la dirección MAC
del AP, el canal y la frecuencia en la que está operando, su calidad, su señal. nivel, si su
clave de cifrado está habilitada y su ESSID.
Necesitará la dirección MAC del AP objetivo (BSSID), la dirección MAC de un
cliente (otra tarjeta de red inalámbrica) y el canal en el que opera el AP para realizar
cualquier tipo de piratería, por lo que esta es información valiosa.
Otro comando muy útil para gestionar tu conexión WiFi

tions es nmcli (o la interfaz de línea de comandos del administrador de red). El
demonio de Linux que proporciona una interfaz de alto nivel para las interfaces de
red (incluidas las inalámbricas) se conoce como administrador de red. Generalmente,
los usuarios de Linux están familiarizados con este demonio por su interfaz gráfica de
usuario (GUI), pero también se puede utilizar desde la línea de comandos.
El comando nmcli se puede utilizar para ver los AP WiFi cercanos y sus datos
clave, como hicimos con iwlist, pero este comando nos brinda un poco más de información.
Lo usamos en el formato nmcli dev tipo de red, donde dev es la abreviatura de dispositivos
y el tipo (en este caso) es wifi, así:
kali > nmcli dev wifi

*SSID MODO TASA DE CANAL BARRAS DE SEÑAL SEGURIDAD
HackersArise Infra 1 54Mbps 100 WPA1 WPA2
Xfinitywifi Infra 1 54Mbps 75 WPA2
TPTV1 infraestructura 11 54Mbps 44 WPA1WPA2
recorte
Además de mostrar los AP WiFi dentro del alcance y datos clave sobre
ellos, incluido el SSID, el modo, el canal, la velocidad de transferencia, la intensidad de
la señal y los protocolos de seguridad habilitados en el dispositivo, nmcli se puede utilizar
para conectarse a los AP. La sintaxis para conectarse a un AP es la siguiente:
nmcli dev conexión wifi Contraseña APSSID Contraseña AP
Entonces, según los resultados de nuestro primer comando, sabemos que hay un
AP con un SSID de HackersArise. También sabemos que tiene seguridad WPA1 WPA2
(esto significa que el AP es capaz de usar tanto el WPA1 antiguo como el WPA2 más
nuevo), lo que significa que tendremos que proporcionar la contraseña para conectarnos
a la red. Afortunadamente como es nuestro AP, sabemos que la contraseña es 12345678,
por lo que podemos ingresar lo siguiente:
kali >nmcli dev wifi conectar HackersArise contraseña 12345678

El dispositivo 'wlan0' se activó correctamente con '394a5bf48af436f849beda6cb530'.

Pruebe esto en una red que conozca y luego, cuando se haya conectado exitosamente
a ese AP inalámbrico, ejecute iwconfig nuevamente para ver qué ha cambiado.
Aquí está mi resultado de conectarme a HackersArise:
Kali >iwconfig
wlan0 IEEE 802.11bg ESSID: "HackersArise"

Modo:Gestionado Frecuencia:2.452GHz Punto de acceso:00:25:9C:97:4F:48
Velocidad de bits = 12 Mbs Potencia de transmisión = 20 dBm
Reintentar límite corto:7 RTS thr:off Fragment thr:off

Gestión de energía: apagado
Calidad del enlace=64/70 Nivel de señal=46 dBm
Rx nwid no válido: 0 Rx cripta no válida: 0 Rx frag no válido: 0
Reties excesivas de Tx:0 Miscelánea no válida:13 Baliza perdida:0
Tenga en cuenta que ahora iwconfig ha indicado que el ESSID es "HackersArise"

y que el AP esté operando a una frecuencia de 2.452GHz. En una red WiFi, es posible que
varios AP formen parte de la misma red, por lo que puede haber muchos AP que formen la red
HackersArise . La dirección MAC 00:25:9C:97:4F:48 es, como era de esperar, la MAC del AP
al que estoy conectado. El tipo de seguridad que utiliza una red WiFi, si funciona a 2,4 GHz
o 5 GHz, cuál es su ESSID y cuál es la dirección MAC del AP son datos críticos necesarios
para el hackeo de WiFi. Ahora que conoces los comandos básicos, comencemos a
piratear.
Reconocimiento de WiFi con aircrackng
Uno de los exploits más populares que pueden probar los nuevos hackers es descifrar puntos
de acceso WiFi. Como se mencionó, antes de que puedas siquiera considerar atacar un
AP WiFi, necesitas la dirección MAC del AP objetivo (BSSID), la dirección MAC de un cliente
y el canal en el que está operando el AP.
Podemos obtener toda esa información y más utilizando las herramientas de la suite
aircrack ng. He mencionado este conjunto de herramientas para piratear WiFi varias veces
antes y ahora es el momento de usarlo. Este conjunto de herramientas está incluido en todas
las versiones de Kali, por lo que no es necesario descargar ni instalar nada.
Para utilizar estas herramientas de forma eficaz, primero debe poner su tarjeta de red
inalámbrica en modo monitor para que la tarjeta pueda ver todo el tráfico que pasa por su camino.
Normalmente, una tarjeta de red captura sólo el tráfico destinado específicamente a esa
tarjeta. El modo monitor es similar al modo promiscuo en las tarjetas de red cableadas.
Para poner su tarjeta de red inalámbrica en modo monitor, use el comando airmonng
comando de la suite aircrackng. La sintaxis de este comando es simple:
airmonng inicio|detener|reiniciar interfaz

¡GUAU! Libro
Entonces, si desea poner su tarjeta de red inalámbrica (designada wlan0) en

modo monitor, deberá ingresar lo siguiente:
kali >airmonng iniciar wlan0
Se encontraron tres procesos que podrían causar problemas.

Si airodumpng, aireplayng o airtunng dejan de funcionar después
En un corto periodo de tiempo, es posible que desees ejecutar 'airmonng check kill'
recorte
fisico INTERFAZ CONDUCTOR

conjunto de chips
phy0 wlan0 rt18187 Realtek Semiconductor Corop RTL8187
(modo de monitor mac8311 vif habilitado para [phy0]wlan0 en [phy0]wlan0mon)
recorte
Los comandos detener y reiniciar , respectivamente, detienen el modo monitor y

reinician el modo monitor si tiene problemas.
Con su tarjeta inalámbrica en modo monitor, puede acceder a todo el tráfico inalámbrico
que pasa dentro del alcance de su adaptador de red inalámbrica y antena (el estándar es
entre 300 y 500 pies). Tenga en cuenta que airmonng cambiará el nombre de su interfaz
inalámbrica: la mía pasó a llamarse "wlan0mon", aunque la suya puede ser diferente.
Asegúrese de anotar el nuevo nombre designado de su servicio inalámbrico porque
necesitará esa información en el siguiente paso.
Ahora usaremos otra herramienta de la suite aircrackng para encontrar datos clave
del tráfico inalámbrico. El comando airodumpng captura y muestra los datos clave de
los AP de transmisión y de cualquier cliente conectado a esos AP o en sus
alrededores. La sintaxis aquí es sencilla: simplemente conecte airdumpng,
seguido del nombre de la interfaz que obtuvo al ejecutar airmonng hace un momento.
Cuando emitas este comando, tu tarjeta inalámbrica recogerá información crucial
(enumerada a continuación) de todo el tráfico inalámbrico de los AP cercanos:
BSSID La dirección MAC del AP o cliente.
PWR La fuerza de la señal.

ENC El cifrado utilizado para asegurar la transmisión.
#Data La tasa de rendimiento de datos
CH El canal en el que está operando el AP
ESSID El nombre del AP
kali >airodumpng wlan0mon
CH 9][ Transcurrido: 28 s ][ 20180208 10:27
BSSID PWR Balizas #Datos #/s CH MB ENC CIPHER AUTH ESSID

01:01:AA:BB:CC:22 1 4 26 0 10 54e WPA2 CCMP PSK Hackers
Surgir

recorte
BSSID Estación Sonda de fotogramas perdidos de tasa de PWR

(no asociado) 01:01:AA:BB:CC:22
01:02:CC:DD:03:CF A0:A3:E2:44:7C:E5
Tenga en cuenta que airodumpng divide la pantalla de salida en una parte superior e inferior
parte. La parte superior tiene información sobre los AP de transmisión, incluido el BSSID, la
potencia del AP, cuántas tramas de baliza se han detectado, la tasa de rendimiento de datos,
cuántos paquetes han atravesado la tarjeta inalámbrica, el canal (114), el límite de rendimiento
teórico, el protocolo de cifrado, el cifrado utilizado para el cifrado, el tipo de autenticación y el ESSID
(comúnmente conocido como SSID). En la parte del cliente, la salida nos dice que un cliente no está
asociado, lo que significa que ha sido detectado pero no está conectado a ningún AP, y que otro
está asociado con una estación, lo que significa que está conectado al AP en esa dirección.
¡Ahora tienes toda la información que necesitas para descifrar el AP! A pesar de
está más allá del alcance de este libro, para descifrar el AP inalámbrico, necesita la dirección MAC
del cliente, la dirección MAC del AP, el canal en el que está operando el objetivo y una lista de
contraseñas.
Entonces, para descifrar la contraseña de WiFi, abrirías tres terminales. En la primera terminal,
ingresaría comandos similares a los siguientes, completando las direcciones MAC del cliente y AP y el
canal:
airodumpng c 10 bssid 01:01:AA:BB:CC:22 w HackersArisePSK wlan0mon
Este comando captura todos los paquetes que atraviesan el AP en el canal 10 usando la opción
c .
En otra terminal, puedes usar el comando aireplayng para eliminar
(desautenticar) a cualquier persona conectada al AP y obligarlos a volver a autenticarse en el AP,
como se muestra a continuación. Cuando se vuelven a autenticar, puede capturar el hash de su
contraseña que se intercambia en el protocolo de enlace de cuatro vías WPA2PSK. El hash de la
contraseña aparecerá en la esquina superior derecha del terminal airodumpng .
aireplayng deauth 100 a 01:01:AA:BB:CC:22c A0:A3:E2:44:7C:E5 wlan0mon
Finalmente, en la terminal final, puede usar una lista de contraseñas (wordlist.dic) para encontrar
la contraseña en el hash capturado (HackersArisePSK.cap), como se muestra aquí:
aircrackng w lista de palabras.dic b 01:01:AA:BB:CC:22 HackerArisePSK.cap
Detección y conexión a Bluetooth

Hoy en día, casi todos los dispositivos, dispositivos móviles y sistemas tienen Bluetooth integrado,
incluidas nuestras computadoras, teléfonos inteligentes, iPods, tabletas, parlantes, controladores
de juegos, teclados y muchos otros dispositivos. Poder hackear

¡GUAU! Libro
Bluetooth puede comprometer cualquier información en el dispositivo, el control del

dispositivo y la capacidad de enviar información no deseada hacia y desde el dispositivo,
entre otras cosas.
Para explotar la tecnología, necesitamos entender cómo funciona. Una comprensión
profunda de Bluetooth está más allá del alcance de este libro, pero le brindaré algunos
conocimientos básicos que lo ayudarán a buscar y conectarse a dispositivos Bluetooth en
preparación para piratearlos.
Cómo funciona Bluetooth
Bluetooth es un protocolo universal para comunicaciones de campo cercano y de baja

potencia que funciona entre 2,4 y 2,485 GHz utilizando espectro ensanchado y saltos de
frecuencia de 1600 saltos por segundo (este salto de frecuencia es una medida de seguridad).
Fue desarrollado en 1994 por Ericsson Corp. de Suecia y lleva el nombre del rey danés
Harald Bluetooth del siglo X (tenga en cuenta que Suecia y Dinamarca eran un solo país
en el siglo X).
La especificación Bluetooth tiene un alcance mínimo de 10 metros, pero no hay
límite en el alcance superior que los fabricantes pueden implementar en sus dispositivos.
Muchos dispositivos tienen alcances de hasta 100 metros. Con antenas especiales,
ese alcance se puede ampliar aún más.
La conexión de dos dispositivos Bluetooth se denomina emparejamiento. Prácticamente
dos dispositivos Bluetooth pueden conectarse entre sí, pero sólo pueden emparejarse si
están en modo reconocible. Un dispositivo Bluetooth en modo detectable transmite la
siguiente información:
•Nombre
•Clase
•Lista de servicios
•Información técnica
Cuando los dos dispositivos se emparejan, intercambian una clave secreta o de enlace. Cada
almacena esta clave de enlace para que pueda identificar al otro en futuros emparejamientos.
Cada dispositivo tiene un identificador único de 48 bits (una dirección similar a MAC)
y normalmente un nombre asignado por el fabricante. Estos serán datos útiles cuando
queramos identificar y acceder a un dispositivo.
Escaneo y reconocimiento de Bluetooth

Linux tiene una implementación de la pila de protocolos Bluetooth llamada BlueZ que
usaremos para buscar señales de Bluetooth. La mayoría de las distribuciones de Linux,
incluido Kali Linux, lo tienen instalado de forma predeterminada. Si el tuyo no lo hace,
normalmente puedes encontrarlo en tu repositorio usando el siguiente comando:
kali >aptget instalar bluez

BlueZ tiene una serie de herramientas simples que podemos usar para administrar y escanear
Dispositivos Bluetooth, incluidos los siguientes:
hciconfig Esta herramienta funciona de manera muy similar a ifconfig en Linux, pero para dispositivos
Bluetooth. Como puede ver en el Listado 141, lo he usado para abrir la interfaz Bluetooth y consultar
las especificaciones del dispositivo.
hcitool Esta herramienta de consulta puede proporcionarnos el nombre del dispositivo, la ID del
dispositivo, la clase del dispositivo y la información del reloj del dispositivo, lo que permite que los
dispositivos funcionen sincrónicamente.
hcidump Esta herramienta nos permite detectar la comunicación Bluetooth, lo que significa que
podemos capturar datos enviados a través de la señal Bluetooth.
El primer paso de escaneo y reconocimiento con Bluetooth es verificar si el adaptador Bluetooth del
sistema que estamos usando está reconocido y habilitado para que podamos usarlo para buscar otros
dispositivos. Podemos hacer esto con la herramienta incorporada de BlueZ hciconfig, como se muestra
en el Listado 141.
kali >hciconfig
hci0: Tipo: BR/EDR Bus: USB
Dirección BD: 10:AE:60:58:F1:37 ACL MTU: 310:10 SCO MTU: 64:8
CONSULTA PSCAN EN EJECUCIÓN
Bytes RX: 131433 acl: 45 sco: 0 eventos: 10519 errores: 0
Bytes TX: 42881 acl: 45 sco: 0 comandos: 5081 errores: 0
Listado 141: Buscando un dispositivo Bluetooth
Como puede ver, mi adaptador Bluetooth se reconoce con una dirección MAC.
de 10:AE:60:58:F1:37. Este adaptador ha sido denominado hci0. El siguiente paso es comprobar que la
conexión está habilitada, lo cual también podemos hacer con hciconfig
proporcionando el nombre y el comando arriba :
kali >hciconfig hci0 arriba
Si el comando se ejecuta correctamente, no deberíamos ver ningún resultado, solo un nuevo mensaje.
¡Bien, hci0 está listo y listo! Pongámoslo a trabajar.
Búsqueda de dispositivos Bluetooth con hcitool
Ahora que sabemos que nuestro adaptador está activo, podemos usar otra herramienta en la suite BlueZ
llamada hcitool, que se usa para buscar otros dispositivos Bluetooth dentro.
rango.
Primero usemos la función de escaneo de esta herramienta para buscar dispositivos Bluetooth que
estén enviando sus balizas de descubrimiento, lo que significa que están en modo de descubrimiento, con
el comando de escaneo simple que se muestra en el Listado 142.
escaneo kali >hcitool

Exploración...

¡GUAU! Libro
72:6E:46:65:72:66 Android BT
22:C5:96:08:5D:32 SCHI535
Listado 142: Buscando dispositivos Bluetooth en modo de descubrimiento
Como puede ver, en mi sistema, hcitool encontró dos dispositivos, ANDROID BT

y SCHI535. Es probable que el suyo le proporcione una salida diferente dependiendo de
los dispositivos que tenga a mano. Para fines de prueba, intente poner su teléfono u otro
dispositivo Bluetooth en modo de descubrimiento y vea si se detecta en el escaneo.
Ahora recopilemos más información sobre los dispositivos detectados con la función de consulta inq:
kali >hcitool inq

Preguntando...
24:C6:96:08:5D:33 compensación del reloj: 0x4e8b clase: 0x5a020c
76:6F:46:65:72:67 compensación del reloj: 0x21c0 clase: 0x5a020c
Esto nos da las direcciones MAC de los dispositivos, la compensación del reloj y la
clase de los dispositivos. La clase indica qué tipo de dispositivo Bluetooth encontró y
puede buscar el código y ver qué tipo de dispositivo es yendo al sitio Bluetooth SIG en
https://www.bluetooth.org/enus/specification/
númerosasignados/descubrimientodeservicios/.
La herramienta hcitool es una potente interfaz de línea de comandos para la pila
Bluetooth que puede hacer muchas, muchas cosas. El Listado 143 muestra la página de
ayuda con algunos de los comandos que puede utilizar. Eche un vistazo a la página de ayuda
para ver la lista completa.
kali >hcitool ayuda

hcitool Herramienta HCI versión 4.99
Uso:
hcitool [opciones] <comando> [parámetros de comando]
Opciones:
ayuda Mostrar ayuda
i dev dispositivo HCI
Comandos
dev Mostrar dispositivos locales
inq Consultar dispositivos remotos
escanear Buscar dispositivos remotos
nombre Obtener nombre de dispositivos remotos
recorte
Listado 143: Algunos comandos de hcitool
Muchas herramientas de pirateo de Bluetooth que verá por ahí simplemente usan
estos comandos en un script, y usted puede crear fácilmente su propia herramienta
usando estos comandos en su propio script bash o Python; veremos los scripts en el
Capítulo 17.

Buscando servicios con sdptool
Service Discovery Protocol (SDP) es un protocolo Bluetooth para buscar servicios Bluetooth
(Bluetooth es un conjunto de servicios) y, útilmente, BlueZ proporciona la herramienta sdptool
para buscar en un dispositivo los servicios que proporciona.
También es importante tener en cuenta que no es necesario que el dispositivo esté en modo de
descubrimiento para poder escanearlo. La sintaxis es la siguiente:
sdptool buscar dirección MAC
El Listado 144 me muestra usando sdptool para buscar servicios en uno de los dispositivos
detectados anteriormente en el Listado 142.
kali >sdptool navegar 76:6E:46:63:72:66

Navegando 76:6E:46:63:72:66...
Servicio RecHandle: 0x10002
Lista de ID de clase de servicio:
""(0x1800)
Lista de descriptores de protocolo:
"L2CAP" (0x0100)
PSM: 31
"ATT" (0x0007)
uint16: 0x1
uint16: 0x5
recorte
Listado 144: Escaneando con sdptool
Aquí podemos ver que la herramienta sdptool pudo extraer información sobre todos los
servicios que este dispositivo es capaz de utilizar. En particular, vemos que este dispositivo es
compatible con el protocolo ATT, que es el protocolo de atributo de baja energía.
Esto puede proporcionarnos más pistas sobre qué es el dispositivo y posibles vías para interactuar
más con él.
Ver si los dispositivos son accesibles con l2ping
Una vez que hayamos recopilado las direcciones MAC de todos los dispositivos cercanos, podemos
enviar pings a estos dispositivos, ya sea que estén en modo de descubrimiento o no, para ver si
están disponibles. Esto nos permite saber si están activos y dentro del alcance. Para enviar un
ping, utilizamos el comando l2ping con la siguiente sintaxis:
dirección MAC l2ping
El Listado 145 me muestra haciendo ping al dispositivo Android descubierto en el

Listado 142.
kali >l2ping 76:6E:46:63:72:66 c 4

Ping: 76:6E:46:63:72:66 desde 10:AE:60:58:F1:37 (tamaño de datos 44)...
44 bytes 76:6E:46:63:72:66 id 0 tiempo 37,57 ms

¡GUAU! Libro
44 bytes 76:6E:46:63:72:66 id 1 vez 27,23 ms

44 bytes 76:6E:46:63:72:66 id 2 tiempo 27,59 ms
recorte
Listado 145: Hacer ping a un dispositivo Bluetooth
Este resultado indica que el dispositivo con la dirección MAC

76:6E:46:63:72:66 está dentro del alcance y es accesible. Este es un conocimiento
útil, porque debemos saber si se puede acceder a un dispositivo antes de siquiera
pensar en piratearlo.
Resumen
Los dispositivos inalámbricos representan el futuro de la conectividad y la piratería. Linux ha desarrollado
comandos especializados para escanear y conectarse a puntos de acceso WiFi en el primer paso hacia el hackeo
de esos sistemas. El conjunto de herramientas de piratería inalámbrica aircrackng incluye airmonng y airodump
ng, que nos permiten escanear y recopilar información clave de dispositivos inalámbricos dentro del alcance. La
suite BlueZ incluye hciconfig, hcitool y otras herramientas capaces de escanear y recopilar información, que son
necesarias para piratear los dispositivos Bluetooth dentro del alcance. También incluye muchas otras herramientas
que vale la pena explorar.
Ejercicios
1. Verifique sus dispositivos de red con ifconfig. Tenga en cuenta las extensiones inalámbricas.
2. Ejecute iwconfig y anote los adaptadores de red inalámbrica.
3. Verifique qué puntos de acceso WiFi están dentro del alcance de iwlist.
4. Verifique qué puntos de acceso WiFi están dentro del alcance de nmcli. cual encuentras
¿Más útil e intuitivo, nmcli o iwlist?
5. Conéctese a su AP WiFi usando nmcli.
6. Abra su adaptador Bluetooth con hciconfig y busque dispositivos cercanos

Dispositivos Bluetooth cubribles con hcitool.
7. Pruebe si esos dispositivos Bluetooth están dentro de una distancia accesible con
l2ping.

15
Administrar el kernel de Linux
y módulos de kernel cargables
Todos los sistemas operativos se componen

de al menos dos componentes principales.
El primero y más importante de ellos es el
núcleo. El núcleo está en el centro del sistema
operativo y controla todo lo que hace el sistema operativo,
incluida la gestión de la memoria, el control de la CPU e
incluso el control de lo que el usuario ve en la pantalla. El
segundo elemento del sistema operativo a menudo se
denomina tierra de usuario e incluye casi todo lo demás.
El kernel está diseñado para ser un área protegida o privilegiada a la que solo
pueden acceder root u otras cuentas privilegiadas. Esto es por una buena razón, ya que
el acceso al kernel puede proporcionar un acceso casi ilimitado al sistema operativo.
Como resultado, la mayoría de los sistemas operativos brindan a los usuarios y servicios
acceso solo al territorio del usuario, donde el usuario puede acceder a casi cualquier
cosa que necesite sin tomar el control del sistema operativo.
¡GUAU! Libro
El acceso al kernel permite al usuario cambiar la forma en que los sistemas operativos
Funciona, se ve y se siente. También les permite bloquear el sistema operativo,
haciéndolo inviable. A pesar de este riesgo, en algunos casos, el administrador del
sistema debe acceder con mucho cuidado al kernel por razones operativas y de seguridad.
En este capítulo, examinaremos cómo alterar la forma en que funciona el kernel y
agregar nuevos módulos al kernel. Probablemente no hace falta decir que si un hacker
puede alterar el kernel del objetivo, podrá controlar el sistema.
Además, es posible que un atacante necesite alterar el funcionamiento del kernel para
algunos ataques, como un ataque de intermediario (MITM), en el que el pirata informático
se coloca entre un cliente y un servidor y puede espiar o alterar la comunicación.
Primero, veremos más de cerca la estructura del núcleo y sus módulos.
¿Qué es un módulo de kernel?

El kernel es el sistema nervioso central de su sistema operativo y controla todo lo que
hace, incluida la gestión de las interacciones entre los componentes de hardware y el
inicio de los servicios necesarios. El kernel opera entre las aplicaciones de usuario que ve
y el hardware que ejecuta todo, como la CPU, la memoria y el disco duro.
Linux es un kernel monolítico que permite la adición de módulos de kernel.

Como tal, se pueden agregar y eliminar módulos del kernel. Ocasionalmente será necesario
actualizar el kernel, lo que podría implicar la instalación de nuevos controladores de
dispositivos (como tarjetas de video, dispositivos Bluetooth o dispositivos USB),
controladores de sistemas de archivos e incluso extensiones del sistema. Estos
controladores deben estar integrados en el kernel para que sean completamente
funcionales. En algunos sistemas, para agregar un controlador, es necesario reconstruir,
compilar y reiniciar todo el kernel, pero Linux tiene la capacidad de agregar algunos módulos
al kernel sin pasar por todo el proceso. Estos módulos se conocen como módulos de kernel cargables o LK
Los LKM tienen acceso a los niveles más bajos del kernel por necesidad, lo que los
convierte en un objetivo increíblemente vulnerable para los piratas informáticos. Un tipo
particular de malware conocido como rootkit se integra en el núcleo de los sistemas
operativos, a menudo a través de estos LKM. Si el malware se incrusta en el kernel, el
hacker puede tomar el control total del sistema operativo.
Si un hacker puede conseguir que el administrador de Linux cargue un nuevo
módulo en el kernel, el hacker no sólo puede obtener control sobre el sistema de destino
sino que, debido a que está operando en el nivel de kernel del sistema operativo, puede
controlar lo que el sistema de destino. son informes en términos de procesos, puertos,
servicios, espacio en el disco duro y casi cualquier otra cosa que se pueda imaginar.
Por lo tanto, si un hacker puede tentar con éxito a un administrador de Linux para
que instale un vídeo u otro controlador de dispositivo que tenga un rootkit integrado, el
hacker puede tomar el control total del sistema y del kernel. Ésta es la forma en que
algunos de los rootkits más insidiosos aprovechan Linux y otros sistemas operativos.
Comprender los LKM es absolutamente clave para ser un administrador de
Linux eficaz y un hacker muy eficaz y sigiloso.
Echemos un vistazo a cómo se puede gestionar el kernel para bien y para mal.
166 Capítulo 15
¡GUAU! Libro
Comprobando la versión del kernel

El primer paso para comprender el kernel es verificar qué kernel está ejecutando su sistema.
Hay al menos dos maneras de hacer esto. Primero, podemos ingresar lo siguiente:
kali >uname a
Linux Kali 4.6.0kalilamd64 #1 SMP Debian 4.6.4lkalil (21/07/2016) x86_64
El kernel responde diciéndonos que la distribución que ejecuta nuestro sistema operativo es
Linux Kali, la compilación del kernel es 4.6.4 y la arquitectura para la que está diseñado es la
arquitectura x86_64. También nos dice que tiene capacidades de multiprocesamiento simétrico
(SMP) (lo que significa que puede ejecutarse en máquinas con múltiples núcleos o procesadores)
y que fue compilado en Debian 4.6.4 el 21 de julio de 2016. Su resultado puede ser diferente,
según el kernel. se utilizó en su compilación y la CPU de su sistema. Esta información puede ser
necesaria al instalar o cargar un controlador del kernel, por lo que es útil saber cómo obtenerla.
Otra forma de obtener esta información, así como otra información útil, es usar el
comando cat en el archivo /proc/version , así:
kali >cat /proc/version

Linux versión 4.6.0kalilamd64 (devel@kali.org) (gcc versión 5.4.0 20160909
(Debian 5.4.06) ) #1 SMP Debian 4.6.4lkalil (21/07/2016)
Aquí puede ver que el archivo /proc/version devolvió lo mismo

información.
Ajuste del kernel con sysctl

Con los comandos correctos, puede ajustar su kernel, lo que significa que puede cambiar las
asignaciones de memoria, habilitar funciones de red e incluso fortalecer el kernel contra ataques
externos.
Los kernels de Linux modernos utilizan el comando sysctl para ajustar las opciones del kernel.
Todos los cambios que realice con sysctl permanecerán vigentes sólo hasta que reinicie el sistema.
Para que cualquier cambio sea permanente, debe editar el archivo de configuración de sysctl
directamente en /etc/sysctl.conf.
Una advertencia: debe tener cuidado al utilizar sysctl porque sin el conocimiento y la
experiencia adecuados, puede hacer que su sistema no pueda arrancar ni utilizarse fácilmente.
Asegúrese de haber considerado cuidadosamente lo que está haciendo antes de realizar cambios
permanentes.
Echemos un vistazo al contenido de sysctl ahora. A estas alturas ya deberías rec
Reconozca las opciones que le damos con el comando que se muestra aquí:
kali >sysctl a | menos

dev.cdrom.autoclose = 1
dev.cdrom.autoeject = 0
dev.cdrom.check_media = 0
dev.cdrom.depuración = 0
recorte
Administrar el kernel de Linux y los módulos del kernel cargables 167

¡GUAU! Libro
En el resultado, debería ver cientos de líneas de parámetros que un administrador

de Linux puede editar para optimizar el kernel. Aquí hay algunas líneas que le resultarán
útiles como hacker. Como ejemplo de cómo podría utilizar sysctl, veremos cómo habilitar el
reenvío de paquetes.
En el ataque de intermediario (MITM), el hacker se coloca entre los hosts en
comunicación para interceptar información. El tráfico pasa a través del sistema del hacker,
por lo que éste puede ver y posiblemente alterar la comunicación. Una forma de lograr este
enrutamiento es habilitar el reenvío de paquetes.
Si se desplaza hacia abajo algunas páginas en el resultado o filtra por "ipv4"
(sysctl a | less | grep ipv4), debería ver lo siguiente:
net.ipv4.ip_dynaddr = 0
net.ipv4.ip_early_demux = 0
net.ipv4.ip_forward = 0
net.ipv4.ip_forward_use_pmtu = 0
recorte
La línea net.ipv4.ip_forward = 0 es el parámetro del kernel que habilita la

kernel para reenviar los paquetes que recibe. En otras palabras, los paquetes que recibe
los devuelve. La configuración predeterminada es 0, lo que significa que el reenvío de
paquetes está deshabilitado.
Para habilitar el reenvío de IP, cambie el 0 a 1 ingresando lo siguiente:
kali >sysctl w net.ipv4.ip_forward=1
Recuerde que los cambios de sysctl se realizan en tiempo de ejecución pero se

pierden cuando se reinicia el sistema. Para realizar cambios permanentes en sysctl, debe
editar el archivo de configuración /etc/sysctl.conf. Cambiemos la forma en que el
kernel maneja el reenvío de IP para ataques MITM y hagamos que este cambio sea
permanente.
Para habilitar el reenvío de IP, abra el archivo /etc/sysctl.conf en cualquier editor de
texto y descomente la línea de ip_forward. Abra /etc/sycstl.conf con cualquier editor de
texto y eche un vistazo:
#/etc/sysctl.conf Archivo de configuración para configurar variables del sistema

# Consulte /etc/sysctl.d/ para obtener variables adicionales del sistema.
# Consulte sysctl.conf (5) para obtener información.
#
#kernel.nombrededominio = ejemplo.com
# Descomente lo siguiente para detener los mensajes de bajo nivel en la consola.

#kernel.printk = 3 4 1 3
################################################## ############3
# Funciones encontradas anteriormente en netbase
#
# Descomente las dos líneas siguientes para habilitar la protección contra falsificación (ruta inversa
# Active la verificación de dirección de origen en todas las interfaces para
# prevenir algunos ataques de suplantación de identidad.

#net.ipv4.conf.default.rp_filter=1
#net.ipv4.conf.all.rp_filter=1
# Descomentar la siguiente línea para habilitar las cookies TCP/IP SYN

#
# Nota: Esto también puede afectar las sesiones TCP IPv6

#net.ipv4.tcp_syncookies=1
Consulte http://lwn.net/Articles/277146/ #
Descomente la siguiente línea para habilitar el reenvío de paquetes para IPv4
tu #net.ipv4.ip_forward=1
La línea relevante está en u; simplemente elimine el comentario (#) aquí para habilitar
el reenvío de IP.
Desde una perspectiva de refuerzo del sistema operativo, podría utilizar este archivo
para deshabilitar las solicitudes de eco ICMP agregando la línea net.ipv4.icmp_echo_ignore_
all=1 para que sea más difícil, pero no imposible, para los piratas informáticos encontrar su sistema. Después
de agregar la línea, deberá ejecutar el comando sysctl p.
Gestión de módulos del kernel

Linux tiene al menos dos formas de administrar los módulos del kernel. La forma más
antigua es utilizar un grupo de comandos creados en torno a la suite insmod ; insmod
significa insertar módulo y está destinado a tratar con módulos. La segunda forma,
utilizando el comando modprobe , la emplearemos un poco más adelante en este capítulo.
Aquí usamos el comando lsmod de la suite insmod para enumerar los módulos instalados
en el kernel:
kali >lsmod
Módulo Tamaño Usado por
nfnetlink_queue 20480 0
nfnetlink_log 201480 0
nfnetlink 16384 2 nfnetlink_log, nfnetlink_queue
bluetooth 516096 0
rfkill 0 2 bluetooth
recorte
Como puede ver, el comando lsmod enumera todos los módulos del kernel, así como
información sobre su tamaño y qué otros módulos pueden usarlos. Así, por ejemplo, el
módulo nfnetlink (un protocolo basado en mensajes para la comunicación entre el kernel y
el espacio de usuario) tiene 16.384 bytes y lo utilizan tanto el módulo nfnetlink_log como el
módulo nf_netlink_queue .
Desde la suite insmod , podemos cargar o insertar un módulo con insmod y eliminar
un módulo con rmmod, que significa eliminar módulo. Estos comandos no son perfectos y
es posible que no tengan en cuenta las dependencias de los módulos, por lo que usarlos
pueden dejar el núcleo inestable o inutilizable. Como resultado, las distribuciones modernas
de Linux ahora han agregado el comando modprobe ,

¡GUAU! Libro
que carga automáticamente las dependencias y hace que cargar y eliminar módulos del
kernel sea menos riesgoso. Cubriremos modprobe en un momento. Primero, veamos cómo
obtener más información sobre nuestros módulos.
Encontrar más información con modinfo

Para obtener más información sobre cualquiera de los módulos del kernel, podemos usar el
comando modinfo . La sintaxis de este comando es sencilla: modinfo seguido del nombre
del módulo sobre el que desea obtener información. Por ejemplo, si desea recuperar
información básica sobre el módulo del kernel bluetooth que vio cuando ejecutó el comando
lsmod anteriormente, puede ingresar lo siguiente:
kali >modinfo bluetooth

nombre de archivo: /lib/modules/4.6.0kaliamd64/kernel/net/bluetooth/bluetooth.ko
alias: netpf31
licencia: GPL
versión: 2.21
descripción: Bluetooth Core versión 2.21
autor: Marcel Holtman <marcel@holtmann.org>
srcversión: FCFDE98577FEA911A3DAFA9
depende: rfkill, crc16
árbol interno: Y
vermagic: 4.6.0kali1amd64 SMP mod_unload modversiones

parm: enable_esco: deshabilita la creación de conexión eSCO (bool)
parm: enable_ertm: deshabilita el modo de retransmisión mejorada (bool)
Como puede ver, el comando modinfo revela información importante sobre este
módulo del kernel que es necesaria para usar Bluetooth en su sistema.
Tenga en cuenta que, entre muchas otras cosas, enumera las dependencias del módulo: rfkill
y crc16. Las dependencias son módulos que deben instalarse para el bluetooth.
módulo funcione correctamente.
Normalmente, esta es información útil para solucionar problemas por los cuales un
dispositivo de hardware en particular no funciona. Además de anotar cosas como las
dependencias, puede obtener información sobre la versión del módulo y la versión del kernel
para la que se desarrolló el módulo y luego asegurarse de que coincidan con la versión
que está ejecutando.
Agregar y quitar módulos con modprobe

La mayoría de las distribuciones más nuevas de Linux, incluido Kali Linux, incluyen modprobe.
comando para la gestión de LKM. Para agregar un módulo a su kernel, usaría el comando
modprobe con el modificador a (agregar), así:
kali >modprobe a <nombre del módulo>
Para eliminar un módulo, use el modificador r (eliminar) con modprobe seguido del
nombre del módulo:
kali >modprobe r <módulo a eliminar>

Una ventaja importante de utilizar modprobe en lugar de insmod es que modprobe

comprende las dependencias, las opciones y los procedimientos de instalación y eliminación,
y los tiene todos en cuenta antes de realizar cambios. Por lo tanto, es más fácil y seguro agregar
y eliminar módulos del kernel con modprobe.
Insertar y quitar un módulo de kernel

Intentemos insertar y quitar un módulo de prueba para ayudarle a familiarizarse con este
proceso. Imaginemos que acaba de instalar una nueva tarjeta de video y necesita instalar los
controladores correspondientes. Recuerde, los controladores de los dispositivos generalmente
se instalan directamente en el kernel para brindarles el acceso necesario para funcionar
correctamente. Esto también convierte a los controladores en un terreno fértil para que piratas
informáticos malintencionados instalen un rootkit u otro dispositivo de escucha.
Supongamos para fines de demostración (en realidad no ejecute estos comandos) que
queremos agregar un nuevo controlador de video llamado HackersAriseNewVideo.
Puede agregarlo a su kernel ingresando lo siguiente:
kali >modprobe a HackersAriseNuevoVideo
Para probar si el nuevo módulo se cargó correctamente, puede ejecutar dmesg

comando, que imprime el búfer de mensajes del kernel y luego filtra por "video" y busca
cualquier alerta que indique un problema:
kali >dmesg | vídeo grep
Si hay algún mensaje del kernel con la palabra "video", se mostrará aquí. Si no aparece
nada, no hay mensajes que contengan esa palabra clave.
Luego, para eliminar este mismo módulo, puede ingresar el mismo comando
pero con el modificador r (eliminar):
kali >modprobe r HackersAriseNuevoVideo
Recuerde, los módulos cargables del kernel son una comodidad para un usuario/
administrador de Linux, pero también son una importante debilidad de seguridad con la que
los hackers profesionales deberían estar familiarizados. Como dije antes, los LKM pueden ser el
vehículo perfecto para introducir su rootkit en el kernel y causar estragos.
Resumen
El kernel es crucial para el funcionamiento general del sistema operativo y, como tal, es un
área protegida. Cualquier cosa que se agregue inadvertidamente al kernel puede alterar el
sistema operativo e incluso tomar el control del mismo.
Los LKM permiten al administrador del sistema agregar módulos directamente al
kernel sin tener que reconstruir todo el kernel cada vez que quieran agregar un módulo.

¡GUAU! Libro
Si un pirata informático puede convencer al administrador del sistema para que agregue un LKM malicioso, el
El pirata informático puede tomar el control total del sistema, a menudo sin que el administrador del sistema se
dé cuenta.
Ejercicios
1. Verifique la versión de su kernel.
2. Enumere los módulos en su kernel.
3. Habilite el reenvío de IP con un comando sysctl .
4. Edite su archivo /etc/sysctl.conf para habilitar el reenvío de IP. Ahora, deshabilite la IP

reenvío.
5. Seleccione un módulo del kernel y obtenga más información sobre él usando modinfo.
dieciséis
Automatiza ción de tareas con

Programación de Trabajo
Como cualquiera que use Linux, el hacker a menudo tiene

trabajos, scripts u otras tareas que quiere ejecutar
periódicamente. Es posible que, por ejemplo, desee
programar el archivo regular automático.
copias de seguridad de su sistema, o tal vez desee rotar los archivos de
registro como lo hicimos en el Capítulo 11. El hacker, por otro lado,
también puede querer que su sistema ejecute el script MySQLscanner.sh
del Capítulo 8 todas las noches o mientras estás en el trabajo o la
escuela. Todos estos son ejemplos de programación de trabajos
automáticos. Programar trabajos le permite ejecutar tareas sin tener
que pensar en ello, y puede programar trabajos para que se ejecuten
cuando no esté usando su sistema, de modo que tenga muchos recursos gratuitos.
Es posible que el administrador de Linux, o el hacker, también desee configurar
ciertos scripts o servicios para que se inicien automáticamente cuando se inicie su
sistema. En el Capítulo 12, analizamos el uso de la base de datos PostgreSQL en
asociación con el marco hacker/pentest Metasploit. En lugar de manualmente
¡GUAU! Libro
Al iniciar la base de datos PostgreSQL cada vez antes de iniciar Metasploit, puede hacer que
PostgreSQL, o cualquier servicio o script, se inicie automáticamente cuando se inicia el
sistema.
En este capítulo, aprenderá más sobre cómo usar el demonio cron y crontab para
configurar scripts para que se ejecuten automáticamente, incluso cuando el sistema está
desatendido. También aprenderá cómo configurar secuencias de comandos de inicio que se
ejecutan automáticamente cada vez que se inicia el sistema, lo que le proporcionará los
servicios necesarios que necesitará ejecutar durante su ajetreado día de piratería.
Programar un evento o trabajo para que se ejecute de forma automática

El demonio cron y la tabla cron (crontab) son las herramientas más útiles para programar
tareas regulares. El primero, crond, es un demonio que se ejecuta en segundo plano. El
demonio cron verifica en la tabla cron qué comandos ejecutar en momentos específicos.
Podemos alterar la tabla cron para programar una tarea o trabajo para que se ejecute
regularmente en un día o fecha particular, a una hora particular diariamente o cada tantas
semanas o meses.
Para programar estas tareas o trabajos, ingréselos en el archivo de la tabla cron ,
ubicado en /etc/crontab. La tabla cron tiene siete campos: los primeros cinco se usan para
programar el tiempo para ejecutar la tarea, el sexto campo especifica el usuario y el
séptimo campo se usa para la ruta absoluta al comando que desea ejecutar. Si estuviéramos
usando la tabla cron para programar un script, simplemente podríamos poner la ruta absoluta
al script en el séptimo campo.
Cada uno de los cinco campos de tiempo representa un elemento de tiempo
diferente: el minuto, la hora, el día del mes, el mes y el día de la semana, en ese orden.
Cada elemento de tiempo debe representarse numéricamente, por lo que marzo se
representa como 3 (no se puede ingresar simplemente "Marzo"). Los días de la semana
comienzan a las 0, que es domingo, y terminan a las 7, que también es domingo. La tabla
161 resume esto.
Tabla 161: Representaciones de tiempo para uso en el crontab
Unidad de tiempo de campo Representación
1 Minuto 0–59
2 Hora 023
3 Día del mes 1–31
4 Mes 1–12
5 Día de la semana 0–7
Entonces, si hubiéramos escrito un script para escanear el mundo en busca de

puertos abiertos vulnerables y quisiéramos que se ejecutara todas las noches a las 2:30
am, de lunes a viernes, podríamos programarlo en el archivo crontab . En breve explicaremos
el proceso de cómo obtener esta información en el crontab , pero primero analicemos el
formato que debemos seguir, que se muestra en el Listado 161.

COMANDO DE USUARIO MH DOM MON DOW

30 2 * *
15 raíz /root/myscanningscript
Listado 161: El formato para programar comandos
El archivo crontab etiqueta las columnas de forma útil. Tenga en cuenta que la primera
El campo proporciona los minutos (30), el segundo campo proporciona la hora (2), el
quinto campo proporciona los días (15, o de lunes a viernes), el sexto campo define el
usuario (raíz) y el séptimo campo es el camino al guión. Los campos tercero y cuarto
contienen asteriscos (*) porque queremos que este script se ejecute todos los días, de
lunes a viernes, independientemente del día del mes o del mes.
En el Listado 161, el quinto campo define un rango para el día de la semana mediante
usando un guión () entre los números. Si desea ejecutar un script en varios días de la
semana no contiguos, puede separar esos días con comas (,). Así, martes y jueves serían
2,4.
Para editar crontab, puede ejecutar el comando crontab seguido de e
(editar) opción:
kali >crontab e
Seleccione un editor. Para cambiar más tarde, ejecute 'selecteditor'.
1. /bin/nano <más fácil
2. /usr/bin/mcedit
3. /usr/bin/vim.basic
4. /usr/bin/vim.gtk
5. /usr/bin/vim.tiny
Elija 15 [1]:
La primera vez que ejecute este comando, le preguntará qué editor desea utilizar. El
valor predeterminado es /bin/nano, la opción 1. Si elige esta opción, se abrirá directamente
en crontab.
Otra opción, y a menudo mejor para el recién llegado a Linux, es
Abre crontab directamente en tu editor de texto favorito, lo cual puedes hacer así:
kali >leafpad /etc/crontab
He usado este comando para abrir crontab en Leafpad. Puede ver un recorte del
archivo en el Listado 162.
# /etc/crontab: crontab de todo el sistema

# A diferencia de cualquier otro crontab, no es necesario ejecutar el 'crontab'
# comando para instalar la nueva versión cuando edites este archivo
# y archivos en /etc/cron.d. Estos archivos también tienen campos de nombre de usuario,
# lo que ningún otro crontab hace.
SHELL=/bin/sh
RUTA=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin

¡GUAU! Libro
# comando de usuario mh dom mon dow

17 * * * * cd raíz / && runparts report /etc/cron.hourly
25 6 * * * prueba raíz x /usr/sbin/anacron II ( cd / && runparts
47 6 * * 7 prueba raíz x /usr/sbin/anacron II ( cd / && runparts
52 6 1 * * prueba raíz x /usr/sbin/anacron II ( cd / && ejecutarpartes
#
Listado 162: El archivo crontab en uso en un editor de texto
Ahora, para configurar una nueva tarea programada regularmente, simplemente necesita ingresar un
nueva línea y guarde el archivo.
Programar una tarea de respaldo
Veamos primero esta utilidad desde la perspectiva del administrador del sistema. Como administrador
del sistema, a menudo querrá ejecutar copias de seguridad de todos sus archivos fuera de horario,
mientras el sistema no se está utilizando y los recursos están disponibles. (Las copias de seguridad
del sistema tienden a requerir recursos del sistema que tienen poca demanda durante el horario
comercial). El momento ideal podría ser en medio de la noche del fin de semana. En lugar de tener
que iniciar sesión a las 2 a. m . del sábado por la noche o el domingo por la mañana (estoy seguro de
que tiene otras prioridades a esa hora), puede programar la copia de seguridad para que se inicie
automáticamente a esa hora, aunque no esté frente a su computadora. .
Tenga en cuenta que el campo de hora utiliza un reloj de 24 horas en lugar de am y pm,
entonces la 1 pm son, por ejemplo, las 13:00. Además, tenga en cuenta que los días de la semana
(DOW) comienzan con el domingo (0) y terminan con el sábado (6).
Para crear un trabajo, simplemente necesita editar el archivo crontab agregando una línea en el
formato prescrito. Entonces, supongamos que desea crear una tarea de respaldo regular utilizando una
cuenta de usuario llamada "copia de seguridad". Escribiría un script para realizar una copia de seguridad
del sistema y lo guardaría como systembackup.sh en el directorio /bin , luego programaría esta copia
de seguridad para que se ejecute todos los sábados por la noche/domingo por la mañana a las 2 a.m.
agregando la siguiente línea a crontab:
00 2 * * 0 copia de seguridad /bin/systembackup.sh
Tenga en cuenta que el comodín * se utiliza para indicar "cualquiera" y usarlo en lugar de un
dígito para el día del mes, mes o día de la semana se lee como "todos" los días o meses. Si lees al otro
lado de esta línea, dice
1. Al final de la hora (00),

2. De la segunda hora (2),
3. De cualquier día del mes (*),
4. De cualquier mes (*),
5. El domingo (0),
6. Como usuario de respaldo,
7. Ejecute el script en /bin/systembackup.sh.

El demonio cron ejecutará ese script todos los domingos por la mañana a las 2 am, todos los meses.
Si solo desea que la copia de seguridad se ejecute los días 15 y 30 de cada mes,
independientemente de en qué días de la semana caigan esas fechas, puede revisar la entrada en
crontab para que aparezca de la siguiente manera :
00 2 15,30 * * copia de seguridad /root/systembackup.sh
Tenga en cuenta que el campo del día del mes (DOM) ahora tiene 15,30. Esto le indica al sistema
que ejecute el script solo los días 15 y 30 de cada mes, es decir, aproximadamente cada dos semanas.
Cuando desee especificar varios días, horas o meses, deberá enumerarlos separados por una coma, como
hicimos aquí.
A continuación, supongamos que la empresa le exige que esté especialmente atento a sus copias
de seguridad. No puede permitirse el lujo de perder ni siquiera un día de datos en caso de un corte de
energía o una falla del sistema. Luego deberá hacer una copia de seguridad de los datos cada noche
de la semana agregando la siguiente línea:
**
00 23 15 copia de seguridad /root/systembackup.sh
Este trabajo se ejecutaría a las 11 p.m. (hora 23), todos los días del mes, todos los meses, pero
solo de lunes a viernes (días 1 a 5). Tenga en cuenta especialmente que designamos los días de lunes a
viernes proporcionando un intervalo de días (1 a 5) separados por un guión (). Esto también podría haberse
designado como 1,2,3,4,5; de cualquier manera funciona perfectamente bien.
Usando crontab para programar su escáner MySQL
Ahora que comprende los conceptos básicos de la programación de un trabajo con el crontab
comando, programemos el script MySQLscanner.sh , que busca puertos MySQL abiertos, que creó en el
Capítulo 8. Este escáner busca sistemas que ejecutan MySQL buscando el puerto abierto 3306.
Para ingresar su MySQLscanner.sh al archivo crontab , edite el archivo para proporcionar

los detalles de este trabajo, tal como lo hicimos con las copias de seguridad del sistema. Lo
programaremos para que se ejecute durante el día mientras usted está en el trabajo para que no consuma
recursos cuando utilice su sistema doméstico. Para hacer esto, ingrese la siguiente línea en su crontab:
***
00 9 usuario /usr/share/MySQLsscanner.sh
Hemos configurado el trabajo para que se ejecute a las 00 minutos, a la novena hora, todos los días de
el mes (*), todos los meses (*), todos los días de la semana (*), y ejecutarlo como usuario habitual.
Simplemente necesitamos guardar este archivo crontab para programar el trabajo.
Ahora, supongamos que quiere ser especialmente cuidadoso y ejecutar este escáner sólo los fines
de semana y a las 2 am , cuando es menos probable que alguien esté observando el tráfico de la red.
También querrás que funcione solo en verano, de junio a agosto. Su trabajo ahora se vería así:
00 2 * 68 0,6 usuario /usr/share/MySQLsscanner.sh

¡GUAU! Libro
Agregarías esto a tu crontab así:
# /etc/crontab: crontab de todo el sistema

# A diferencia de cualquier otro crontab, no es necesario ejecutar el 'crontab'
# comando para instalar la nueva versión cuando edites este archivo
# y archivos en /etc/cron.d. Estos archivos también tienen campos de nombre de usuario,
# lo cual ninguno de los otros crontabs hace.
SHELL=/bin/sh
RUTA=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin
# comando de usuario mh dom mon dow

17 * * * * cd raíz / && runparts report /etc/cron.hourly
25 6 * * * prueba raíz x /usr/sbin/anacron II ( cd / && runparts report /etc/cron.daily )
47 6 * * 7 prueba raíz x /usr/sbin/anacron II ( cd / && runparts report /etc/cron.weekly )
52 6 1 * * prueba raíz x /usr/sbin/anacron II ( cd / && runparts report /etc/cron.monthly )
00 2 * 68 0,6 usuario /usr/share/MySQLsscanner.sh
Ahora, MySQLscanner.sh solo se ejecutará los fines de semana de junio, julio y agosto a
las 2 am.
Atajos de crontab
El archivo crontab tiene algunos atajos integrados que puede utilizar en lugar de especificar la
hora, el día y el mes cada vez. Estos incluyen lo siguiente:
• @anual
• @anualmente
• @mensual
• @semanal
• @diario
• @medianoche
• @mediodía
• @reiniciar
Entonces, si desea que el escáner MySQL se ejecute todas las noches a medianoche,
puede agregar la siguiente línea al archivo crontab :
@medianoche usuario /usr/share/MySQLsscanner.sh
Uso de scripts rc para ejecutar trabajos al inicio

Cada vez que inicia su sistema Linux, se ejecutan una serie de scripts para configurar el entorno
por usted. Estos se conocen como scripts rc . Después de que el kernel se ha inicializado y
cargado todos sus módulos, el kernel inicia un demonio conocido
178 Capítulo 16
¡GUAU! Libro
como init o init.d. Este demonio luego comienza a ejecutar una serie de scripts que se encuentran
en /etc/init.d/rc. Estos scripts incluyen comandos para iniciar muchos de los servicios necesarios
para ejecutar su sistema Linux como espera.
Niveles de ejecución de Linux
Linux tiene múltiples niveles de ejecución que indican qué servicios deben iniciarse durante el
arranque. Por ejemplo, el nivel de ejecución 1 es el modo de usuario único y los servicios como
las redes no se inician en el nivel de ejecución 1. Los scripts rc están configurados para
ejecutarse según el nivel de ejecución seleccionado:
0 Detener el sistema
1 usuario único/modo mínimo

2–5 modos multiusuario
6 Reinicie el sistema
Agregar servicios a rc.d
Puede agregar servicios para que el script rc.d se ejecute al inicio usando updaterc.d
dominio. Este comando le permite agregar o eliminar servicios del script rc.d. La sintaxis de update
rc.d es sencilla; simplemente enumera el comando seguido del nombre del script y luego la acción
a realizar, así:
kali >updaterc.d <nombre del script o servicio> <remove|defaults|disable|enable>
Como ejemplo de cómo puedes usar updaterc.d, supongamos que siempre

desea que la base de datos PostgreSQL se inicie al iniciar el sistema para que su marco
Metasploit pueda usarlo para almacenar resultados de pentesting y piratería.
Usaría updaterc.d para agregar una línea a su script rc.d para tenerlo en funcionamiento cada vez
que inicie su sistema.
Antes de hacer eso, verifiquemos si PostgreSQL ya se está ejecutando en su sistema. Puedes
hacerlo usando el comando ps y canalizándolo a un filtro que busque PostgreSQL usando grep, así:
kali >ps auxiliar | grep postgresql

raíz 3876 0,0 127200.0 964 puntos/1 S+ 14.24 0.00 grep postgresql
Este resultado nos dice que el único proceso que ps encontró ejecutándose para PostgreSQL
fue el mismo comando que ejecutamos buscándolo, por lo que actualmente no hay ninguna base
de datos PostgreSQL ejecutándose en este sistema.
Ahora, actualicemos nuestro rc.d para que PostgreSQL se ejecute automáticamente en
el arranque:
kali >updaterc.d valores predeterminados de postgresql
Automatizar tareas con programación de trabajos 179

¡GUAU! Libro
Esto agrega la línea al archivo rc.d. Debe reiniciar el sistema para que se realice el
cambio. Una vez que hayas hecho eso, usemos nuevamente el comando ps con grep
para buscar un proceso PostgreSQL:
kali >ps auxiliar | grep postgresql

postgresql 757 0,0 0,1 287636 25180? S 14 de marzo
0.00 /usr/lib/postgresql/9.6/bin/postgresql D /var/lib/postgresql/
9.6/main c config_file=/etc/postgresql/
9.6/main/postgresql.conf
raíz 3876 964 puntos/1 0.0 0,0 12720 S+ 14.24 0.00 grep postgresql
Como puede ver, PostgreSQL se ejecuta sin que usted ingrese ningún
comandos manualmente. ¡Se inicia automáticamente cuando su sistema arranca,
listo y esperando ser utilizado con su Metasploit!
Agregar servicios a su inicio a través de una GUI

Si se siente más cómodo trabajando desde una GUI para agregar servicios al inicio,
puede descargar la herramienta rudimentaria basada en GUI rcconf desde el repositorio
de Kali, así:
kali >aptget instalar rcconf
Una vez que haya completado su instalación, puede iniciar rcconf ingresando lo
siguiente:
kali > rcconf
Esto abrirá una GUI simple como la de la Figura 161. Luego puede desplazarse
por los servicios disponibles, seleccionar los que desea iniciar al iniciar y hacer clic en
Aceptar.
Figura 161: La GUI de rcconf para agregar servicios al inicio

En esta figura, puede ver el servicio PostgreSQL listado en segundo lugar desde
último. Presione la barra espaciadora para seleccionar este servicio, presione el tabulador
para resaltar <Ok> y luego presione Intro. La próxima vez que inicie Kali, PostgreSQL se
iniciará automáticamente.
Resumen
Tanto los administradores de sistemas como los piratas informáticos a menudo necesitan
programar servicios, scripts y utilidades para que se ejecuten a intervalos regulares. Linux le
permite programar casi cualquier script o utilidad para que se ejecute de forma regular utilizando
el demonio cron , que ejecuta estos trabajos desde la tabla cron . Además, puede hacer que los
servicios se inicien automáticamente durante el arranque utilizando el comando updaterc.d o la
herramienta basada en GUI rcconf para actualizar los scripts rc.d.
Ejercicios
1. Programe su script MySQLscanner.sh para que se ejecute todos los miércoles a las 3 p. m.
2. Programe su script MySQLscanner.sh para que se ejecute cada décimo día del mes en abril, junio y
agosto.
3. Programe su script MySQLscanner.sh para que se ejecute todos los martes a jueves a las
10 am.
4. Programe su script MySQLscanner.sh para que se ejecute diariamente al mediodía usando el

atajos.
5. Actualice su script rc.d para ejecutar PostgreSQL cada vez que arranque su sistema.
6. Descargue e instale rcconf y agregue las bases de datos PostgreSQL y MySQL para comenzar
durante el arranque.

¡GUAU! Libro
¡GUAU! Libro
17
Conceptos básicos de Python Scripting
para hackers
Las habilidades básicas de programación son fundamentales

para convertirse en un maestro hacker. Sin haber desarrollado
algunas habilidades básicas de programación, un hacker principiante
Quien simplemente utilice herramientas creadas por otra persona
será condenado al reino de los script kiddies. Esto significa que estará
limitado a utilizar herramientas desarrolladas por otra persona, lo que
disminuye su probabilidad de éxito y aumenta su probabilidad de detección por
parte del software antivirus (AV), los sistemas de detección de intrusiones (IDS)
y las autoridades. ¡Con algunas habilidades de programación, podrás elevarte
al escalón superior de los maestros hackers!
En el Capítulo 8, cubrimos los conceptos básicos de las secuencias de comandos bash y
creamos algunas secuencias de comandos simples, incluido MySQLScanner.sh, que encuentra
sistemas que ejecutan el omnipresente sistema de base de datos MySQL. En este capítulo,
comenzaremos analizando el lenguaje de secuencias de comandos más utilizado por los piratas
informáticos: Python. Muchas de las herramientas de hackers más populares están escritas en
Python, incluidas sqlmap, scapy, SocialEngineer Toolkit (SET), w3af y muchas más.
Python tiene algunas características importantes que lo hacen particularmente adecuado
para la piratería, pero probablemente lo más importante es que tiene una gran variedad.
¡GUAU! Libro
de bibliotecas (módulos de código prediseñados que se pueden importar externamente y

reutilizar) que proporcionan algunas funciones poderosas. Python viene con más de 1000
módulos integrados y muchos más están disponibles en otros repositorios.
También es posible crear herramientas de piratería en otros lenguajes, como bash,

Perl y Ruby, pero los módulos de Python facilitan mucho la creación de estas herramientas.
Agregar módulos de Python
Cuando instala Python, también instala su conjunto de bibliotecas y módulos estándar que
brindan una amplia gama de capacidades, incluidos tipos de datos integrados, manejo de
excepciones, módulos numéricos y matemáticos, manejo de archivos, servicios criptográficos,
manejo de datos de Internet e interacción. con protocolos de Internet (IP).
A pesar de toda la potencia que ofrecen estas bibliotecas y módulos estándar,

es posible que necesite o desee módulos adicionales de terceros. Los módulos de terceros
disponibles para Python son extensos y probablemente sean la razón por la que la mayoría de
los piratas informáticos prefieren Python para las secuencias de comandos. Puede encontrar
una lista completa de módulos de terceros en PyPI (el índice de paquetes de Python, que se
muestra en la Figura 171) en http://www.pypi.org/.
Figura 171: Índice del paquete Python
Usando pepita
Python tiene un administrador de paquetes específicamente para instalar y administrar

paquetes de Python conocido como pip (Pip Installs Packages). ya que estamos trabajando

con Python 3 aquí, necesitará pip para Python 3 para descargar e instalar paquetes.
Puede descargar e instalar pip desde el repositorio de Kali ingresando lo siguiente:
kali >aptget instalar python3pip
Ahora, para descargar módulos de PyPI, simplemente puedes ingresar esto:
kali >pip3 instalar <nombre del paquete>
Cuando descarga estos paquetes, se colocan automáticamente en el directorio /usr/

local//lib/<pythonversion>/distpackages . Entonces, por ejemplo, si hubiera usado pip
para instalar la implementación Python del protocolo SNMP para Python 3.6, lo encontraría
en /usr/local/lib/python3.6/pysnmp. Si no está seguro de dónde se ha colocado un paquete
en su sistema (a veces, diferentes distribuciones de Linux usan directorios diferentes),
puede ingresar pip3 seguido de show y el nombre del paquete, como se muestra aquí:
kali >pip3 mostrar pysnmp

Nombre: pysnmp
Versión: 4.4.4
Resumen: biblioteca SNMP para Python
Página de inicio: https://github.com/etingof/pysnmp
Autor: Ilya Etingof <etingof@gmail.com>
Correo electrónico del autor: etingof@gmail.com
Licencia: BSD
Ubicación: usr/local/lib/python3.6/distpackages
Requiere: ptsmi, pyansl, pycryptodomex
Puede ver que esto le brinda mucha información sobre el paquete, incluido el
directorio que lo contiene.
Como alternativa al uso de pip, puede descargar un paquete directamente desde
el sitio (asegúrese de descargarlo en el directorio adecuado), descomprimirlo (consulte
el Capítulo 9 sobre cómo descomprimir el software) y luego ejecutar lo siguiente:
kali > instalación de python setup.py
Esto instalará todos los paquetes descomprimidos que aún no se hayan instalado.
Instalación de módulos de terceros

Para instalar un módulo de terceros creado por otro miembro de la comunidad Python
(a diferencia de un paquete Python lanzado oficialmente), simplemente puede usar wget
para descargarlo desde cualquier lugar donde esté almacenado en línea, descomprimir el
módulo y luego ejecutar el comando de instalación python setup.py .
Como ejemplo, descarguemos e instalemos el módulo Python para la herramienta
de escaneo de puertos que usamos en el Capítulo 8, nmap, desde su repositorio en línea
en https://xael.org.

¡GUAU! Libro
Primero, necesitamos descargar el módulo desde xael.org:
kali >wget http://xael.org/norman/python/pythonnmap/pythonnmap0.3.4.tar.gz

20141228 17:48:32 http://xael.org/norman/python/pythonnmap/pythonnmap 0.3.4.tar.gz
Resolviendo xael.org (xael.org)...194.36.166.10

Conectándose a xael.org (xael.org)|194.36.166.10|:80...conectado.
recorte
20182128 17.48:34 (113 KB/s) 'pythonnmap0.3.4.tar.gz' guardado [40307/40307]
Aquí puede ver que usamos el comando wget y la URL completa del paquete. Una
vez descargado el paquete, deberá descomprimirlo con tar, como aprendió en el
Capítulo 9:
kali >tar xzf pythonnmap0.3.4.tar.gz
Luego cambie los directorios al directorio recién creado:
kali >cd pythonnmap.03.4/
Finalmente, en ese directorio, instale el nuevo módulo ingresando lo siguiente:
kali >~/pythonnmap0.3.4 >instalación de python setup.py

ejecutando instalación
ejecutando compilación
ejecutando build_py
creando construcción
recorte
ejecutando install_egg_info
escribiendo /usr/local/lib/python2.7/distpackages/python_nmap0.3.4.egg.info
También se pueden obtener muchos otros módulos de esta manera. Una vez
que haya instalado este módulo nmap, puede usarlo en sus scripts de Python
importando el módulo. Más sobre esto más adelante. Ahora comencemos con algunas
secuencias de comandos.
Introducción a las secuencias de comandos con Python
Ahora que sabes cómo instalar módulos en Python, quiero cubrir algunos de los conceptos
y la terminología básicos de Python, y luego la sintaxis básica.
Después de eso, escribirás algunos scripts que serán útiles para los hackers de todo
el mundo y que espero demuestren el poder de Python.

Al igual que con bash o cualquier otro lenguaje de scripting, podemos crear scripts de
Python usando cualquier editor de texto. Para este capítulo, para simplificar las cosas, le
aconsejo que utilice un editor de texto simple como Leafpad, pero es útil saber que hay varios
entornos de desarrollo integrados, o IDE, disponibles para usar con Python. Un IDE es como
un editor de texto con otras capacidades integradas, como codificación de colores, depuración y
compilación. Kali tiene el IDE PyCrust integrado, pero hay muchos más IDE disponibles para
descargar, de los cuales el mejor es posiblemente PyCharm de JetBrain. Este es un IDE
excelente con muchas mejoras que hacen que aprender Python sea más fácil y rápido. Existe
una versión profesional para comprar y una edición comunitaria que es gratuita. Puede
encontrarlos en https://www.jetbrains.com/pycharm/.
Una vez que hayas completado este capítulo, si quieres seguir aprendiendo Python,
PyCharm es una excelente herramienta que te ayudará en tu desarrollo. Por ahora, usaremos un
editor de texto básico como Leafpad para simplificar las cosas.
Tenga en cuenta que aprender cualquier lenguaje de programación requiere tiempo y
mucho trabajo. Sea paciente consigo mismo: intente dominar cada uno de los pequeños
guiones que le proporciono antes de continuar.
Formatear en Python
Una diferencia entre Python y otros lenguajes de programación es que el

formato es de vital importancia en Python. El intérprete de Python utiliza for
matting para determinar cómo se agrupa el código. Los detalles del formato
son menos importantes que simplemente ser coherente, particularmente con
los niveles de sangría.
Si tiene un grupo de líneas de código que comienza con doble sangría,
por ejemplo, debe ser coherente con la doble sangría en todo el bloque para
que Python reconozca que estas líneas de código van juntas. Esto es diferente
de las secuencias de comandos en otros lenguajes de programación, donde el
formateo es opcional y una mejor práctica, pero no es obligatorio. Notarás esto
a medida que avances y practiques; ¡Es algo a tener siempre en cuenta!
variables
Ahora, pasemos a algunos conceptos más prácticos en Python. Una variable es uno de los tipos
de datos más básicos en programación, y la encontró anteriormente en el Capítulo 8 con
scripts bash. En términos simples, una variable es un nombre asociado con un valor particular
de modo que siempre que use ese nombre en su programa, invocará el valor asociado.
La forma en que funciona es que el nombre de la variable apunta a datos almacenados

en una ubicación de memoria, que puede contener cualquier tipo de valor, como un número
entero, un número real, una cadena, un número de punto flotante, un booleano (declaración
verdadera o falsa), lista o diccionario. Cubriremos brevemente todos estos en este capítulo.
Para familiarizarnos con los conceptos básicos, creemos un script simple, que se muestra en
Listado 171, en Leafpad y guárdelo como hackersarise_greetings.py.
¡GUAU! Libro Conceptos básicos de secuencias de comandos Python para piratas informáticos 187
#! /usr/bin/python3
nombre="OcuparLaWeb"
" "
imprimir ("Saludos a + nombre + de HackersArise. ¡El mejor lugar para aprender a hackear!")
Listado 171: Su primer programa Python
La primera línea simplemente le dice a su sistema que desea que use Python.
intérprete para ejecutar este programa, en lugar de cualquier otro lenguaje. La segunda
línea define una variable llamada nombre y le asigna un valor (en este caso,
"OccupyTheWeb"). Debe cambiar este valor a su propio nombre. El valor de esta variable
está en el formato de datos de caracteres de cadena , lo que significa que el contenido
está entre comillas y se trata como texto. También puedes poner números en cadenas y
serán tratados como texto, en el sentido de que no podrás usarlos en cálculos numéricos.
La tercera línea crea una declaración print() que concatena Saludos a

con el valor en la variable de nombre , seguido del texto de HackersArise.
¡El mejor lugar para aprender a hackear! Una declaración print() mostrará todo lo que le pase entre
paréntesis en su pantalla.
Ahora, antes de poder ejecutar este script, debe darse permiso para ejecutarlo.
Necesitamos el comando chmod para hacer eso. (Para obtener más información sobre
los permisos de Linux, consulte el Capítulo 5).
kali >chmod 755 hackersarise_greetings.py
Tal como lo hizo en el Capítulo 8 con los scripts bash, para ejecutar su script,
preceda el nombre del script con un punto y una barra diagonal. Su directorio actual
no está en la variable $PATH por razones de seguridad, por lo que debemos anteponer
el nombre del script con ./ para indicarle al sistema que busque el nombre del archivo
en el directorio actual y lo ejecute.
Para ejecutar este script en particular, ingrese lo siguiente:
kali >./hackersarise_greetings.py
Saludos a OccupyTheWeb de parte de HackersArise. ¡El mejor lugar para aprender a hackear!
En Python, cada tipo de variable se trata como una clase. Una clase es una
especie de plantilla para crear objetos. Consulte ""Programación orientada a objetos
(OOP)" en la página 192 para obtener más información. En el siguiente script, intenté
demostrar algunos de los tipos de variables. Las variables pueden contener más que
solo cadenas. El Listado 172 muestra algunas variables que contienen diferentes tipos de datos.
#! /usr/bin/python3
HackersAriseStringVariable = "HackersArise es el mejor lugar para aprender

Hackear"
HackersAriseIntegerVariable = 12

HackersAriseFloatingPointVariable = 3.1415
ListaHackersArise = [1,2,3,4,5,6]
HackersAriseDictionary = {'nombre': 'OccupyTheWeb', 'valor': 27)
imprimir (HackersAriseStringVariable)
imprimir (HackersAriseIntegerVariable)
imprimir (HackersAriseFloatingPointVariable)
Listado 172: Una serie de estructuras de datos asociadas con variables
Esto crea cinco variables que contienen diferentes tipos de datos: una cadena,
tratada como texto; un número entero, que es un tipo de número sin decimales que se
puede utilizar en operaciones numéricas; un flotante, que es un tipo de número con
decimales que también se puede utilizar en operaciones numéricas; una lista, que es una
serie de valores almacenados juntos; y un diccionario, que es un conjunto desordenado de
datos donde cada valor está emparejado con una clave, lo que significa que cada valor
en el diccionario tiene una clave de identificación única. Esto es útil cuando desea hacer
referencia o cambiar un valor haciendo referencia al nombre de una clave. Por ejemplo,
digamos que tiene un diccionario llamado color_fruta configurado de la siguiente manera:
color_fruta = {'manzana': 'rojo', 'uva': 'verde', naranja: 'naranja'}
Si más adelante en tu script quieres obtener el color_fruta de la uva, simplemente

llámalo por su clave:
imprimir (color_fruta['uva'])
También puede cambiar los valores de claves particulares; por ejemplo, aquí
cambiamos el color de la manzana:
color_fruta['manzana'] : 'verde'
Analizaremos listas y diccionarios con más detalle más adelante en este capítulo.
Crea este script en cualquier editor de texto, guárdalo como secondpythonscript.py
y luego date permiso para ejecutarlo, así:
kali >chmod 755 segundopythonscript.py
Cuando ejecutamos este script, imprime los valores de la variable de cadena, el

variable entera y la variable numérica de punto flotante, así:
kali >./segundopythonscript.py
HackersArise es el mejor lugar para aprender a piratear
12
3.1415

¡GUAU! Libro
N ota En Python, no es necesario declarar una variable antes de asignarle un valor, como
en otros lenguajes de programación.
Comentarios
Como cualquier otro lenguaje de programación y scripting, Python tiene la capacidad de agregar
comentarios. Los comentarios son simplemente partes de su código (palabras, oraciones e
incluso párrafos) que explican lo que el código debe hacer.
Python reconocerá los comentarios en su código y los ignorará. Aunque los comentarios no
son necesarios, son increíblemente útiles cuando regresa a su código dos años después y no
recuerda qué debe hacer.
Los programadores suelen utilizar comentarios para explicar qué hace un determinado bloque
de código o para explicar la lógica detrás de la elección de un método de codificación particular.
El intérprete ignora los comentarios. Esto significa que cualquier línea
designados como comentarios son omitidos por el intérprete, que simplemente continúa
hasta que encuentra una línea de código legítima. Python usa el #
símbolo para designar el inicio de un comentario de una sola línea. Si desea escribir
comentarios de varias líneas, puede utilizar tres comillas dobles (""") al principio y al final de la
sección de comentarios.
Como puede ver en el siguiente script, agregué un breve mensaje de varias líneas
comente nuestro sencillo script hackersarise_greetings.py .
#! /usr/bin/python3
"""
Este es mi primer script de Python con comentarios. Los comentarios se utilizan para ayudarnos a explicar el
código a nosotros mismos y a otros programadores. En este caso, este sencillo script crea un saludo para el
usuario.
"""
nombre = "OcuparLaWeb"
print ("Saludos a "+nombre+" de HackersArise. ¡El mejor lugar para aprender a hackear!")
Cuando volvemos a ejecutar el script, nada cambia respecto a la última vez que se
ejecutó, como puedes ver aquí:
kali >./hackersarise_greetings.py
Saludos a OccupyTheWeb de parte de HackersArise. ¡El mejor lugar para aprender a hackear!
Funciona exactamente igual que en el Listado 171, pero ahora tenemos algunas
información sobre nuestro script cuando volvamos al código más adelante.
Funciones
Las funciones en Python son fragmentos de código que realizan una acción particular. La
instrucción print() que usó anteriormente, por ejemplo, es una función que muestra cualquier
valor que le pase. Python tiene una serie de funciones integradas que puedes importar y
usar inmediatamente. La mayoría de ellos están disponibles en su instalación predeterminada
de Python en Kali Linux, aunque muchos más están disponibles.

disponible en las bibliotecas descargables. Echemos un vistazo a algunas de las miles de

funciones disponibles para usted:
• exit() sale de un programa.

• float() devuelve su argumento como un número de punto flotante. Por ejemplo,
float(1) devolvería 1.0.
• help() muestra ayuda sobre el objeto especificado por su argumento.
• int() devuelve la porción entera de su argumento (trunca).
• len() devuelve el número de elementos de una lista o diccionario.
• max() devuelve el valor máximo de su argumento (una lista).
• open() abre el archivo en el modo especificado por sus argumentos.
• range() devuelve una lista de números enteros entre dos valores especificados por su
argumentos.
• sorted() toma una lista como argumento y la devuelve con sus elementos en
orden.
• type() devuelve el tipo de su argumento (por ejemplo, int, archivo, método,

función).
También puede crear sus propias funciones para realizar tareas personalizadas. Dado
que ya hay tantas funciones integradas en el lenguaje, siempre vale la pena comprobar si una
función ya existe antes de realizar el esfuerzo de crearla usted mismo. Hay muchas maneras
de hacer esta verificación. Una es consultar la documentación oficial de Python disponible
en https://docs.python.org. Elija la versión con la que está trabajando y luego seleccione
Referencia de biblioteca.
Liza
Muchos lenguajes de programación utilizan matrices como una forma de almacenar múltiples
objetos separados. Una matriz es una lista de valores que se pueden recuperar, eliminar,
reemplazar o trabajar de varias maneras haciendo referencia a un valor particular en la
matriz por su posición en la lista, conocida como su índice. Es importante tener en cuenta
que Python, como muchos otros entornos de programación, comienza a contar índices en 0,
por lo que el primer elemento de una lista es el índice 0, el segundo es el índice 1, el tercero
es el índice 3, y así sucesivamente. Entonces, por ejemplo, si quisiéramos acceder al tercer
valor de la matriz, podríamos hacerlo con la matriz [2]. En Python, existen algunas
implementaciones de matrices, pero probablemente la implementación más común se conoce
como listas.
Las listas en Python son iterables, lo que significa que la lista puede proporcionar
elementos sucesivos cuando la recorre por completo (consulte “"Bucles" en la página 208).
Esto es útil porque muy a menudo cuando usamos listas, las buscamos para encontrar
un valor determinado, imprimir valores uno por uno o tomar valores de una lista y colocarlos
en otra lista.
Entonces, imaginemos que necesitamos mostrar el cuarto elemento de nuestra
lista HackersAriseList del Listado 172. Podemos acceder a ese elemento e imprimirlo
llamando al nombre de la lista, HackersAriseList, seguido del índice del elemento al que
queremos acceder entre corchetes.
191
¡GUAU! Libro
Conceptos básicos de secuencias de comandos Python para piratas informáticos
Para probar esto, agregue la siguiente línea al final de su segundo script de Python
Script .py para imprimir el elemento en el índice 3 en HackersAriseList:
recorte
imprimir (HackersAriseStringVariable)
imprimir (HackersAriseIntegerVariable)
imprimir (HackersAriseFloatingPointVariable)
imprimir (HackersAriseList[3])
Cuando ejecutamos este script nuevamente, podemos ver que la nueva declaración de impresión
imprime 4 junto con la otra salida:
kali >./segundopythonscript.py
HackersArise es el mejor lugar para aprender a piratear
12
3.1415
4
Módulos
Un módulo es simplemente una sección de código guardada en un archivo separado para que
puedas usarlo tantas veces como necesites en tu programa sin tener que escribirlo todo nuevamente.
Si desea utilizar un módulo o cualquier código de un módulo, debe importarlo . Como se mencionó
anteriormente, el uso de módulos estándar y de terceros es una de las características clave que hace
que Python sea tan poderoso para el hacker. Si quisiéramos utilizar el módulo nmap que instalamos
anteriormente, agregaríamos la siguiente línea a nuestro script:
importar mapa nm
Más adelante en este capítulo, usaremos dos módulos muy útiles: socket y ftplib.
Programación orientada a objetos (POO)

Antes de profundizar en Python, probablemente valga la pena tomarse unos minutos para
analizar el concepto de programación orientada a objetos (POO).
Python, como la mayoría de los lenguajes de programación actuales (C++, Java y Ruby, por nombrar
algunos), se adhiere al modelo OOP.
La Figura 172 muestra el concepto básico detrás de la programación orientada a objetos: la
herramienta principal del lenguaje es el objeto, que tiene propiedades en forma de atributos y estados,
así como métodos que son acciones realizadas por o sobre el objeto.

Objeto
Propiedad Método
Atributo o estado Función o procedimiento
Figura 172: Ilustración de programación orientada a objetos
La idea detrás de los lenguajes de programación basados en POO es crear objetos que actúen
como cosas del mundo real. Por ejemplo, un automóvil es un objeto que tiene propiedades, como sus
ruedas, color, tamaño y tipo de motor; también tiene métodos, que son las acciones que realiza el auto,
como acelerar y bloquear las puertas. Desde la perspectiva del lenguaje humano natural, un objeto es un
sustantivo, una propiedad es un adjetivo y un método es generalmente un verbo.
Los objetos son miembros de una clase, que es básicamente una plantilla para crear objetos con
variables, propiedades y métodos iniciales compartidos. Por ejemplo, digamos que tenemos una clase
llamada autos; nuestro coche (un BMW) pertenecería a la clase de coches. Esta clase también incluiría
otros objetos/automóviles, como Mercedes y Audi, como se muestra en la Figura 173.
Clase Objetos
mercedes
Auto
BMW
Audi
Figura 173: Clases y objetos de programación orientada a objetos
Las clases también pueden tener subclases. Nuestra clase de automóviles tiene una subclase BMW, y
un objeto de esa subclase podría ser el modelo 320i.
Cada objeto tendría propiedades (marca, modelo, año y color) y métodos (arranque, conducción y
estacionamiento), como se muestra en la Figura 174.
Auto
Propiedades Métodos
BMW
hacer comenzar
modelo conducir
año parque
color
320i
Figura 174: Propiedades y métodos de programación orientada a objetos

¡GUAU! Libro
En los lenguajes POO, los objetos heredan las características de su clase, por lo que el
El BMW 320i heredaría los métodos de arranque, conducción y aparcamiento del coche de su clase.
Estos conceptos de programación orientada a objetos son cruciales para comprender cómo Python y otros
Los lenguajes OOP funcionan, como verá en los scripts de las siguientes secciones.
Comunicaciones de red en Python

Antes de pasar a más conceptos de Python, usemos lo que ha aprendido hasta ahora para escribir un par de
scripts de piratería relacionados con las conexiones de red.
Construyendo un cliente TCP
Crearemos una conexión de red en Python usando el módulo socket . Ya mencioné que Python viene con
una biblioteca de módulos para una multitud de tareas. En este caso, necesitaremos el módulo de socket para
crear una conexión TCP. Veámoslo en acción.
Eche un vistazo al script en el Listado 173 llamado HackersAriseSSHBanner

Grab.py (lo sé, es un nombre largo, pero tengan paciencia). Un banner es lo que presenta una aplicación
cuando alguien o algo se conecta a ella. Es algo así como una aplicación que envía un saludo anunciando de
qué se trata. Los piratas informáticos utilizan una técnica conocida como captura de banners para descubrir
información crucial sobre qué aplicación o servicio se está ejecutando en un puerto.
#! /usr/bin/python3
u importar socket
vs = socket.socket()
w s.conectar(("192.168.1.101", 22))
x respuesta = s.recv(1024)
y imprimir (respuesta)
s.cerrar
Listado 173: Un script de Python para captar banners
Primero, importamos el módulo de socket u para que podamos usar sus funciones y herramientas.
Aquí, usaremos las herramientas de red del módulo de socket para encargarnos de interconectar una conexión
a través de la red por nosotros. Un socket proporciona una forma para que dos nodos de computadora se
comuniquen entre sí.
Por lo general, uno es un servidor y el otro es un cliente.
Luego creamos una nueva variable, s, y la asociamos con la clase de socket .
del módulo de socket v. De esta manera, no tenemos que hacer referencia a la sintaxis completa de
socket.socket() cada vez que queramos usar la clase de socket ; simplemente podemos usar el nombre de
la variable s .
Luego usamos el método connect() del módulo de socket w para realizar una conexión de red a una IP
y un puerto en particular. Recuerde que los métodos
son funciones que están disponibles para un objeto en particular. La sintaxis es objeto.
.método (por ejemplo, socket.connect). En este caso, me estoy conectando a la
dirección IP 192.168.1.101, que es la dirección IP de una máquina en mi red, y al puerto
22, que es el puerto SSH predeterminado. Puedes probar esto en otra instancia de
Linux o Kali. La mayoría tiene el puerto 22 abierto de forma predeterminada.
Una vez que establezca la conexión, hay varias cosas que puede hacer. Aquí,
utilizamos el método de recepción recv para leer 1024 bytes de datos del socket x y
almacenarlos en una variable denominada respuesta; Estos 1024 bytes contendrán la
información del banner. Luego imprimimos el contenido de esa variable en la pantalla
con la función print() y para ver qué datos se han pasado por ese socket, ¡permitiéndonos
espiarlo! En la línea final, cerramos la conexión.
Guarde este script como HackersAriseSSHBannerGrab.py y luego cambie su

permisos usando el comando chmod para que puedas ejecutarlo.
Ejecutemos este script para conectarnos a otro sistema Linux (puede usar un sistema
Ubuntu o incluso otro sistema Kali) en el puerto 22. Si SSH se está ejecutando en ese
puerto, deberíamos poder leer el banner en nuestra variable de respuesta e imprimirlo .
a la pantalla, como se muestra aquí:
kali >./HackersAriseSSHBannerGrab.py
SSH2.0OpenSSH_7.3p1 Debian1
¡Acabamos de crear un script Python simple para capturar pancartas! Podemos

usar este script para averiguar qué aplicación, versión y sistema operativo se están
ejecutando en esa dirección IP y puerto. Esto nos brinda información clave que un
pirata informático necesita antes de atacar un sistema. Esto es esencialmente lo que
hace el sitio web Shodan.io para casi todas las direcciones IP del planeta, y cataloga e
indexa esta información para que podamos buscarla.
Crear un oyente TCP

Acabamos de crear un cliente TCP que puede establecer una conexión con otra dirección
y puerto TCP/IP y luego espiar la información que se transmite. Ese socket también se
puede utilizar para crear un escucha TCP, para escuchar conexiones de personas
externas a su servidor. Intentemos hacer eso a continuación.
En el script Python que se muestra en el Listado 174, creará un socket en cualquier
puerto de su sistema que, cuando alguien se conecta a ese enchufe, recopila
información clave sobre el sistema del conector. Ingrese el script y guárdelo como
tcp_server.py. Asegúrese de otorgarse permisos de ejecución con chmod.
#! /usr/bin/python3
conector de importación
TCP_IP = "192.168.181.190"
TCP_PORT = 6996
TAMAÑO_BUFFER = 100
vs = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

¡GUAU! Libro
w s.bind((TCP_IP, TCP_PORT))
x s.escuchar (1)
y conexión, dirección = s.accept()

imprimir ('Dirección de conexión: ', dirección)
mientras 1:
datos=conn.recv(BUFFER_SIZE)
si no son datos: romper
imprimir ("Datos recibidos: ", datos)
conexión.enviar(datos) #echo
con.cerrar
Listado 174: Un script Python que escucha TCP
Declaramos que queremos que el script se ejecute con el intérprete de Python y

luego importemos el módulo de socket como antes, para que podamos usar sus capacidades.
Luego definimos variables para contener información para la dirección TCP/IP, el puerto
para escuchar y el tamaño del búfer de los datos que queremos capturar del sistema de
conexión u.
Definimos el socket v y vinculamos el socket a la dirección IP y al puerto w
usando las variables que acabamos de crear. Le decimos al socket que escuche
usando el método listening() de la biblioteca de sockets x.
Luego capturamos la dirección IP y el puerto del sistema de conexión utilizando
el método de aceptación de la biblioteca de sockets e imprimimos esa información en la
pantalla para que el usuario pueda verla. Observe la sintaxis while 1: aquí; Hablaremos
de esto más adelante en el capítulo, pero por ahora solo debes saber que se usa para
ejecutar el código sangrado que viene después indefinidamente, lo que significa que
Python continúa buscando datos hasta que se detiene el programa.
Finalmente, colocamos la información del sistema de conexión en un
buffer, imprimirlo y luego cerrar la conexión.
Ahora, vaya a otra computadora en su red y use un navegador para conectarse al
puerto 6996 designado en nuestro script. Ejecute tcp_server.py
script, y debería poder conectarse y recopilar información clave sobre ese sistema, incluida
la dirección IP y el puerto del sistema de conexión, como se muestra aquí:
Kali >./tcp_server.py
Dirección de conexión: ('192.168.181.190', 45368)
Datos recibidos: Obtener /HTTP/1.1
Anfitrión: 192.168.181.190:6996
Usuario Agente:Mozilla/5.0 (X11; Linux x86_64; rv:45.0) Gec
recorte
Esta es información crítica que un hacker debe recopilar antes de decidirse por una
explotar. Los exploits (o hacks) son muy específicos del sistema operativo, la aplicación e
incluso el idioma utilizado, por lo que el hacker necesita conocer la mayor cantidad de
información posible sobre el objetivo antes de proceder. Este acto de

La recopilación de información antes de un ataque a menudo se denomina reconocimiento.

Acaba de desarrollar una herramienta que recopilará información clave de reconocimiento sobre un
objetivo potencial, ¡muy similar a la popular herramienta de hackers p0F!
Diccionarios, bucles y declaraciones de control

Sigamos ampliando su comprensión de Python y luego usemos todo lo que ha aprendido hasta
ahora para crear un descifrador de contraseñas para un servidor FTP.
Diccionarios
Los diccionarios contienen información como pares desordenados, donde cada par contiene una
clave y un valor asociado. Podemos usar un diccionario para almacenar una lista de elementos y
darle a cada elemento una etiqueta para que podamos usarlo y referirnos a ese elemento individualmente.
Podríamos usar un diccionario para almacenar, por ejemplo, ID de usuario y sus nombres
asociados, o para almacenar vulnerabilidades conocidas asociadas con un host específico.
Los diccionarios en Python actúan como matrices asociativas en otros idiomas.
Al igual que las listas, los diccionarios son iterables, lo que significa que usamos una estructura
de control como una declaración for para recorrer todo el diccionario, asignando cada elemento del
diccionario a una variable hasta llegar al final del diccionario.
Entre otras cosas, puede utilizar esta estructura para crear un descifrador de contraseñas
que repita cada contraseña almacenada en un diccionario hasta que funcione o hasta que el
descifrador llegue al final del diccionario.
La sintaxis para crear un diccionario es la siguiente:
dict = {clave1:valor1, clave2:valor2, clave3:valor3...}
Tenga en cuenta que para los diccionarios se utilizan llaves y elementos separados.
con una coma. Puede incluir tantos pares clavevalor como desee.
Declaraciones de control
Las declaraciones de control permiten que su código tome decisiones basadas en alguna condición.
Hay varias formas en Python de controlar el flujo del script.
Veamos algunas de estas estructuras en Python.
La declaración si
La estructura if en Python, como en muchos otros lenguajes de programación, incluido bash, se

usa para verificar si una condición es verdadera o no y ejecutar diferentes conjuntos de código
para cada escenario. La sintaxis se ve así:
si expresión condicional
ejecuta este código si la expresión es verdadera
La declaración if contiene una condición que podría ser algo así como si la variable
<10, por ejemplo. Si se cumple la condición, la expresión se evalúa

¡GUAU! Libro
a verdadero y luego se ejecuta el código siguiente, conocido como bloque de control .

Si la declaración se evalúa como falsa, entonces las declaraciones en el bloque de
control se omiten y no se ejecutan.
En Python, el bloque de control debe tener sangría. Esta sangría identifica el
bloque de control para el intérprete. La siguiente declaración que no tiene sangría está
fuera del bloque de control y, por lo tanto, no forma parte del if.
declaración, y así es como Python sabe dónde saltar si no se cumple la condición.
si... si no
La estructura if...else en Python se ve así:
si expresión condicional
*** # ejecutar este código cuando se cumpla la condición
demás
*** # ejecuta este código cuando no se cumple la condición
Como antes, primero el intérprete verifica la condición en la expresión if . Si se

evalúa como verdadero, el intérprete ejecuta las declaraciones en el bloque de control.
Si la declaración condicional se evalúa como falsa, en su lugar se ejecuta el bloque de
control que sigue a la declaración else .
Por ejemplo, aquí tenemos un fragmento de código que verifica el valor de un usuario.
IDENTIFICACIÓN; si es 0 (el usuario root en Linux siempre es UID 0), imprimimos el
mensaje “Usted es el usuario root”. De lo contrario, si es cualquier otro valor, imprimimos el
mensaje “NO eres el usuario root”.
si ID de usuario == 0
print ("Usted es el usuario root")
demás
print ("Usted NO es el usuario root")
Bucles
Los bucles son otra estructura muy útil en Python. Los bucles permiten al programador
repetir un bloque de código varias veces, dependiendo de un valor o una condición. Los
dos más utilizados son while y for.
El bucle while
El bucle while evalúa una expresión booleana (una expresión que sólo puede evaluarse
como verdadera o falsa) y continúa la ejecución mientras la expresión se evalúa como
verdadera. Por ejemplo, podríamos crear un fragmento de código que imprima cada
número del 1 al 10 y luego salga del bucle, así:
contar = 1
mientras (cuenta <= 10):
imprimir (contar)
contar += 1
El bloque de control sangrado se ejecuta mientras la condición sea verdadera.
198 Capítulo 17
¡GUAU! Libro
El bucle for
El bucle for puede asignar valores de una lista, cadena, diccionario u otra estructura iterable
a una variable de índice cada vez que pasa por el bucle, lo que nos permite usar cada elemento
de la estructura uno tras otro. Por ejemplo, podemos usar un bucle for para intentar
contraseñas hasta que encontremos una coincidencia, así:
para contraseña en contraseñas:

intento = conectar (nombre de usuario, contraseña)
si intento == "230"
"
imprimir ("Contraseña encontrada: + contraseña)
salida del sistema (0)
En este fragmento de código, creamos una declaración for que continúa a través de una
lista de contraseñas que hemos proporcionado e intenta conectarse con un nombre de
usuario y contraseña. Si el intento de conexión recibe un código 230, que es el código para
una conexión exitosa, el programa imprime "Contraseña encontrada:"
y luego la contraseña. Luego sale. Si no obtiene un 230, continuará con cada una de las
contraseñas restantes hasta que reciba un 230 o hasta que agote la lista de contraseñas.
Mejorando nuestros scripts de piratería

Ahora, con un poco más de experiencia sobre las estructuras de bucle de Python y las
declaraciones condicionales, volvamos a nuestro script de captura de banners y agreguemos
algunas capacidades.
Agregaremos una lista de puertos de los que queremos tomar el banner, en lugar de
simplemente escuchar en un puerto, y luego recorreremos la lista usando un for
declaración. De esta manera, podemos buscar y capturar pancartas para múltiples puertos
y mostrarlas en la pantalla.
Primero, creemos una lista y coloquemos puertos adicionales en ella. Abrir HackersArise
SSHBannerGrab.py y trabajaremos desde allí. El listado 175 muestra el código completo.
Tenga en cuenta que las líneas atenuadas siguen siendo las mismas; las líneas negras son las
que necesitas cambiar o agregar. Intentaremos obtener pancartas para los puertos 21
(ftp), 22 (ssh), 25 (smtp) y 3306 (mysql).
#! /usr/bin/python3
conector de importación
u Puertos = [21,22,25,3306]
v para i en el rango (0,4):
s = socket.socket()
w Puertos = Puerto[i]

¡GUAU! Libro
print ('Este es el cartel del puerto')
imprimir (Puertos)
x s.connect (("192.168.1.101", Puerto))
respuesta = s.recv (1024)
imprimir (respuesta)
s.cerrar ()
Listado 175: Mejorando el capturador de banners
Creamos una lista llamada Puertos u y agregamos cuatro elementos, cada uno de los cuales representa
un puerto. Luego creamos una declaración for que recorre esa lista cuatro veces, ya que tiene
cuatro elementos v.
Recuerde que cuando utiliza un bucle for , el código asociado con el bucle debe tener
sangría debajo de la declaración for .
Necesitamos modificar el programa para reflejar el uso de una variable de la lista en cada
iteración. Para hacerlo, creamos una variable llamada Puerto
y asígnelo al valor de la lista en cada iteración w. Luego usamos esa variable en nuestra conexión
x.
Cuando el intérprete llegue a esa declaración, intentará conectar
a cualquier puerto asignado a la variable en la dirección IP.
Ahora, si ejecuta este script en un sistema con todos los puertos listados abiertos y
habilitados, debería ver algo como el Listado 176.
kali >./HackersArisePortBannerGrab.py
Este es el estandarte del puerto.
21
220 (frente a FTPd 2.3.4)
Este es el cartel del puerto

22
SSH2.0OpenSSH_4.7p1 Debian8ubuntu1

25
220 metasploitable.localdomain ESMTP Postfix (Ubuntu)

3306
5.0.51a3ubuntu5
Listado 176: Salida para el capturador de banner del puerto
Tenga en cuenta que el script encontró el puerto 21 abierto con vsFTPd 2.3.4 ejecutándose
en él, el puerto 22 se abre con OpenSSH 4.7 ejecutándose, el puerto 25 con Postfix y el puerto
3306 con MySQL 5.0.51a.

Acabamos de crear con éxito una herramienta de captura de banners multipuerto en

Python para realizar reconocimiento en un sistema de destino. ¡La herramienta nos dice
qué servicio se está ejecutando en el puerto y la versión de ese servicio! Esta es información
clave que un hacker necesita antes de proceder con un ataque.
Excepciones y descifradores de contraseñas

Cualquier código que escriba correrá el riesgo de sufrir errores o excepciones. En términos
de programación, una excepción es cualquier cosa que interrumpa el flujo normal de su código.
normalmente es un error causado por un código o entrada incorrectos. Para lidiar con
posibles errores, utilizamos el manejo de excepciones, que es simplemente código que
maneja un problema particular, presenta un mensaje de error o incluso usa una excepción
para la toma de decisiones. En Python, tenemos la estructura try/except para manejar
estos errores o excepciones.
Un bloque try intenta ejecutar algún código y, si ocurre un error, la declaración
except maneja ese error. En algunos casos, podemos usar la estructura try/except para
la toma de decisiones, similar a if...else. Por ejemplo, podemos usar try/except en un
descifrador de contraseñas para probar una contraseña y, si ocurre un error debido a que
la contraseña no coincide, pasar a la siguiente contraseña con la declaración except .
Intentemos eso ahora.
Ingrese el código en el Listado 177 y guárdelo como ftpcracker.py; Lo veremos en un
momento. Este script solicita al usuario el número del servidor FTP y el nombre de usuario de
cualquier cuenta FTP que desee descifrar. Luego lee un archivo de texto externo que
contiene una lista de posibles contraseñas y prueba cada una en un esfuerzo por acceder
a la cuenta FTP. El script hace esto hasta que tiene éxito o se queda sin contraseñas.
#! /usr/bin/python3
importar ftplib
u servidor = entrada(Servidor FTP: ")
v usuario = entrada("nombre de usuario: ")
w Lista de contraseñas = entrada ("Ruta a la lista de contraseñas > ")
x intentar:
con open(Lista de contraseñas, 'r') como pw:
para palabra en pw:
y palabra = palabra.strip ('\r').strip('\n')
intenta:
ftp = ftplib.FTP(servidor)
ftp.login(usuario, palabra)
Conceptos básicos de secuencias de comandos de Python para piratas informáticos 201

¡GUAU! Libro
'
{ imprimir (¡Éxito! La contraseña es + palabra)
| excepto:
print('todavía lo intento...')
excepto:
imprimir ('Error en la lista de palabras')
Listado 177: Script Python para descifrar contraseñas de FTP
Usaremos herramientas del módulo ftplib para el protocolo FTP, así que primero lo
importamos. A continuación, creamos una variable llamada servidor y otra variable llamada usuario,
que almacenará algunos comandos para la entrada del usuario. Su secuencia de comandos le
pedirá al usuario que ingrese la dirección IP del servidor FTP u y el nombre de usuario de la
cuenta v que el usuario está intentando ingresar.
Luego le preguntamos al usuario la ruta a la lista de contraseñas w. Puedes encontrar
numerosas listas de contraseñas en Kali Linux ingresando localizar la lista de palabras en
una terminal.
Luego comenzamos el bloque de código de prueba que utilizará la lista de contraseñas
proporcionada por el usuario para intentar descifrar la contraseña del nombre de usuario
proporcionado por el usuario.
Tenga en cuenta que utilizamos una nueva función de Python llamada strip() y. Esta
función elimina el primer y último carácter de una cadena (en este caso, la lista de contraseñas).
Esto es necesario si las contraseñas de esta lista tienen un espacio en blanco o una coma
delante. La función strip() los elimina y deja solo la cadena de caracteres de la posible contraseña.
Si no eliminamos los espacios en blanco, podríamos obtener un falso negativo.
Luego, usamos un segundo bloque try z. Aquí, usamos el módulo ftplib para conectarnos
primero al servidor usando la dirección IP que proporcionó el usuario y luego probamos la
siguiente contraseña de la lista de contraseñas de esa cuenta.
Si la combinación del nombre de usuario y la contraseña resulta en un error, el bloque
sale y va a la cláusula excepto |, donde se imprime aún intentándolo.
y luego regresa a la parte superior de la cláusula for y toma la siguiente contraseña de la lista
de contraseñas para probar.
Si la combinación tiene éxito, la contraseña exitosa se imprime en la pantalla {. La última
línea recoge cualquier otra situación que de otro modo daría lugar a errores. Un ejemplo sería si
el usuario ingresa algo que el programa no puede procesar, como una ruta incorrecta a la lista
de palabras o una lista de palabras faltante.
Ahora, ejecutemos este script en el servidor FTP en 192.168.1.101 y veamos si podemos
descifrar la contraseña del usuario root. Estoy usando una lista de contraseñas llamada
bigpasswordlist.txt en mi directorio de trabajo. Es posible que necesite proporcionar la ruta
completa a cualquier lista de contraseñas que esté utilizando si no está en su directorio de
trabajo (por ejemplo, /usr/share/bigpasswordlist.txt).
kali >./ftpcracker.py
Servidor FTP: 192.168.1.101
nombre de usuario: raíz
Ruta a Lista de Contraseñas >bigpasswordlist.txt

aún intentando...
aún intentando...
aún intentando...
recorte
¡Éxito! La contraseña es demasiado
Como puede ver, ftpcracker.py encontró con éxito la contraseña para el usuario root y la
presentó en pantalla.
Resumen
Para superar el estatus de scriptkiddie, un hacker debe dominar un lenguaje de scripting,
y Python generalmente es una buena primera opción por su versatilidad y curva de
aprendizaje relativamente pequeña. La mayoría de las herramientas de piratería están
escritas en Python, incluidas sqlmap, scapy y muchas otras. Aquí, ha aprendido algunos
conceptos básicos de Python que puede utilizar para crear algunas herramientas de
piratería útiles pero sencillas, incluido un capturador de pancartas y un descifrador de
contraseñas de FTP. Para obtener más información sobre Python, recomiendo
encarecidamente el excelente libro de No Starch Press Automate the Boring Stuff with Python (2015) de Al Sw
Ejercicios
Pruebe las habilidades que aprendió en este capítulo completando los siguientes ejercicios:
1. Construya la herramienta de captura de banners SSH del Listado 175 y luego edítela para hacer
un estandarte en el puerto 21.
2. En lugar de codificar la dirección IP en el script, edite su herramienta de captura de banners para

que solicite al usuario la dirección IP.
3. Edite su tcp_server.py para solicitarle al usuario el puerto para escuchar.
4. Construya el FTPcracker en el Listado 177 y luego edítelo para usar una lista de palabras para
variable de usuario (similar a lo que hicimos con la contraseña) en lugar de solicitar entrada al
usuario.
5. Agregue una cláusula de excepción a la herramienta de captura de pancartas que imprima "sin respuesta"
si el puerto está cerrado.
¡GUAU! Libro Conceptos básicos de secuencias de comandos Python para piratas informáticos 203
¡GUAU! Libro
Índice
Símbolos y números B
""" (comentario) caracteres, 190 procesos en segundo plano, 68–69 tareas

# (comentario) carácter, 83 de programación de copias de seguridad,
#! (shebang) caracteres, 82 176–177 tabla de bloques
comando de ayuda , 8– defectuosos, 108 captura de pancartas, 194–195,
9 ? comando (ayuda), 199–201
9 h (ayuda) comando, 8– pancartas, 194 bash (shell Bourneagain)
9 Comando (ejecutar), 84, 90 ... comandos comunes, 90–91 descripción
opción de comando (subir nivel), 7 / general, 2, 4, 72, 82
comando (adelante), 25 Bcast (dirección de transmisión),
tipos de CPU de 32 bits/64 comando 30 bg (en segundo plano), 90
bits, xxv : comando (devolver directorios /bin , 5, 76 binarios
verdadero), 84, 90 [ comando (prueba condicional), 91
definido, 2 en
el sistema de archivos Linux,
A
5 comandos de búsqueda, 10
acceso. Véase también red de BIND (nombre de Internet de Berkeley)
permisos, 31, 32 Dominio), 34
bases de datos remotas, 132–133 hackers de sombrero negro,
Internet restringido, 148–149 listas de 86 dispositivos de bloqueo, 105–106
acceso. Consulte también listas de palabras, Bluetooth, 159–164
125 puntos de acceso (AP), 31, 154, 155–156, 157 descripción general, 159–
Herramienta de empaquetado avanzada (apt), 160 escaneo, 160–164
40–44 Sitio Bluetooth SIG, 162
suite aircracking, 9, 157–159 comando Pila de protocolos BlueZ, cargador de
aireplayng , 159 comando airmon arranque 160–161,
ng , 157–158 comando airodumpng , comando break xxxiv,
158–159 anonimato dirección de transmisión 90
cambiar, 32
Seguimiento de direcciones IP, 140– información, 30 opción
141 con servidores proxy, 143–148 de comando de transmisión , 32
con red Tor, 141–143 con VPN, 148– BSSID (identificador de conjunto de servicios
149 básicos), 154,
Servicio de servidor web Apache, 122–125 apt 158–159 comando bunzip2 , 97
(herramienta de empaquetado avanzada), 40– Mayordomo, Max “Max Vision”, 86–87
44 comando bzip2 , 97
comando aptcache , 40
comando aptget , 40–43
C
archivado, 94–96, 115
Arquitectura ARM, matrices xxvi, distinción entre
191 en mayúsculas y minúsculas, 2 comando cat
demonio, 69 montaje
automático, 106 (concatenación), 13–14, 22, 167 comando cd (cambiar directorio), 7
¡GUAU! Libro
canales (CH), WiFi, 154, 158, 158–159 directorios. Véase también cambio de
sistemas de
dispositivos de caracteres, archivos, 7
105 comando chgrp (cambiar grupo), 51 creación, 15 sistema
comando chmod (cambiar modo), 52–55, 56, 58 de archivos Linux, 5 listado de
contenido,
comando chown (cambiar propietario), 50 7–8, 51–52 nombres, 2 y
clases y subclases, 193–194 directorios variable PATH , 76–77
de comandos, 76–77 interfaz de permisos, 51–52 trabajo
línea de comandos (CLI), 2 caracteres de actual, 6
comentario, 83, 190 comando de eliminación, 16
compresión , 97 compresión, búsqueda, 11–12 espacio en
93–94, 96–97 concatenación, 13– disco, xxix, 107–108
14, 22, 67 archivos de configuración, comando dmesg , 171 DNS (Sistema de
5 método de conexión , nombres de dominio), 33–35
194–195 comando de cambiar servidores, 34–35 información, 33–34
continuación , 90
declaraciones de control, 197–199 mi
comandos de copia
bit a bit, 98–99 escuchas ilegales, 150, 166
archivo, comando de eco , 35, 83, 90
15 comando cp (copiar archivo), 15 servicios de cifrado de correo
Tipos de CPU, xxv electrónico,
comando createuser , 137 150 correo
demonio cron , 174 electrónico cifrado,
tabla cron , 174–178 150 con VPN, 149 seguridad
comando crond , 69, 174 inalámbrica (ENC), 158 comando env
comando crontab , 175–176 (entorno), 72 variables de entorno. Ver también concha
variables
D
cambiar valores, 73–74
directorios de comandos, 76–77
demonios, 32, 69 conceptos, 71–72
web oscura, 142 símbolo del shell, 75–76
bases de datos. Véase también Hackeo de definido por el usuario,
bases de datos 77–78 visualización,
MySQL, 87, 130 comando 72–73 espionaje, xxiii, 141, 148, 149
db_status , 137 comando ESSID (identificador de conjunto de servicios
dd , 98–99 Distribución Debian, extendido ),
xxv copia de archivo eliminado, 154, 158–159 archivo /etc/apt/
98–99 ataques de denegación de servicio sources.list , 43 archivo /etc/
(DoS), 31 comando describe , crontab , 174–176
134 directorio /dev , 102 – directorio /etc, 5
106 controladores de dispositivos, como archivo /etc/fstab ,
objetivo de piratería, 171 comando df 107 archivo /etc/hosts ,
(disco libre), 107–108 36 /etc/init Archivo .d/rc , 179 Archivo /
comando dhclient , etc/logrotate.conf , 115–117
33 demonio dhcp , 32 solicitud Archivo /etc/proxychains.conf ,
DHCPDISCOVER , 33 144 Archivo /etc/resolv.conf , 34–
solicitud DHCPOFFER , 33 35 Archivo /etc/
servidores DHSCP, 32– rsyslog.conf , 112–115 / archivo
33, 35 declaraciones etc/shadow , 57
dict, 197 diccionarios, 197 comando de excavación , 33–34
archivo /etc/sysctl.conf , 167, 168 interfaz eth0 , 30 piratería ética,
206 índice
¡GUAU! Libro
Comando eval (evaluar expresión), 90 manejo de piratas informáticos de sombrero

excepciones, 201 comando gris, 86–87 comando grep , 12–13, 22, 24, 63, 73
exec , 90 permisos de GRUB (Gran cargador de arranque unificado),
ejecución, 55–56, 57–58, 83–84 xxxivxxxv
comando gzip , 96–97

comando de salida , 90
exploits, 196–197
h
comando de exportación , 74, 75–76, 90
piratería
maliciosa, 86–87 como
F
profesión, xxi–xxiii y habilidades
Utilidad fdisk , de programación, 183 particiones
comando 104 fg (primer plano), 68–69, 90 contenido de disco duro, xxxiii comando
del archivo. Consulte tipos hciconfig , 161 comando hcidump ,
de archivos de texto, 104– 161 comando hcitool , 161–
105 archivos. Ver también archivos 162 comando head (ver archivo), 20–
de registro; archivar 21, 23 comandos de ayuda , 8–9 cambio de
texto, 94–96 comprimir, 96– archivo oculto, 8 tamaño del
97 copiar, 15, 97–98 archivo histórico, 73–74
crear, 13–15 variable HISTSIZE (archivo
enumerar, 7–8, 51–52 histórico), 73 directorio de inicio, 2, 5 archivo
mover, 15–16 hosts , 36 ejemplo de
nombrar, 2 código html,
propiedad, 50–51 124–125 HTTP vs. Torrent, xxv–xxvi
eliminar, 16 HWaddr . Ver dirección MAC
cambiar nombre, 15–
16 búsqueda, 10–12
sistemas de
I
archivos estructura Linux, 4–
5 monitoreo, 107–109 IDE (entornos de desarrollo integrados),
navegación, 6–8 187 declaración if , 197–
búsqueda, 9–12 198 comando ifconfig , 29–
dispositivos de almacenamiento en, 102– 30, 31–32, 154–155 declaración if...else , 198
declaración
106, 107 filtrado con palabras clave, 12–13, 22– 23,
63–64, 73 de importación , 192 archivo
comando de búsqueda , 11–12, 59 index.html , 124–125 demonio
unidades flash, 104–105, 106 para de inicio , 179 suite insmod
bucle, 199 (insertar módulo), 169
frecuencia, WiFi, 154 reenvío de IP, 168–169 análisis de direcciones

comando fsck (verificación del sistema de IP (Protocolo de Internet), 29–
archivos), 30 cambios, 31 asignación de nombres de
108–109 módulo ftplib, 201–202 dominio, 36 solicitud
de nuevos, 32–
33 script de escáner, 87–88
GRAMO
seguimiento, 140 –141

comando getopts , 91 Extensión de archivo .iso ,
comando git clone , 46–47 github, 46 xxx listas iterables, 191
comando iwconfig , 30–31,
Seguimiento de Internet de Google, 140 155, 157 comando
Gran cargador de arranque unificado (GRUB), iwlist , 155–156
xxxivxxxv
Índice 207
¡GUAU! Libro
j compresión con pérdida versus sin pérdida,

94 comando ls (lista), 7–8, 51–52 comando
programación de trabajos, 173–
lsblk (lista de bloques), 105–106 comando lsmod
178 comando de trabajos , 91
(lista de módulos), 169
k
METRO
Dirección MAC
Escritorio Kali, 3–5
visualización, 30, 156
descargas, instalación xxv–
suplantación de
xxvi, inicio de sesión xxix–xxxi,
identidad, 32 ataques de intermediario (MITM), 166,
descripción general de
168
xxxv–xxxvi, 2
comando man ( manual), 9, 23 modo
configuraciones, kernel
administrado, 31 páginas
xxxi–xxxv, 62, 165–166, 167–169 módulos
de manual, 9 información
del kernel. Ver también kernel cargable
de máscara , 30 modo
módulos, 166, 169–171
maestro, 155 /media
Declaraciones CLAVE , 72
directorio, 5, 106–107 registro de
comando de eliminación , 67–68
mensajes. Consulte los sistemas de registro
señales de eliminación,
Metasploit, 63, 136–137 métodos,
67 comando de eliminación total , 67–68
193–194, 195 piratería militar,
xxiii ataques MITM (hombre en
l el medio), 166, 168 comando mkdir (crear directorio),
15
Comando l2ping , 163–164
directorio / mnt , 5 , 106 dispositivos móviles, xxiv–
herramientas LAMP,
xxv, xxvi comando modinfo ,
123 comandos menos , 25–26
170 comando modprobe , 169, 170–171
directorio /lib , 5
modo monitor, 155, 157–158
bibliotecas, 5
comando más , 25 puntos de montaje, 106
ventajas
dispositivos de montaje/desmontaje, 106–
de Linux, xxiv distinción
107
entre mayúsculas y
minúsculas, 2
distribuciones, xxv
niveles de ejecución, 179 LKM. Consulte la
Comando de archivo mv (mover/renombrar), 16
información
Bases de datos MySQL, 130–135
sobre los módulos del kernel cargables (LKM) lo
acceso, 132–133 conexión,
(dirección de bucle invertido), 30 módulos del kernel
133–134 información, 131–132
cargables (LKM). Consulte también
tablas, 134–135
módulos del kernel, 166,
169–171, 171–
Script del escáner MySQL
172 localhost, 30 comando
ejemplo de código, 87–90
de localización , 10
programación, 177–178
archivos de registro, 115–
servicio mysql , 130–135
118 rotación, 115–117
destrucción, 117–118
conceptos de norte
sistemas de registro, 111 configuración y reglas,

servidores de nombres, 33–35
112–115 deshabilitación ,
Agencia de Seguridad Nacional (NSA), 139,
118–119 comprobación
143 opción
de inicio de sesión, 6 utilidad
de comando de máscara de red , 32
logrotate , 115–117 dirección
tarjetas de red, 155, 157
de bucle invertido, 30 bucles, 198–199
208 índice
¡GUAU! Libro
scripts de conexión de red, 194–197 sistema concesión, 50–51, 83–84

de detección de intrusiones en la red especial, 57–59
(NIDS), 19 PID (ID de proceso), 62, 63
administrador de red, 156 pip (paquetes de instalación de Pip),
cambio de
máscara de administrador,
red, 32 184–
pantalla, 30 redes. Consulte también 185 tuberías, 12–13 puertos script de
Análisis de redes captura de banner, 199–
WiFi, 29–31 cambio de información, 201 conexión a, 194–195 escaneo, 86–90
31–33 módulo nfnetlink , Bases de datos PostgreSQL (Postgres),
169 comando nice (prioridad de 135–137
servicio postgresql , 136–137
proceso), 65–66 NIDS (sistema de energía (PWR) y WiFi, 154, 158, 158–
detección de intrusiones en la red), 19 159
Comando nl (líneas numéricas), 22, 23 registro
Comando nmap (mapa de red), 86, 87–88 de mensajes prioritarios, 114–
115 procesos, 64–
Comando nmcli (interfaz de línea de comandos 66 escalada de privilegios,
del administrador de red), 156 58 archivo /proc/version ,
167 ID de proceso (PID), 62,
oh 63 procesos, 61–69
fondo y primer plano, 68–69
programación orientada a objetos (POO), 192–
194 conceptos, 61–62
objetos, 193–194, 195 información sobre, 12–13, 62–64
dígitos octales, matar, 66–68
53 direcciones .onion , administrar prioridad de, 64–66
142 sistema Onion Router, 141–143 programación,
POO. Consulte el código 69
fuente abierto de archivo .profile , 57 modo
programación orientada a objetos promiscuo, 31
(OOP), xxiv, xxv, servicio OpenSSH, 125–126. propiedades, 193
ProtonMail, 150 servidores
PAG proxy, 143– 148
elección, 148
reenvío de paquetes, 168–169 conceptos, 143–144
emparejamiento Bluetooth, configuración, 144–148 comando
160 proxychains , 143–148 comando ps (procesos),
particiones 12–13, 62–63 variable PS1 (indicador
definidas, xxxiii sistema de de shell), 75–76 PSK (clave
etiquetado, 103–104 precompartida) ), 154 comando pwd
comando (directorio de
passwd , 4 trabajo actual), 6
cambio de contraseñas, 4 comentarios del
craqueo, 31, 159, 201–203 usuario root, xxxii–xxxiii, 132–133
lenguaje Python, 190
Variable PATH , 76–77 funciones, 190–191
pruebas de penetración, xxiii instalación, 184–186 aprendizaje,
permisos, 49–59 183–184, 187,
cambios, 52–57 203 listas, 191–
comprobaciones, 192 módulos, 192
51–52 conceptos, 49–50 variables, 187–190 Python Índice de paquetes (PyPI), 184
Índice 209
¡GUAU! Libro
servicios
R
definido, 121
Arquitectura de
programación al inicio, 179–181 inicio,
Raspberry Pi, xxvi
detención, reinicio, 122 establecer comando,
Proyecto de espionaje, 125129
72–73, 91 bit SGID , 58–59
Sistema operativo Raspbian, 126, 129 aplicación
extensión de
raspistill , 129 scripts rc , 178–180
archivo .sh, 85 shebang
herramienta rcconf, 180–
(#!), 82 indicador de
181 comando de lectura ,
shell, 75–76 variables de
85, 91 comando de solo
shell, 71–72 shells, 2, 82
lectura , 91 reconocimiento,
comando shift ,
160–164, 197 comando renice , 65, 66
91 comando show , 134
repositorios, 40, 43–44, 185 uso
comando shred , 117–118
de recursos, 64 comando rm (eliminar),
Snort, 19–20, 20 módulo de
16 comando rmdir
socket , 194–196
(eliminar directorio), 16 comando
administradores e instaladores
rmmod (eliminar módulo), 169 / directorio raíz, 5
de software, 40, 45–46
paquetes de software
usuario root
definidos, 39
definido, 2
instalación, 40–41
contraseñas, xxxii–xxxiii, 130–
eliminación, 41–42
131, 132
actualización y mejora, 42–43 archivo
privilegios, 5, 6, 50, 65, 66 rootkits,
fuentes.list , 43–44 proyecto
166, 171 demonio
de cámara espía, 125–129 comandos
rsyslog, 112, 119 niveles de
SQL (lenguaje de consulta estructurado), 131
ejecución, 179
SSH (Secure Shell ),
125–126 SSID (identificador de conjunto
S de servicios), 154 bit de permiso de bit
adhesivo, 58 dispositivos de
Directorios /sbin , 76
almacenamiento, 102–109
programación
monitoreo y verificación, 107–109 montaje y
con at, 69 con
desmontaje, 106–107
crond, 174–178 al inicio,
178–181 variables de
representación de, 102–106 función
script, 84–85, 89 conceptos de
strip() , 202 comando su
scripts,
(cambiar de usuario), 136 bit SUID , 57–59
2, 81 ejemplos, 86–
preocupaciones de
90 ejecutando
vigilancia, 142–143, 148, 149 Administrador
(ejecutando), 83–84 programación ,
de
174–178 escritura, 82–85
paquetes Synaptic, 45–46 comando sysctl ,
SDP (Protocolo de
167–169 syslogd demonio, 112
descubrimiento de servicios), 163 comando sdptool ,
administrador del sistema.
163 seguridad. Ver también
Ver usuario root
permisos
y módulos de kernel cargables, 171–172
y vigilancia, t
142–143, 148, 149
Comando tail (ver archivo), 21–22, 23 Comando
Protocolo WiFi, 154
tar (archivar), 94–96 Extensión de
comando sed (editor de secuencias), 23–24
archivo .tar , 95 archivos
Comando SELECCIONAR ,
tarballs/tar, 94–96 Script de
135 comando de servicio , 119, 122
cliente TCP, 194–195
Protocolo de descubrimiento de servicios (SDP), 163
210 índice
¡GUAU! Libro
Escaneo de conexión TCP, 86, 88–90 W.

Script de escucha TCP, 195–197
comando de espera ,
terminales, 2, 4, 68
91 servicios de servidor web, 122–125
comando de prueba , 91
texto Protocolo WEP (Privacidad equivalente
por cable), 154
concatenar a un archivo, 13–14
comando wget , 185–186
mostrar, 20–23, 24–26 buscar y
comando whereis , 10
reemplazar, 23–24 editores de
comando what , 10
texto, 82, 187 extensión
bucles while , 198
de archivo .tgz , 96
hackeo de sombrero blanco,
comando times , 91
xxiii comando whoami , 6
comando superior (uso de recursos), 64, 66 Tor
Redes WiFi, 154–159
red, 141–143 descargas de
comandos básicos, 154–157
torrents, xxv–xxvi comando táctil ,
piratería, 157–159
14–15 comando traceroute ,
comodines, 12
140 comando trap , 91
Windows vs. Linux, xxiv–xxv, 101
declaraciones try/
dispositivos de red inalámbrica, 30–31, 153
except , 201–202 comando de tipo , 91
alcance inalámbrico, 154
interfaz wlan0, 30, 31, 155 listas
de palabras, 27 , 159 , 202
Ud. Protocolo WPA (Acceso protegido Wi
Fi), 154 Protocolo
Sintaxis UGO (usuario, grupo y otros),
54–55 WPA2PSK, 154
valores de umask (desenmascarar), 56–

57, 91 comando umount (desmontar), 107 z
comando uname , 167
procesos zombies, 66, 67
comando descomprimir , 97
comando unset , 72–73, 78, 91
comando updaterc.d , 179
unidades flash USB , 104–105, 106 usar
comando, 134 variables
definidas por el usuario, 77–78 terreno
de usuario, 165
tipos de usuario, 50
V
variables. Ver también variables de entorno
Python, 187–190
script, 84–85, 89
shell, 71–72
máquinas virtuales, conceptos e
instalación, xxvi–xxvii redes
privadas virtuales (VPN), 148–149
Instalación y
configuración de VirtualBox, xxvi–xxix
instalación de Kali, xxix–xxxi
software de virtualización, xxxi
VPN (redes privadas virtuales), 148–149
evaluaciones de vulnerabilidad, xxiii
Índice 211
¡GUAU! Libro
COMPUTADORAS/
AMBICIOSO CUBIERTAS
¿HACKER? LINUX
EMPIEZA AQUI. Y PITÓN 3
Si está comenzando en el apasionante camino de la piratería, la • Mantenga su actividad en Internet en secreto usando Tor, proxy
ciberseguridad y el pentesting, Linux Basics for Hackers es un excelente Servidores, VPN y correo electrónico cifrado
primer paso. Usando Kali Linux, una distribución avanzada de prueba de

• Escriba un script bash para escanear puertos abiertos en busca de posibles
penetración de Linux, aprenderá los conceptos básicos del uso del sistema
objetivos
SEGURIDAD
operativo Linux y adquirirá las herramientas y técnicas que necesitará
para tomar el control de un entorno Linux. • Usar y abusar de servicios como MySQL, el servidor web Apache y
OpenSSH
Primero, aprenderá cómo instalar Kali en una máquina virtual y obtendrá una • Cree sus propias herramientas de piratería, como una cámara de vídeo
introducción a los conceptos básicos de Linux. A continuación, abordará espía remota y un descifrador de contraseñas.
temas más amplios de Linux, como la manipulación de texto, el control de

La piratería es compleja y no existe una única forma de lograrlo. ¿Por qué no
permisos de archivos y directorios y la gestión de variables de entorno del
empezar por el principio con los conceptos básicos de Linux para piratas informáticos?
usuario. Luego, se concentrará en conceptos fundamentales de piratería,
como seguridad y anonimato, y aprenderá habilidades de programación SOBRE EL AUTOR

con bash y Python.
OccupyTheWeb es un consultor de seguridad de la información,
GUARDAR
Los tutoriales prácticos y los ejercicios reforzarán y pondrán a prueba tus investigador forense y formador con más de 20 años en la industria.
habilidades a medida que aprendes a: Mantiene el sitio de capacitación HackersArise (https://www.hackers
arise.com/) y capacita a personal militar estadounidense, contratistas del

• Cubra sus huellas cambiando la información de su red y manipulando la
Departamento de Defensa y empleados federales en seguridad de la
utilidad de registro rsyslog
información y piratería.
• Escribir una herramienta para buscar conexiones de red, y
conectarse y escuchar redes inalámbricas
EN:
LO MEJOR EN GE EKE NTERTA INME NT™
www.nostarch.com
$34.95 ($45.95 CDN)
¡GUAU! Libro

Linux Basics For Hackers

Cargado por

Copyright:

Formatos disponibles

Linux Basics For Hackers

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Linux Basics For Hackers

Cargado por

Copyright:

Formatos disponibles

Machine Translated by Google

FUNDAMENTOS BÁSICOS DE LINUX

Conceptos básicos de Linux para piratas informáticos

CONCEPTOS BÁSICOS DE LINUX PARA HACKERS. Copyright © 2019 por OccupyTheWeb.

Editorial: William Pollock

Datos de catalogación en publicación de la Biblioteca del Congreso

Nombres: OccupyTheWeb, autor.

Dedico este libro a mis tres increíbles hijas.

Acerca del revisor técnico

Capítulo 1: Introducción a los conceptos básicos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1

Capítulo 2: Manipulación de texto. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

Capítulo 3: Análisis y gestión de redes. . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

Capítulo 4: Agregar y eliminar software. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

Capítulo 5: Control de permisos de archivos y directorios. . . . . . . . . . . . . . . . . . . . . . . . . 49

Capítulo 6: Gestión de procesos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61

Capítulo 7: Gestión de variables de entorno de usuario. . . . . . . . . . . . . . . . . . . . . . . . . . . 71

Capítulo 8: Secuencias de comandos Bash. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81

Capítulo 9: Compresión y Archivado. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93

Capítulo 10: Gestión de sistemas de archivos y dispositivos de almacenamiento. . . . . . . . . . . . . . . . . . . . . 101

Capítulo 11: El sistema de registro. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111

Capítulo 12: Uso y abuso de los servicios. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121

Capítulo 13: Volverse seguro y anónimo. . . . . . . . . . . . . . . . . . . . . . . . . . . . 139

Capítulo 14: Comprensión e inspección de redes inalámbricas. . . . . . . . . . . . . . . . . 153

Capítulo 16: Automatización de tareas con programación de trabajos. . . . . . . . . . . . . . . . . . . . . . . . . 173

Expresiones de gratitud xix

Términos y conceptos introductorios. . .. .. .. .. . .. .. .. .. . .. .. .. .. .. . .. .. .. .. . 1

xiii Contenido en detalle

Diferentes tipos de usuarios. . . . . . . . . . . . . . . . . . .

Visualización y modificación de variables de entorno. . . . . .. .. . .. .. .. .. .. . .. .. .. . . 72

xiv Contenido en detalle

Limpieza automática de registros con logrotate. .. .. .. .. . .. .. .. .. .. . .. .. .. . 115

Automatización de tareas con programación de trabajos 173

Programar un evento o trabajo para que se ejecute de forma automática. . . . . . . . . . . . . . . . . . . . 174

Agregar módulos de Python. . . . . . . . . . . . . . . .. .. .. .. .. . .. .. .. .. .. . .. .. .. . 184

xvi Contenido en detalle

Contenido en detalle xvii

Cualquier error u omisión restante es únicamente culpa mía.

¡El hacking es el conjunto de habilidades más

¿Qué hay en este libro?

El Capítulo 4 le enseña a agregar, eliminar y actualizar software y cómo mantener su

El Capítulo 8 le presenta el scripting bash, un elemento básico para cualquier hacker

El capítulo 14 trata de las redes inalámbricas. Aprenderás redes básicas

El Capítulo 15 profundiza en Linux con una visión de alto nivel de cómo

malicioso. En el Capítulo 16 aprenderá habilidades de programación esenciales para automatizar

¿Qué es el hacking ético?

¡GUAU! Libro Introducción xxiii

Por qué los piratas informáticos utilizan Linux

Linux es de código abierto

Linux ofrece control granular

La mayoría de las herramientas de piratería están escritas para Linux

El futuro pertenece a Linux/Unix

XXIV Introducción ¡GUAU! Libro

Descargando Kali Linux

¡GUAU! Libro Introducción xxvi

Figura 1: página de inicio de VirtualBox

xxvi Introducción ¡GUAU! Libro

Figura 2: El cuadro de diálogo del Asistente de configuración

Haga clic en Siguiente y aparecerá la pantalla Configuración personalizada, como en la Figura

Figura 3: El cuadro de diálogo Configuración personalizada

Figura 11: Iniciar sesión en Kali usando la cuenta raíz

Figura 12: El escritorio Kali

Figura 13: La terminal Kali

Figura 14: El sistema de archivos de Linux