├── FUNDING.yml ├── README.md ├── TODO.md ├── _includes └── head-custom.html ├── imagenes ├── cat.jpg ├── cd_ejemplo.jpg ├── echo.jpg ├── ls.jpg ├── portada.png ├── ps1.jpg ├── pwd.jpg └── termux-setup-storage.png └── paginas └── mostrarArch.html /FUNDING.yml: -------------------------------------------------------------------------------- 1 | github: stringmanolo 2 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | ![Portada Libro](https://github.com/StringManolo/hackingTermux101/raw/master/imagenes/portada.png) 2 | 3 | ----- 4 | 5 | ### Languages 6 | 7 | ##### ESP 8 | Este libro está escrito originalmente en español. Puedes acceder en otros lenguajes usando el traductor de Google, si bien no es perfecto puede ser de utilidad. 9 | 10 | ##### EN 11 | This book is original writen in spanish. You can access it in other languages too using google translator. Even if not perfect may be usefull. [English Translation](https://stringmanolo-github-io.translate.goog/hackingTermux101/?_x_tr_sl=es&_x_tr_tl=en&_x_tr_hl=es&_x_tr_pto=wapp#tabla-de-contenidos) 12 | 13 | ### Tabla de Contenidos 14 | 15 | * [Prefacio](#prefacio) 16 | * [Capítulo 0: Requisitos y Programas Extra](#cap%C3%ADtulo-0-requisitos-y-programas-extra) 17 | * [Capítulo 1: Qué es Termux?](#cap%C3%ADtulo-1-qu%C3%A9-es-termux) 18 | * [Capitulo 2: Descarga e Instalación](#capitulo-2-descarga-e-instalaci%C3%B3n) 19 | * [Capítulo 3: Configuración Básica](#cap%C3%ADtulo-3-configuraci%C3%B3n-b%C3%A1sica) 20 | * [Capítulo 4: Uso básico de la terminal](#cap%C3%ADtulo-4-uso-b%C3%A1sico-de-la-terminal) 21 | * [Capítulo 5: Introducción a Bash](#cap%C3%ADtulo-5-introducci%C3%B3n-a-bash) 22 | * [Capítulo 6: Uso de VI y de VIM](#cap%C3%ADtulo-6-uso-de-vi-y-de-vim) 23 | * [Capitulo 7: Configuración de Bash](#capitulo-7-configuraci%C3%B3n-de-bash) 24 | * [Capítulo 8: Sistema de Ficheros](#cap%C3%ADtulo-8-sistema-de-ficheros) 25 | * [Capítulo 9: Creando comandos](#cap%C3%ADtulo-9-creando-comandos) 26 | * [Capítulo 10: Comandos Intermedios](#cap%C3%ADtulo-10-comandos-intermedios) 27 | * [Capítulo 11: Proot-Distro](#cap%C3%ADtulo-11-proot-distro) 28 | * [Capitulo 12: Introducción a Sistemas Linux](#capitulo-12-introducci%C3%B3n-a-sistemas-linux) 29 | * [Capitulo 13: Uso básico de Debian](#capitulo-13-uso-b%C3%A1sico-de-debian) 30 | * [Capítulo 14: Uso básico de Ubuntu](#cap%C3%ADtulo-14-uso-b%C3%A1sico-de-ubuntu) 31 | * [Capítulo 15: Uso básico de Alpine](#cap%C3%ADtulo-15-uso-b%C3%A1sico-de-alpine) 32 | * [Capítulo 16: Uso básico de Fedora](#cap%C3%ADtulo-16-uso-b%C3%A1sico-de-fedora) 33 | * [Capítulo 17: Introducción a Servicios](#cap%C3%ADtulo-17-introducci%C3%B3n-a-servicios) 34 | * [Capítulo 18: Creando un Servidor](#cap%C3%ADtulo-18-creando-un-servidor) 35 | * [Capítulo 19: Ngrok y Exponer Servicios](#cap%C3%ADtulo-19-ngrok-y-exponer-servicios) 36 | * [Capítulo 20: Tor, Configuración y Uso](#cap%C3%ADtulo-20-tor-configuraci%C3%B3n-y-uso) 37 | * [Capítulo 21: Servicios Ocultos](#cap%C3%ADtulo-21-servicios-ocultos) 38 | * [Capítulo 22: SSH, SCP y SSHD](#cap%C3%ADtulo-22-ssh-scp-y-sshd) 39 | * [Capítulo 23: Bots de Telegram](#cap%C3%ADtulo-23-bots-de-telegram) 40 | * [Capítulo 24: Telegram RAT](#cap%C3%ADtulo-24-telegram-rat) 41 | * [Capítulo 25: Protocolo HTTP](#cap%C3%ADtulo-25-protocolo-http) 42 | * [Capítulo 26: Protocolo DNS](#cap%C3%ADtulo-26-protocolo-dns) 43 | * [Capítulo 27: Servicios Web](#cap%C3%ADtulo-27-servicios-web) 44 | * [Capítulo 28: Hosting Gratuitos](#cap%C3%ADtulo-28-hosting-gratuitos) 45 | * [Capítulo 29: Dominios Gratuitos](#cap%C3%ADtulo-29-dominios-gratuitos) 46 | * [Capítulo 30: Introducción a Programación](#cap%C3%ADtulo-30-introducci%C3%B3n-a-programaci%C3%B3n) 47 | * Capítulo 31: Comparación de Lenguajes 48 | * Capitulo 32: Introducción a C 49 | * Capìtulo 33: Introducción a C++ 50 | * Capítulo 34: Introducción a C# 51 | * Capítulo 35: Introducción a Go 52 | * Capítulo 36: Introducción a Java 53 | * Capítulo 37: Introducción a Javascript 54 | * Capítulo 38: Introducción a Lua 55 | * Capítulo 39: Introducción a PHP 56 | * Capítulo 40: Introducción a Python 57 | * Capítulo 41: Introducción a Rust 58 | * Capítulo 42: Introducción a Node 59 | * Capítulo 43: Introducción a Typescript 60 | * Capítulo 44: Introducción a la Criptografìa 61 | * Capítulo 45: Introducción al Malware 62 | * Capítulo 46: Desarrollo de RATs 63 | * Capítulo 47: Desarrollo de Ransomwares 64 | * Capítulo 48: Desarrollo de Greyware 65 | * Capítulo 49: Introducción a Hacking 66 | * Capítulo 50: Introducción a OSINT 67 | * Capitulo 51: Google Hacking (dorks) 68 | * Capitulo 52: Introducción a Hacking Web 69 | * Capítulo 53: Introducción a Ingeniería Social 70 | * Capítulo 54: Laboratorios y Páginas de Hacking legal. 71 | * Capìtulo 55: HTMLi (inyección de HTML) 72 | * Capítulo 56: XSS (Inyección de Javascript) 73 | * Capítulo 57: CSFR (Peticiones entre sitios) 74 | * Capítulo 58: Clickjacking (secuestro de clicks) 75 | * Capítulo 59: HPP (Polución de parámetros HTTP) 76 | * Capítulo 60: Open Redirects (redirecciones abiertas) 77 | * Capitulo 61: SSRF (falsificación de peticiones en el lado del servidor) 78 | * Capítulo 62: Path Traversal (recorrer rutas) 79 | * Capítulo 63: Referrer Leaks (Filtraciones del referido) 80 | * Capítulo 64: Dangling HTML (HTML pendiente) 81 | * Capítulo 65: Subdomain/Domain Takeover (secuestro de sub/dominios) 82 | * Capítulo 66: Template Injection (Inyección de plantillas) 83 | * Capítulo 67: IDOR (Referencia a objecto indirecta) 84 | * Capítulo 68: SQLi (Inyección del lenguaje de consultas estructurado) 85 | * Capítulo 69: Cookie Tossing (lanzamiento de cookies) 86 | * Capítulo 70: Web Cache Poisoning (envenenamiento de la caché web) 87 | * Capítulo 71: Malas prácticas 88 | * Capítulo 72: Post Explotación 89 | * Capítulo 73: Herramientas de Hacking 90 | * Capítulo 74: Dig 91 | * Capítulo 75: Dirstalk 92 | * Capítulo 76: Impulse 93 | * Capítulo 77: ncat 94 | * Capítulo 78: nmap 95 | * Capítulo 79: nuclei 96 | * Capítulo 80: searchsploit 97 | * Capítulo 81: shodan 98 | * Capítulo 82: sqlmap 99 | * Capítulo 83: turbolist3r 100 | * Capítulo 84: C++ intermedio 101 | * Capítulo 85: Go intermedio 102 | * Capítulo 86: Javascript intermedio 103 | * Capítulo 87: PHP intermedio 104 | * Capítulo 88: Python intermedio 105 | * Capítulo 89: Node intermedio 106 | * Capítulo 90: Quickjs intermedio 107 | * Capítulo 91: Typescript intermedio 108 | * Capítulo 92: Criptografía intermedio 109 | * Capítulo 93: Malware intermedio 110 | * Capítulo 94: Ingeniería Social intermedio 111 | * Capítulo 95: Creando laboratorios y aplicaciones vulnerables 112 | * Capítulo 96: Desarrollando aplicaciones de hacking 113 | * Capítulo 97: Retos nivel basico 114 | * Capítulo 98: Retos nivel intermedio 115 | * Capítulo 99: Retos nivel avanzado 116 | * Capítulo 100: Retos nivel 3l1t3 117 | 118 | * Glosario 119 | * Apéndice 120 | 121 | ----- 122 | 123 | ## Prefacio 124 | 125 | Bienvenido a la primera edición del libro Termux Hacking 101. Aquí vas a aprender a instalar Termux en Android, su uso básico, virus, programación y hacking. 126 | 127 | Termux es un emulador de terminal para Android y un entorno de Linux que funciona directamente sin necesidad de rootear el dispositivo o configurarlo. Un sistema base mínimo se instala automáticamente - Y muchos paquetes adicionales están disponibles desde su gestor de paquetes. 128 | 129 | Un pequeño inciso antes de comenzar. Este libro es 100% gratuito y se financia a través e donaciones. Si quieres contribuir a la creación de este libro, puedes realizar una tranferencia a la cuenta ```ES59 2080 5029 1630 0011 2266``` indicando como motivo de la transferencia "Libro Termux". Por donaciones de 20$ o más, se ofrece un día de clases particulares por Telegram. Indica tu nombre de Telegram en el asunto de la tranferencia. DONAR ES OPCIONAL, puedes leer el libro aunque no dones. Por qué deberías donar entonces? Si obtengo múltiples donaciones, me animará a seguir escribiendo el libro o a sacar nuevos libros. 130 | 131 | **Disfrútalo!** 132 | 133 | [Tabla de Contenidos](#tabla-de-contenidos) 134 | 135 | ----- 136 | 137 | ## Capítulo 0: Requisitos y Programas Extra 138 | 139 | Para poder utilizar Termux, necesitas un dispositivo Android. Termux soporta versiones de **android** comprendidas **entre** la **versión 7 y** la **última version** de Android. 140 | 141 | Necesitas un **mínimo** de **300 megas de espacio** en disco. Yo te **recomiendo** como **mínimo 8 gigas disponibles de memoria interna**. 64 Gigas está genial y suele ser mas que suficiente, depende del uso que le des. 142 | 143 | Antes de empezar, algunos programas extra son recomendados, aunque no necesarios. 144 | * [Hackers Keyboard](https://github.com/klausw/hackerskeyboard/releases/download/1.40.7/hackerskeyboard-v1.40.7.apk) 145 | Este sencillo teclado offline funciona de marabilla en la mayoría de dispositivos. No vende tus datos, ya que no se conecta nunca a internet y te ofrece un teclado como el del PC, aunque no es necesario. Yo no utilizo esta característica en concreto, pero si este es el único teclado que utilizo en Android por seguridad. 146 | 147 | Los que vienen preinstalados suelen vender tus datos aunque los configures para que no lo hagan. 148 | 149 | * [Fx File Explorer](https://play.google.com/store/apps/details?id=nextapp.fx) 150 | Explorador de ficheros para Android que te permite el acceso a las carpetas de Termux. No lo he probado pero es recomendado por los desarrolladores de Termux. 151 | 152 | [Tabla de Contenidos](#tabla-de-contenidos) 153 | 154 | ----- 155 | 156 | ## Capítulo 1: Qué es Termux? 157 | 158 | Termux es una aplicación para Android de código abierto que trae todo el poder Linux a tu dispositivo móvil. Puedes realizar prácticamente cualquier tarea que realices en tu PC con un Linux instalado. Todo se realiza directamente desde la terminal escribiendo comandos, aunque también es posible [instalar](https://wiki.termux.com/wiki/Graphical_Environment) un entorno gráfico como X11. 159 | 160 | Termux instala por defecto un sistema base con comandos y paquetes comunes que suelen ser imprescindibles en cualquier distribución de Linux. Los paquetes se compilan de forma cruzada con Android NDK y en la mayoría de casos solo necesitan añadirle pequeños parches para que sean totalmente compatibles con Android. Hay miles de paquetes disponibles y cada día la comunidad añade nuevos paquetes. 161 | 162 | Es seguro, ya que todo es código abierto y miles de profesionales revisan el código y los nuevos cambios a diario. 163 | 164 | Tiene un montón de características extra, como poder ver los SMS, los archivos del dispositivo, etc. Esto te premite automatizar un montón de tareas, hacer interfaces con distintas tecnologías y todo lo que se te ocurra. 165 | 166 | Totalmente customizable. Puedes modificar la apariencia, añadir atajos de teclado, nuevas funcionalidades... 167 | 168 | Soporta teclado y ratón externos. Puedes conectar Termux a una pantalla externa y utilizar un teclado y un ratón. 169 | 170 | #### Cómo funciona? 171 | La terminal emulada es básicamente una aplicación que arranca los programas de linea de comandos usando una llamada del sistema [execve(2)](https://www.man7.org/linux/man-pages/man2/execve.2.html) y redirige la entrada y la salida de datos de la función, hacia la pantalla. 172 | 173 | La mayoría de terminales para Android, trabajan con conjuntos de herramientas pobres que ya trae Android. Termux porta una gran cantidad de herramientas de GNU/Linux hacia Android. 174 | 175 | Termux no es una máquina virtual ni otro tipo de sistema/entorno emulado. Todos los paquetes son compilados en cruce con Android NDK y solo se parchean para que funcionen en Android/Termux. 176 | 177 | El sistema operativo no proporciona acceso completo al sistema de ficheros, por lo cual Termux no puede instalar los paquetes en las rutas típicas /bin, /etc, /usr, /var. Termux traslada este sistema de ficheros a un directorio privado de la aplicación en la ruta /data/data/com.termux/files/usr 178 | 179 | Este directorio se llama **prefix** y su ruta se puede visualizar en la variable de entorno "$PREFIX". Esta ruta se hardcodea directamente en muchos de los binarios/paquetes disponibles para Termux. Esto es uno de los típicos parches que se añaden. 180 | 181 | [Tabla de Contenidos](#tabla-de-contenidos) 182 | 183 | ----- 184 | 185 | ## Capitulo 2: Descarga e Instalación 186 | 187 | ### Descarga 188 | Puedes instalar Termux descargando la última [release](https://github.com/termux/termux-app/releases) directamente desde el repositorio del proyecto en github. O desde la tienda de [F-Droid](https://f-droid.org/en/packages/com.termux/). 189 | 190 | La descarga también está disponible en Play Store, pero descargar la app de la Play Store NO SE RECOMIENDA. El motivo está relacionado con políticas de Google con respecto a dar soporte a nuevas versiones de Android. Si se cumpliese con dichas políticas, habría que dejar de dar soporte a versiones anteriores. [Aquí mas detalles](https://github.com/termux/termux-app#google-play-store-deprecated). 191 | 192 | Si no conoces la arquitectura de tu dispositivo, puedes pinchar [aquí](https://stringmanolo.github.io/hackingTermux101/paginas/mostrarArch.html). 193 | 194 | ### Instalacion 195 | - Abre F-Droid en tu Android pinchando [aquí](https://f-droid.org/packages/com.termux/) 196 | - Pincha en el primer enlace que dice [Descargar Apk]() 197 | - Pincha en el archivo descargado para iniciar la instalación 198 | - Pincha en Permitir instalación de aplicaciones desde orígenes desconocidos 199 | - Espera a que se complete la instalación 200 | - Cuando finalice la instalación tendrás el icono de Termux en tu escritorio, haz click para arrancar la app. 201 | 202 | [Tabla de Contenidos](#tabla-de-contenidos) 203 | 204 | ----- 205 | 206 | ## Capítulo 3: Configuración Básica 207 | 208 | Una vez tienes la consola de comandos ante ti, lo primero es configurar el acceso al sistema interno de ficheros de Android. Para ello debes correr el comando 209 | ```bash 210 | termux-setup-storage 211 | ``` 212 | Y permitir el acceso de termux al sistema interno de ficheros. 213 | 214 | ![Imagen de Android que pide permisos de acceso al espacio interno de ficheros](https://github.com/StringManolo/hackingTermux101/raw/master/imagenes/termux-setup-storage.png) 215 | 216 | El comando **termux-setup-storage** va a configurar el acceso a las siguientes carpetas. 217 | * ~/storage/shared 218 | Carpeta utilizada por las aplicaciones de Android para compartir archivos 219 | * ~/storage/downloads 220 | La carpeta por defecto de descargas, por ejemplo donde tu navegador descarga los archivos. 221 | * ~/storage/dcim 222 | Aquí la cámara suele almacenar las fotos y videos del dispositivo 223 | * ~/storage/pictures 224 | En esta carpeta se suelen almacenar imágenes del dispositivo 225 | * ~/storage/music 226 | Esta es la carpeta que Android suele utilizar para guardar la música del usuario 227 | * ~/storage/movies 228 | Donde se suelen almacenar las películas 229 | * ~/storage/external-1 230 | Carpeta especial creada por Termux en el almacenamiento externo (si este está disponible), normalmente una tarjeta micro-sd, aunque se permite también el acceso a pendrives y otro tipo de dispositivos de memoria externos. No instales paquetes, programas o archivos de programas aquí (como puedan ser logs de un servidor, archivos de configuración, ...) , ya que Android no proporciona permisos de escritura/lectura directamente y es necesario utilizar una API a la que los programas no tienen acceso. 231 | 232 | Si utilizas Android 11 y se muestra el error __Permission denied__ (Permiso denegado) cuando intentas acceder a la carpeta shared, aún cuando le diste permisos, sigue los pasos siguientes: 233 | - Ve a Ajustes -> Aplicaciones -> Termux -> Permisos 234 | - Revoca el permiso de acceso a ficheros (Storage permission) 235 | - Autoriza de nuevo el permiso de acceso a ficheros. 236 | 237 | Este es un bug de Android 11, no de Termux. 238 | 239 | > Nunca elimines Termux directamente desde Android, ya que si tienes archivos en la tarjeta sd, todo su contenido será eliminado, incluyendo archivos que no tienen ninguna relación con Termux 240 | 241 | [Tabla de Contenidos](#tabla-de-contenidos) 242 | 243 | ----- 244 | 245 | ## Capítulo 4: Uso básico de la terminal 246 | 247 | Una terminal es una interfaz conducida por comandos capaz de realizar todo tipo de tareas. Usualmente realizamos las tareas utilizando interfaces, esto es, pulsando botones, arrastrando carpetas, viendo la información en forma de imágenes e iconos... La terminal utiliza un modelo completamente distinto, remplazando los iconos, las imágenes, los botones y toda la gestión de ficheros por comandos y texto que se muestra en pantalla. 248 | 249 | Utilizar una terminal en lugar de una interfaz gráfica, nos permite realizar tareas de todo tipo de forma mas ágil y rápida. 250 | 251 | Todas las terminales de GNU/Linux, así como Termux, incluyen una gran variedad de comandos básicos que nos permiten realizar estas tareas. Este capítulo se enfoca en los comandos más básicos de Linux. 252 | 253 | Al entrar en Termux, veremos un **$** que indica el "prompt" de la terminal, en Bash se guarda en la variable de entorno "$PS1". Este caracter del dolar, nos indica que podemos escribir comandos en la terminal. La sintaxis es **$ comando**, para enviar el comando y que este sea procesado, pulsamos la tecla Enter. En caso de Hacker's Keyboard, esta tecla se representa como una flecha situada en la esquina inferior derecha **⏎**. 254 | 255 | ### Comandos básicos de Linux 256 | 257 | #### pwd 258 | El comando **pwd** nos va a mostrar la ruta completa de la carpeta en la cual nos encontramos. 259 | 260 | ![Salida del comando pwd](https://github.com/StringManolo/hackingTermux101/raw/master/imagenes/pwd.jpg) 261 | 262 | > pwd son las siglas de Print Working Directory (Imprime Directorio de Trabajo) 263 | 264 | #### cd 265 | El comando **cd** sirve para cambiar el directorio en el cual estamos trabajando. Es el equivalente a moverse a una carpeta haciendo doble-click en ella desde cualquier interfaz gráfica. 266 | Si escribes el comando cd sin mas, se cambiará el directorio a la variable de entorno "$HOME", por defecto /data/data/com.termux/files/home. 267 | 268 | > Existe un símbolo especial **~** que sirve para indicar explícitamente que nos mueva a la carpeta home. Esto nos será útil cuando queramos crear o referenciar un archivo en home desde otro directorio. 269 | 270 | Podemos movernos a cualquier directorio alcanzable poniendo su ruta relativa tras el comando cd, o poniendo su ruta absoluta desde cualquier lugar. En la siguiente imagen puedes comprobar como se cambia el directorio a la carpeta __ejemplo__, que existe dentro de la carpeta home, y como después se imprime el directorio actual de trabajo. Indicándonos la terminal, que nos encontramos dentro de la carpeta ejemplo que existe en home. 271 | 272 | Cuando quieras moverte al directorio anterior utiliza dos puntos. 273 | ```bash 274 | cd .. 275 | ``` 276 | 277 | ![Salida del comando cd ejemplo y pwd](https://github.com/StringManolo/hackingTermux101/raw/master/imagenes/cd_ejemplo.jpg) 278 | 279 | > cd son las siglas de Change Directory (Cambia Directorio), 280 | 281 | #### ls 282 | El comando **ls** muestra la lista de archivos y carpetas que contiene el directorio actual de trabajo. 283 | 284 | ![Salida del comando ls y pwd](https://github.com/StringManolo/hackingTermux101/raw/master/imagenes/ls.jpg) 285 | 286 | En este ejemplo nos movemos al directorio home, desde ahí al directorio ejemplo que está dentro de home y con **ls** listamos todo lo que contiene el directorio actual. 287 | 288 | En blanco se muestran los archivos comunes (foto_perfil.jpg, listaDeLaCompra.txt), en azul/violeta se muestran los directorios que contiene el directorio __ejemplo__. En este caso hay un directorio llamado __documentosDelTrabajo__. En verde se muestran archivos con permisos de ejecución, en esta imagen no hay ninguno. 289 | 290 | > ls es una abreviatura de List (Listar) 291 | 292 | #### cat 293 | El comando **cat** muestra el contenido de un fichero. 294 | 295 | ![Salida del comando cat](https://github.com/StringManolo/hackingTermux101/raw/master/imagenes/cat.jpg) 296 | 297 | En este ejemplo se muestra el contenido del fichero listaDeLaCompra.txt. Es simplemente un texto que escribí en un fichero. La escritura de ficheros se detalla en el [capítulo 6: Uso de VI y de VIM](#cap%C3%ADtulo-6-uso-de-vi-y-de-vim). 298 | 299 | > cat viene de concatenate (concatenar) 300 | 301 | #### touch 302 | El comando **touch** crea ficheros vacios en el directorio actual. 303 | ```bash 304 | touch miListaDeLaCompra.txt 305 | ``` 306 | 307 | Con este comando crearás un archivo miListaDeLaCompra.txt en el directorio actual, que podras ver en el listado del directorio en el que crees el archivo. Por ejemplo si quisieses crear el archivo en home y listar el contenido de home, usarías los siguientes comandos: 308 | ```bash 309 | cd 310 | touch miListaDeLaCompra.txt 311 | ls 312 | ``` 313 | 314 | > touch significa tocar 315 | 316 | #### mkdir 317 | El comando **mkdir** crea directorios/carpetas vacias en el directorio actual. 318 | ```bash 319 | cd 320 | mkdir ejemplo 321 | ``` 322 | 323 | Con estes comandos crearás una carpeta (puedes usar el nombre de carpeta/directorio indistintamente) llamada __ejemplo__ dentro de la carpeta home. Puedes listarla con ls. 324 | 325 | Si intentas crear un nuevo directorio y un directorio hijo directamente, puede usar el argumento -p (de parents, en español directorios padres) 326 | 327 | ```bash 328 | mkdir ~/ejemplo/hijoDeEjemplo/hijoDeHijoDeEjemplo 329 | ``` 330 | 331 | 332 | > mkdir es una abreviatura de Make Directory (Crea Directorio) 333 | 334 | #### cp 335 | El comando **cp** permire copiar archivos. Puedes copiarlos en el mismo directorio o en otro directorio. Tambien puedes modificar el nombre de destino. 336 | ```bash 337 | cp miListaDeLaCompra.txt miSegundaListaDeLaCompra.txt 338 | ``` 339 | 340 | El primer argumento del comando **cp** es el nombre del fichero del que deseamos realizar una copia. El segundo argumento es el nuevo nombre que tendrá la copia. Si el archivo contiene texto o cualquier otro contenido, este estará presente en ambos archivos, tanto en el original como en la copia. 341 | 342 | La mayoría de comandos nos permite especificar las ruta junto al nombre de los ficheros. Si nos encontramos en la carpeta home, y dentro de esta tenemos una carpeta llamada ejemplo que contiene un archivo miListaDeLaCompra.txt, podemos copiar este archivo directamente desde la carpera home. El comando para realizar esta acción sería: 343 | 344 | ```bash 345 | cd 346 | cp ejemplo/miListaDeLaCompra.txt listaDeLaCompra.txt 347 | ``` 348 | 349 | Tras este comando tendremos una copia del archivo miListaDeLaCompra.txt (que se encuentra en la carpeta ejemplo) en la carpeta home con el nombre de listaDeLaCompra.txt 350 | 351 | > cp es una abreviatura de copy (copiar) 352 | 353 | #### mv 354 | El comando **mv** permite mover archivos. El funcionamiente es exactamente igual al del comando **cp**, con la diferencia de que el archivo original es eliminado y solo se conserva la nueva copia. 355 | 356 | Esto hace de **mv** el comando ideal para mover archivos entre directorios. 357 | 358 | > mv es una abreviatura de move (mover) 359 | 360 | #### rm 361 | El comando **rm** se utiliza para eliminar archivos de forma permanente. 362 | 363 | ```bash 364 | cd 365 | rm listaDeLaCompra.txt 366 | ``` 367 | 368 | > rm es una abreviatura de remove (eliminar) 369 | 370 | #### clear 371 | El comando **clear**, limpia el contenido de la pantalla. 372 | ```bash 373 | clear 374 | ``` 375 | 376 | > clear significa limpiar 377 | 378 | #### pkg 379 | El comando **pkg** es único de Termux, no existe en GNU/Linux, aunqie si existen sus equivalentes. Este comando se encarga de gestionar por nosotros toda la instalación de paquetes, sus versiones, actualizaciones, dependencias, ... 380 | 381 | Si corres el comando: 382 | ```bash 383 | pkg 384 | ``` 385 | 386 | Te mostrará la lista de subcomandos que soporta y una breve descripción de que hace cada uno. Aquí me limito a explicar los subcomandos mas básicos: 387 | 388 | * ##### pkg list-all 389 | Muestra un listado todos los comandos/programas/paquetes disponibles para instalar. El listado es bastante grande. 390 | ```bash 391 | pkg list-all 392 | ``` 393 | 394 | * ##### pkg list-installed 395 | Muestra el listado de los comandos que ya están instalados en tu Termux. Este listado solo hace referencia a paquetes que se han instalado por **pkg**. Esto significa que no verás en la lista comandos como cp, cat, mv, ls, ... También significa que puedan aparecer algunos paquetes que tu no instalases. 396 | 397 | Por ejemplo si instalas una herramienta que utiliza una base de datos, es común que en el listado te aparezcan tanto la herramienta que descargaste como la base de datos. Esto sucede porque pkg se encarga de bajar las dependencias necesarias (para que las herramientas funcionen) por su cuenta. 398 | ```bash 399 | pkg list-installed 400 | ``` 401 | 402 | * ##### pkg show 403 | Muestra información adicional incluyendo una breve descripción sobre el paquete que se indique. Puedes utilizar el nombre de cualquiera de los paquetes listados con los 2 anteriores subcomandos 404 | ```bash 405 | pkg show unzip 406 | ``` 407 | 408 | El comando **pkg show unzip** nos muestra esta descripción para el comando unzip. 409 | ``` 410 | Package: unzip 411 | Version: 6.0-7 412 | Maintainer: Termux members @termux 413 | Installed-Size: 340 kB 414 | Depends: libbz2 415 | Homepage: https://sourceforge.net/projects/infozip/ 416 | Download-Size: 115 kB 417 | APT-Manual-Installed: yes 418 | APT-Sources: https://termux.org/packages stable/main aarch64 Packages 419 | Description: Tools for working with zip files 420 | ``` 421 | 422 | En este ejemplo la información que se nos muestra indica: 423 | - El nombre del paquete 424 | - La versión del programa 425 | - Las personas/organización que se encargan de gestionar este paquete 426 | - El tamaño que ocupará en el sistema una vez instalado 427 | - Otros paquetes que necesita para funcionar 428 | - La página oficial del programa (o repositorio de su código fuente) 429 | - El tamaño de la descarga comprimida 430 | - Si se instaló manualmente 431 | - Repositorio donde está el paquete listado 432 | - Descripción de que es el paquete 433 | 434 | Si tienes la opción de buscar en Google el paquete, te será de mas ayuda para saber exactamente para que sirve. 435 | 436 | * ##### pkg install 437 | Instala un comando en Termux. 438 | ```bash 439 | pkg install tree 440 | ``` 441 | 442 | Una vez instalado, ya podras utilizarlo. 443 | Es posible que se muestre un error si el repositorio por defecto no está disponible. Si este es tu caso, corre el comando termux-change-repo. Presiona enter sobre Main Repository para poder ver un listado de los servidores disponibles y cambia el servidos moviéndote por el listado hacia abajo, presionando espacio para marcar tu selección y enter para guardar los cambios. 444 | 445 | 446 | 447 | Tree es similar a ls pero también muestra todos los subdirectorios. 448 | ```bash 449 | tree 450 | ``` 451 | 452 | * ##### pkg uninstall 453 | Desinstala un comando en Termux. 454 | ```bash 455 | pkg uninstall tree 456 | ``` 457 | 458 | Una vez desinstalado, se borrará permanentemente del sistema el comando que hayas escrito en este caso tree. Si intentas volver a utilizarlo tras desinstalarlo, verás que ya no existe. 459 | 460 | Puedes borrarlo si quieres, siempre podrás volver a instalarlo si lo necesitas. 461 | 462 | * ##### pkg upgrade 463 | Actualiza todos los paquetes instalados. 464 | ```bash 465 | pkg update 466 | ``` 467 | 468 | > Si tienes espacio de sobra, es recomendado que todos los días actualices tus comandos usando **pkg upgrade** Las actualizaciones, sirven principalmente para mantener tus paquetes seguros. 469 | > Cuando un programador o hacker, encuentra un fallo de seguridad en un programa, se programa un código (parche de seguridad). Cuando tu le das a actualizar, se instalan estos parches automáticamente. También se instalan parches de mejoras de rendimiento para que los comandos se ejecuten mas rápido o utilicen menos batería, asi como también nuevas funcionalidades. 470 | 471 | #### man 472 | El comando **man** sirve para mostrar el manual de un comando, si lo tiene. 473 | ```bash 474 | man ls 475 | ``` 476 | 477 | Con **man ls** se nos muestra el manual para el comando ls, con todas sus opciones extra. 478 | 479 | > man son la iniciales de manual 480 | 481 | Para salir de man utiliza la combinación de teclas **ESC : q** 482 | 483 | #### exit 484 | Cierra la terminal 485 | 486 | 487 | #### Argumentos 488 | Los comandos de GNU/Linux aceptan argumentos especiales que van precedidos de guiones. Hay 2 formas de argumentos con guiones. La forma corta y la forma léxica del argumento. La forma corta es siempre una letra, normalmente la inicial de la forma léxica. 489 | 490 | Uno de los argumentos que vamos a encontrar presentes en prácticamente todos los comandos es **-h**. Versión corta de **--help**. Normalmente podemos acompañar nuestros comandos de cualquiera de estos indistintamente, aunque no hay ninguna norma escrita y muchos desarrolladores muestran distintos mensajes de ayuda según utilizas la versión corta o la léxica. Yo suelo dar prioridad a las opción léxica del argumento help. 491 | 492 | ```bash 493 | ls --help 494 | ``` 495 | 496 | 497 | 498 | [Tabla de Contenidos](#tabla-de-contenidos) 499 | 500 | ----- 501 | 502 | ## Capítulo 5: Introducción a Bash 503 | Bash es una shell de comandos. Todos los comandos que usamos hasta ahora, han sido enviados a Bash y Bash es quien se ha encargado de interpretarlos y llamar a los paquetes correspondientes. Se encarga de procesar el texto que le introducimos y el símbolo dolar **$** nos está indicando que se trata de una Shell normal. 504 | 505 | > En Linux cuando eres root usando el comando **sudo su** el dolar se cambia por un hash (asterisco) #. En Android no disponemos de root por defecto, y este libro asume que no eres root. Es posible obtenerlo, pero yo no lo recomiendo en Android por motivos de seguridad del sistema. 506 | 507 | Bash no es un simple intérprete, si no que admite un gran número de instrucciones muy diversas y tambien algunas complejas, dando lugar a un lenguaje de programación potente ampliamente utilizado para configurar sistemas GNU/Linux, crear comandos y otro tipo de utilidades. 508 | 509 | #### Variables 510 | Las variables te permiten almacenar valores para poder utilizarlos mas adelante. 511 | 512 | Para almacenar texto en una variable usaremos la siguiente sintaxis **nombreDeLaVariable**="__valorDeLaVariable__" 513 | ```bash 514 | miNombre="Manolo" 515 | ``` 516 | 517 | También es posible almacenar el resultado de un comando en la variable utilizando la sintaxis **nombreDeLaVariable**=__$(comando argumentos)__ 518 | ```bash 519 | listaArchivosEnHome=$(ls ~) 520 | ``` 521 | 522 | Podremos referenciar la variable anteponiendo el símbolo del dolar al nombre de la variable, como veremos en el siguiente apartado. 523 | 524 | #### Imprimir en pantalla 525 | Para imprimir texto o el contenido de variables (en este caso en pantalla) podemos utilizar echo o printf. 526 | 527 | ##### echo 528 | echo es un comando sencillo para imprimir texto 529 | ```bash 530 | miNombre="Manolo" 531 | echo "Hola, mi nombre es $miNombre" 532 | ``` 533 | 534 | Puedes usar variables como en el ejemplo anterior, y también comandos: 535 | ```bash 536 | echo "Hola, te encuentras en el directorio $(pwd)" 537 | ``` 538 | 539 | Si quieres que se imprima un salto de linea, puedes anteponer el argumento simple -e del texto. Y en el texto incluyes la secuencia de caracteres \n para indicar un salto de linea. 540 | ```bash 541 | echo "$(clear)\n\n\n\n\n\n\n\n\n\nHola, te encuentras en el directorio\n$(pwd)\nNo es genial\n?\n\n" 542 | ``` 543 | 544 | ![Salida del comando echo en multiples lineas](https://github.com/StringManolo/hackingTermux101/raw/master/imagenes/echo.jpg) 545 | 546 | ##### printf 547 | printf hace lo mismo que echo pero se ejecuta mas rápido y permite mas opciones para formatear el texto. 548 | ```bash 549 | miNombre="Manolo" 550 | printf "Hola, mi nombre es %s" "$miNombre" 551 | ``` 552 | 553 | Con respecto a echo, puedes apreciar que no se añade el salto de linea al final de la frase. Tienes que añadirla manualmente. También ves en el comando que las variables se separan en otros argumentos a parte. En este caso %s indica que la variable es un string (cadena de texto). 554 | 555 | Otra de las ventajas de printf, es que nos avisa de errores. Por ejemplo %d sirve para imprimir numeros enteros. Si le pasamos como argumento un numero que no es entero, nos avisará del error 556 | ```bash 557 | numeroPI="3.1416" 558 | printf "El numero PI es %d" "$numeroPI" 559 | ``` 560 | 561 | Bash nos indicará el error: **bash: printf: 3.1416: invalid number** e imprimirá solo la parte entera. Esta es la lista de tipos que acepta: 562 | 563 | | secuencia | tipo | descripción | 564 | | --- | --- | --- | 565 | | %d | digit | Números enteros | 566 | | %f | float | Números flotantes (numeros con decimales) | 567 | | %s | string | Cadena de texto | 568 | | %x | hexadecimal | Imprime un número en hexadecimal | 569 | | %X | hexadecimal | Imprime un número en hexadecimal (letras en mayúsculas) | 570 | 571 | 572 | #### Leer de la terminal 573 | Podemos interactura con el usuario de múltiples formas. 574 | 575 | ##### read 576 | El comando **read** nos permite leer datos de la entrada de la terminal. Nosotros usaremos read con el argumento simple -p (la p es de la palabra prompt, en español sugerencia) y nos srive para sugerir al usuario el tipo de datos que queremos que introduza. 577 | 578 | Si por ejemplo queremos preguntarle el nombre al usuario 579 | ```bash 580 | read -p "Cómo te llamas? " nombre 581 | echo "Tu nombre es $nombre" 582 | ``` 583 | 584 | En este ejemplo vemos que readme se parece a echo, pero admite un argumento extra, que será el nombre de la variable en la cual queremos que se guarden los datos que introduzca el usuario. 585 | 586 | > read significa leer 587 | 588 | #### Condicionales 589 | Los condicionales permiten realizar acciones si se cumple una condición. **if [ condición ]; then comando fi**. En español se traduciría a algo similar a **sì [ seCumpleEstaCondición ]; entonces ejecutaEsteComando fin**. Podemos ver un ejemplo. 590 | 591 | ```bash 592 | read -p "Introduce tu edad y pulsa enter: " edad 593 | if [ "$edad" -gt 17 ]; then 594 | echo "Eres mayor de edad" 595 | fi 596 | ``` 597 | 598 | En este ejemplo tenemos: 599 | - Un read 600 | Almacena la edad que introduce el usuario en la variable edad. 601 | - La palabra clave if 602 | Indica que la expresión es un condicional 603 | - Unos corchetes (que también son comandos, aunque no lo parezcan) 604 | Evaluan la siguiente expresión y delimitan donde empieza ([) y acaba (]) la condición 605 | - El punto y coma (;) 606 | Sirve para indicar el final de los comandos asociados a if 607 | - La palabra then 608 | Indica que a continuación vienen las instrucciones que queremos que se ejecuten si se ha cumplido la condición. 609 | - Un echo que imprime un texto 610 | Aunque podría ser cualquier otro comando, asignación de variables, etc. 611 | - Y la palabra fi (es if al revés) 612 | Indica el final del condicional 613 | 614 | La condición **"$edad" -gt 17** está compuesta de 3 elementos: 615 | - "$edad" 616 | Es una variable que contiene la edad del usuario 617 | - -gt 618 | Es un operador especial de Bash, siglas de Greater Than (Mayor Que). Sería equivalente al operador matemático **>** 619 | - 17 620 | Si la edad del usuario es mayor que 17, entonces es mayor de edad (18 años o más en mi país) 621 | 622 | Recuerdas que te dije que **[** era un comando mas? Igual que echo o printf. Pues **[** también tiene argumentos. 623 | Hay distintos tipos de condiciones, aquí un listado de las mas comunes: 624 | ```bash 625 | [ -a listaDeLaCompra.txt ] 626 | ``` 627 | Se cumple si el archivo existe 628 | 629 |   630 | 631 | ```bash 632 | [ -d ejemplo ] 633 | ``` 634 | Se cumple si la carpeta existe 635 | 636 |   637 | 638 | ```bash 639 | [ -f listaDeLaCompra.txt ] 640 | ``` 641 | Se cumple si el archivo existe y es un archivo normal 642 | 643 |   644 | 645 | ```bash 646 | [ -s listaDeLaCompra.txt ] 647 | ``` 648 | Se cumple si el archivo existe y no está vacio 649 | 650 |   651 | 652 | ```bash 653 | [ listaDeLaCompra.txt -nt otraListaDeLaCompra.txt ] 654 | ``` 655 | Se cumple si el primer archivo es mas reciente que el segundo 656 | > nt abreviado de newer than (mas nuevo que) 657 | 658 |   659 | 660 | ```bash 661 | [ listaDeLaCompra.txt -ot recetaChurros.txt ] 662 | ``` 663 | Se cumple si el primer archivo es mas viejo que el segundo 664 | > ot abreviado de older than (mas viejo que) 665 | 666 |   667 | 668 | ```bash 669 | [ -z "$nombre" ] 670 | ``` 671 | Se cumple si la variable está vacia 672 | 673 |   674 | 675 | ```bash 676 | [ -n "$nombre" ] 677 | ``` 678 | Se cumple si la variable no está vacia 679 | 680 |   681 | 682 | ```bash 683 | [ "$nombre" = "Paco" ] 684 | ``` 685 | Se cumple si el contendio de la variable **$nombre** es **Paco** 686 | 687 |   688 | 689 | ```bash 690 | [ "$nombre" != "Paco" ] 691 | ``` 692 | Se cumple si el contenido de la variable **$nombre** no es **Paco** 693 | 694 |   695 | 696 | ```bash 697 | [ "$nombre" < "Paco" ] 698 | ``` 699 | Se cumple si el contenido de la variable **$nombre** se posiciona antes que Paco, alfabéticamente 700 | 701 |   702 | 703 | ```bash 704 | [ "$nombre" > "Paco" ] 705 | ``` 706 | Se cumple si el contenido de la variable **$nombre** se posiciona después que Paco, alfabéticamente 707 | 708 |   709 | 710 | ```bash 711 | [ -v "$nombre" ] 712 | ``` 713 | Se cumple si la variable existe 714 | 715 |   716 | 717 | ```bash 718 | [ ! condicion ] 719 | ``` 720 | Se cumple si la condición no se cumple 721 | 722 |   723 | 724 | ```bash 725 | [ condicion -o otraCondicion ] 726 | ``` 727 | Se cumple si cualquiera de las 2 condiciones se cumple (o ambas se cumplen) 728 | 729 |   730 | 731 | ```bash 732 | [ condicion -a otraCondicion ] 733 | ``` 734 | Se cumple solo si ambas condiciones se cumplen 735 | 736 |   737 | 738 | ```bash 739 | [ 7 -eq 7 ] 740 | ``` 741 | Se cumple si el primer número es igual al segundo (recuerda que puedes usar variables) 742 | > eq de equals (igual a) 743 | 744 |   745 | 746 | ```bash 747 | [ 7 -ne 7 ] 748 | ``` 749 | Se cumple si el primer número es distinto al segundo 750 | > ne de not equal (no igual a) 751 | 752 |   753 | 754 | ```bash 755 | [ 7 -lt 7 ] 756 | ``` 757 | Se cumple si el primer numero es menor que el segundo 758 | > lt de less than (menor que) 759 | 760 |   761 | 762 | ```bash 763 | [ 7 -le 7 ] 764 | ``` 765 | Se cumple si el primer número es menor o igual al segundo 766 | > le de less equal (menor o igual a) 767 | 768 |   769 | 770 | ```bash 771 | [ 7 -gt 7 ] 772 | ``` 773 | Se cumple si el primer número es mayor que el segundo 774 | > gt de greater than (mayor que) 775 | 776 |   777 | 778 | ```bash 779 | [ 7 -ge 7 ] 780 | ``` 781 | Se cumple si el primer número es mayor o igual que el segundo 782 | > ge de greater equal (mayor o igual a) 783 | 784 |   785 | 786 | A parte de if, hay un par de palabras mas que podemos utilizar en los condicionales. 787 | El comando **else** permite ejecutar comandos si la condición no se ha cumplido. Queda mas claro con un ejemplo: 788 | ```bash 789 | read -p "Introduce tu edad y pulsa enter: " edad 790 | if [ "$edad" -gt 17 ]; then 791 | echo "Eres mayor de edad" 792 | else 793 | echo "Eres menor de edad" 794 | fi 795 | ``` 796 | 797 | Si pruebas el ejemplo pegándolo en tu terminal y pulsando enter, verás que si se cumple la condición mostrará el texto indicando que eres mayor de edad, y si no se cumple, te dirá que eres menor de edad. 798 | 799 | La última palabra clave es **elif**, y sirve para introducir mas if, que se ejecutarán solo si el anterior **if** no se cumple. Ejemplo: 800 | ```bash 801 | read -p "Introduce tu edad y pulsa enter: " edad 802 | if [ "$edad" -lt 12 ]; then 803 | echo "Eres un niño" 804 | elif [ "$edad" -lt 18 ]; then 805 | echo "Eres un adolescente" 806 | elif [ "$edad" -lt 65 ]; then 807 | echo "Eres un adulto" 808 | else 809 | echo "Eres un anciano" 810 | fi 811 | ``` 812 | 813 | En español esto viene diciendo: 814 | ```bash 815 | si (tienes menos de 12 años) entonces 816 | muestra "Eres un niño" 817 | en caso contrario, si (tienes menos de 18 años) entonces 818 | muestra "Eres un adolescente" 819 | en caso contrario, si (tienes menos de 65 años) entonces 820 | muestra "Eres un adulto" 821 | en caso contrario 822 | muestra "Eres un anciano" 823 | ``` 824 | 825 | El comando *case* es una forma distinta de crear condicionales, en otros lenguajes se le conoce como **switch** o también **switch case** y se utiliza principalmente cuando quieres comprobar la variable con valores concretos 826 | ```bash 827 | printf "1. Imprimir Directorio Actual\n2. Listar ficheros \n3. Crear Archivo\n4. Crear Carpeta\n\n0. Salir\n\nSelecciona el número correspondiente a tu opción -> " 828 | read opcion 829 | case $opcion in 830 | 1) 831 | echo $(pwd) 832 | ;; 833 | 834 | 2) 835 | echo $(ls) 836 | ;; 837 | 838 | 3) 839 | read -p "Introduce el nombre que tendrá el nuevo fichero: " nombreFichero 840 | touch $nombreFichero 841 | ;; 842 | 843 | 4) 844 | read -p "Introduce el nombre que tendrá el nuevo directorio: " nombreDirectorio 845 | mkdir $nombreDirectorio 846 | ;; 847 | 848 | 0) 849 | echo "Adios" 850 | ;; 851 | 852 | *) 853 | echo "La opción que elegiste no existe" 854 | ;; 855 | esac 856 | ``` 857 | 858 | #### Bucles 859 | Los bucles nos permiten correr un comando/realizar una tarea de forma repetida. 860 | Existen 4 tipos de bucles basicos en Bash. Los bucles **while**, **until**, **for** y **select**. 861 | 862 | ##### while 863 | El comando **while** permite ejecutar comandos mientras la condición sea verdadera. Su sintaxis es similar a la del condicional **if**. Ejemplo: 864 | ```bash 865 | read -p "Introduce tu contraseña: " contra 866 | while [ "$contra" != "admin123" ]; do 867 | read -p "La contraseña '$contra' es incorrecta. Inténtalo de nuevo: " contra 868 | done 869 | echo "Acceso Permitido" 870 | ``` 871 | 872 | > Si no supieses la contraseña, no sabrías como salir del programa. Cuando quieras cancelar la ejecución de un programa que está en bucle, presiona las teclas **CTRL** y **c**. Si no funciona, prueba con las teclas **CTRL** y **d**. 873 | 874 | Otro tipo de bucles comunes son los bucles infinitos 875 | ```bash 876 | while [ true ]; do 877 | date 878 | sleep 8s 879 | done 880 | ``` 881 | En este ejemplo vamos a mostrar la fecha cada 8 segundos. 882 | 883 | ##### until 884 | El bucle **until** es prácticamente igual al bucle **while**, con la diferencia de que se ejecutará mientras no se alcance la condición. 885 | ```bash 886 | read -p "Introduce tu contraseña: " contra 887 | until [ "$contra" = "admin123" ]; do 888 | read -p "La contraseña '$contra' es incorrecta. Inténtalo de nuevo: " contra 889 | done 890 | echo "Acceso Permitido" 891 | ``` 892 | 893 | > Puedes usar while o until indistintamente. Until existe simplemente porque puede ser mas sencilla de leer la expresión en inglés. 894 | Los ejemplos anteriores en español dirían; Para **while**: 895 | > Mientras (laContraseña no es igual a "admin123") haz ... 896 | Para **until**: 897 | > Hasta que (laContraseña no sea igual a "admin123") haz ... 898 | 899 | ##### for 900 | El bucle for sirve principalmente para recorrer elemenos. Los elementos pueden ser frases, palabras, secuencias numéricas, etc. 901 | ```bash 902 | frase="Hola me llamo Manolo" 903 | echo "La frase '$frase' tiene las siguientes palabras:" 904 | for palabra in $frase; do 905 | echo "$palabra" 906 | done 907 | ``` 908 | 909 | Lo mismo que haces con palabras, puedes hacerlo directamente con la salida de comandos. Da mucho juego 910 | ```bash 911 | for archivo in $(ls ~); do 912 | echo "$archivo" 913 | done 914 | ``` 915 | 916 |   917 | También puedes recorrer rangos de números 918 | ```bash 919 | echo "Los números del 1 al 20 son:" 920 | for numero in {1..20}; do 921 | printf "%d, " $numero 922 | done 923 | ``` 924 | 925 |   926 | Si queremos omitir la última coma tras el 20, podemos usar un condicional: 927 | ```bash 928 | echo "Los números del 1 al 20 son:" 929 | for numero in {1..20}; do 930 | if [ "$numero" -ne 20 ]; then 931 | printf "%d, " $numero 932 | else 933 | printf "%d" $numero 934 | fi 935 | done 936 | ``` 937 | 938 | Hay otra forma de usar el **for** que le será familiar a quien utilice el for en otros lenguajes de programación. Esta versión del **for** se le conoce como **for clásico** 939 | ```bash 940 | for ((i=1; i <= 10; i++)) do 941 | echo "$i" 942 | done 943 | ``` 944 | 945 | Algunos lenguajes de programación no disponen del bucle **for clásico**, pero si tienen el **while**. Hay una forma simple de conseguir esta misma funcionalidad con el bucle **while** 946 | ```bash 947 | i=1 948 | while [ $i -le 10 ]; do 949 | echo "$i" 950 | ((++i)) 951 | done 952 | ``` 953 | 954 | ##### select 955 | El bucle **select** es un tipo de bucle ideal para hacer menus de forma sencilla. 956 | ```bash 957 | opciones="Sumar Restar Multiplicar Dividir Salir" 958 | select opcion in $opciones; do 959 | if [ "$opcion" = "Salir" ]; then 960 | echo "Adios" 961 | break 962 | fi 963 | 964 | read -p "Introduce el primer número: " primerNumero 965 | read -p "Introduce el segundo número: " segundoNumero 966 | if [ "$opcion" = "Sumar" ]; then 967 | resultado=$(( $primerNumero + $segundoNumero )) 968 | elif [ "$opcion" = "Restar" ]; then 969 | resultado=$(( $primerNumero - $segundoNumero )) 970 | elif [ "$opcion" = "Multiplicar" ]; then 971 | resultado=$(( $primerNumero * $segundoNumero )) 972 | elif [ "$opcion" = "Dividir" ]; then 973 | resultado=$(( $primerNumero / $segundoNumero )) 974 | else 975 | resultado="Opcion incorrecta." 976 | fi 977 | 978 | echo "El resultado es $resultado"; 979 | done 980 | ``` 981 | 982 | En este ejemplo podemos ver una calculadora simple en Bash. A destacar la palabra **break** que sirve para salir de cualquier tipo de bucle. 983 | 984 | ##### funciones 985 | Las **funciones** en Bash nos permiten agrupar varias instrucciones bajo el mismo nombre y son similares a los comandos en su uso. Para crear una función: 986 | 987 | ```bash 988 | saludar() { 989 | echo "hola $1, bienvenido a mi programa" 990 | } 991 | ``` 992 | 993 | De esta forma creamos una función que podremos reusar las veces que queramos. La principal utilidad de las funciones es reducir el tamaño del código. 994 | ```bash 995 | saludar() { 996 | echo "hola $1, bienvenido a mi programa" 997 | } 998 | 999 | saludar "Manolo" 1000 | saludar "Arturo" 1001 | ``` 1002 | 1003 | Como puedes ver, puedes saludar a tantos usuarios como quieras sin necesidad de tener que escribir el mismo texto una y otra vez. Puedes poner cualquier tipo de comandos dentro de las funciones. 1004 | 1005 | Si quieres que quede mas claro que estás creando una función, puedes usar la palabra clave **function** y omitir los paréntesis: 1006 | ```bash 1007 | function saludar { 1008 | echo "hola $1, bienvenido a mi programa" 1009 | } 1010 | 1011 | saludar "Manolo" 1012 | saludar "Arturo" 1013 | ``` 1014 | 1015 | Puedes usar cualquier de las 2 formas, la que tu prefieras. A destacar el uso del dolar. Sirve para referenciar argumentos. $1 referencia el primer argumento. Puedes utilizar todos los que tu quieras: 1016 | ```bash 1017 | saludar() { 1018 | echo "Quiero dar la bienvenida a $1, $2 y $3" 1019 | } 1020 | 1021 | saludar "Manolo" "Arturo" "Jose" 1022 | ``` 1023 | 1024 | #### Miscelanea (otros operadores) 1025 | Bash permite realizar redirecciones entre comandos, salida a pantalla, entrada a comandos y ficheros. Una redirección es el envio de texto desde un fichero a otro. Todo lo que vemos en pantalla en realidad es enviado a un fichero de texto y Bash se encarga de imprimir su contenido para que lo veamos. 1026 | 1027 | ##### > 1028 | El caracter **>** nos permite enviar la salida de un comando hacia un fichero. Si el nombre del fichero no existe, se creará uno nuevo. 1029 | ```bash 1030 | echo -e "Lista de la compra:\n2 paquetes de letejas\n1 cartón de leche" > ~/miListaDeLaCompra.txt 1031 | ``` 1032 | 1033 | Con el **>** indicamos que en lugar de mostrar el texto en pantalla queremos que se mande al archivo __miListaDeLaCompra.txt__ que está ubicado en la carpeta **~** (home). Si el archivo no existe **>** se encarga de crearlo antes de volcar la salida del comando **echo**, y si este archivo ya existía en home, se le borrará todo el contenido antes de añadir el nuevo contenido 1034 | 1035 | Ahora puedes imprimir su contenido cuando quieras 1036 | ```bash 1037 | cat ~/miListaDeLaCompra.txt 1038 | ``` 1039 | 1040 | > La extensión .txt no hace nada, ninguna extensión hace nada en particular. Solo se añaden para ayudar al usuario o a otros programas a intuir que tipo de datos puede contener el fichero. 1041 | 1042 | Otro uso común es ocultar la salida de un comando. Para ello redirigimos la salida a un archivo especial diseñado para ello. 1043 | ```bash 1044 | echo "Hola" > /dev/null 1045 | ``` 1046 | 1047 | Redirigir a __/dev/null__ es una práctica común cuando queremos correr un comando pero no nos interesa lo que nos muestre. Puede ser el caso de un servidor de una página web cuando muestra los logs en pantalla y no nos interesan. 1048 | 1049 | Aunque redirigas la salida a __/dev/null__ los comandos siguen mostrando los errores en pantalla si estos se dan. Si quieres ocultar los errores, debes redirigir un archivo especial hacia __/dev/null__ 1050 | 1051 | ```bash 1052 | cat esteArchicoNoExiste.txt 2>/dev/null 1053 | ``` 1054 | 1055 | ##### >> 1056 | Qué pasa si quiesieses añadir un nuevo producto a tu lista de la compra sin eliminar el contenido del fichero? Se utiliza el operador **>>** en lugar de **>**. Al igual que **>**, si no existe el fichero también se creará, pero si ya existe el fichero, en lugar de remplazar su contenido por el nuevo que indiquemos, se añadirá al que ya existe. 1057 | ```bash 1058 | echo -e "\n6 latas de mejillones" >> ~/miListaDeLaCompra.txt 1059 | ``` 1060 | 1061 | > Puedes redirigir la salida de cualquier comando, no solo de echo 1062 | 1063 | ##### | 1064 | El operador **|** sirve para redirigir la salida de un comando hacia otro comando. 1065 | Existen una multitud de utilidades que son perfectas para su uso con **|** 1066 | ```bash 1067 | echo "Hola qué tal?" | wc 1068 | ``` 1069 | 1070 | > El comando **wc** (word counter en español, contador de palabras) muestra el número de lineas, palabras y caracteres que tiene un texto. En este caso el texto lo pasamos del comando **echo** hacia el comando **wc** utilizando **|** 1071 | 1072 | 1073 | ##### || 1074 | El operador **||** (OR) sirve para ejecutar un comando si el anterior falla. 1075 | ```bash 1076 | cat esteArchivoNoExiste.txt || echo "El archivo no existe" 1077 | ``` 1078 | 1079 | Es común redirigir los errores a __/dev/null__ y mostrar nuestros errores personalizados 1080 | ```bash 1081 | cat archivoQueNoExiste 2>/dev/null || echo "No se pudo mostrar el contenido del archivo" 1082 | ``` 1083 | 1084 | ##### & 1085 | El operador **&** sirve para crear __jobs__ (trabajos en español) mandando a comandos que se están ejecutando a un segundo plano hasta que estos finalicen por si mismos o nosostros los finalicemos de alguna de las múltiples formas que existen. 1086 | 1087 | ```bash 1088 | despedirse() { 1089 | sleep 5s 1090 | printf "Adios" 1091 | sleep 5s 1092 | printf ", ha sido un placer!" 1093 | } 1094 | 1095 | despedirse & 1096 | ``` 1097 | 1098 | > El comando **sleep** (dormir en español) pausa el programa durante el tiempo que le indiquemos. En este ejemplo son dos intervalos de 5s (segundos) cada uno. 1099 | 1100 | Puedes ver los comandos que tengas corriendo en segundo plano (background) con el comando **jobs**, la salida para este ejemplo sería: 1101 | ```bash 1102 | [1]+ Running despedirse & 1103 | ``` 1104 | 1105 | El número de la izquierda es un identificador. La primera palabra __running__ (corriendo) nos dice el estado actual del __job__ y a la derecha de todo encontramos el comando que ejecutamos. 1106 | 1107 | Puedes traer el proceso al frente (foreground) usando el comando **fg %1**, el número tiene que ser el identificador mostrado en el comando **jobs**. Y como puede forzar el cierre del proceso con las combinaciones de teclas que vimos en apartados anteriores de este mismo capítulo (CTRL C, CTRL D) 1108 | 1109 | ##### && 1110 | El operador **&&** (AND) sirve para ejecutar un comando si el anterior funcionó correctamente. 1111 | ```bash 1112 | cat archivoQueExista && echo "El archivo existe y se imprimió correctamente" 1113 | ``` 1114 | 1115 | Muy útil cuando queramos que un comando solo se ejecute si el anterior funcionó 1116 | ```bash 1117 | pkg install tree && tree 1118 | ``` 1119 | 1120 | ##### ; 1121 | El operador **;** es útil para indicar el fin de un comando. Es de uso común cuando quieres correr varios comandos en la misma linea independientemente de si el comando anterior falla o no 1122 | ```bash 1123 | cat archivo1.txt; cat archivo2.txt; echo "Adios" 1124 | ``` 1125 | 1126 | #### help 1127 | El comando **help** nos proporciona ayuda con Bash. 1128 | ```bash 1129 | help 1130 | ``` 1131 | 1132 | Si corres el comando, verás un listado de los comandos internos de Bash que disponen de un mensaje de ayuda. Puedes consultar cada uno de ellos escribiendo **help** y el nombre del comando que quieres consultar. 1133 | ```bash 1134 | help history 1135 | ``` 1136 | 1137 | #### Extra 1138 | Puedes reutilizar los comandos de una linea de la terminal navegando por el historial si le das a las flecha hacia arriba y hacia abajo. 1139 | 1140 | Si pones # al inicio o final de una linea, estás indicando que la linea a partir del # es un comentario que Bash debe ignorar. Los comentarios son útiles para indicar lo que hace el código. Ejemplo: 1141 | ```bash 1142 | # La siguiente linea imprime un texto en pantalla saludando 1143 | echo "Hola" 1144 | echo "Adios" # Esta linea imprime Adios en pantalla 1145 | ``` 1146 | 1147 | Bash te permite autompletar comandos, nombre de carpetas y ficheros... Pulsa la tecla tab para ello. Si hay varios resultados no sucederá nada, pero si vuelves a pulsar otra vez tab, los resultados disponibles se mostraran para que puedas tener una vista previa de que comando o archivo quieres autocompletar. Tendrás que escribir caracteres hasta que el texto que tengas escrito solo coincida con uno de los comandos o archivos disponibles. 1148 | 1149 | Si por ejemplo tienes un archivo que se llama miFoto_729272927282729172917291919372919172728191928372891.jpg, y quisieses eliminarlo, en lugar de escribir todo el nombre, podrías escribir solo **rm miFo** y pulsar la tecla tab para que el nombre se autocompletase. Si también existe otro archivo que se llama miFortaleza.txt, cuando pulsas tab, Bash no sabe cual de los 2 archivos autocompletar, ya que ambos empiezan por **miFo**. Si vuelves a pulsar tab, ambos saldrán en pantalla para indicarte que debes seguir escribiendo. **rm miFot** sería suciente para que se autocompletase miFoto_.... al pulsar tab. 1150 | 1151 | > En Termux la tecla tab se representa por 2 flechas y esta ubicada entre **ESC** y **CTRL** 1152 | 1153 | En lugar de utilizar secuencias de caracteres para saltos de linea, puedes usar comillas simples 1154 | ```bash 1155 | echo 'Hola 1156 | Los saltos de linea también se imprimen asì 1157 | No es genial?' 1158 | ``` 1159 | Si utilizas comillas simples, todo lo que escribas dentro será interpretado como texto, entre otras cosas esto te inhabilita de utilizar variables dentro. Ejemplo: 1160 | ```bash 1161 | nombre=Manolo 1162 | echo 'Mi nombre es $nombre' 1163 | ``` 1164 | 1165 | Si utilizas **printf** en lugar de **echo**, si podrás insertar variables de la siguiente forma 1166 | ```bash 1167 | nombre=Manolo 1168 | printf 'Mi nombre es %s' $nombre 1169 | ``` 1170 | 1171 | 1172 | [Tabla de Contenidos](#tabla-de-contenidos) 1173 | 1174 | ----- 1175 | 1176 | ## Capítulo 6: Uso de VI y de VIM 1177 | VI y VIM son editores de texto muy completos. VI es la versión mas pequeña y suele venir por defecto instalado en muchos sistemas. VIM es su hermano mayor e incluye cientos de características. Por si fueran pocas, la comunidad de programadores va creando sus plugins, temas y colores para VIM para extender aún mas su funcionalidad. 1178 | 1179 | Dado lo extenso de VI y VIM, pondré el foco en los comandos y atajos que yo mas utilizo, dejando de lado muchísima funcionalidad útil. VIM por si solo daría para un libro entero y no es mi idea reinventar la rueda escribiendo un libro de VIM, asique centrando el tiro. 1180 | 1181 | #### Instalar VIM 1182 | VI suele venir instalado, pero VIM no. Es un paquete mas, asique usaremos el comando que ya conocemos para instalar paquetes en Termux 1183 | ```bash 1184 | pkg install vim 1185 | ``` 1186 | 1187 | #### Abrir un fichero 1188 | 1189 | Para abrir un archivo que ya existe o crear uno nuevo, usaremos el siguiente comando 1190 | ```bash 1191 | vim miListaDeLaCompra.txt 1192 | ``` 1193 | 1194 | Verás que se abre una nueva pantalla desconocida hasta ahora. A lo primero que tenemos que echar ojo es a la barra de estado de VIM. Se encuentra exactamente encima del teclado a la izquierda y si no tocas nada tras abrir el archivo, verás el mensaje: **"miListaDeLaCompra.txt" [new]** en la barra de estado de VIM. 1195 | 1196 | Si el archivo ya existía, el mensaje será: **"miListaDeLaCompra.txt" xL xB** donde xL mostrará el número de lineas que tiene el archivo y xB el número de Bytes (un caracter suele pesar al menos 1 Byte, asique es un buen indicador del número aproximado de caracteres que tiene el archivo) que tiene. 1197 | 1198 | #### Escribir en un fichero 1199 | 1200 | Si pulsas la tecla **i**, verás como el estado cambia a **-- INSERT --**. Esto nos indica que ahora nos encontramos en modo inserción de texto. Si ahora pulsas las teclas, podrás escribir en el archivo al igual que haces en el mítico bloc de notas de Windows. 1201 | 1202 | Una vez que tengas tu texto escrito, puedes salir del modo __inserción__ pulsando la tecla ESC. Si te fijas ahora, encima de la barra de estado, que se encontrará vacia tras pulsar ESC, se mostrará el símbolo **[+]** que nos indica que el archivo tiene cambios sin guardar. 1203 | 1204 | #### Guardar los cambios 1205 | 1206 | Hay varias formas de guardar los cambios. Si queremos guardar los cambios pero continuar usando VIM, usaremos la combinación de teclas **ESC :w**, verás que se muestra **:w** en la barra de estado. Pulsa Enter para introducir la secuencia. El **[+]** desaparecerá, indicando que ya no hay nuevos cambios sin guardar. En la barra de estado verás que se muestra el mismo tipo de mensaje que antes y al final hay una nueva palabra __written__ indicándonos que se han escrito los cambios en el archivo. 1207 | 1208 | Si quieres guardar los cambios y cerrar VIM, en lugar de **:w**, debes utilizar **:x** 1209 | 1210 | #### Salir de VIM 1211 | 1212 | Si no hay cambios pendientes en el archivo, puedes cerrar VIM utilizando **:q**. Recuerda que no debes estar en el modo __insercion__, si estás en ese modo, en su lugar acabarás escribiendo el texto ":q" en el documento. 1213 | 1214 | Si tienes cambios en el documento pero quieres salir de todas formas y descartar los cambios que hiciste, debes introducir **:q!**. Solo se descartarán los cambios que no guardases con **:w** 1215 | 1216 | #### Cifrar un archivo 1217 | Es posible cifrar un archivo utilizando **:X**. VIM te pedirá una contraseña y que repitas tu contraseña. Una vez cifrado debes guardar los cambios. Tras guardar los cambios, si no saliste de VIM en la barra de estado se te indicará el algoritmo de cifrado utilizado. En mi caso es **blowfish2**. 1218 | 1219 | #### Navegación 1220 | 1221 | En VIM puedes tocar sobre el texto del fichero para posicionar el cursor. Tras tener el cursor posicionado, se puede usar el caracter **i** para entrar en modo __insercion__ en el caracter en el que esté el cursor. Si quieres posicionarte para escribir delante de donde tienes el cursor utiliza **a** en lugar de **i** 1222 | 1223 | También puedes entrar en modo inserción al principio de la linea usando **I**, al inicio de la linea siguiente (añadiendo un salto de linea en el proceso) utilizando **o**, en la linea anterior (añadiendo un salto de linea en el proceso) utilizando **O**, en el caracter actual (eliminándolo en el proceso) utilizando **x** 1224 | 1225 | A parte de moverte tocando el texto e insertar usando teclas, también puedes moverte utilizando distintas teclas. Con **w** te mueves a la siguiente palabra, con **b** te mueves a la palabra anterior, con **e** te mueves al final de la palabra actual, con **$** te mueves al final de la linea actual, con **0** te mueves al inicio de la linea. 1226 | 1227 | Si quieres moverte a la linea anterior **k**, a la linea siguiente **j**, al caracter anterior **h**, al caracter siguiente **l**. Si añades un número antes de cualquiera de estas opciones the moverás la cantidad indicada de caracteres/lineas. 1228 | 1229 | Si quieres moverte al inicio del archivo **gg**, a la última linea del archivo **G**. Puedes ir a lineas concretas poniendo **:** y el número de la linea concreta a la que quires ir. Por ejemplo si quieres ir a la tercera linea del fichero **:3** y pulsas enter. 1230 | 1231 | #### Eliminar contenido 1232 | 1233 | También puedes eliminar palabras, lineas, caracteres o partes concretas del archivo. Los comandos son los mismos que los de mover el cursor, pero anteponiendo **d**. Ejemplos: 1234 | 1235 | ```bash 1236 | # Recuerda que estos son comentarios, y su única finalidad es que tu los leas 1237 | 1238 | dd # Eliminar la linea en la que está el cursor 1239 | d$ # Eliminar desde el cursor hasta el final de la linea 1240 | d0 # Eliminar desde el cursor hasta el inicio de la linea 1241 | dw # Eliminar desde el cursor hasta el final de la palabra 1242 | dgg # Eliminar desde el cursor hasta el inicio del archivo 1243 | dG # Eliminar desde el cursor hasta el final del archivo 1244 | d16 # Eliminar desde el cursor 16 lineas 1245 | ``` 1246 | 1247 | #### Substituir texto 1248 | 1249 | En VIM se pueden substituir todas las palabras de un texto de forma sencilla usando expresiones regulares. Si quieres substituir todas las palabras que digan "hola" por "adios", utilizas el comando 1250 | ```bash 1251 | :%s/hola/adios/g # substituye todos los hola por adios 1252 | :%s/hola/adios/gi # substituye todos los hola por adios aunque tengan mayúsculas 1253 | ``` 1254 | 1255 | > Cuando la palabra/texto tenga caracteres especiales, debes __escaparlos__ usando la barra de escape **\\**. 1256 | 1257 | A veces nos equivocamos y queremos deshacer las últimas acciones, para ello puedes usar **u**. También puedes rehacer los cambios que hayas eliminado con **u** utilizando **CTRL r**. Si cierras VIM, se perderá el historial y no podrás deshacer ni rehacer. 1258 | 1259 | #### Modo Visual 1260 | 1261 | A parte del modo __comando__ que estamos usando y del modo __inserción__, también hay un modo visual al que podemos acceder desde el modo __comando__ pulsando **v**. 1262 | 1263 | Una vez estás en el modo visual, podras mover el cursor con las teclas para remarcar un texto. Una vez tienes el texto marcado puedes realizar múltiples acciones sobre él. 1264 | ```bash 1265 | y # Copia el texto seleccionado 1266 | p # Pega el texto 1267 | x # Corta el texto seleccionado 1268 | > # Añade identación a las lineas (espacios) 1269 | < # Quita identación a las lineas (espacios) 1270 | u # Convierte a minúsculas 1271 | U # Convierte a mayúsculas 1272 | ``` 1273 | 1274 | > También puedes substituir palabras del texto seleccionado usando expresiones regulares 1275 | 1276 | #### Manejo de ventanas y pestañas 1277 | 1278 | En VIM también puedes abrir múltiples ventanas con la combinación **CTRL w v**. Cada vez que pulses esta combinación, abrirás una ventana nueva. Si prefieres que la ventana se abra debajo de la actual en lugar de al lado, utiliza **CTRL w s**. Puedes combinarlas y tener ambos tipos de ventanas abiertas a la vez. 1279 | 1280 | Puedes modificar el ancho de la ventana usando **CTRL w >** para aumentar su ancho o **CTRL w <** para reducirlo. 1281 | 1282 | Puedes modificar la altura de la ventana usando **CTRL w +** para aumentarla o **CTRL w -** para reducirla. 1283 | 1284 | Si vas a cerrar el archivo actual, para abrir otro distinto, en su lugar puedes hacer directamente **:open nombreDelArchivo.txt**, sirve tanto para nuevos archivos, como para archivos que ya existen. 1285 | 1286 | Otra opción para abrir un nuevo archivo, esta vez, sin cerrar el actual es **:e nombreDelArchivo.txt**. Puedes cambiar entre archivos utilizando **:bn** y **:bN** 1287 | 1288 | La opción **:tabnew ejemplo.txt** sirve para abrir el archivo indicado en una nueva pestaña. Puedes moverte entre las pestañas abiertas utilizando **:b#** 1289 | 1290 | #### Realizar búsquedas 1291 | 1292 | Puedes buscar palabras si pones una **/**. Ejemplo: 1293 | ```bash 1294 | /hola 1295 | ``` 1296 | 1297 | Una vez tengas tu palabra resaltada, puedes fijarla usando enter. Al estar la búsqueda fija, podras moverte a la siguiente palabra que cumpla tu búsqueda utilizando el caracter **n** o a la anterior utilizando **N** 1298 | 1299 | 1300 | [Tabla de Contenidos](#tabla-de-contenidos) 1301 | 1302 | ----- 1303 | 1304 | ## Capitulo 7: Configuración de Bash 1305 | Bash tiene múltiples opciones de configuración y hay varias formas de configurarlo dependiendo del sistema. En Termux lo configuraremos utilizando el archivo .bashrc. 1306 | 1307 | Este archivo debemos crearlo en la carpeta Home. Usaremos vim para ello. 1308 | ```bash 1309 | vim ~/.bashrc 1310 | ``` 1311 | 1312 | Todos los comandos que escribamos en este archivo se ejecutarán cada vez que iniciemos Termux, o cuando iniciemos una nueva pestaña de Termux. 1313 | 1314 | > Al final del capítulo veremos como activar todo lo que tengamos en el archivo sin necesidad de abrir una nueva terminal, para poder visualizar los cambios directamente en la terminal actual. 1315 | 1316 | Lo primero será añadir el siguiente texto en el archivo: 1317 | ```bash 1318 | # Si Bash no es interactivo, detiene la lectura de este archivo 1319 | case $- in 1320 | *i*) 1321 | ;; 1322 | 1323 | *) 1324 | return 1325 | ;; 1326 | esac 1327 | ``` 1328 | 1329 | Este pequeño script/código sirve para que no se configuren las terminales de Bash que no sean interactivas. Esto sirve para evitar que se configure Bash cuando lo utilizemos para correr un comando. Por ejemplo **bash miArchivo.sh**. En el [capítulo 9: Creando comandos](#cap%C3%ADtulo-9-creando-comandos) lo entenderás mejor. 1330 | 1331 | ##### EDITOR 1332 | La variable "$EDITOR" sirve para configurar un editor de texto como editor por defecto de Bash. 1333 | ```bash 1334 | export EDITOR='vim' 1335 | ``` 1336 | 1337 | Al exportar la variable __"$EDITOR"__ indicando que se use **vim**, podremos editar los comandos que estamos escribiendo en la terminal usando la combinación de teclas **CTRL X CTRL E**. 1338 | 1339 | ##### histappend 1340 | El argumento __histappend__ sirve para que el historial se comparta entre pestañas, ventanas y sesiones. Nos servirá para asegurarnos que si abrimos una nueva terminal, tengamos accesible el historial, permitiéndonos reutilizar los comandos sin tener que escribirlos de 0. Si lo quieres activar añádelo a una nueva linea: 1341 | ```bash 1342 | shopt -s histappend 1343 | ``` 1344 | 1345 | ##### checkwinsize 1346 | El argumento __checkwinsize__ hará comprobaciones automáticas tras dar o quitar zoom en Termux para ajustar las filas y columnas de las tablas que tengamos impresas en pantalla. 1347 | ```bash 1348 | shopt -s checkwinsize 1349 | ``` 1350 | 1351 | ##### autocd 1352 | El argumento __autocd__ nos permite omitir cd para entrar en carpetas. Es útil para todas aquellas carpetas que no compartan nombre con comandos instalados. 1353 | ```bash 1354 | shopt -s autocd 1355 | ``` 1356 | 1357 | Con este opción, si tienes una carpeta que se llama fotos, en lugar de escribir **cd fotos** para entrar en ella, podrás escribir directamente **fotos**. Si por ejemplo nombrases a tu carpeta **ls**, entonces no funcionaría porque estarías corriendo el comando **ls** en lugar de ingresar a la carpeta ls. 1358 | 1359 | ##### cdable_vars 1360 | El argumento __cdable_vars__ te permitirá utilizar cd con variables si el nombre de la variable no coincide con el de una carpeta a la que puedes hacer cd. 1361 | ```bash 1362 | shopt -s cdable_vars 1363 | ``` 1364 | 1365 | Cuando activemos el archivo __.bashrc__, podremos hacer lo siguiente para ir a la carpeta __ejemplo__ (si esta existe en HOME) desde cualquier lugar. 1366 | ```bash 1367 | EJEMPLO=/data/data/com.termux/files/home/ejemplo 1368 | cd EJEMPLO 1369 | ``` 1370 | 1371 | Si existiese una carpeta llamada __EJEMPLO__, **cd** entraría dentro de esta, si no existe es entonces cuando se comprobaría si **$EJEMPLO** existe y se haría **cd** a la ruta que tenga esta variable. 1372 | 1373 | 1374 | ##### cdspell 1375 | El argumento __cdspell__ te permitirá utiliza cd sobre archivos cuando cometas pequeños errores ortograficos. Si tienes una carpeta que se llama __ejemplo__ y escribes por error **cd ejemplos** Bash te corregirá el error automáticamente. 1376 | ```bash 1377 | shopt -s cdspell 1378 | ``` 1379 | 1380 | ##### globstar 1381 | El argumento __globstar__ te permitirá utilizar **\*\*** para referenciar todos los archivos en el directorio y subdirectorios referenciados 1382 | ```bash 1383 | shopt -s globstar 1384 | ``` 1385 | 1386 | Con un ejemplo se entiende mejor. Digamos que tenemos la siguiente estructura de archivos: 1387 | ```bash 1388 | test/ 1389 | ├── adios.txt 1390 | ├── carpeta 1391 | │   └── numeros.txt 1392 | └── hola.txt 1393 | ``` 1394 | 1395 | Si utilizamos el comando **cat test/\*\*** sin tener __globstar__ activado, se imprimirá: 1396 | ```bash 1397 | adios 1398 | cat: test/carpeta: Is a directory 1399 | hola 1400 | ``` 1401 | 1402 | Si hemos activado __globstar__, el resultado será: 1403 | ```bash 1404 | cat: test/: Is a directory 1405 | adios 1406 | cat: test/carpeta: Is a directory 1407 | 1 1408 | 2 1409 | 3 1410 | hola 1411 | ``` 1412 | 1413 | 1414 | ##### addPath 1415 | La función **addPath** nos será útil en el capìtulo 9, añádela también a este archivo. Sirve para indicarle a Bash en que carpetas tenemos comandos. 1416 | ```bash 1417 | addPath() { 1418 | if [ -d "$1" ] && [[ ":$PATH:" != *":$1:"* ]]; then 1419 | PATH="${PATH:+"$PATH:"}$1"; 1420 | fi 1421 | } 1422 | ``` 1423 | 1424 | ##### extract 1425 | La función **extract** comprueba la extensión de un archivo comprimido y lo descomprime como corresponda según la extensión detectada 1426 | ```bash 1427 | extract() { 1428 | for archive in $*; do 1429 | if [ -f $archive ]; then 1430 | case $archive in 1431 | *.tar.bz2) 1432 | tar xvjf $archive 1433 | ;; 1434 | 1435 | *.tar.gz) 1436 | tar xvzf $archive 1437 | ;; 1438 | 1439 | *.bz2) 1440 | bunzip2 $archive 1441 | ;; 1442 | 1443 | *.rar) 1444 | rar x $archive 1445 | ;; 1446 | 1447 | *.gz) 1448 | gunzip $archive 1449 | ;; 1450 | 1451 | *.tar) 1452 | tar xvf $archive 1453 | ;; 1454 | 1455 | *.tbz2) 1456 | tar xvjf $archive 1457 | ;; 1458 | 1459 | *.tgz) 1460 | tar xvzf $archive 1461 | ;; 1462 | 1463 | *.zip) 1464 | unzip $archive 1465 | ;; 1466 | 1467 | *.Z) 1468 | uncompress $archive 1469 | ;; 1470 | 1471 | *.7z) 1472 | b7z x $archive 1473 | ;; 1474 | 1475 | *) 1476 | echo "don't know how to extract $archive..." 1477 | ;; 1478 | esac 1479 | else 1480 | echo "$archive is not a valid file!" 1481 | fi 1482 | done 1483 | } 1484 | ``` 1485 | 1486 | ##### alias 1487 | En este archivo también podrás crear alias, que sirven para poder llamar a otros comando o carpetas utilizando nombres personalizados. Aquí un ejemplo con alias que sirven para añadir colores a algunos comandos. 1488 | ```bash 1489 | alias ls='ls --color=auto' 1490 | alias dir='dir --color=auto' 1491 | alias vdir='vdir --color=auto' 1492 | alias grep='grep --color=auto' 1493 | alias fgrep='fgrep --color=auto' 1494 | alias egrep='egrep --color=auto' 1495 | ``` 1496 | 1497 | Ahora cuando escribas el comando **ls**, Bash le añadirá el argumento __--color=auto__ de forma transparente. 1498 | 1499 | Mas alias útiles que suelo utilizar: 1500 | ```bash 1501 | alias l='ls' # Utiliza l en lugar de ls 1502 | alias la='ls -a' # Utiliza la para listar ficheros ocultos 1503 | alias v='vim' # Utiliza v en lugar de vim 1504 | alias c='clear' # Utiliza c en lugar de clear 1505 | alias cl='clear && ls' # Utiliza cl para limpisr la pantalla y listar 1506 | alias ..='cd ..' # Muevete a la carpeta 1 nivel superior 1507 | alias ...='cd ../..' # Muevete a la carpeta 2 niveles superior 1508 | alias ....='cd ../../..' # Muevete a la carpeta 3 niveles superior 1509 | alias .....='cd ../../../..' # Muevete a la carpeta 4 niveles superiores 1510 | alias pserv='python -m http.server' # Sirve la carpeta actual 1511 | alias gitc='"'"'git clone'"'"' # Clona un repositorio 1512 | alias 775='"'"'chmod +775'"'"' # Da permisos de ejecución 1513 | alias folder='du -h --max-depth=1' # Muestra el tamaño de ficheros 1514 | alias h='history' # Muestra el historial 1515 | alias myip='curl http://ifconfig.me/ip' # Muestra tu ip pública 1516 | alias quit='exit' # Cierra la terminal 1517 | alias q='exit' # Cierra la terminal 1518 | alias sb='source ~/.bashrc' # Actualiza los cambios en el archivo de Bash 1519 | ``` 1520 | 1521 | 1522 | ##### colores 1523 | Exportar variables que guarden colores nos será muy útil. Por ejemplo para usarlos con echo u otros comandos. 1524 | ```bash 1525 | export red=$'\e[1;31m' # rojo 1526 | export green=$'\e[1;32m' # verde 1527 | export yellow=$'\e[1;33m' # amarillo 1528 | export blue=$'\e[1;34m' # azul 1529 | export cyan=$'\e[1;35m' # cian 1530 | export white=$'\e[1;37m' # blanco 1531 | export endc=$'\e[0m' # finaliza el color (color normal) 1532 | export lightgray=$'\e[0;37m' # gris claro 1533 | export black=$'\e[0;30m' # negro 1534 | export darkgray=$'\e[1;30m' # gris oscuro 1535 | export darkred=$'\e[0;31m' # rojo oscuro 1536 | export darkgreen=$'\e[0;32m' # verde oscuro 1537 | export darkyellow=$'\e[0;33m' # amarillo oscuro 1538 | export darkblue=$'\e[0;34m' # azul oscuro 1539 | export magenta=$'\e[0;35m' # magenta 1540 | export darkcyan=$'\e[0;36m' # cian oscuro 1541 | export underlinedarkgray=$'\e[0;30m' # subrayado gris oscuro 1542 | ``` 1543 | 1544 | Ahora podemos usar los colores, por ejemplo para resaltar palabras de los manuales: 1545 | ```bash 1546 | export LESS_TERMCAP_mb=${green}; 1547 | export LESS_TERMCAP_md=${green}; 1548 | ``` 1549 | 1550 | > Estos colores se aplicarán a las páginas mostradas por el comando **man** 1551 | 1552 | ##### prompts 1553 | La prompt de la terminal en Termux solo muestra un dolar. Podemos usar distintos comandos para configurarla. Ya sea por utilidad o por estética. Aquí tienes el código de mi prompt: 1554 | ```bash 1555 | PS1='\n\n${underlinedarkgray}${darkgray}(${blue}$(date +%H${darkgray}:${blue}%M${darkgray}:${blue}%S${darkgray}:${blue}%4N)${darkgray}) ${green}$(pwd)${endc}\n> ' 1556 | PS2='${blue}.${endc} ' 1557 | ``` 1558 | ![Prompt de Bash, ps1](https://github.com/StringManolo/hackingTermux101/raw/master/imagenes/ps1.jpg) 1559 | 1560 | Como ves, esta prompt pinta la fecha, la hora, minutos, segundos... y el directorio actual de trabajo. Así sabes siempre en que carpeta te encuentras sin necesidad de recurrir al comando **pwd** directamente. 1561 | 1562 | Para que se apliquen inmediatamente todos los cambios usaremos el comando **source** 1563 | ```bash 1564 | source ~/.bashrc 1565 | ``` 1566 | 1567 | [Tabla de Contenidos](#tabla-de-contenidos) 1568 | 1569 | ----- 1570 | 1571 | ## Capítulo 8: Sistema de Ficheros 1572 | En Termux así como en GNU/Linux, disponemos de un sistema base que incluye múltiples archivos y carpetas. Vamos a conocer mejor la estuctura del sistema de ficheros de Termux. (Puede variar un poco entre versiones) 1573 | 1574 | ###### com.termux/ 1575 | Carpeta privada de la app Termux 1576 | 1577 | ###### com.termux/files/ 1578 | Archivos de la aplicación 1579 | 1580 | ###### com.termux/files/home/ 1581 | Carpeta principal del usuario 1582 | 1583 | ###### com.termux/files/home/.termux/ 1584 | Archivos de configuración de la app como atajos de teclado de Termux 1585 | 1586 | ###### com.termux/files/home/.termux/termux.properties 1587 | Archivo con la configuración de la app de Termux. Atajos y ajustes de teclado, modo pantalla completa, etc. Corre el comando termux-reload-settings para aplicar los cambios sin necesidad de reiniciar la app. 1588 | 1589 | ###### com.termux/files/home/storage/ 1590 | Se activa con el comando termux-setup-storage y te permite acceder a los archivos internos del dispositivo. 1591 | 1592 | ###### com.termux/files/home/storage/dcim/ 1593 | La usa la cámara para guardas las fotografías de la cámara 1594 | 1595 | ###### com.termux/files/home/storage/downloads/ 1596 | Carpeta por defecto de Android para descargas 1597 | 1598 | ###### com.termux/files/home/storage/movies/ 1599 | Carpeta para almacenar los videos del dispositivo 1600 | 1601 | ###### com.termux/files/home/storage/music/ 1602 | La música se puede almacenar aquì 1603 | 1604 | ###### com.termux/files/home/storage/pictures/ 1605 | Las imágenes del dispositivo se pueden guardar aquí 1606 | 1607 | ###### com.termux/files/home/storage/shared/ 1608 | Carpeta compartida de propósito general para todas las apps 1609 | 1610 | ###### com.termux/files/usr/ 1611 | Imita la carpeta / de GNU/Linux 1612 | 1613 | ###### com.termux/files/usr/bin/ 1614 | Carpeta principal para ejecutables/comandos de Termux 1615 | 1616 | ###### com.termux/files/usr/etc/ 1617 | Archivos de configuración diversos relacionados con el sistema o programas 1618 | 1619 | ###### com.termux/files/usr/etc/alternatives 1620 | Selecciona los ejecutables por defecto para trabajar con ciertos tipos de archivos. Por ejemplo el enlace directo al editor de texto de Termux por defecto. 1621 | 1622 | ###### com.termux/files/usr/etc/apt/ 1623 | Archivos del gestor de paquetes APT 1624 | 1625 | ###### com.termux/files/usr/etc/apt/apt.conf.d 1626 | Archivos de configuración de APT 1627 | 1628 | ###### com.termux/files/usr/etc/apt/preferences.d 1629 | Archivos para configurar las preferencias de APT, por ejemplo si quieres priorizar que se descarge la versión mas reciente de los paquetes por defecto, priorizar que se descargen los paquetes estables, .... 1630 | 1631 | ###### com.termux/files/usr/etc/apt/sources.list 1632 | Este es un archivo de configuración de APT (el sistema de gestión de paquetes de Debian) que indica a APT dónde buscar paquetes para instalar. En este caso, se refiere a los repositorios que se pueden usar en Termux. 1633 | 1634 | ###### com.termux/files/usr/etc/apt/trusted.gpg 1635 | Archivo de claves públicas utilizados por APT para verificar la autenticidad de los paquetes descargados de los repositorios. trusted.gpg contiene las claves de confianza que se aplican a todos los repositorios. 1636 | 1637 | ###### com.termux/files/usr/etc/apt/trusted.gpg.d 1638 | Trusted.gpg.d es un directorio que contiene archivos adicionales de claves de confianza para repositorios específicos. 1639 | 1640 | ###### com.termux/files/usr/etc/bash.bashrc 1641 | Este es un archivo de configuración de shell de Bash, que se ejecuta cada vez que se inicia una sesión de Bash en Termux. Aquí se pueden agregar alias, variables de entorno y otras configuraciones personalizadas para Bash. 1642 | 1643 | ###### com.termux/files/usr/etc/bindresvport.blacklist 1644 | Se utiliza para especificar los puertos que deben evitarse al enlazar un socket en el sistema. Los puertos incluidos en este archivo son los que están reservados por el sistema operativo y no deben ser utilizados por aplicaciones normales, ya que pueden causar conflictos con otros servicios del sistema. El archivo puede ser editado para agregar o quitar puertos de la lista negra según sea necesario. 1645 | 1646 | 1647 | ###### com.termux/files/usr/etc/inputrc 1648 | Este es un archivo de configuración de readline, que controla el comportamiento de la entrada de texto en la línea de comandos. Aquí se pueden configurar atajos de teclado y otras opciones relacionadas con la entrada de texto. 1649 | 1650 | ###### com.termux/files/usr/etc/motd 1651 | Archivo de mensaje de bienvenida que se muestra al iniciar sesión en la terminal. 1652 | 1653 | ###### com.termux/files/usr/etc/motd-playstore 1654 | Archivo de mensaje de bienvenida que se muestra solo cuando se instala Termux desde Google Play Store. 1655 | 1656 | ###### com.termux/files/usr/etc/nanorc 1657 | Archivo de configuración utilizado por el editor de texto "Nano" que contiene configuraciones para personalizar la interfaz de usuario y las funciones del editor de texto Nano, como el color del texto, los atajos de teclado, el número de espacios por tabulación y mucho más. 1658 | 1659 | ###### com.termux/files/usr/etc/netconfig 1660 | Este archivo es utilizado por los programas que necesitan acceder a la red, como los navegadores web o los clientes de correo electrónico, para determinar cómo conectarse a Internet y cómo acceder a los servicios de red. El archivo netconfig también puede contener información sobre la configuración de proxy y otras opciones de red. 1661 | 1662 | ###### com.termux/files/usr/etc/profile 1663 | Archivo de configuración de shell que se ejecuta cada vez que se inicia una sesión de shell en Termux. profile es el archivo de configuración principal. 1664 | 1665 | ###### com.termux/files/usr/etc/profile.d 1666 | Directorio que contiene archivos de configuración adicionales que se ejecutan después de profile. 1667 | 1668 | ###### com.termux/files/usr/etc/profile.d/gawk.csh 1669 | Este archivo es parte del paquete "gawk" y contiene configuraciones de variables de entorno específicas de la aplicación gawk. Es ejecutado automáticamente cuando se inicia el shell de Termux y se carga la aplicación gawk. La función de este archivo es establecer variables de entorno para la aplicación, lo que permite que el software funcione correctamente. 1670 | 1671 | ###### com.termux/files/usr/etc/profile.d/gawk.sh 1672 | Este archivo agrega algunas configuraciones específicas para el programa gawk en la variable de entorno PATH, que es la ruta de búsqueda para los ejecutables. En concreto, agrega el directorio /data/data/com.termux/files/usr/bin al principio de la ruta de búsqueda y luego exporta la variable AWK para que apunte al programa gawk. Esto permite que gawk se ejecute directamente desde la línea de comandos sin tener que proporcionar la ruta completa al ejecutable. 1673 | 1674 | ###### com.termux/files/usr/etc/profile.d/init-termux-properties.sh 1675 | Script de shell que se ejecuta automáticamente cada vez que se inicia una sesión de terminal en Termux. Este script se utiliza para establecer algunas propiedades de Termux, como el color de la terminal, el comportamiento del teclado, el directorio de trabajo predeterminado, etc. 1676 | 1677 | ###### com.termux/files/usr/etc/termux-login.sh 1678 | Script de inicio de sesión que se ejecuta al iniciar sesión en la aplicación Termux en un dispositivo Android. Este archivo permite personalizar el inicio de sesión de Termux y configurar variables de entorno adicionales, aliases y otras opciones personalizadas. Por ejemplo, se puede agregar un mensaje personalizado o mostrar información sobre la versión de Termux instalada en el dispositivo. 1679 | 1680 | ###### com.termux/files/usr/etc/tls 1681 | Este es un directorio que contiene archivos de configuración relacionados con TLS (Transport Layer Security), que se utiliza para cifrar las comunicaciones de red. 1682 | 1683 | ###### com.termux/files/usr/etc/tls/cert.pem 1684 | Archivo de certificado de seguridad que se utiliza para autenticar la identidad de otros sistemas en la red. 1685 | 1686 | ###### com.termux/files/usr/etc/tls/openssl.cnf 1687 | Archivo de configuración para OpenSSL, que es una biblioteca de cifrado utilizada por muchos programas de línea de comandos. 1688 | 1689 | ###### com.termux/files/usr/etc/unbound 1690 | Directorio que contiene archivos de configuración para el servidor DNS Unbound, que se utiliza para resolver nombres de dominio en direcciones IP. 1691 | 1692 | ###### com.termux/files/usr/etc/unbound/unbound.conf 1693 | Archivo de configuración principal de Unbound. 1694 | 1695 | ###### com.termux/files/usr/include 1696 | Generalmente contiene los archivos de cabecera (header files) de bibliotecas C que se utilizan para compilar aplicaciones en Termux. Estos archivos proporcionan las declaraciones de funciones y estructuras necesarias para que las aplicaciones se comuniquen con las bibliotecas. Las bibliotecas C son componentes esenciales del sistema operativo y proporcionan una variedad de funcionalidades, desde la gestión de archivos hasta el procesamiento de imágenes. 1697 | 1698 | ###### com.termux/files/usr/lib 1699 | Carpeta donde se almacenan las bibliotecas compartidas de programas instalados en Termux. Las bibliotecas compartidas son fragmentos de código que pueden ser utilizados por diferentes programas, en lugar de tener que escribir el mismo código repetidamente en cada programa. 1700 | 1701 | ###### com.termux/files/usr/libexec 1702 | Contiene archivos ejecutables que son utilizados por otros programas del sistema. En general, los archivos que se encuentran en esta carpeta no son ejecutables de forma independiente, sino que son llamados por otros programas cuando se necesitan realizar ciertas tareas específicas. 1703 | 1704 | ###### com.termux/files/usr/opt 1705 | Directorio de instalación opcional para aplicaciones adicionales que no son necesarias para el funcionamiento básico de Termux. Esta carpeta se usa para instalar paquetes y software adicionales que no se encuentran en los repositorios predeterminados de Termux. Los programas instalados en esta carpeta a menudo necesitan configuración adicional para funcionar correctamente en Termux. 1706 | 1707 | ###### com.termux/files/usr/share 1708 | Contiene una variedad de recursos compartidos que pueden ser utilizados por diferentes programas en el sistema. 1709 | 1710 | ###### com.termux/files/usr/tmp 1711 | Directorio donde se almacenan archivos temporales creados por diferentes programas y procesos en ejecución en el sistema. 1712 | 1713 | ###### com.termux/files/usr/var 1714 | Puede contener registros de actividades del sistema, archivos temporales, archivos de caché, bases de datos de aplicaciones, entre otros. 1715 | 1716 | 1717 | 1718 | 1719 | [Tabla de Contenidos](#tabla-de-contenidos) 1720 | 1721 | ----- 1722 | 1723 | ## Capítulo 9: Creando comandos 1724 | Los comandos de Bash pueden ser alias y funciones como ya vimos en el [capitulo 7: Configuración de Bash](#capitulo-7-configuraci%C3%B3n-de-bash). La forma mas común de crear comandos es creando un archivo con código Bash y añadir en la primera linea un shebang. Vamos a crear un archivo que solo diga "Hola". Ponle de nombre saludar con el comando **vim saludar**. 1725 | ```bash 1726 | #!/usr/bin/env bash 1727 | 1728 | echo "Hola" 1729 | ``` 1730 | 1731 | Para poder ejecutar el archivo debes darle permisos: 1732 | ```bash 1733 | chmod 775 saludar 1734 | ``` 1735 | 1736 | Si corres el comando **ls**, verás que saludar sale de color verde. Esto significa que tiene permisos de ejecución. Para correr ejecutables usaremos el comando **./saludar** 1737 | 1738 | Para poder utilizar el comando desde cualquier lugar del sistema debes mover el fichero s alguna de las carpetas listadas en la variable **"$PATH"**. Puedes imprimirla para ver el listado de carpetas. En este ejemplo, movemos el archivo a /bin, en Termux puedes correr el siguiente comando: 1739 | ```bash 1740 | mv saludar ~/../usr/bin 1741 | ``` 1742 | 1743 | Ahora puedes ejecutar el comando saludar desde cualquier lugar y omitiendo el **./** 1744 | ```bash 1745 | saludar 1746 | ``` 1747 | 1748 | La gran mayoría de veces que creemos comandos, querremos aceptar argumentos. Vamos a añadir funcionalidad a nuestro comando saludar. Puedes remplazar el contenido de saludar con el comando **vim ~/../usr/bin/saludar**, por el siguiente: 1749 | ```bash 1750 | #!/usr/bin/env bash 1751 | 1752 | argumentos="help,name:" 1753 | argumentosSimples="hn:" 1754 | 1755 | procesados=$(getopt --options=$argumentosSimples --longoptions=$argumentos --name "$0" -- "$@") 1756 | 1757 | ayuda() { 1758 | echo -e "This commands says hi in spanish\nExample: saludar --name Manolo\n"; 1759 | exit 1760 | } 1761 | 1762 | while true; do 1763 | case "$1" in 1764 | -h | --help) 1765 | ayuda; 1766 | shift 1767 | ;; 1768 | 1769 | -n | --name) 1770 | name="$2" 1771 | shift 2 1772 | ;; 1773 | 1774 | --) 1775 | shift 1776 | break 1777 | ;; 1778 | 1779 | *) 1780 | echo "Error" 1781 | exit 3 1782 | ;; 1783 | esac 1784 | done 1785 | 1786 | if [ -n "$name" ]; then 1787 | echo "Hola $name" 1788 | else 1789 | echo "Hola" 1790 | fi 1791 | ``` 1792 | 1793 | Esta sería la forma mas completa para poder procesar argumentos en Bash. Si corres el comando **saludar**, verás que te dice __Hola__. Ahora también acepta varios argumentos. Por ejemplo el argumento name (nombre en español). **saludar --name Manolo** y también el argumento **--help**. Ambos argumentos admiten su versión cortas **-n**, **-h** respectivamente. 1794 | 1795 | 1796 | Explicación del código: 1797 | ```bash 1798 | #!/usr/bin/env bash 1799 | ``` 1800 | El shebang sirve para indicar a la consola que tipo de programa es. En este caso un binario de Bash. Si utilizases código Python o cualquier otro lenguaje, podrías remplazar **bash** por python o el ejecutable que correspondiese. En este caso usamos lenguaje **Bash**, asique indicamos __bash__ en el shebang. 1801 | 1802 | ```bash 1803 | argumentos="help,name:" 1804 | ``` 1805 | En la variable **$argumentos** almacenamos una lista de argumentos léxicos separados por comas. Si quieres que uno de los argumentos acepte texto del usuario debes añadirle **:**. Por ejemplo **argumentos="nombre:,edad:,ayuda,domicilio:** acepta texto para los argumentos nombre, edad y domicilio. 1806 | 1807 | ```bash 1808 | argumentosSimples="hn:" 1809 | ``` 1810 | En la variable **$argumentosSimples** almacenamos una lista (sin comas) de argumentos simples. Por ejemplo **n:e:ad:** serían los argumentos cortos para nombre, edad, ayuda y domicilio. 1811 | 1812 | ```bash 1813 | procesados=$(getopt --options=$argumentosSimples --longoptions=$argumentos --name "$0" -- "$@") 1814 | ``` 1815 | En la variable procesados almacenamos el resultado de ejecutar el comando **getopt**. Este comando sirve para procesar argumentos en Bash. 1816 | A **getopt** le pasamos los argumentos que hemos guardado previamente para que los procese. 1817 | 1818 | El argumento --name de **getopt** sirve para indicarle a **getopt** el nombre de nuestro comando. En este caso utilizamos la variable **"$0"**. 1819 | 1820 | > La variable **$0** almacena el primer argumento de la terminal (separado por espacios). Si por ejemplo corremos el comando **saludar --nombre manolo** tendríamos "saludar" en **$0**, --nombre en **$1** y manolo en **$2**. En los comandos/scripts/archivos de Bash, asi como en funciones, también disponemos de la variable **$#** que contiene el número de argumentos del comando. 1821 | 1822 | > En el caso de **saludar --nombre manolo** la variable "$#" imprime 2. (El nombre del comando no se cuenta, ya que **$#** solo imprime el número de argumentos. Si usases el comando **bash ./saludar --nombre manolo** también se omitiría el comando **bash**. 1823 | 1824 | > La variable "$@" contiene todos los argumentos. Al igual que en **$#** se omite el nombre del comando. 1825 | 1826 | Dentro del **switch case** verás 3 comandos nuevos. **shift**, **break** y **exit**: 1827 | ##### shift 1828 | El comando **shift** permite "avanzar" el nùmero indicado de argumentos. Si por ejemplo tenemos el comando **saludar hola que tal estas**, detectamos el argumento __hola__ en un case y ejecutamos shift, se avanza hacia el argumento __que__. Si ponemos **shift 2**, avanzamos hasta el argumento __tal__, y asì sucesivamente. Esto nos permite ignorar elementos en un bucle. 1829 | 1830 | ##### break 1831 | El comando **break** nos permite finalizar un bucle sin dejarlo terminar de ejecutarse como haría normalmente, asì podremos avanzar en el programa cancelando el resto de iteraciones del bucle. 1832 | 1833 | ##### exit 1834 | El comando exit utilizando dentro de un script, nos permite indicar que queremos que se finalice el programa inmediatamente y el comando enviará una señal de cierre a **Bash**. 1835 | 1836 | El resto del código que queda por analizar ya lo vimos en ejemplos similares en el [capítulo 5: Introducción a Bash](#cap%C3%ADtulo-5-introducci%C3%B3n-a-bash). 1837 | 1838 | Bash es un lenguaje pontente y no existe una única forma de hacer las cosas. Puedes parsear los argumentos perfectamente usando un bucle for y recorriendo los argumentos 1839 | ```bash 1840 | #!/usr/bin/bash 1841 | 1842 | for (( i=1; i <= "$#"; i++ )) do # bucle for clásico 1843 | next=$((i+1)) # Guarda el siguiente argumento en la variable next 1844 | if [[ ${!i} == "-h" || ${!i} == "--help" ]]; then # Si el argumento es -h o --help 1845 | echo "Este es el mansaje de ayuda" 1846 | exit 1847 | elif [[ ${!i} == "-n" || ${!i} == "--name" ]]; then 1848 | echo "Hola ${!next}" 1849 | exit 1850 | fi 1851 | done 1852 | ``` 1853 | 1854 | Esta forma de hacer el mismo comando **saludar** tiene la deventaja de que no puede procesar múltiples argumentos como **saludar -hn Manolo**, pero tiene la ventaja de que el código es mas corto. 1855 | 1856 | [Tabla de Contenidos](#tabla-de-contenidos) 1857 | 1858 | ----- 1859 | 1860 | ## Capítulo 10: Comandos Intermedios 1861 | Los sistemas GNU/Linux tiene una inmensidad de comandos distintos. Muchos de ellos vienen instalados por defecto y otros podremos descargarlos. En este capítulo prestaremos atención a los mas populares. 1862 | 1863 | 1864 | ### 7z 1865 | Comprime archivos en múltiples formatos con muy buena compresión. 1866 | 1867 | ### apt 1868 | Descarga paquetes de Gnu/Linux 1869 | 1870 | ### apt-get 1871 | Descarga paquetes de Gnu/Linux 1872 | 1873 | ### awk 1874 | Lenguaje de programación orientado al manejo de texto 1875 | 1876 | ### base64 1877 | Codifica o decodifica base64 1878 | 1879 | ### cal 1880 | Calendario 1881 | 1882 | ### clang 1883 | Compilador de C/C++/Objective C 1884 | 1885 | ### curl 1886 | Cliente de múltiples protolos. Principalmente utilizado por su capacidad como cliente HTTP 1887 | 1888 | ### dialog 1889 | Utiliza diálogos en la terminal 1890 | 1891 | ### dig 1892 | Consulta los registro DNS de un dominio 1893 | 1894 | ### dpkg 1895 | Gestor de paquetes de Debian 1896 | 1897 | ### espeak 1898 | Comando text-to-speach que reproduce el texto en el altavoz o crea un archivo reproducible 1899 | 1900 | ### figlet 1901 | Crea textos grandes a base de caracteres. 1902 | 1903 | ### find 1904 | Busca archivos en sistema de ficheros 1905 | 1906 | ### file 1907 | Mueatra meta información a cerca de ub fichero. 1908 | 1909 | ### gcc 1910 | Compila un programa escrito en C 1911 | 1912 | ### g++ 1913 | Compila un programa escrito en C++ 1914 | 1915 | ### gdb 1916 | Debuger para encontrar erroes en programas 1917 | 1918 | ### gh 1919 | Utiliza github en la terminal 1920 | 1921 | ### git 1922 | Maneja repositorios 1923 | 1924 | ### grep 1925 | Encuentra palabras y patrones en un texto 1926 | 1927 | ### go 1928 | Compila un programa escrito en Go 1929 | 1930 | ### gotty 1931 | Comparte tu terminal para que otras personas puede ver lo mismo que tú 1932 | 1933 | ### gzip 1934 | Comprime y descomprime archivos con extensión .z 1935 | 1936 | ### head 1937 | Muestra solo el número indicado de caracteres 1938 | 1939 | ### htop 1940 | Muestra información sobre procesos 1941 | 1942 | ### httping 1943 | Mide la latencia de un servidor web/http 1944 | 1945 | ### hugo 1946 | Generador de sitios estáticos 1947 | 1948 | ### iverilog 1949 | Lenguaje de programación para modelado de circuitos electrónicos 1950 | 1951 | ### jq 1952 | Comando para parsear JSON 1953 | 1954 | ### less 1955 | Abre archivos muy grandes rápidamente cargándolo en bloques 1956 | 1957 | ### lighttpd 1958 | Servidor web rápido, pequeño y flexible 1959 | 1960 | ### lua 1961 | Ejecuta código lua 1962 | 1963 | ### luarocks 1964 | Instala módulos de lua 1965 | 1966 | ### logcat 1967 | Accede al registro de mensajes de Android para debuggear aplicaciones 1968 | 1969 | ### lynx 1970 | Navegador Web de terminal 1971 | 1972 | ### make 1973 | Compila proyectos 1974 | 1975 | ### md5sum 1976 | Obten un hash (utilizando el algoritmo md5) de un archivo/texto 1977 | 1978 | ### more 1979 | Muestra texto en pantalla, facilita la navegación 1980 | 1981 | ### mongodb 1982 | Base de datos NoSQL 1983 | 1984 | ### mono 1985 | Compila C# en GNU/Linux 1986 | 1987 | ### mpg123 1988 | Reproductor de música 1989 | 1990 | ### nc 1991 | Herramienta con múltiples utiidades de red integradas 1992 | 1993 | ### netlify 1994 | Maneja la creación de sitios web en netlify 1995 | 1996 | ### nmap 1997 | Escaner de puertos de red 1998 | 1999 | ### ncat 2000 | Versión mejorada de nc, se instala conjuntamente a nmap 2001 | 2002 | ### nginx 2003 | Servidor Web y proxy web muy completo. 2004 | 2005 | ### ngrok 2006 | Comparte tus servicios sin abrir puertos 2007 | 2008 | ### nodejs 2009 | Ejecuta código javascript y crea aplicaciones de todo tipo. 2010 | 2011 | ### npm 2012 | Instala paquetes de node 2013 | 2014 | ### openssl 2015 | Suit de algorimtos criptográficos 2016 | 2017 | ### openvpn 2018 | Establece un tunel VPN 2019 | 2020 | ### perl 2021 | Intérprete del lenguaje de programación Perl 2022 | 2023 | ### php 2024 | Intérprete del lenguaje de programación PHP 2025 | 2026 | ### postgresql 2027 | Base de datos SQL 2028 | 2029 | ### pkill 2030 | Mata un proceso 2031 | 2032 | ### proot 2033 | Emula un entorno root 2034 | 2035 | ### proxychains-ng 2036 | Utiliza cadenas de proxies 2037 | 2038 | ### python 2039 | Intérprete del lenguaje python2 2040 | 2041 | ### python3 2042 | Intérprete del lenguaje python3 2043 | 2044 | ### qemu 2045 | Emula procesadores y sistemas operativos 2046 | 2047 | ### quickjs 2048 | Pequeño motor y librería de javascript 2049 | 2050 | ### radare2 2051 | Desensamblador, debugger y editor hexadecimal para trabajar con binarios 2052 | 2053 | ### ruby 2054 | Intérprete para el lenguaje de programación Ruby 2055 | 2056 | ### rust 2057 | Compilador código Rust 2058 | 2059 | ### scp 2060 | Copia y sube archivos utilizando un tunel SSH 2061 | 2062 | ### sed 2063 | Filtra y remplaza texto 2064 | 2065 | ### shasum 2066 | Obten un hash de un archivo/text utilizando sha 2067 | 2068 | ### ssh 2069 | Ingresa a máquinas remotas m 2070 | 2071 | ### steghide 2072 | Esconde texto en imágenes y audios 2073 | 2074 | ### strings 2075 | Imprime todo lo que pueda ser interpretado como texto de un archivo de bytes/caracteres 2076 | 2077 | ### sqlite 2078 | Pequeña y potente base de datos SQL 2079 | 2080 | ### tail 2081 | Muestra el final de un fichero o texto 2082 | 2083 | ### tar 2084 | Comprime y descomprime archivos en múltiples formatos 2085 | 2086 | ### top 2087 | Muestra un resumen de los procesos del sistema 2088 | 2089 | ### tor 2090 | Establece un circuito virtual en la red Tor. 2091 | 2092 | ### torsocks 2093 | Utiliza un comando con Tor. 2094 | 2095 | ### tsc 2096 | Compilador del lenguaje Typescript 2097 | 2098 | ### unrar 2099 | Comprime y descomprime archivos .rar 2100 | 2101 | ### unzip 2102 | Comprime y descomprime archivos .zip 2103 | 2104 | ### which 2105 | Muestra la ruta de instalación de un archivo. 2106 | 2107 | ### whois 2108 | Cliente que nuestra información sobre direcciones 2109 | 2110 | ### xxd 2111 | Muestra un fichero como hexadecimal 2112 | 2113 | ### yes 2114 | Confirma automáticamente las opciones interactivas de un comando 2115 | 2116 | 2117 | [Tabla de Contenidos](#tabla-de-contenidos) 2118 | 2119 | ---- 2120 | 2121 | ## Capítulo 11: Proot-Distro 2122 | Proot distro es una versión custom del comando proot que ha sido diseñada para Termux. Con proot-distro podremos instalar distribuciones populares de GNU/Linux en Termux. Esto nos va a permitir instalar programas de esas distribuciones y disponer del sistema de ficheros común de GNU/Linux. 2123 | 2124 | ### Lista las distribuciones disponibles 2125 | ```bash 2126 | proot-distro list 2127 | ``` 2128 | Mustra las distribuciones de GNU/Linux disponibles, su nombre, su alias y su estado de instalación 2129 | 2130 | ### Instala una distribución 2131 | ```bash 2132 | proot-distro install alpine 2133 | ``` 2134 | Para instalar una distribución, debes utilizar el alias correspondiente a la distribución que deseas instalar. 2135 | 2136 | ### Arranca una distribución 2137 | ```bash 2138 | proot-distro login alpine 2139 | ``` 2140 | 2141 | ### Haz copia de seguridad de una distribución 2142 | ```bash 2143 | proot-distro backup alpine 2144 | ``` 2145 | 2146 | ### Elimina una distribución 2147 | ```bash 2148 | proot-distro remove alpine 2149 | ``` 2150 | 2151 | ### Elimina y reinstala una distribución 2152 | ```bash 2153 | proot-distro reset alpine 2154 | ``` 2155 | 2156 | ### Recupera un sistema mediante copia de seguridad 2157 | ```bash 2158 | proot-distro restore alpine 2159 | ``` 2160 | 2161 | ### Arranca una distribución aislada de Termux 2162 | ```bash 2163 | proot-distro login alpine --isolated 2164 | ``` 2165 | 2166 | ### Ejecuta un comando desde una distribución 2167 | ```bash 2168 | proot-distro login alpine --isolated -- pwd 2169 | ``` 2170 | [Tabla de Contenidos](#tabla-de-contenidos) 2171 | 2172 | ---- 2173 | 2174 | ## Capitulo 12: Introducción a Sistemas Linux 2175 | Linux es un sistema operativo libre y gratuito que ha ganado una gran popularidad debido a su estabilidad, seguridad y flexibilidad. Aunque Linux es conocido por ser utilizado en servidores, también es posible utilizarlo en dispositivos móviles como smartphones y tablets. 2176 | 2177 | #### ¿Qué es Linux? 2178 | Linux es un sistema operativo similar a Windows o macOS, pero con una diferencia importante: es de código abierto. Esto significa que cualquiera puede descargar el código fuente de Linux y modificarlo para adaptarlo a sus necesidades. Además, Linux está disponible de forma gratuita para cualquier persona que quiera utilizarlo. 2179 | 2180 | #### ¿Qué es una distribución de Linux? 2181 | Aunque Linux es un sistema operativo por sí solo, existen muchas distribuciones de Linux disponibles, cada una con sus propias características y enfoques. Una distribución de Linux es una versión de Linux que incluye un conjunto de programas y aplicaciones preinstalados y una interfaz de usuario específica. Algunas distribuciones de Linux están diseñadas para usuarios principiantes, mientras que otras están diseñadas para usuarios avanzados. 2182 | 2183 | 2184 | #### Distribuciones Linux 2185 | + [Ubuntu](https://help.ubuntu.com/) 2186 | Es una de las distribuciones de Linux más populares y se utiliza ampliamente en todo el mundo. Es conocida por su facilidad de uso y su gran cantidad de aplicaciones disponibles. También tiene una gran comunidad de usuarios que puede proporcionar ayuda y soporte. 2187 | + [Debian](https://www.debian.org/doc/) 2188 | Es una distribución de Linux estable y confiable. Está diseñada para ser utilizada en servidores, pero también es adecuada para usuarios de escritorio. Debian se enfoca en la estabilidad y la seguridad, por lo que sus actualizaciones son más lentas que en otras distribuciones. 2189 | 2190 | + [Fedora](https://docs.fedoraproject.org/es/docs/) 2191 | Es una distribución de Linux que está diseñada para usuarios avanzados. Incluye herramientas de desarrollo y es conocida por ser una plataforma para nuevas tecnologías. Fedora es la distribución de prueba para Red Hat Enterprise Linux, que es utilizado en empresas. 2192 | 2193 | + [Arch Linux](https://wiki.archlinux.org/title/Arch_Linux_(Espa%C3%B1ol)) 2194 | Es una distribución de Linux que se enfoca en la simplicidad y el minimalismo. Está diseñada para usuarios avanzados que desean un control completo sobre su sistema. Arch Linux es una distribución rolling release, lo que significa que las actualizaciones se liberan continuamente. 2195 | 2196 | + [Kali Linux](https://kali-linux.net/) 2197 | Es una distribución de Linux especializada en seguridad informática. Incluye una gran cantidad de herramientas de hacking ético y pruebas de penetración. 2198 | 2199 | + [Alpine](https://docs.alpinelinux.org/) 2200 | Está diseñada para ser liviana y segura. Es popular en entornos de contenedores y en dispositivos de IoT. 2201 | 2202 | Al igual que Termux, Linux se basa en la línea de comandos para realizar tareas, aunque también se puede instalar una interfaz gráfica. Linux también tiene una gran cantidad de herramientas y paquetes disponibles que se pueden instalar y personalizar para adaptarse a tus necesidades. 2203 | 2204 | [Tabla de Contenidos](#tabla-de-contenidos) 2205 | 2206 | ---- 2207 | 2208 | ## Capitulo 13: Uso básico de Debian 2209 | 2210 | ### Instalación de paquetes en Debian 2211 | #### apt 2212 | 2213 | `apt` es el gestor de paquetes de Debian. Permite instalar, actualizar y desinstalar paquetes en el sistema. Aquí tienes algunos comandos útiles: 2214 | 2215 | - `apt update`: actualiza la lista de paquetes disponibles en los repositorios. 2216 | - `apt upgrade`: actualiza todos los paquetes instalados en el sistema. 2217 | - `apt install `: instala un paquete en el sistema. 2218 | - `apt remove `: desinstala un paquete del sistema. 2219 | - `apt search `: busca un paquete en los repositorios disponibles. 2220 | - `apt show `: muestra información detallada sobre un paquete. 2221 | 2222 | Es importante tener en cuenta que necesitas ejecutar `apt update` para actualizar la lista de paquetes disponibles antes de instalar cualquier paquete. 2223 | 2224 | #### dpkg 2225 | 2226 | `dpkg` es la herramienta de bajo nivel para gestionar paquetes de Debian. Permite instalar, desinstalar, configurar y verificar paquetes en el sistema. Aquí tienes algunos comandos útiles: 2227 | 2228 | - `dpkg -i `: instala un paquete .deb en el sistema. 2229 | - `dpkg -r `: desinstala un paquete del sistema. 2230 | - `dpkg -L `: muestra una lista de archivos que pertenecen a un paquete. 2231 | - `dpkg -S `: muestra el paquete que contiene un archivo en particular. 2232 | - `dpkg-reconfigure `: reconfigura un paquete ya instalado. 2233 | 2234 | Ten en cuenta que `dpkg` no resuelve automáticamente las dependencias, por lo que es posible que necesites instalar manualmente las dependencias de un paquete antes de instalar el paquete en sí. 2235 | 2236 | 2237 | [Tabla de Contenidos](#tabla-de-contenidos) 2238 | 2239 | ---- 2240 | 2241 | ## Capítulo 14: Uso básico de Ubuntu 2242 | 2243 | ### Instalación de paquetes en Ubuntu 2244 | #### apt 2245 | 2246 | `apt` es el gestor de paquetes de Ubuntu. Permite instalar, actualizar y desinstalar paquetes en el sistema. Aquí tienes algunos comandos útiles: 2247 | 2248 | - `sudo apt update`: actualiza la lista de paquetes disponibles en los repositorios. 2249 | - `sudo apt upgrade`: actualiza todos los paquetes instalados en el sistema. 2250 | - `sudo apt install `: instala un paquete en el sistema. 2251 | - `sudo apt remove `: desinstala un paquete del sistema. 2252 | - `sudo apt search `: busca un paquete en los repositorios disponibles. 2253 | - `sudo apt show `: muestra información detallada sobre un paquete. 2254 | 2255 | Es importante tener en cuenta que necesitas ejecutar `sudo apt update` para actualizar la lista de paquetes disponibles antes de instalar cualquier paquete. 2256 | 2257 | #### dpkg 2258 | 2259 | `dpkg` es la herramienta de bajo nivel para gestionar paquetes en Ubuntu. Permite instalar, desinstalar, configurar y verificar paquetes en el sistema. Aquí tienes algunos comandos útiles: 2260 | 2261 | - `sudo dpkg -i `: instala un paquete .deb en el sistema. 2262 | - `sudo dpkg -r `: desinstala un paquete del sistema. 2263 | - `sudo dpkg -L `: muestra una lista de archivos que pertenecen a un paquete. 2264 | - `sudo dpkg -S `: muestra el paquete que contiene un archivo en particular. 2265 | - `sudo dpkg-reconfigure `: reconfigura un paquete ya instalado. 2266 | 2267 | Ten en cuenta que `dpkg` no resuelve automáticamente las dependencias, por lo que es posible que necesites instalar manualmente las dependencias de un paquete antes de instalar el paquete en sí. 2268 | 2269 | 2270 | [Tabla de Contenidos](#tabla-de-contenidos) 2271 | 2272 | ---- 2273 | 2274 | ## Capítulo 15: Uso básico de Alpine 2275 | 2276 | ### Instalación de paquetes en Alpine 2277 | #### apk 2278 | 2279 | `apk` es el gestor de paquetes de Alpine Linux. Permite instalar, actualizar y desinstalar paquetes en el sistema. Aquí tienes algunos comandos útiles: 2280 | 2281 | - `apk update`: actualiza la lista de paquetes disponibles en los repositorios. 2282 | - `apk upgrade`: actualiza todos los paquetes instalados en el sistema. 2283 | - `apk add `: instala un paquete en el sistema. 2284 | - `apk del `: desinstala un paquete del sistema. 2285 | - `apk search `: busca un paquete en los repositorios disponibles. 2286 | - `apk info `: muestra información detallada sobre un paquete. 2287 | 2288 | Es importante tener en cuenta que necesitas ejecutar `apk update` para actualizar la lista de paquetes disponibles antes de instalar cualquier paquete. 2289 | 2290 | #### Otros comandos útiles 2291 | 2292 | - `apk add --no-cache `: instala un paquete sin caché. Esto reduce la cantidad de espacio utilizado por el paquete. 2293 | - `apk add --virtual `: instala un paquete como una dependencia virtual. Esto es útil si necesitas instalar un paquete que no existe en los repositorios, pero que es necesario para que otro paquete funcione correctamente. 2294 | - `apk cache clean`: limpia la caché de paquetes para liberar espacio en disco. 2295 | 2296 | Ten en cuenta que `apk` también puede ser utilizado para instalar paquetes desde fuentes externas, como archivos APK o repositorios de terceros. Sin embargo, debes tener cuidado al hacer esto, ya que los paquetes pueden no ser seguros o compatibles con tu sistema. 2297 | 2298 | 2299 | [Tabla de Contenidos](#tabla-de-contenidos) 2300 | 2301 | ---- 2302 | 2303 | ## Capítulo 16: Uso básico de Fedora 2304 | 2305 | ### Instalación de paquetes en Fedora 2306 | #### dnf 2307 | 2308 | `dnf` es el gestor de paquetes por defecto en Fedora. Permite instalar, actualizar y desinstalar paquetes en el sistema. Aquí tienes algunos comandos útiles: 2309 | 2310 | - `dnf update`: actualiza todos los paquetes instalados en el sistema. 2311 | - `dnf upgrade`: actualiza todos los paquetes instalados en el sistema, incluyendo los que requieren cambios en la configuración. 2312 | - `dnf install `: instala un paquete en el sistema. 2313 | - `dnf remove `: desinstala un paquete del sistema. 2314 | - `dnf search `: busca un paquete en los repositorios disponibles. 2315 | - `dnf info `: muestra información detallada sobre un paquete. 2316 | 2317 | Es importante tener en cuenta que necesitas ejecutar `dnf update` para actualizar todos los paquetes instalados en el sistema. 2318 | 2319 | #### Otros comandos útiles 2320 | 2321 | - `dnf history`: muestra un registro detallado de todas las operaciones realizadas por `dnf`, incluyendo las actualizaciones e instalaciones de paquetes. 2322 | - `dnf repoquery `: busca un paquete en los repositorios disponibles sin instalarlo. 2323 | - `dnf list installed`: muestra una lista de todos los paquetes instalados en el sistema. 2324 | - `dnf clean all`: limpia la caché de paquetes y metadatos para liberar espacio en disco. 2325 | 2326 | Ten en cuenta que `dnf` también puede ser utilizado para instalar paquetes desde fuentes externas, como archivos RPM o repositorios de terceros. Sin embargo, debes tener cuidado al hacer esto, ya que los paquetes pueden no ser seguros o compatibles con tu sistema. 2327 | 2328 | [Tabla de Contenidos](#tabla-de-contenidos) 2329 | 2330 | ---- 2331 | 2332 | ## Capítulo 17: Introducción a Servicios 2333 | 2334 | Los servicios son programas que se ejecutan en segundo plano, es decir, que están funcionando en la computadora sin que el usuario tenga que interactuar directamente con ellos. 2335 | 2336 | Estos programas pueden ser muy variados y realizar diferentes funciones. Por ejemplo, un servicio puede ser el que controla el acceso a una red, otro puede ser el que permite imprimir documentos, otro puede ser el que guarda archivos en un servidor, etc. 2337 | 2338 | Cada servicio se comunica con otros programas o dispositivos a través de puertos específicos, que funcionan como una especie de "ventana" por donde los datos entran y salen. 2339 | 2340 | Cuando utilizas una aplicación o accedes a un sitio web, estás interactuando con uno o varios servicios que están funcionando en segundo plano. Por ejemplo, si estás utilizando un navegador para acceder a un sitio web, el navegador está utilizando el servicio de red para conectarse a Internet y el servicio de DNS para buscar la dirección IP del sitio web. 2341 | 2342 | En resumen, los servicios son programas que realizan funciones específicas en segundo plano, y se comunican con otros programas y dispositivos a través de puertos específicos. 2343 | 2344 | [Tabla de Contenidos](#tabla-de-contenidos) 2345 | 2346 | ---- 2347 | 2348 | ## Capítulo 18: Creando un Servidor 2349 | 2350 | Hay muchos tipo de servidores y muchos programas que te permiten crearlos. 2351 | 2352 | #### Creando un servidor Web con Python3 2353 | 2354 | **1. Instalar Python 3:** 2355 | 2356 | Para instalar Python 3 en Termux, sigue estos pasos: 2357 | 2358 | 1. Abre la aplicación Termux en tu dispositivo Android. 2359 | 2. Ejecuta el siguiente comando para actualizar los paquetes existentes: 2360 | 2361 | ```bash 2362 | pkg update && pkg upgrade 2363 | ``` 2364 | 2365 | 3. Ahora, ejecuta el siguiente comando para instalar Python 3: 2366 | 2367 | ```bash 2368 | pkg install python3 2369 | ``` 2370 | 2371 | 4. Una vez que se complete la instalación, verifica que Python 3 esté instalado correctamente ejecutando el siguiente comando: 2372 | 2373 | ```bash 2374 | python3 --version 2375 | ``` 2376 | 2377 | Debería mostrar la versión de Python instalada en tu sistema. 2378 | 2379 | **2. Crear una carpeta para el servidor web:** 2380 | 2381 | Ahora, vamos a crear una carpeta para nuestro servidor web. Para ello, ejecuta el siguiente comando: 2382 | 2383 | ```bash 2384 | mkdir mywebsite 2385 | ``` 2386 | 2387 | Este comando creará una carpeta llamada "mywebsite" en el directorio actual. 2388 | 2389 | **3. Crear un archivo HTML:** 2390 | 2391 | Ahora, vamos a crear un archivo HTML muy simple para nuestra página web. Para ello, ejecuta los siguientes comandos: 2392 | 2393 | ```bash 2394 | cd mywebsite 2395 | echo "

Mi sitio web

" > index.html 2396 | ``` 2397 | 2398 | El primer comando nos lleva al directorio "mywebsite". El segundo comando crea un archivo llamado "index.html" en el directorio actual y agrega el código HTML necesario para mostrar un encabezado "Mi sitio web" en nuestra página. 2399 | 2400 | **4. Agregar un archivo de texto de ejemplo:** 2401 | 2402 | Para agregar un archivo de texto de ejemplo, ejecuta los siguientes comandos: 2403 | 2404 | ```bash 2405 | echo "Este es un archivo de texto de ejemplo." > example.txt 2406 | ``` 2407 | 2408 | Este comando crea un archivo de texto llamado "example.txt" en el directorio actual y agrega el texto "Este es un archivo de texto de ejemplo." en el archivo. 2409 | 2410 | **5. Iniciar el servidor web:** 2411 | 2412 | Ahora que hemos creado nuestra carpeta y nuestros archivos, podemos iniciar el servidor web utilizando el comando `python3 -m http.server`. Para ello, ejecuta los siguientes comandos: 2413 | 2414 | ```bash 2415 | python3 -m http.server 8000 2416 | ``` 2417 | 2418 | El comando inicia el servidor web en el puerto 8000 (puedes elegir cualquier otro puerto si lo deseas). 2419 | 2420 | **6. Acceder a la página web:** 2421 | 2422 | Para acceder a la página web, abre un navegador en tu dispositivo Android y escribe la siguiente dirección URL: 2423 | 2424 | ``` 2425 | http://localhost:8000/ 2426 | ``` 2427 | 2428 | Deberías ver la página web con el encabezado "Mi sitio web". 2429 | 2430 | **7. Acceder al archivo de texto:** 2431 | 2432 | Para acceder al archivo de texto, abre un navegador en tu dispositivo Android y escribe la siguiente dirección URL: 2433 | 2434 | ``` 2435 | http://localhost:8000/example.txt 2436 | ``` 2437 | 2438 | Deberías ver el contenido del archivo de texto "example.txt". 2439 | 2440 | ¡Listo! Ahora tienes un servidor web en ejecución en tu dispositivo Android, creado con Python 3 en Termux. Puedes personalizar la página web agregando más contenido y archivos a la carpeta "mywebsite". 2441 | 2442 | En el final del [Capítulo 25: Protocolo HTTP](#cap%C3%ADtulo-25-protocolo-http) también tienes un servidor web mínino usando Bash y ncat. 2443 | 2444 | [Tabla de Contenidos](#tabla-de-contenidos) 2445 | 2446 | ---- 2447 | 2448 | ## Capítulo 19: Ngrok y Exponer Servicios 2449 | 2450 | #### Qué es Ngrok? 2451 | 2452 | Ngrok es una herramienta que permite crear un túnel seguro hacia un servidor local, lo que permite exponer aplicaciones o servicios que se ejecutan en un equipo local a Internet. Básicamente, permite que una aplicación web que se ejecuta en un equipo local sea accesible a través de una URL pública. Esto es muy útil para desarrolladores que necesitan probar sus aplicaciones web en diferentes dispositivos o compartir sus aplicaciones con otros. 2453 | 2454 | Ngrok crea una conexión segura entre su equipo local y la nube, lo que le permite acceder a su servidor local desde cualquier lugar del mundo. También proporciona un panel de control web para administrar su conexión y configurar diferentes opciones, como la autenticación y el registro de solicitudes. 2455 | 2456 | Ngrok es fácil de usar y se puede instalar en diferentes sistemas operativos. Además, tiene una versión gratuita y varias opciones de pago con características adicionales, como el uso de subdominios personalizados y la asignación de puertos dedicados. 2457 | 2458 | #### Qué es un servicio local y cómo se expone? 2459 | 2460 | Un servicio local es un servicio o aplicación que se ejecuta en un equipo local, como una aplicación web, una API o un servidor de base de datos. Estos servicios suelen estar disponibles solo en el equipo donde están instalados y no son accesibles desde otros equipos en la red o desde Internet. 2461 | 2462 | Los usuarios pueden utilizar Ngrok para exponer estos servicios locales y hacerlos accesibles desde cualquier lugar del mundo a través de una URL pública. Esto es útil para desarrolladores que necesitan probar sus aplicaciones en diferentes dispositivos o compartir sus aplicaciones con otros, ya que les permite acceder a sus servicios locales sin tener que exponerlos a Internet directamente. Además, Ngrok facilita la configuración de conexiones seguras y elimina la necesidad de abrir puertos en el router, lo que lo hace una solución fácil y segura para exponer servicios locales. 2463 | 2464 | #### Por que utilizar una versión opensource en lugar de la oficial 2465 | 2466 | La seguridad es un factor importante cuando se trata de exponer servicios a través de Internet. Mientras que Ngrok es una herramienta popular y útil para crear túneles seguros y exponer servicios locales, algunos usuarios pueden tener preocupaciones sobre la seguridad de su código cerrado y la privacidad de sus datos. 2467 | 2468 | Una de las ventajas de utilizar una versión de Ngrok de código abierto (open source) es que cualquier persona puede revisar y auditar el código para detectar posibles vulnerabilidades y problemas de seguridad. Esto significa que hay una mayor transparencia y confianza en el software, ya que los usuarios pueden ver exactamente lo que está sucediendo en el código subyacente. 2469 | 2470 | Además, los desarrolladores de la versión open source de Ngrok pueden responder a las preocupaciones de seguridad de la comunidad y proporcionar soluciones rápidas en caso de que se descubran vulnerabilidades. También hay una comunidad de usuarios activa que puede proporcionar soporte y asistencia en caso de que surjan problemas. 2471 | 2472 | Por otro lado, al ser una versión cerrada de código (closed source), los usuarios no pueden revisar el código y tienen que confiar en que la empresa detrás de Ngrok está tomando las medidas de seguridad necesarias para proteger sus datos y privacidad. 2473 | 2474 | En conclusión, utilizar una versión open source de Ngrok proporciona una mayor transparencia y seguridad, ya que los usuarios pueden revisar el código y confiar en la comunidad de usuarios para solucionar posibles vulnerabilidades y problemas de seguridad. 2475 | 2476 | #### cómo instalar un cliente de ngrok opensource 2477 | 2478 | 1. Abre la aplicación Termux en tu dispositivo Android. 2479 | 2480 | 2. Instala las dependencias necesarias ejecutando el siguiente comando: 2481 | 2482 | ```bash 2483 | pkg install openssh tmux 2484 | ``` 2485 | 2486 | 3. Descarga el cliente de ngrok opensource en tu dispositivo Android ingresando el siguiente comando: 2487 | 2488 | ```bash 2489 | git clone https://github.com/stringmanolo/ngrok.git 2490 | ``` 2491 | 2492 | 4. Navega hasta el directorio donde se encuentra el cliente de ngrok ingresando el siguiente comando: 2493 | 2494 | ```bash 2495 | cd ngrok 2496 | ``` 2497 | 2498 | 5. Configura el cliente de ngrok utilizando el asistente ingresando el siguiente comando: 2499 | 2500 | ```bash 2501 | chmod 775 ngrokWizard.sh 2502 | ./ngrokWizard.sh 2503 | ``` 2504 | 2505 | Sigue las instrucciones que se muestran en pantalla para configurar el cliente de ngrok. Esto incluirá generar una clave pública ECDSA, pegar la clave en la página de configuración de ngrok y establecer el puerto de tu servidor. 2506 | 2507 | 6. Una vez que hayas configurado el cliente de ngrok utilizando el asistente, puedes iniciar y detener el cliente utilizando los siguientes comandos: 2508 | 2509 | ```bash 2510 | ./ngrokStart.sh 2511 | ``` 2512 | 2513 | y 2514 | 2515 | ```bash 2516 | ./ngrokStop.sh 2517 | ``` 2518 | 2519 | El primer comando iniciará el cliente de ngrok y establecerá una conexión inversa SSH con el servidor, lo que permitirá que el tráfico se reenvíe a través de ngrok. El segundo comando detendrá la conexión SSH y cerrará el cliente de ngrok. 2520 | 2521 | Asegúrate de establecer el puerto correcto cada vez que ejecutes el comando `ngrokStart.sh`. 2522 | 2523 | Ahora puedes usar el cliente de ngrok opensource para exponer tu servidor web a través de ngrok en tu dispositivo Android usando Termux. Recuerda que la URL pública que te proporciona ngrok cambiará cada vez que ejecutes el comando `ngrokStart.sh`, por lo que es posible que debas actualizar la URL que compartes con otros usuarios cada vez que la uses. 2524 | 2525 | [Tabla de Contenidos](#tabla-de-contenidos) 2526 | 2527 | ---- 2528 | 2529 | ## Capítulo 20: Tor, Configuración y Uso 2530 | 2531 | #### Qué es Tor? 2532 | Tor (The Onion Router) es una red de comunicaciones en línea diseñada para proporcionar anonimato y privacidad a los usuarios de Internet. Fue desarrollado originalmente por la Marina de los Estados Unidos para proteger las comunicaciones gubernamentales, pero posteriormente se convirtió en un proyecto de código abierto para permitir que cualquier persona pueda utilizarlo. 2533 | 2534 | Tor funciona enrutando las conexiones de Internet a través de una serie de nodos (también llamados "nodos de cebolla" o "onion routers") distribuidos por todo el mundo. Cada nodo en la red solo conoce la dirección IP del nodo anterior y el siguiente nodo en la cadena, lo que hace que sea difícil (aunque no imposible) rastrear las comunicaciones de un usuario de Internet. 2535 | 2536 | Además, Tor también utiliza técnicas de cifrado para proteger las comunicaciones y garantizar que solo el usuario final pueda leer el contenido de los mensajes. Esto hace que Tor sea una herramienta valiosa para aquellos que desean proteger su privacidad y anonimato en línea, ya sea por razones políticas, de seguridad o simplemente por preferencia personal. 2537 | 2538 | #### Instalación, configuración y uso 2539 | 2540 | ##### 1 Abre Termux y asegúrate de que estás en la última versión actualizada. Para actualizar, escribe en la terminal: 2541 | 2542 | ```bash 2543 | apt update && apt upgrade 2544 | ``` 2545 | 2546 | ##### 2 A continuación, es necesario instalar el paquete de Tor y torify. Para hacerlo, escribe en la terminal: 2547 | 2548 | ```bash 2549 | pkg install tor torsocks 2550 | ``` 2551 | 2552 | ##### 3 Añade las siguientes líneas al archivo de configuración de Tor, usando el comando `echo`: 2553 | 2554 | ```bash 2555 | echo 'ControlPort 9051' >> $PREFIX/etc/tor/torrc && echo 'CookieAuthentication 1' >> $PREFIX/etc/tor/torrc 2556 | ``` 2557 | 2558 | ##### 4 Inicia el servicio de Tor en background usando el ampersand: 2559 | 2560 | ```bash 2561 | tor & 2562 | ``` 2563 | 2564 | Nota: El ampersand al final del comando permite que el proceso se ejecute en segundo plano, lo que significa que puedes seguir utilizando la terminal mientras Tor está activo. 2565 | 2566 | ##### 5 Para asegurarte de que Tor está funcionando, ejecuta: 2567 | 2568 | ```bash 2569 | torify curl -s https://check.torproject.org/ | grep -q "Congratulations" 2570 | ``` 2571 | 2572 | Este comando debería mostrar un mensaje de felicitación si estás usando Tor. Si no ves el mensaje, es posible que algo esté mal configurado o que Tor no esté funcionando correctamente. 2573 | 2574 | ##### 6 Ahora puedes usar Tor con cualquier aplicación que soporte proxies SOCKS5, incluyendo `curl`. Simplemente precede cualquier comando que quieras ejecutar con `torsocks`. Por ejemplo: 2575 | 2576 | ```bash 2577 | torsocks curl https://example.com 2578 | ``` 2579 | 2580 | ##### 7 Cuando hayas terminado de usar Tor, detén el servicio ejecutando el siguiente comando: 2581 | 2582 | ```bash 2583 | killall tor 2584 | ``` 2585 | 2586 | ¡Listo! Ahora sabes cómo instalar, configurar y usar Tor en Termux. Recuerda que el uso de Tor es importante para proteger tu privacidad y anonimato en línea. 2587 | 2588 | 2589 | [Tabla de Contenidos](#tabla-de-contenidos) 2590 | 2591 | ---- 2592 | 2593 | ## Capítulo 21: Servicios Ocultos 2594 | 2595 | ### Qué es? 2596 | Un Hidden Service (también conocido como Servicio Oculto) es un sitio web alojado en la red Tor (conocida también como Dark Web o internet profunda) que se encuentra en una ubicación desconocida para los usuarios normales de la web y que solo puede ser accedido a través de la red Tor. En lugar de tener una dirección IP pública y estar alojado en un servidor web estándar, un Hidden Service se aloja en una red anónima y utiliza una dirección web única que termina en ".onion". 2597 | 2598 | Cuando un usuario intenta acceder a un sitio web alojado en un Hidden Service, su conexión se enruta a través de una serie de nodos de la red Tor, lo que proporciona un alto nivel de anonimato. 2599 | 2600 | Los Hidden Services se pueden utilizar para una amplia variedad de propósitos, desde sitios web de periodismo y activismo político hasta mercados en línea y comunidades en línea privadas. Algunos usuarios también utilizan Hidden Services para alojar sus propios sitios web personales sin revelar su ubicación física o dirección IP pública. 2601 | 2602 | En resumen, los Hidden Services ofrecen una forma segura y anónima de alojar y acceder a contenido en línea, lo que los hace útiles para una variedad de aplicaciones en línea que requieren privacidad y anonimato. 2603 | 2604 | ### Crear un servicio oculto 2605 | 2606 | ##### 1 Crea una carpeta para el sitio web y otra para el hidden service utilizando los siguientes comandos: 2607 | 2608 | ```bash 2609 | mkdir -p $PREFIX/var/lib/tor/hidden_service/mywebsite; 2610 | mkdir -p $PREFIX/etc/tor/hidden_service; 2611 | ``` 2612 | 2613 | ##### 2 Cambia los permisos de la carpeta: 2614 | ```bash 2615 | chmod 700 $PREFIX/var/lib/tor/hidden_service/mywebsite 2616 | ``` 2617 | 2618 | ##### 3 Agrega las líneas de configuración de Tor al archivo `torrc` utilizando el siguiente comando: 2619 | 2620 | ```bash 2621 | echo -e "HiddenServiceDir $PREFIX/var/lib/tor/hidden_service/mywebsite\nHiddenServicePort 80 127.0.0.1:8000" >> $PREFIX/etc/tor/torrc; 2622 | ``` 2623 | 2624 | ##### 4 Reinicia el servicio Tor ejecutando el siguiente comando: 2625 | 2626 | ```bash 2627 | killall tor; 2628 | tor & 2629 | ``` 2630 | 2631 | ##### 5 Crea un archivo `index.html` para el sitio web utilizando el siguiente comando: 2632 | 2633 | ```bash 2634 | echo "Hello, world!" > $PREFIX/var/lib/tor/hidden_service/mywebsite/index.html; 2635 | ``` 2636 | 2637 | ##### 6 Inicia un servidor web local en la carpeta `mywebsite` usando el siguiente comando: 2638 | 2639 | ```bash 2640 | cd $PREFIX/var/lib/tor/hidden_service/mywebsite; 2641 | python3 -m http.server 8000 & 2642 | ``` 2643 | 2644 | ##### 7 Obten la dirección de tu servicio: 2645 | ```bash 2646 | cat $PREFIX/var/lib/tor/hidden_service/mywebsite/hostname 2647 | ``` 2648 | 2649 | ##### 8 Accede al sitio web a través del Hidden Service ejecutando el siguiente comando en la terminal: 2650 | ```bash 2651 | torify curl http://.onion/; 2652 | ``` 2653 | 2654 | Reemplaza `` con la dirección del Hidden Service que obtuviste en el paso 7. 2655 | 2656 | Otra forma de comprobar si funciona es utilizando el servicio tor2web. Te vas a [este](https://www.tor2web.fi/) enlace en cualquier navegador e introduces la dirección de tu servicio. Si funciona verás tu página web con el mensaje "Hello World". Esta web sirve para poder visualizar páginas web alojadas en la red tor en tu navegador sin necesidad de instalar el navegador de tor. 2657 | 2658 | ##### 9 Para detener el servicio Tor y el servidor web de Python, ejecuta los siguientes comandos en la terminal: 2659 | ```bash 2660 | killall tor; 2661 | killall python3; 2662 | ``` 2663 | 2664 | Con estos pasos, se creará una carpeta para el sitio web y otra para el hidden service, se configurará el archivo de Tor para exponer el servidor web local en el Hidden Service, se creará un archivo `index.html` para el sitio web y se iniciará un servidor web local. Cualquier persona con conexión a tor podrá acceder a tu servicio utilizando el dominio .onion. 2665 | 2666 | [Tabla de Contenidos](#tabla-de-contenidos) 2667 | 2668 | ---- 2669 | 2670 | 2671 | ## Capítulo 22: SSH, SCP y SSHD 2672 | 2673 | ### SSH 2674 | 2675 | SSH (Secure Shell) es un protocolo de red que permite a los usuarios acceder y controlar de forma remota otros dispositivos a través de una conexión segura. En Termux, también es posible utilizar SSH para establecer una conexión remota con otros sistemas y ejecutar comandos en ellos. A continuación, te mostraré cómo puedes utilizar SSH en Termux. 2676 | 2677 | #### Instalación de OpenSSH 2678 | Para utilizar SSH en Termux, primero debes instalar el paquete OpenSSH. Puedes hacerlo ejecutando el siguiente comando en la terminal de Termux: 2679 | 2680 | ```bash 2681 | pkg install openssh 2682 | ``` 2683 | 2684 | #### Generación de claves SSH 2685 | Antes de utilizar SSH, es recomendable generar un par de claves SSH para autenticarte de forma segura en los sistemas remotos. Puedes generar un par de claves SSH ejecutando el siguiente comando: 2686 | 2687 | ```bash 2688 | ssh-keygen -t rsa 2689 | ``` 2690 | 2691 | Este comando generará una clave privada y una clave pública en tu directorio de inicio. Puedes dejar los valores predeterminados presionando "Enter" en cada pregunta. 2692 | 2693 | 2694 | #### Conexión SSH 2695 | Una vez que hayas generado las claves SSH, estás listo para establecer una conexión SSH con un sistema remoto. Utiliza el siguiente comando para conectarte a un sistema remoto 2696 | ```bash 2697 | ssh usuario@dirección_ip 2698 | ``` 2699 | 2700 | Reemplaza "usuario" con tu nombre de usuario en el sistema remoto y "dirección_ip" con la dirección IP del sistema remoto al que deseas conectarte, también puedes usar un dominio en lugar de una IP al igual que con las páginas web. 2701 | 2702 | Si es la primera vez que te conectas a ese sistema, se te pedirá que confirmes la autenticidad de la clave del host. Verifica que la clave mostrada coincida con la clave del sistema remoto y responde "yes" para agregarla a la lista de conocidos. 2703 | 2704 | A continuación, se te solicitará la contraseña del usuario remoto. Ingrésala y presiona "Enter" para establecer la conexión 2705 | 2706 | Normalmente ssh se utiliza para obtener acceso a servidores privados pero también hay alguno público. En el siguiente ejemplo veremos como utilizar openssh para conectarnos a un servidor remoto: 2707 | ```bash 2708 | ssh bandit0@bandit.labs.overthewire.org -p 2220 2709 | ``` 2710 | 2711 | Cuando te conectas por SSH por primera vez a un servidor es normal que se te muestre un mensaje indicando la huella digital del servidor, por ejemplo: 2712 | ```bash 2713 | The authenticity of host '[bandit.labs.overthewire.org]:2220 ([16.16.8.216]:2220)' can't be established. 2714 | ED25519 key fingerprint is SHA256:C2ihUBV7ihnV1wUXRb4RrEcLfXC5CXlhmAAM/urerLY. 2715 | This key is not known by any other names. 2716 | Are you sure you want to continue connecting (yes/no/[fingerprint])? 2717 | ``` 2718 | 2719 | Escribiremos **yes** para continuar la conexión. 2720 | 2721 | Lo que estamos haciendo es conectarnos al ordenador con dirección IP 16.16.8.216 usando el protocolo SSH con el usuario bandit0. Nos pedirá una contraseña que también es bandit0. Y con esto ya nos hemos conectado a un ordenador remoto a través de SSH. 2722 | 2723 | Si tienes multiples dispositivos, smartphones, computadores, hostings, vpns, ... SSH es una forma segura y simple de obtener una terminal remota. En esta parte se explica solo el cliente (como conectarse a), a continuación se explica como configurar el servicio ssh para que una maquina sea accesible a través de SSH. 2724 | 2725 | ### SSHD 2726 | 2727 | SSHD es el Daemon de SSH que se ejecuta en segundo plano permaneciendo a la escucha de conexiones entrantes (por defecto en el puerto 8022 en Termux). Este servicio nos sirve para permitir que la máquina sea controlada desde el exterior a través del protocolo SSH. 2728 | 2729 | ##### Instalar Alpine en proot-distro 2730 | En lugar de correr directamente el servidor SSH sobre Termux, vamos a hacerlo sobre proot-distro con el argumento --isolated para tener una pequeña capa extra de seguridad. Ya vimos como utilizar la herramienta proot-distro en el [capítulo 11](#cap%C3%ADtulo-11-proot-distro): 2731 | ```bash 2732 | proot-distro install alpine 2733 | ``` 2734 | 2735 | ##### Iniciar sesión interactiva aislada de Alpine 2736 | 2737 | A continuación, utilizaremos proot-distro para iniciar sesión en la distribución Alpine Linux de forma aislada. Ejecutamos el siguiente comando: 2738 | ```bash 2739 | proot-distro login alpine --isolated 2740 | ``` 2741 | 2742 | ##### Instalar openssh en Alpine 2743 | 2744 | Una vez que hemos iniciado sesión en la distribución Alpine Linux, podemos instalar el paquete de OpenSSH, que nos permitirá configurar el servidor SSHD. Ejecutamos el siguiente comando: 2745 | ```bash 2746 | apk add openssh 2747 | ``` 2748 | 2749 | ##### Generación de claves SSH 2750 | 2751 | Antes de configurar el servidor SSHD, necesitamos generar las claves SSH necesarias. Ejecutamos el siguiente comando: 2752 | 2753 | ```bash 2754 | ssh-keygen -A 2755 | ``` 2756 | 2757 | ##### Creae archivo de configuración de SSHD 2758 | 2759 | Este comando sobrescribe el contenido del archivo /etc/ssh/sshd_config con la configuración especificada. Aquí estamos permitiendo el inicio de sesión como usuario root, configurando el puerto de escucha en el puerto 8022, habilitando la autenticación por contraseña y desactivando algunas opciones de reenvío y redireccionamiento. 2760 | 2761 | ```bash 2762 | echo 'Include /etc/ssh/sshd_config.d/*.conf 2763 | Port 8022 2764 | PermitRootLogin yes 2765 | AuthorizedKeysFile .ssh/authorized_keys 2766 | PasswordAuthentication yes 2767 | AllowTcpForwarding no 2768 | GatewayPorts no 2769 | X11Forwarding no 2770 | Subsystem sftp internal-sftp' > /etc/ssh/sshd_config 2771 | ``` 2772 | 2773 | ##### Generación de una contraseña para el usuario root 2774 | Para habilitar el inicio de sesión como usuario root, necesitamos establecer una contraseña. Ejecutamos el siguiente comando: 2775 | 2776 | ```bash 2777 | tr -dc '[:alnum:][:punct:]' < /dev/urandom | head -c 16 2778 | ``` 2779 | 2780 | Este comando genera una contraseña aleatoria de 16 caracteres para el usuario root. Puedes utilizar cualquier contraaeña que tu quieras, pero debes tener en cuenta que hay miles de scanneres y herramientas de fuerza bruta scanneando servicios SSH. Si pones una contraseña frágil, te van a hackear y podrán ejecutar comandos en tu dispositivo. 2781 | 2782 | ##### Establecimiento de la contraseña del usuario root 2783 | Ahora, estableceremos la contraseña generada para el usuario root. Ejecutamos el siguiente comando: 2784 | ```bash 2785 | passwd root 2786 | ``` 2787 | 2788 | Este comando solicitará que ingresemos la nueva contraseña para el usuario root. 2789 | 2790 | ##### Inicio del servidor SSHD 2791 | Finalmente, iniciamos el servidor SSHD ejecutando el siguiente comando: 2792 | 2793 | ```bash 2794 | /usr/sbin/sshd 2795 | ``` 2796 | 2797 | ##### Conexión al servidor SSHD 2798 | Ahora que hemos configurado y activado el servidor SSHD, podemos conectarnos a él desde otras máquinas (pcs, smartphones, etc) y/o otras terminales. Utilizamos el comando ssh para establecer una conexión SSH. 2799 | 2800 | ###### Para conexión desde otra pestaña de Termux u otro software en el mismo equipo: 2801 | ```bash 2802 | ssh root@127.0.0.1 -p 8022 2803 | ``` 2804 | 2805 | ###### Para conexión desde otra maquina que se encuentre en la misma red local (mismo wi-fi) 2806 | ```bash 2807 | ssh root@192.168.1.40 -p 8022 2808 | ``` 2809 | __Remplaza la IP 192.168.1.40 por la IP privada que el router te asignó (IP local de tu Smartphone)__ 2810 | 2811 | ###### Para conexión desde fuera de nuestra red (cualquier máquina en cualquier parte, con router en casa) 2812 | ```bash 2813 | ssh root@93.184.216.34 -p 8022 2814 | ``` 2815 | __Remplaza la IP 93.184.216.34 por la IP pública de tu router y configura en el router la apertura/redirección de puertos de la IP pública hacia la IP local de tu Smartphone__ 2816 | 2817 | ###### Para conexión desde fuera de nuestra red (cualquier máquina en cualquier parte, datos móviles o no) 2818 | Si utilzas datos móviles normalmente los proveedores de internet no te dan una IP pública única ni tampoco un router o una forma de abrir puertos, si no que te meten en una red compartida llamada CGNAT. Cuando estás en CGNAT no puedes exponer ningún tipo de servicio a internet. Para exponer nuestro servidor SSH lo que haremos será utilizar un servidor intermedio que encapsule el trafico mediante técnicas de tunelación. __Esta técnica funciona también aunque no uses datos móviles, asique si simplemente quierer ahorrarte abrir puertos, o tienes cualquier otro motivo también te sirve__ 2819 | 2820 | En el [Capítulo 19: Ngrok y Exponer Servicios](#cap%C3%ADtulo-19-ngrok-y-exponer-servicios) tienes mas información. 2821 | 2822 | 2823 | ##### Instalar git 2824 | 2825 | Instalamos git para poder clonar el repositorio de un cliente código abierto de Ngrok 2826 | 2827 | ```bash 2828 | apk add git 2829 | ``` 2830 | 2831 | ##### Instalar tmux 2832 | 2833 | Instalamos también tmux ya que es una dependencia del cliente codigo abierto de ngrok 2834 | 2835 | ```bash 2836 | apk add tmux 2837 | ``` 2838 | 2839 | ##### Instalar ngrok opensource 2840 | ```bash 2841 | git clone https://github.com/StringManolo/ngrok; 2842 | cd ngrok; 2843 | chmod 775 ngrokWizard.sh; 2844 | chmod 775 ngrokStart.sh; 2845 | chmod 775 ngrokStop.sh; 2846 | ./ngrokWizard.sh; 2847 | 2848 | ``` 2849 | 2850 | Lee y sigue las indicaciones que se muestran en consola para configurar y ejecutar ngrok. 2851 | 2852 | Una vez completado el proceso, en la salida de consola te saldrá un url con protocolo tcp acompañado de un puerto, por ejemplo: __tcp://8.tcp.ngrok.io:16459__ 2853 | 2854 | Podremos conectarnos a nuestra máquina al igual que hicimos en local pero ahora desde cualquier lugar/dispositivo; 2855 | 2856 | ```bash 2857 | ssh root@8.tcp.ngrok.io -p 16459 2858 | ``` 2859 | 2860 | Puedes cerrar todo simplemente corriendo el comando __exit__ 2861 | 2862 | Para volver a activar el SSH ngrok y demás no necesitarás repetir todo el proceso, simplemente ingresas al Alpine linux, ejecutas el ssh y el ./ngrokStart.sh, pones el puerto 8022 y listo: 2863 | ```bash 2864 | proot-distro login alpine --isolated 2865 | ``` 2866 | 2867 | ```bash 2868 | /usr/sbin/sshd; 2869 | /root/ngrok/ngrokStart.sh; 2870 | ``` 2871 | 2872 | ### SCP 2873 | 2874 | SCP (Secure Copy) es un protocolo basado en SSH que permite la transferencia segura de archivos entre sistemas remotos. Con SCP, puedes copiar archivos y directorios de forma segura de un sistema a otro. 2875 | 2876 | ##### Copiar archivos desde el sistema local al sistema remoto 2877 | Para copiar archivos desde el sistema local al sistema remoto utilizando SCP, utiliza el siguiente comando: 2878 | ```bash 2879 | scp miArchivo.txt root@127.0.0.1:/home/archivos -p 8022 2880 | ``` 2881 | 2882 | El comando te pedirá la contraseña del usuario remoto. Ingrésala y presiona "Enter" para iniciar la transferencia del archivo. 2883 | 2884 | ##### Copiar archivos desde el sistema remoto al sistema local 2885 | Para copiar archivos desde el sistema remoto al sistema local utilizando SCP, utiliza el siguiente comando: 2886 | ```bash 2887 | scp root@127.0.0.1:/home/archivos/logServidor.txt ~/logs/ -p 8022 2888 | 2889 | ``` 2890 | 2891 | ##### Copiar directorios recursivamente 2892 | Para copiar un directorio completo de forma recursiva desde el sistema local al sistema remoto o viceversa, utiliza el siguiente comando: 2893 | ``` 2894 | scp -r fotos root@127.0.0.1:/home/imagenes 2895 | ``` 2896 | 2897 | 2898 | [Tabla de Contenidos](#tabla-de-contenidos) 2899 | 2900 | ---- 2901 | 2902 | 2903 | ## Capítulo 23: Bots de Telegram 2904 | Telegram es una app de mensajería que puede resultar de gran utilidad para desarrolladores y hackers, en parte gracias a los bots. 2905 | 2906 | Los bots son programas normales pero con la capacidad añadida de que pueden usar telegram. Esto te permite enviar texto desde telegram a tu dispositivo y viceversa, esto nos da infinitas posibilidades. 2907 | 2908 | ##### Listado de bots útiles: 2909 | - [Conversor De Archivos](https://t.me/newfileconverterbot) 2910 | Le pasas un archivo y te lo convierte a otro formato. Soporta 874 formatos. 2911 | - [Email Temporal DropMail](https://t.me/DropMailBot) 2912 | Te da emails temporales que duran 10 minutos. 2913 | - [Email Temporal TempMail](https://t.me/TempMail_org_bot) 2914 | Otro bot de email temporales. 2915 | - [Email Mailable](https://t.me/mailableBot) 2916 | Este bot the permite crear tu dirección de correo, mandar y recibir correos desde Telegram 2917 | - [GMAIL](https://t.me/GmailBot) 2918 | Bot oficial de gmail. Te llevan los emails a telegram y puedes contestarles, enviar correos, etc. 2919 | - [Subir Archivos AnonFile](https://t.me/anonfileuploaderbot) 2920 | Te permite subir archivos a anonfiles.com desde telegram y te da el enlace de descarga 2921 | - [Traductor De Idiomas](https://t.me/BabelgramBot) 2922 | Traduce conversaciones entre distintos idiomas. 2923 | - [Imagenes de mapas y satellites](https://t.me/openmap_bot) 2924 | Le introduces una dirección y te da una imagen de la zona. 2925 | - [Convierte audios a texto](https://t.me/TranscribeME_bot) 2926 | Le mandas un audio y te da en texto lo que dice la persona. 2927 | - [Obten el texto de imágenes](https://t.me/TexifyBot) 2928 | Le mandas una imagen y te da el texto que salga en ella. 2929 | - [Convierte texto a voz](https://t.me/text_to_speach_bot) 2930 | Le mandas un texto y te devuelve un audio leyendo el texto. 2931 | - [Convierte Web a imagen/es o pdf](https://t.me/BetterWebShotBot) 2932 | Le pones la url y te permite obtener una (o varias) imagen o pdf de la web. 2933 | - [Antivirus VirusTotal](https://t.me/VirusTotalAV_bot) 2934 | Le mandas un archivo y comprueba si tiene virus. 2935 | - [Antivirus DrWeb](https://t.me/DrWebBot) 2936 | Le mandas un archivo y comprueba si tiene virus. 2937 | - [BD de Smartphones](https://t.me/SmartphoneDBot) 2938 | Introduces la marca/modelo y te sale todo el listado de modelos y todas sus especificaciones. 2939 | - [Ejecuta código javascript](https://t.me/injsbot) 2940 | Ejecuta el código javascript que le envies y te devuelve el resultado. 2941 | - [Ejecuta código en múltiples lenguajes](https://t.me/RextesterRoBot) 2942 | Ejecuta código en muchos lenguajes distintos y te da el resultado. 2943 | - [Descarga Youtube/Tiktok](https://t.me/redownload_bot) 2944 | Descarga videos como video o audio. 2945 | - [Crea códigos QR](https://t.me/qr_livebot) 2946 | Introduce un texto o url y te genera la imagen QR. 2947 | 2948 | 2949 | _Estos bots están todos operativos y son accesibles gratuitamente en el momento en el que se ha escrito este artículo. Esto puede cambiar si lo lees mucho tiempo después de que se escribiese_ 2950 | 2951 | 2952 | [Tabla de Contenidos](#tabla-de-contenidos) 2953 | 2954 | ---- 2955 | 2956 | 2957 | ## Capítulo 24: Telegram RAT 2958 | 2959 | ### Qué es un RAT? 2960 | RAT puede hacer referencia a 2 acrónimos en inglés: 2961 | 1. Remote Access Tool 2962 | 2. Remote Acesss Trojan 2963 | 2964 | Una Remote Access Tool (Herramienta de Acceso Remoto) es un programa informático que permite a un usuario acceder/controlar un dispositivo remoto. Son herramientas creadas para permitir administrar o dar soporte a sistemas sin tener accesso físico a ellos. 2965 | 2966 | Un Remote Access Trojan (Troyano de Acceso Remoto) es un tipo de software malicioso que se oculta en un programa aparentemente legítimo y permite a un atacante acceder y controlar un dispositivo remoto de manera no autorizada. Estos troyanos son utilizados con fines maliciosos, permitiendo a los ciberdelincuentes acceder y controlar dispositivos a distancia sin el conocimiento del usuario. Es decir es una herramienta de acceso remoto a la que se le han incluido funcionalidades que permitan su uso malicioso, como pueden ser la elevación de privilegios, polymorfismo, exfiltración de datos, invisibilidad, persistencia, etc. 2967 | 2968 | Si te suena el término botnet, normalmente las botnets son un montón de sistemas infectados por un RAT que pueden ser controlados simultaneamente. 2969 | 2970 | ### Requisitos 2971 | - Cuenta de Telegram 2972 | - Bash 2973 | - jq 2974 | - curl 2975 | 2976 | ### Creando el RAT 2977 | En el [Capítulo 5: Introducción a Bash](#cap%C3%ADtulo-5-introducci%C3%B3n-a-bash) aprendimos un poco sobre el lenguaje Bash, asique será el que vamos a utilizar para crear el bot. 2978 | 2979 | Antes de programar algo, sobre todo si somos inexpertos, es importante definir la lógica y las funcionalidades que queremos que tenga nuestro programa. Para hacer esto podemos usar pseudocódigo o bien el propio idioma español. Esto nos permitirá definir una idea clara de como y que será el programa. 2980 | 2981 | Podemos primero hacer un listado de las funcionalidades: 2982 | - Leer los mensajes de una cuenta Bot de Telegram 2983 | - Borrar los mensajes de la cuenta Bot de Telegram 2984 | - Enviar mensajes a la cuenta de Telegram 2985 | - Sistema de login 2986 | - Usuarios logeados pueden correr comandos en el sistema 2987 | - Usuarios no logeados pueden correr comandos como /help o /login 2988 | 2989 | Una vez tenemos la lista de lo que queremos que haga el programa, podemos escribir como sería el código en español en un lenguaje inventado: 2990 | 2991 | ``` 2992 | -comentario- VariablesGlobales: 2993 | crear lista usuariosLogeados 2994 | 2995 | -comentario- Funciones: 2996 | funcion LeerMensajes 2997 | mensajes = solicitarMensajes a telegram 2998 | retornar mensajes 2999 | 3000 | funcion BorrarMensajes 3001 | solicitarBorradoDeMensajes a telegram 3002 | 3003 | funcion EnviarMensaje mensaje_del_bot usuario_x 3004 | enviarMensaje mensaje_del_bot al usuario_x de telegram 3005 | 3006 | funcion Login usuario_x contrasena_x 3007 | si usuario_x está en la lista 3008 | retornar VERDADERO 3009 | 3010 | funcion CorrerComandosEnSistema usuario_x comando_a_correr 3011 | si (ComprobarSiUsuarioEnLista usuario_x) igual a VERDADERO 3012 | respuestaDelComando = ejecutar comando_a_correr 3013 | retornar respuestaDelComando 3014 | 3015 | 3016 | -comentario- Código principal: 3017 | bucleInfinito: 3018 | mensaje = LeerMensajes 3019 | 3020 | si mensaje tiene /login 3021 | si login usuario_x contrasena_x igual a VERDADERO 3022 | Añadir usuario_x a la lista de usuariosLogeados 3023 | 3024 | si mensaje tiene hola 3025 | EnviarMensaje "Hola soy el RAT" usuario_x 3026 | 3027 | si mensaje tiene /ejecutar_comando 3028 | si (ComprobarSiUsuarioEnLista usuario_x) igual a VERDADERO 3029 | respuestaDelComando = ejecutar comando_a_correr 3030 | EnviarMensaje respuestaDelComando usuario_x 3031 | 3032 | BorrarMensajes 3033 | Esperar 5 segundos 3034 | ``` 3035 | 3036 | Como puedes observar el código es bastante sencillo. Esto es lo que sería la lógica principal del programa. Obviamente se omiten pequeños detalles como manejo de errores, obtener el nombre del usuario de los mensajes, etc. Ya que el objetivo de hacer este pseudocódigo es definir la lógica principal/estructura que queremos que tenga nuestro programa. 3037 | 3038 | El siguiente paso es escribir este mismo código pero en un lenguaje real. En nuestro caso Bash, pero se puede utilizar cualquier otro. 3039 | 3040 | ##### Creando el bot de Telegram 3041 | Para poder interactuar con Telegram, lo primero será crear un bot de telegram que guardará los mensajes que le mandemos, y así nosotros podremos acceder a ellos desde el RAT. Como ya vimos en los requisitos necesitamos tener una cuenta de Telegram para poder crear bots. Una vez tienes una cuenta puedes crear un bot en la siguiente url: [https://t.me/BotFather](https://t.me/BotFather), si estás en Android con hacer click ya te abre el chat con BotFather para poder crear tu bot. 3042 | 3043 | Una vez dentro del chat de tg con BotFather le escribirás el comando /newbot para iniciar la creación de un nuevo bot. Te pedirá que escribas el nombre del bot. Puedes ponerle por ejemplo: RAT_De_TuNombre 3044 | 3045 | Tras enviarle el nombre de tu bot, te dirá que necesita un nombre de usuario para la cuenta del bot. Es decir, te está pidiendo el @ del bot. Una de las condiciones de las cuentas de bots es que su nombre de cuenta debe terminar por la palabra bot. Asique puedes llamarlo RAT_De_TuNombre_Bot que en mi caso sería RAT_De_Manolo_Bot 3046 | 3047 | Si el nombre es válido, verás un mensaje como: 3048 | ``` 3049 | Done! Congratulations on your new bot. You will find it at t.me/RAT_De_Manolo_Bot. You can now add a description, about section and profile picture for your bot, see /help for a list of commands. By the way, when you've finished creating your cool bot, ping our Bot Support if you want a better username for it. Just make sure the bot is fully operational before you do this. 3050 | 3051 | Use this token to access the HTTP API: 3052 | 5863933391:HBGUBfzdfpp0QtZVSvGaWUMbWvJi7dWLJK9 3053 | Keep your token secure and store it safely, it can be used by anyone to control your bot. 3054 | 3055 | For a description of the Bot API, see this page: https://core.telegram.org/bots/api 3056 | ``` 3057 | 3058 | En este mensaje se incluye una url para poder hablar con el bot y un token que debes poner en las peticiones que hagas al bot, por ejemplo para obtener los mensajes que le enviaron al bot. 3059 | 3060 | *IMPORTANTE*: _Este token no debes compartirlo con nadie, ya que se puede utilizar para controlar el bot y por tanto si lo tienes funcionando en tu sistema o en otro, un desconocido que tenga tu token del bot podría también controlar el sistema sin que tu lo sepas._ 3061 | 3062 | Podemos probar que todo funciona correctamente con un comando de curl. Abre un chat con el bot usando el enlace que te dio BotFather y envíale el mensaje Hola! 3063 | 3064 | Utiliza el siguiente comando para solicitar los mensajes del bot con curl: 3065 | ```bash 3066 | curl 'https://api.telegram.org/botYOUR_BOT_TOKEN/getUpdates' 3067 | ``` 3068 | 3069 | Obviamente remplaza YOUR_BOT_TOKEN por el token de tu bot. En mi caso sería: 3070 | ```bash 3071 | curl 'https://api.telegram.org/bot5863933391:HBGUBfzdfpp0QtZVSvGaWUMbWvJi7dWLJK9/getUpdates' 3072 | ``` 3073 | 3074 | *NOTA*: _/getUpdates así como otros endpoints de la API de Telegram Bot están publicadas en la web de telegram. [Bot API](https://core.telegram.org/bots/api). Si bajas por la web verás el getUpdates que estoy utilizando, asi como otros que están disposibles_ 3075 | 3076 | Si todo está correcto, verás una respuesta similar a: 3077 | ```json 3078 | {"ok":true,"result":[{"update_id":241851273, 3079 | "message":{"message_id":1,"from":{"id":827150271,"is_bot":false,"first_name":"StringManolo","username":"StringManolo","language_code":"es"},"chat":{"id":167170617,"first_name":"StringManolo","username":"StringManolo","type":"private"},"date":1662723616,"text":"Hola"}}]} 3080 | ``` 3081 | 3082 | Este formato se conoce como JSON y es bastante utilizado por muchos servicios. Con el comando *jq* podremos extraer exactamente lo que necesitemos de la respuesta del bot. Por ejemplo si queremos obtener solo el mensaje: 3083 | ```bash 3084 | curl -s curl 'https://api.telegram.org/bot5863933391:HBGUBfzdfpp0QtZVSvGaWUMbWvJi7dWLJK9/getUpdates' | jq .result[0].message.text 3085 | ``` 3086 | 3087 | Veremos como resultado el mensaje 'Hola' que le escribimos al bot en el chat. La sintaxis de jq es sencilla de entender, los puntos son para acceder a propiedades (es decir los nombres), y los corchetes son para acceder al mensaje en concreto. Por ejemplo con [0] accedemos al primer mensaje, con [1] accedemos al segundo, con [9] accedemos al décimo, etc. En este caso solo tenemos el de Hola, pero si le envias mas cosas al chat del bot, tendrás mas. 3088 | 3089 | Si espaciamos el JSON podemos ver mejor su estructura visualmente: 3090 | ```json 3091 | { 3092 | "ok": true, 3093 | "result": [ 3094 | { 3095 | "update_id": 241851273, 3096 | "message": { 3097 | "message_id": 1, 3098 | "from": { 3099 | "id": 827150271, 3100 | "is_bot": false, 3101 | "first_name": "StringManolo", 3102 | "username": "StringManolo", 3103 | "language_code": "es" 3104 | }, 3105 | "chat": { 3106 | "id": 167170617, 3107 | "first_name": "StringManolo", 3108 | "username": "StringManolo", 3109 | "type": "private" 3110 | }, 3111 | "date": 1662723616, 3112 | "text": "Hola" 3113 | } 3114 | }, 3115 | 3116 | { 3117 | "update_id": 241851274, 3118 | "message": { 3119 | "message_id": 2, 3120 | "from": { 3121 | "id": 827150271, 3122 | "is_bot": false, 3123 | "first_name": "StringManolo", 3124 | "username": "StringManolo", 3125 | "language_code": "es" 3126 | }, 3127 | "chat": { 3128 | "id": 167170617, 3129 | "first_name": "StringManolo", 3130 | "username": "StringManolo", 3131 | "type": "private" 3132 | }, 3133 | "date": 1662723640, 3134 | "text": "Otro Mensaje" 3135 | } 3136 | } 3137 | ] 3138 | } 3139 | ``` 3140 | 3141 | Le añadí otro mensaje para que veas como queda. 3142 | 3143 | 3144 | Pues ahora que ya vemos mas o menos como funciona, lo que haremos es usar Bash para obtener estos mensajes programáticamente, analizarlos y tomar decisiones en base al texto que recibamos, por ejemplo si recibimos el mensaje /saluda podremos obtener el nombre del usuario que nos envió ese mensaje, el id del chat y enviarle un mensaje tal que 'Hola Manolo' al mismo chat que nos envió el mensaje /saluda. Con esta sencilla técnica si detectamos el mensaje '/run ls' podremos ejecutar el comando ls usando Bash y enviarle al chat del usuario la respuesta del comando ls. Así de esta forma es como tener una terminal remota, ya que todos los comandos que le ponemos en el chat de telegram nuestro programa en bash los ejecutará y nos enviará la respuesta. 3145 | 3146 | Pues procedamos a implementar en bash nuestra primera función LeerMensajes que hicimos en pseudocódugo en español. _Para programar usaré VIM como editor de texto. Si no lo manejas puedes revisar el_ [Capítulo 6: Uso de VI y de VIM](#cap%C3%ADtulo-6-uso-de-vi-y-de-vim) _o puedes utilizar cualquier otro editor de texto._ 3147 | 3148 | Crearé el archivo llamado rat.sh con el siguiente comando: 3149 | ```bash 3150 | vim rat.sh 3151 | ``` 3152 | 3153 | ##### Y dentro del archivo haremos la función LeerMensajes: 3154 | ```bash 3155 | TOKEN='5863933391:HBGUBfzdfpp0QtZVSvGaWUMbWvJi7dWLJK9'; 3156 | 3157 | LeerMensajes() { 3158 | local -n referenciaMensajes=$2; 3159 | local comando='curl '"'"'https://api.telegram.org/bot'; 3160 | comando+=$1; # $TOKEN 3161 | comando+='/getUpdates'"'"' --silent'; 3162 | referenciaMensajes=$(eval $comando); 3163 | } 3164 | 3165 | LeerMensajes $TOKEN mensajes; 3166 | echo $mensajes 3167 | ``` 3168 | 3169 | Explicación del código: 3170 | - Utilizo una variable para almacenar el token, ya que si lo metes directamente en el url y en el futuro utilizas otro bot, o cambias el token de tu bot tendrías que cambiarlo de todas las urls. En cambio usando la variable TOKEN tan solo hay que cambiarle el token ahí. 3171 | 3172 | - Obtengo una referencia local a la segunda variable que se pase en la llamada a la función (es una técnica para poder rellenar la variable mensajes con lo que queramos) 3173 | 3174 | - Creo un texto tal que curl 'https://.....' después le añado el TOKEN, después el resto de la url. 3175 | 3176 | - Evalúo el texto para ejecutarlo como comando. 3177 | 3178 | - Le asigno a mensajes la respuesta del comando (el JSON). 3179 | 3180 | - Añadí también un código de ejemplo de como se utiliza la función para guardar el JSON en una variable y lo imprimo en consola. 3181 | 3182 | 3183 | Si sales del editor y ejecutas el código con el comando: 3184 | ```bash 3185 | bash rat.sh 3186 | ``` 3187 | 3188 | Verás la misma salida que obteníamos al correr el comando curl en consola solicitando los mensajes. Es decir, la función lo único que hace es guardar en una variable $mensajes la respuesta del comando curl. 3189 | 3190 | ##### Para la función BorrarMensajes haremos lo mismo: 3191 | ```bash 3192 | ultimoId=0; 3193 | 3194 | BorrarMensajes() { 3195 | local -n referenciaMensajes=$2; 3196 | local comando='curl '"'"'https://api.telegram.org/bot'; 3197 | comando+=$1; # $TOKEN 3198 | comando+='/getUpdates?offset='; 3199 | comando+=$(($ultimoId)); 3200 | comando+=''"'"' --silent'; 3201 | referenciaMensajes=$(eval $comando); 3202 | } 3203 | ``` 3204 | 3205 | Explicación del código: 3206 | - El código es prácticamente igual que la función LeerMensajes 3207 | - Cambiamos el método del endpoint a /getUpdates?offset=$ultimoId 3208 | Por el resto es lo mismo. Esto lo explican en la documentación de Telegram Bot API. Al pasarle el id de update del JSON se borran automáticamente los mensajes anteriores. El id de update lo verás en el json, en este caso la variable ultimoId es una variable global como TOKEN que modificaremos mas adelante. 3209 | 3210 | ##### La siguiente función es la de EnviarMensaje: 3211 | ```bash 3212 | # Codifica comillas, guiones, barra invertida y otros caracteres especiales 3213 | CodificarMensaje() { 3214 | local cadena="${1}"; 3215 | local tamanhoCadena=${#cadena}; 3216 | local codificado=""; 3217 | local pos c o; 3218 | 3219 | for (( pos=0 ; pos 3913 | 3914 | 3915 | Example Domain 3916 | 3917 | 3918 | 3919 | 3920 | 3947 | 3948 | 3949 | 3950 |
3951 |

Example Domain

3952 |

This domain is for use in illustrative examples in documents. You may use this 3953 | domain in literature without prior coordination or asking for permission.

3954 |

More information...

3955 |
3956 | 3957 | 3958 | ``` 3959 | 3960 | Como puedes observar la primera linea nos indica la versión del protocolo con la que nos responde, un número que se conoce como _código de estado_ y una descripción corta en texto con lo que significa ese código _frase de estado_. Por ejemplo 200 nos dice que todo está OK, que en respuesta a GET suele significar que encontró el rescurso que le pedimos (el /index.html). Otro código de respuesta muy conocido es el 404 Not Found (no encontrado que nos suele aparecer cuando solicitamos un recurso que no existe en el servidor. 3961 | 3962 | A partir de ahí también nos responde con cabeceras. Vamos a ver que significa cada una de las cabeceras que nos envió: 3963 | 3964 | - *Age*: Indica cuánto tiempo ha pasado desde que la respuesta fue generada por el servidor (en segundos). 3965 | - *Cache-Control*: Especifica las directivas de control de caché que deben aplicarse tanto a la solicitud como a la respuesta. En este caso, `max-age=604800` indica que el contenido se puede almacenar en caché durante 604800 segundos (7 días). 3966 | - *Content-Type*: Indica el tipo de contenido del cuerpo de la respuesta. En este caso, `text/html; charset=UTF-8` indica que el contenido es HTML con codificación UTF-8. 3967 | - *Date*: Muestra la fecha y hora en que se generó la respuesta. 3968 | - *Etag*: Proporciona una etiqueta que identifica única e individualmente la versión actual del recurso. Se utiliza para la validación de la caché condicional. 3969 | - *Expires*: Indica la fecha y hora en que expira el contenido almacenado en caché. 3970 | - *Last-Modified*: Muestra la fecha y hora en que se modificó por última vez el recurso en el servidor. 3971 | - *Server*: Indica el software del servidor que respondió a la solicitud. 3972 | - *Vary*: Indica qué encabezados de solicitud se utilizaron para determinar la respuesta almacenada en caché. En este caso, `Accept-Encoding` indica que la respuesta puede variar según la codificación de contenido aceptada. 3973 | - *X-Cache*: Proporciona información sobre el estado de la caché en el servidor. `HIT` indica que la respuesta se sirvió desde la caché. 3974 | - *Content-Length*: Indica la longitud del cuerpo de la respuesta en bytes. Mas o menos equivale al número de caracteres que tiene el archivo que le solicitamos. 3975 | 3976 | Tras las cabeceras de respuesta se incluye el contenido del archivo solicitado, en este caso es el index.html de la página example.com. Si lo guardas y lo abres en un navegador verás la web de example.com 3977 | 3978 | ##### HTTPS 3979 | Ya sabes que es HTTP, pero entonces que es HTTPS, otro protocolo? En verdad no, cuando nos referimos a HTTPS nos estamos refieriendo a HTTP pero enviado en un tunel seguro. Si conectamos directamente a un servidor por ejemplo con el comando ncat example.com 80 estamos estableciendo un tunel TCP/IP con el servidor de example.com por el cual mandaremos el mensaje siguiendo el protocolo HTTP. El puerto 80 es el puerto por defecto para el protocolo HTTP sin cifrar, si queremos establecer un canal cifrado usaremos el puerto 443. Por ejemplo: 3980 | ```bash 3981 | echo 'GET / HTTP/1.1 3982 | Host: example.com 3983 | 3984 | 3985 | ' | ncat example.com 443 3986 | ``` 3987 | 3988 | Si hacemos esto sin más estaremos enviando una petición HTTP sin cifrar a un tunel que requiere cifrado y el servidor o cerrará el tunel TCP sin respondernos o nos avisará que estamos enviando texto sin cifrar. En el caso concreto de example.com simplemente cierra el tunel y ncat nos avisará con el mensaje: *Ncat: Connection reset by peer.* en español *Ncat: Conexión restablecida por la otra parte*. Es decir, la otra parte de la comunicación (el servidor de example.com) nos cerró la conexión (tunel) porque le enviamos texto sin cifrar en lugar de negociar el cifrado. La parte de negociación del cifrado es un tema complejo que pertenece al protocolo TLS y no tiene que ver con el protocolo HTTP, asique no es algo que corresponda explicar en este capítulo. Si quieres usar un tunel cifrado simplemente añade la flag --ssl al comando ncat y el programa se encargará automáticamente de negociar el cifrado. 3989 | 3990 | ```bash 3991 | echo 'GET / HTTP/1.1 3992 | Host: example.com 3993 | 3994 | 3995 | ' | ncat example.com 443 --ssl 3996 | ``` 3997 | 3998 | Verás la misma respuesta si utilizas http en el puerto 80 que si utilizas https en el puerto 443, la diferencia es que el mensaje viaja cifrado, esto quiere decir que si alguien te está espiando en el wi-fi en lugar de ver las peticiones tal como tu las escribes verá "caracteres sin sentido" (el tráfico cifrado). Asique siempre que puedas utiliza https ya que es lo mismo pero en lugar de usar un tunel sin cifrado, las peticiones y respuestas van cifradas y solo tú y example.com teneis las contraseñas para descifrarlas. 3999 | 4000 | Aquí un resumen de lo que pasa cuando utilizas la flag --ssl: 4001 | 1. El cliente (ncat) se conecta al servidor en el puerto 443. 4002 | 2. El servidor responde con su certificado digital. 4003 | 3. El cliente verifica la autenticidad del certificado. 4004 | 4. El cliente y el servidor intercambian información para acordar el cifrado y la clave. 4005 | 5. Se genera una clave de sesión para cifrar y descifrar los datos. 4006 | 6. Una vez establecida la conexión segura, el cliente y el servidor pueden intercambiar datos cifrados. 4007 | 4008 | ##### Servidor Web mínimo 4009 | A parte de enviar peticiones a un servidor, podemos crear un servidor mínimo que nos responda a las peticiones, ncat nos sirve para hacer una versión mínima de HTTP. 4010 | 4011 | ```bash 4012 | #!/usr/bin/env bash 4013 | 4014 | # Puerto en el que escuchará el servidor web 4015 | PUERTO=8080 4016 | 4017 | # Función para manejar las solicitudes HTTP 4018 | manejar_solicitud() { 4019 | cat index.html 4020 | } 4021 | 4022 | # Iniciar el servidor web 4023 | while true; do 4024 | respuesta=$(manejar_solicitud) 4025 | echo -ne "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n$respuesta\r\n" | ncat -lk -p $PUERTO 4026 | done 4027 | ``` 4028 | 4029 | Puedes guardar este archivo como servidor_web.sh darle permisos y ejecutarlo con el comando: 4030 | 4031 | ```bash 4032 | chmod 775 ./servidor_web.sh 4033 | ./servidor_web.sh 4034 | ``` 4035 | 4036 | Ahora podrás interactuar con él en el puerto 8080. Como ves en su código lo único que hace es enviar siempre la misma respuesta. Si tienes un archivo index.html te lo enviará en la respuesta. Puedes probar a crear el index.html con el comando: 4037 | 4038 | ```bash 4039 | echo '

Esta es mi web de ejemplo

' > index.html 4040 | ``` 4041 | 4042 | Y ahora puedes verla desde el navegador visitando la URL http://localhost:8080 o http://127.0.0.1:8080 4043 | 4044 | También puedes usar url o ncat desde otra sesión de la terminal en lugar del navegador. 4045 | 4046 | 4047 | [Tabla de Contenidos](#tabla-de-contenidos) 4048 | 4049 | 4050 | 4051 | ---- 4052 | 4053 | 4054 | 4055 | ## Capítulo 26: Protocolo DNS 4056 | 4057 | [Tabla de Contenidos](#tabla-de-contenidos) 4058 | 4059 | ---- 4060 | 4061 | 4062 | 4063 | ## Capítulo 27: Servicios Web 4064 | 4065 | [Tabla de Contenidos](#tabla-de-contenidos) 4066 | 4067 | ---- 4068 | 4069 | 4070 | 4071 | ## Capítulo 28: Hosting Gratuitos 4072 | 4073 | [Tabla de Contenidos](#tabla-de-contenidos) 4074 | 4075 | ---- 4076 | 4077 | 4078 | 4079 | ## Capítulo 29: Dominios Gratuitos 4080 | 4081 | [Tabla de Contenidos](#tabla-de-contenidos) 4082 | 4083 | ---- 4084 | 4085 | 4086 | ## Capítulo 30: Introducción a Programación 4087 | 4088 | [Tabla de Contenidos](#tabla-de-contenidos) 4089 | 4090 | ---- 4091 | 4092 | -------------------------------------------------------------------------------- /TODO.md: -------------------------------------------------------------------------------- 1 | - Añadir case a condicionales 2 | - Añadir una opción para dar soporte económico al proyecto 3 | - Hacer tree a una instalación de Termux limpia para obtener sistema de ficheros a documentar 4 | - Probar a añadir etiquetas metas para mejorar la previsualización de del enlace a githubpages en Telegram 5 | - Revisar capítulos a partir del 12 paso a paso en instalación limpia de termux 6 | - Crear contraportada explicando que es Termux, qie se puede instalar gratuitamente en smartphones sin riesgo y demás características 7 | - Añadir protocolo de copia al capitulo de ssh y sshd 8 | - Comentar riesgos y prácticas de seguridad para ssh/d asi como opciones de config 9 | - Comentar opciones y argumentos de ssh, scp, sshd, etc 10 | - Testear rsync como alternstiva a scp en Termux 11 | - Añadir mas imágenes 12 | - Añadir páginas xon scripts útiles 13 | - Testear SCP 14 | -------------------------------------------------------------------------------- /_includes/head-custom.html: -------------------------------------------------------------------------------- 1 | 3 | -------------------------------------------------------------------------------- /imagenes/cat.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/StringManolo/hackingTermux101/f9dc741342ca830eae315910af8c1d69b58ed45c/imagenes/cat.jpg -------------------------------------------------------------------------------- /imagenes/cd_ejemplo.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/StringManolo/hackingTermux101/f9dc741342ca830eae315910af8c1d69b58ed45c/imagenes/cd_ejemplo.jpg -------------------------------------------------------------------------------- /imagenes/echo.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/StringManolo/hackingTermux101/f9dc741342ca830eae315910af8c1d69b58ed45c/imagenes/echo.jpg -------------------------------------------------------------------------------- /imagenes/ls.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/StringManolo/hackingTermux101/f9dc741342ca830eae315910af8c1d69b58ed45c/imagenes/ls.jpg -------------------------------------------------------------------------------- /imagenes/portada.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/StringManolo/hackingTermux101/f9dc741342ca830eae315910af8c1d69b58ed45c/imagenes/portada.png -------------------------------------------------------------------------------- /imagenes/ps1.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/StringManolo/hackingTermux101/f9dc741342ca830eae315910af8c1d69b58ed45c/imagenes/ps1.jpg -------------------------------------------------------------------------------- /imagenes/pwd.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/StringManolo/hackingTermux101/f9dc741342ca830eae315910af8c1d69b58ed45c/imagenes/pwd.jpg -------------------------------------------------------------------------------- /imagenes/termux-setup-storage.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/StringManolo/hackingTermux101/f9dc741342ca830eae315910af8c1d69b58ed45c/imagenes/termux-setup-storage.png -------------------------------------------------------------------------------- /paginas/mostrarArch.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | Muestra Arquitectura 8 | 9 | 10 |
11 | 12 | 16 | 17 | 18 | --------------------------------------------------------------------------------