{"id":22960316,"url":"https://github.com/stringmanolo/hackingtermux101","last_synced_at":"2025-04-04T21:10:31.282Z","repository":{"id":95119405,"uuid":"477487725","full_name":"StringManolo/hackingTermux101","owner":"StringManolo","description":"Libro sobre hacking básico/avanzado en Termux","archived":false,"fork":false,"pushed_at":"2023-10-23T15:30:46.000Z","size":498,"stargazers_count":643,"open_issues_count":20,"forks_count":59,"subscribers_count":39,"default_branch":"master","last_synced_at":"2025-03-28T20:11:46.769Z","etag":null,"topics":["bash","book","cli","comandos","command","hacking","libro","terminal","termux","termux-hacking","termux-tool","tutorial","vim"],"latest_commit_sha":null,"homepage":"https://stringmanolo.github.io/hackingTermux101/","language":"HTML","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":null,"status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/StringManolo.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":"FUNDING.yml","license":null,"code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null},"funding":{"github":"stringmanolo"}},"created_at":"2022-04-03T23:04:52.000Z","updated_at":"2025-03-27T11:48:19.000Z","dependencies_parsed_at":null,"dependency_job_id":"f5495b7e-ad0c-4f3d-bc06-f14c8792c681","html_url":"https://github.com/StringManolo/hackingTermux101","commit_stats":null,"previous_names":[],"tags_count":0,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/StringManolo%2FhackingTermux101","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/StringManolo%2FhackingTermux101/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/StringManolo%2FhackingTermux101/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/StringManolo%2FhackingTermux101/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/StringManolo","download_url":"https://codeload.github.com/StringManolo/hackingTermux101/tar.gz/refs/heads/master","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":247249532,"owners_count":20908212,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["bash","book","cli","comandos","command","hacking","libro","terminal","termux","termux-hacking","termux-tool","tutorial","vim"],"created_at":"2024-12-14T18:32:54.522Z","updated_at":"2025-04-04T21:10:31.260Z","avatar_url":"https://github.com/StringManolo.png","language":"HTML","funding_links":["https://github.com/sponsors/stringmanolo"],"categories":[],"sub_categories":[],"readme":"![Portada Libro](https://github.com/StringManolo/hackingTermux101/raw/master/imagenes/portada.png)\n\n-----\n\n### Languages\n\n##### ESP\nEste 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.\n\n##### EN\nThis 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\u0026_x_tr_tl=en\u0026_x_tr_hl=es\u0026_x_tr_pto=wapp#tabla-de-contenidos) \n\n### Tabla de Contenidos\n\n* [Prefacio](#prefacio)\n* [Capítulo 0: Requisitos y Programas Extra](#cap%C3%ADtulo-0-requisitos-y-programas-extra)\n* [Capítulo 1: Qué es Termux?](#cap%C3%ADtulo-1-qu%C3%A9-es-termux)\n* [Capitulo 2: Descarga e Instalación](#capitulo-2-descarga-e-instalaci%C3%B3n)\n* [Capítulo 3: Configuración Básica](#cap%C3%ADtulo-3-configuraci%C3%B3n-b%C3%A1sica)\n* [Capítulo 4: Uso básico de la terminal](#cap%C3%ADtulo-4-uso-b%C3%A1sico-de-la-terminal)\n* [Capítulo 5: Introducción a Bash](#cap%C3%ADtulo-5-introducci%C3%B3n-a-bash)\n* [Capítulo 6: Uso de VI y de VIM](#cap%C3%ADtulo-6-uso-de-vi-y-de-vim)\n* [Capitulo 7: Configuración de Bash](#capitulo-7-configuraci%C3%B3n-de-bash)\n* [Capítulo 8: Sistema de Ficheros](#cap%C3%ADtulo-8-sistema-de-ficheros)\n* [Capítulo 9: Creando comandos](#cap%C3%ADtulo-9-creando-comandos)\n* [Capítulo 10: Comandos Intermedios](#cap%C3%ADtulo-10-comandos-intermedios)\n* [Capítulo 11: Proot-Distro](#cap%C3%ADtulo-11-proot-distro)\n* [Capitulo 12: Introducción a Sistemas Linux](#capitulo-12-introducci%C3%B3n-a-sistemas-linux)\n* [Capitulo 13: Uso básico de Debian](#capitulo-13-uso-b%C3%A1sico-de-debian)\n* [Capítulo 14: Uso básico de Ubuntu](#cap%C3%ADtulo-14-uso-b%C3%A1sico-de-ubuntu)\n* [Capítulo 15: Uso básico de Alpine](#cap%C3%ADtulo-15-uso-b%C3%A1sico-de-alpine)\n* [Capítulo 16: Uso básico de Fedora](#cap%C3%ADtulo-16-uso-b%C3%A1sico-de-fedora)\n* [Capítulo 17: Introducción a Servicios](#cap%C3%ADtulo-17-introducci%C3%B3n-a-servicios)\n* [Capítulo 18: Creando un Servidor](#cap%C3%ADtulo-18-creando-un-servidor)\n* [Capítulo 19: Ngrok y Exponer Servicios](#cap%C3%ADtulo-19-ngrok-y-exponer-servicios)\n* [Capítulo 20: Tor, Configuración y Uso](#cap%C3%ADtulo-20-tor-configuraci%C3%B3n-y-uso)\n* [Capítulo 21: Servicios Ocultos](#cap%C3%ADtulo-21-servicios-ocultos)\n* [Capítulo 22: SSH, SCP y SSHD](#cap%C3%ADtulo-22-ssh-scp-y-sshd)\n* [Capítulo 23: Bots de Telegram](#cap%C3%ADtulo-23-bots-de-telegram)\n* [Capítulo 24: Telegram RAT](#cap%C3%ADtulo-24-telegram-rat)\n* [Capítulo 25: Protocolo HTTP](#cap%C3%ADtulo-25-protocolo-http)\n* [Capítulo 26: Protocolo DNS](#cap%C3%ADtulo-26-protocolo-dns)\n* [Capítulo 27: Servicios Web](#cap%C3%ADtulo-27-servicios-web)\n* [Capítulo 28: Hosting Gratuitos](#cap%C3%ADtulo-28-hosting-gratuitos)\n* [Capítulo 29: Dominios Gratuitos](#cap%C3%ADtulo-29-dominios-gratuitos)\n* [Capítulo 30: Introducción a Programación](#cap%C3%ADtulo-30-introducci%C3%B3n-a-programaci%C3%B3n)\n* Capítulo 31: Comparación de Lenguajes\n* Capitulo 32: Introducción a C\n* Capìtulo 33: Introducción a C++\n* Capítulo 34: Introducción a C#\n* Capítulo 35: Introducción a Go\n* Capítulo 36: Introducción a Java\n* Capítulo 37: Introducción a Javascript\n* Capítulo 38: Introducción a Lua\n* Capítulo 39: Introducción a PHP\n* Capítulo 40: Introducción a Python\n* Capítulo 41: Introducción a Rust\n* Capítulo 42: Introducción a Node\n* Capítulo 43: Introducción a Typescript\n* Capítulo 44: Introducción a la Criptografìa\n* Capítulo 45: Introducción al Malware\n* Capítulo 46: Desarrollo de RATs\n* Capítulo 47: Desarrollo de Ransomwares\n* Capítulo 48: Desarrollo de Greyware\n* Capítulo 49: Introducción a Hacking \n* Capítulo 50: Introducción a OSINT\n* Capitulo 51: Google Hacking (dorks)\n* Capitulo 52: Introducción a Hacking Web\n* Capítulo 53: Introducción a Ingeniería Social\n* Capítulo 54: Laboratorios y Páginas de Hacking legal.\n* Capìtulo 55: HTMLi (inyección de HTML)\n* Capítulo 56: XSS (Inyección de Javascript)\n* Capítulo 57: CSFR (Peticiones entre sitios)\n* Capítulo 58: Clickjacking (secuestro de clicks)\n* Capítulo 59: HPP (Polución de parámetros HTTP)\n* Capítulo 60: Open Redirects (redirecciones abiertas)\n* Capitulo 61: SSRF (falsificación de peticiones en el lado del servidor)\n* Capítulo 62: Path Traversal (recorrer rutas)\n* Capítulo 63: Referrer Leaks (Filtraciones del referido)\n* Capítulo 64: Dangling HTML (HTML pendiente)\n* Capítulo 65: Subdomain/Domain Takeover (secuestro de sub/dominios)\n* Capítulo 66: Template Injection (Inyección de plantillas)\n* Capítulo 67: IDOR (Referencia a objecto indirecta)\n* Capítulo 68: SQLi (Inyección del lenguaje de consultas estructurado)\n* Capítulo 69: Cookie Tossing (lanzamiento de cookies)\n* Capítulo 70: Web Cache Poisoning (envenenamiento de la caché web)\n* Capítulo 71: Malas prácticas\n* Capítulo 72: Post Explotación\n* Capítulo 73: Herramientas de Hacking\n* Capítulo 74: Dig\n* Capítulo 75: Dirstalk\n* Capítulo 76: Impulse\n* Capítulo 77: ncat\n* Capítulo 78: nmap\n* Capítulo 79: nuclei\n* Capítulo 80: searchsploit\n* Capítulo 81: shodan\n* Capítulo 82: sqlmap\n* Capítulo 83: turbolist3r\n* Capítulo 84: C++ intermedio\n* Capítulo 85: Go intermedio\n* Capítulo 86: Javascript intermedio\n* Capítulo 87: PHP intermedio\n* Capítulo 88: Python intermedio\n* Capítulo 89: Node intermedio\n* Capítulo 90: Quickjs intermedio\n* Capítulo 91: Typescript intermedio\n* Capítulo 92: Criptografía intermedio\n* Capítulo 93: Malware intermedio\n* Capítulo 94: Ingeniería Social intermedio\n* Capítulo 95: Creando laboratorios y aplicaciones vulnerables\n* Capítulo 96: Desarrollando aplicaciones de hacking\n* Capítulo 97: Retos nivel basico\n* Capítulo 98: Retos nivel intermedio\n* Capítulo 99: Retos nivel avanzado\n* Capítulo 100: Retos nivel 3l1t3\n \n* Glosario\n* Apéndice\n\n-----\n\n## Prefacio\n\nBienvenido 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. \n\nTermux 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.\n\nUn 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. \n \n**Disfrútalo!**\n\n[Tabla de Contenidos](#tabla-de-contenidos) \n\n-----\n\n## Capítulo 0: Requisitos y Programas Extra\n\nPara poder utilizar Termux, necesitas un dispositivo Android. Termux soporta versiones de **android** comprendidas **entre** la **versión 7 y** la **última version** de Android. \n\nNecesitas 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. \n \nAntes de empezar, algunos programas extra son recomendados, aunque no necesarios.\n* [Hackers Keyboard](https://github.com/klausw/hackerskeyboard/releases/download/1.40.7/hackerskeyboard-v1.40.7.apk) \nEste 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. \n \nLos que vienen preinstalados suelen vender tus datos aunque los configures para que no lo hagan.\n\n* [Fx File Explorer](https://play.google.com/store/apps/details?id=nextapp.fx) \nExplorador 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. \n\n[Tabla de Contenidos](#tabla-de-contenidos) \n\n-----\n\n## Capítulo 1: Qué es Termux?\n\nTermux 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. \n \nTermux 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. \n \nEs seguro, ya que todo es código abierto y miles de profesionales revisan el código y los nuevos cambios a diario. \n\nTiene 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. \n \nTotalmente customizable. Puedes modificar la apariencia, añadir atajos de teclado, nuevas funcionalidades... \n\nSoporta teclado y ratón externos. Puedes conectar Termux a una pantalla externa y utilizar un teclado y un ratón. \n\n#### Cómo funciona?\nLa 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. \n \nLa 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. \n\nTermux 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. \n \nEl 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 \n \nEste 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. \n\n[Tabla de Contenidos](#tabla-de-contenidos)\n\n-----\n\n## Capitulo 2: Descarga e Instalación\n\n### Descarga\nPuedes 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/). \n \nLa 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). \n \nSi no conoces la arquitectura de tu dispositivo, puedes pinchar [aquí](https://stringmanolo.github.io/hackingTermux101/paginas/mostrarArch.html). \n \n### Instalacion\n- Abre F-Droid en tu Android pinchando [aquí](https://f-droid.org/packages/com.termux/) \n- Pincha en el primer enlace que dice [Descargar Apk]() \n- Pincha en el archivo descargado para iniciar la instalación \n- Pincha en Permitir instalación de aplicaciones desde orígenes desconocidos \n- Espera a que se complete la instalación \n- Cuando finalice la instalación tendrás el icono de Termux en tu escritorio, haz click para arrancar la app.\n \n[Tabla de Contenidos](#tabla-de-contenidos)\n\n-----\n\n## Capítulo 3: Configuración Básica\n\nUna 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\n```bash\ntermux-setup-storage\n```\nY permitir el acceso de termux al sistema interno de ficheros. \n\n![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)\n \nEl comando **termux-setup-storage** va a configurar el acceso a las siguientes carpetas. \n* ~/storage/shared \nCarpeta utilizada por las aplicaciones de Android para compartir archivos \n* ~/storage/downloads \nLa carpeta por defecto de descargas, por ejemplo donde tu navegador descarga los archivos. \n* ~/storage/dcim \nAquí la cámara suele almacenar las fotos y videos del dispositivo \n* ~/storage/pictures \nEn esta carpeta se suelen almacenar imágenes del dispositivo\n* ~/storage/music \nEsta es la carpeta que Android suele utilizar para guardar la música del usuario\n* ~/storage/movies \nDonde se suelen almacenar las películas\n* ~/storage/external-1 \nCarpeta 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.\n\nSi 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:\n- Ve a Ajustes -\u003e Aplicaciones -\u003e Termux -\u003e Permisos\n- Revoca el permiso de acceso a ficheros (Storage permission)\n- Autoriza de nuevo el permiso de acceso a ficheros.\n\nEste es un bug de Android 11, no de Termux.\n\n\u003e 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\n\n[Tabla de Contenidos](#tabla-de-contenidos)\n\n-----\n\n## Capítulo 4: Uso básico de la terminal\n\nUna 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. \n\nUtilizar una terminal en lugar de una interfaz gráfica, nos permite realizar tareas de todo tipo de forma mas ágil y rápida. \n\nTodas 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. \n \nAl 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 **⏎**. \n\n### Comandos básicos de Linux\n\n#### pwd \nEl comando **pwd** nos va a mostrar la ruta completa de la carpeta en la cual nos encontramos. \n \n![Salida del comando pwd](https://github.com/StringManolo/hackingTermux101/raw/master/imagenes/pwd.jpg) \n\n\u003e pwd son las siglas de Print Working Directory (Imprime Directorio de Trabajo)\n\n#### cd \nEl 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. \nSi escribes el comando cd sin mas, se cambiará el directorio a la variable de entorno \"$HOME\", por defecto /data/data/com.termux/files/home. \n \n\u003e 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. \n \nPodemos 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.\n\nCuando quieras moverte al directorio anterior utiliza dos puntos.\n```bash\ncd ..\n```\n \n![Salida del comando cd ejemplo y pwd](https://github.com/StringManolo/hackingTermux101/raw/master/imagenes/cd_ejemplo.jpg) \n\n\u003e cd son las siglas de Change Directory (Cambia Directorio), \n\n#### ls \nEl comando **ls** muestra la lista de archivos y carpetas que contiene el directorio actual de trabajo. \n \n![Salida del comando ls y pwd](https://github.com/StringManolo/hackingTermux101/raw/master/imagenes/ls.jpg) \n \nEn 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. \n \nEn 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. \n \n\u003e ls es una abreviatura de List (Listar) \n\n#### cat\nEl comando **cat** muestra el contenido de un fichero.\n \n![Salida del comando cat](https://github.com/StringManolo/hackingTermux101/raw/master/imagenes/cat.jpg) \n \nEn 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).\n \n\u003e cat viene de concatenate (concatenar) \n \n#### touch\nEl comando **touch** crea ficheros vacios en el directorio actual. \n```bash\ntouch miListaDeLaCompra.txt\n```\n \nCon 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: \n```bash\ncd\ntouch miListaDeLaCompra.txt\nls\n```\n \n\u003e touch significa tocar\n\n#### mkdir\nEl comando **mkdir** crea directorios/carpetas vacias en el directorio actual. \n```bash\ncd\nmkdir ejemplo\n``` \n \nCon 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. \n\nSi intentas crear un nuevo directorio y un directorio hijo directamente, puede usar el argumento -p (de parents, en español directorios padres) \n\n```bash\nmkdir ~/ejemplo/hijoDeEjemplo/hijoDeHijoDeEjemplo\n```\n\n\n\u003e mkdir es una abreviatura de Make Directory (Crea Directorio)\n\n#### cp\nEl comando **cp** permire copiar archivos. Puedes copiarlos en el mismo directorio o en otro directorio. Tambien puedes modificar el nombre de destino.\n```bash\ncp miListaDeLaCompra.txt miSegundaListaDeLaCompra.txt\n```\n \nEl 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. \n \nLa 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: \n \n```bash\ncd\ncp ejemplo/miListaDeLaCompra.txt listaDeLaCompra.txt\n```\n\nTras 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 \n\n\u003e cp es una abreviatura de copy (copiar)\n\n#### mv\nEl 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. \n \nEsto hace de **mv** el comando ideal para mover archivos entre directorios. \n \n\u003e mv es una abreviatura de move (mover) \n\n#### rm\nEl comando **rm** se utiliza para eliminar archivos de forma permanente. \n \n```bash\ncd\nrm listaDeLaCompra.txt\n```\n\n\u003e rm es una abreviatura de remove (eliminar)\n\n#### clear\nEl comando **clear**, limpia el contenido de la pantalla.\n```bash\nclear\n```\n \n\u003e clear significa limpiar \n \n#### pkg\nEl 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, ... \n \nSi corres el comando:\n```bash\npkg\n```\n\nTe 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: \n\n* ##### pkg list-all \nMuestra un listado todos los comandos/programas/paquetes disponibles para instalar. El listado es bastante grande. \n```bash \npkg list-all\n```\n\n* ##### pkg list-installed \nMuestra 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. \n \nPor 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. \n```bash\npkg list-installed\n```\n\n* ##### pkg show\nMuestra 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\n```bash\npkg show unzip\n```\n\nEl comando **pkg show unzip** nos muestra esta descripción para el comando unzip.\n```\nPackage: unzip\nVersion: 6.0-7\nMaintainer: Termux members @termux\nInstalled-Size: 340 kB\nDepends: libbz2\nHomepage: https://sourceforge.net/projects/infozip/\nDownload-Size: 115 kB\nAPT-Manual-Installed: yes\nAPT-Sources: https://termux.org/packages stable/main aarch64 Packages\nDescription: Tools for working with zip files\n```\n\nEn este ejemplo la información que se nos muestra indica: \n- El nombre del paquete \n- La versión del programa \n- Las personas/organización que se encargan de gestionar este paquete\n- El tamaño que ocupará en el sistema una vez instalado \n- Otros paquetes que necesita para funcionar\n- La página oficial del programa (o repositorio de su código fuente)\n- El tamaño de la descarga comprimida\n- Si se instaló manualmente\n- Repositorio donde está el paquete listado\n- Descripción de que es el paquete\n \nSi tienes la opción de buscar en Google el paquete, te será de mas ayuda para saber exactamente para que sirve.\n\n* ##### pkg install\nInstala un comando en Termux. \n```bash\npkg install tree\n```\n\nUna vez instalado, ya podras utilizarlo. \nEs 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.\n\n\n\nTree es similar a ls pero también muestra todos los subdirectorios.\n```bash\ntree\n```\n\n* ##### pkg uninstall\nDesinstala un comando en Termux.\n```bash\npkg uninstall tree\n```\n\nUna 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. \n \nPuedes borrarlo si quieres, siempre podrás volver a instalarlo si lo necesitas.\n\n* ##### pkg upgrade\nActualiza todos los paquetes instalados.\n```bash\npkg update\n```\n\n\u003e 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.\n\u003e 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. \n\n#### man\nEl comando **man** sirve para mostrar el manual de un comando, si lo tiene.\n```bash\nman ls\n```\n\nCon **man ls** se nos muestra el manual para el comando ls, con todas sus opciones extra. \n \n\u003e man son la iniciales de manual\n\nPara salir de man utiliza la combinación de teclas **ESC : q**\n\n#### exit\nCierra la terminal\n\n\n#### Argumentos\nLos 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. \n \nUno 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.\n\n```bash\nls --help\n```\n\n\n\n[Tabla de Contenidos](#tabla-de-contenidos)\n\n-----\n\n## Capítulo 5: Introducción a Bash\nBash 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. \n\n\u003e 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. \n \nBash 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.\n\n#### Variables\nLas variables te permiten almacenar valores para poder utilizarlos mas adelante. \n \nPara almacenar texto en una variable usaremos la siguiente sintaxis **nombreDeLaVariable**=\"__valorDeLaVariable__\" \n```bash\nmiNombre=\"Manolo\"\n```\n \nTambién es posible almacenar el resultado de un comando en la variable utilizando la sintaxis **nombreDeLaVariable**=__$(comando argumentos)__ \n```bash\nlistaArchivosEnHome=$(ls ~)\n```\n\nPodremos referenciar la variable anteponiendo el símbolo del dolar al nombre de la variable, como veremos en el siguiente apartado.\n\n#### Imprimir en pantalla\nPara imprimir texto o el contenido de variables (en este caso en pantalla) podemos utilizar echo o printf. \n \n##### echo \necho es un comando sencillo para imprimir texto \n```bash\nmiNombre=\"Manolo\"\necho \"Hola, mi nombre es $miNombre\"\n```\n\nPuedes usar variables como en el ejemplo anterior, y también comandos:\n```bash\necho \"Hola, te encuentras en el directorio $(pwd)\"\n``` \n \nSi 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. \n```bash\necho \"$(clear)\\n\\n\\n\\n\\n\\n\\n\\n\\n\\nHola, te encuentras en el directorio\\n$(pwd)\\nNo es genial\\n?\\n\\n\"\n```\n \n![Salida del comando echo en multiples lineas](https://github.com/StringManolo/hackingTermux101/raw/master/imagenes/echo.jpg) \n \n##### printf\nprintf hace lo mismo que echo pero se ejecuta mas rápido y permite mas opciones para formatear el texto. \n```bash\nmiNombre=\"Manolo\"\nprintf \"Hola, mi nombre es %s\" \"$miNombre\"\n```\n\nCon 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). \n \nOtra 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 \n```bash\nnumeroPI=\"3.1416\"\nprintf \"El numero PI es %d\" \"$numeroPI\"\n```\n\nBash nos indicará el error: **bash: printf: 3.1416: invalid number** e imprimirá solo la parte entera. Esta es la lista de tipos que acepta:\n\n| secuencia | tipo | descripción |\n| --- | --- | --- |\n| %d | digit | Números enteros |\n| %f | float | Números flotantes (numeros con decimales) |\n| %s | string | Cadena de texto |\n| %x | hexadecimal | Imprime un número en hexadecimal |\n| %X | hexadecimal | Imprime un número en hexadecimal (letras en mayúsculas) |\n \n\n#### Leer de la terminal \nPodemos interactura con el usuario de múltiples formas.\n\n##### read \nEl 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. \n \nSi por ejemplo queremos preguntarle el nombre al usuario\n```bash\nread -p \"Cómo te llamas? \" nombre\necho \"Tu nombre es $nombre\"\n``` \n \nEn 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. \n \n\u003e read significa leer\n\n#### Condicionales \nLos 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.\n\n```bash\nread -p \"Introduce tu edad y pulsa enter: \" edad\nif [ \"$edad\" -gt 17 ]; then\n echo \"Eres mayor de edad\"\nfi\n```\n\nEn este ejemplo tenemos:\n- Un read \nAlmacena la edad que introduce el usuario en la variable edad. \n- La palabra clave if \nIndica que la expresión es un condicional\n- Unos corchetes (que también son comandos, aunque no lo parezcan) \nEvaluan la siguiente expresión y delimitan donde empieza ([) y acaba (]) la condición \n- El punto y coma (;) \nSirve para indicar el final de los comandos asociados a if \n- La palabra then \nIndica que a continuación vienen las instrucciones que queremos que se ejecuten si se ha cumplido la condición. \n- Un echo que imprime un texto \nAunque podría ser cualquier otro comando, asignación de variables, etc. \n- Y la palabra fi (es if al revés)\nIndica el final del condicional \n \nLa condición **\"$edad\" -gt 17** está compuesta de 3 elementos: \n- \"$edad\"\nEs una variable que contiene la edad del usuario\n- -gt\nEs un operador especial de Bash, siglas de Greater Than (Mayor Que). Sería equivalente al operador matemático **\u003e** \n- 17 \nSi la edad del usuario es mayor que 17, entonces es mayor de edad (18 años o más en mi país) \n \nRecuerdas que te dije que **[** era un comando mas? Igual que echo o printf. Pues **[** también tiene argumentos.\nHay distintos tipos de condiciones, aquí un listado de las mas comunes: \n```bash\n[ -a listaDeLaCompra.txt ] \n```\nSe cumple si el archivo existe \n \n\u0026nbsp; \n \n```bash\n[ -d ejemplo ] \n```\nSe cumple si la carpeta existe \n \n\u0026nbsp; \n \n```bash\n[ -f listaDeLaCompra.txt ] \n```\nSe cumple si el archivo existe y es un archivo normal \n \n\u0026nbsp; \n\n```bash\n[ -s listaDeLaCompra.txt ] \n```\nSe cumple si el archivo existe y no está vacio \n \n\u0026nbsp; \n \n```bash\n[ listaDeLaCompra.txt -nt otraListaDeLaCompra.txt ] \n```\nSe cumple si el primer archivo es mas reciente que el segundo \n\u003e nt abreviado de newer than (mas nuevo que) \n \n\u0026nbsp; \n \n```bash\n[ listaDeLaCompra.txt -ot recetaChurros.txt ] \n```\nSe cumple si el primer archivo es mas viejo que el segundo \n\u003e ot abreviado de older than (mas viejo que) \n \n\u0026nbsp; \n \n```bash\n[ -z \"$nombre\" ]\n```\nSe cumple si la variable está vacia \n \n\u0026nbsp; \n \n```bash\n[ -n \"$nombre\" ] \n```\nSe cumple si la variable no está vacia \n \n\u0026nbsp; \n \n```bash\n[ \"$nombre\" = \"Paco\" ]\n```\nSe cumple si el contendio de la variable **$nombre** es **Paco** \n \n\u0026nbsp; \n \n```bash\n[ \"$nombre\" != \"Paco\" ]\n```\nSe cumple si el contenido de la variable **$nombre** no es **Paco** \n \n\u0026nbsp; \n\n```bash\n[ \"$nombre\" \u003c \"Paco\" ] \n```\nSe cumple si el contenido de la variable **$nombre** se posiciona antes que Paco, alfabéticamente \n \n\u0026nbsp; \n \n```bash\n[ \"$nombre\" \u003e \"Paco\" ] \n```\nSe cumple si el contenido de la variable **$nombre** se posiciona después que Paco, alfabéticamente \n \n\u0026nbsp; \n \n```bash\n[ -v \"$nombre\" ]\n```\nSe cumple si la variable existe \n \n\u0026nbsp; \n \n```bash\n[ ! condicion ]\n```\nSe cumple si la condición no se cumple \n \n\u0026nbsp; \n\n```bash\n[ condicion -o otraCondicion ]\n```\nSe cumple si cualquiera de las 2 condiciones se cumple (o ambas se cumplen) \n \n\u0026nbsp; \n\n```bash\n[ condicion -a otraCondicion ]\n```\nSe cumple solo si ambas condiciones se cumplen \n \n\u0026nbsp; \n\n```bash\n[ 7 -eq 7 ] \n```\nSe cumple si el primer número es igual al segundo (recuerda que puedes usar variables) \n\u003e eq de equals (igual a) \n \n\u0026nbsp; \n\n```bash\n[ 7 -ne 7 ]\n```\nSe cumple si el primer número es distinto al segundo \n\u003e ne de not equal (no igual a) \n \n\u0026nbsp; \n\n```bash\n[ 7 -lt 7 ]\n```\nSe cumple si el primer numero es menor que el segundo \n\u003e lt de less than (menor que) \n \n\u0026nbsp; \n \n```bash\n[ 7 -le 7 ] \n```\nSe cumple si el primer número es menor o igual al segundo \n\u003e le de less equal (menor o igual a) \n \n\u0026nbsp; \n\n```bash\n[ 7 -gt 7 ] \n```\nSe cumple si el primer número es mayor que el segundo \n\u003e gt de greater than (mayor que) \n \n\u0026nbsp; \n\n```bash\n[ 7 -ge 7 ]\n```\nSe cumple si el primer número es mayor o igual que el segundo \n\u003e ge de greater equal (mayor o igual a) \n \n\u0026nbsp; \n\nA parte de if, hay un par de palabras mas que podemos utilizar en los condicionales. \nEl comando **else** permite ejecutar comandos si la condición no se ha cumplido. Queda mas claro con un ejemplo:\n```bash\nread -p \"Introduce tu edad y pulsa enter: \" edad\nif [ \"$edad\" -gt 17 ]; then\n echo \"Eres mayor de edad\"\nelse \n echo \"Eres menor de edad\"\nfi\n```\n\nSi 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. \n \nLa última palabra clave es **elif**, y sirve para introducir mas if, que se ejecutarán solo si el anterior **if** no se cumple. Ejemplo:\n```bash\nread -p \"Introduce tu edad y pulsa enter: \" edad\nif [ \"$edad\" -lt 12 ]; then\n echo \"Eres un niño\"\nelif [ \"$edad\" -lt 18 ]; then\n echo \"Eres un adolescente\"\nelif [ \"$edad\" -lt 65 ]; then\n echo \"Eres un adulto\"\nelse \n echo \"Eres un anciano\"\nfi\n```\n\nEn español esto viene diciendo:\n```bash\nsi (tienes menos de 12 años) entonces\n muestra \"Eres un niño\"\nen caso contrario, si (tienes menos de 18 años) entonces\n muestra \"Eres un adolescente\"\nen caso contrario, si (tienes menos de 65 años) entonces\n muestra \"Eres un adulto\"\nen caso contrario \n muestra \"Eres un anciano\"\n```\n\nEl 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\n```bash\nprintf \"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 -\u003e \"\nread opcion\ncase $opcion in \n 1)\n echo $(pwd) \n ;;\n\n 2)\n echo $(ls)\n ;;\n\n 3)\n read -p \"Introduce el nombre que tendrá el nuevo fichero: \" nombreFichero\n touch $nombreFichero\n ;;\n\n 4)\n read -p \"Introduce el nombre que tendrá el nuevo directorio: \" nombreDirectorio\n mkdir $nombreDirectorio\n ;;\n\n 0)\n echo \"Adios\" \n ;;\n \n *)\n echo \"La opción que elegiste no existe\"\n ;;\nesac\n```\n\n#### Bucles\nLos bucles nos permiten correr un comando/realizar una tarea de forma repetida. \nExisten 4 tipos de bucles basicos en Bash. Los bucles **while**, **until**, **for** y **select**. \n \n##### while\nEl comando **while** permite ejecutar comandos mientras la condición sea verdadera. Su sintaxis es similar a la del condicional **if**. Ejemplo:\n```bash\nread -p \"Introduce tu contraseña: \" contra\nwhile [ \"$contra\" != \"admin123\" ]; do\n read -p \"La contraseña '$contra' es incorrecta. Inténtalo de nuevo: \" contra\ndone\necho \"Acceso Permitido\"\n```\n\n\u003e 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**. \n\nOtro tipo de bucles comunes son los bucles infinitos\n```bash\nwhile [ true ]; do\n date\n sleep 8s\ndone\n```\nEn este ejemplo vamos a mostrar la fecha cada 8 segundos. \n \n##### until \nEl bucle **until** es prácticamente igual al bucle **while**, con la diferencia de que se ejecutará mientras no se alcance la condición. \n```bash\nread -p \"Introduce tu contraseña: \" contra\nuntil [ \"$contra\" = \"admin123\" ]; do\n read -p \"La contraseña '$contra' es incorrecta. Inténtalo de nuevo: \" contra\ndone\necho \"Acceso Permitido\"\n```\n\n\u003e Puedes usar while o until indistintamente. Until existe simplemente porque puede ser mas sencilla de leer la expresión en inglés. \nLos ejemplos anteriores en español dirían; Para **while**:\n\u003e Mientras (laContraseña no es igual a \"admin123\") haz ... \nPara **until**: \n\u003e Hasta que (laContraseña no sea igual a \"admin123\") haz ...\n \n##### for\nEl bucle for sirve principalmente para recorrer elemenos. Los elementos pueden ser frases, palabras, secuencias numéricas, etc. \n```bash\nfrase=\"Hola me llamo Manolo\"\necho \"La frase '$frase' tiene las siguientes palabras:\"\nfor palabra in $frase; do\n echo \"$palabra\"\ndone\n```\n\nLo mismo que haces con palabras, puedes hacerlo directamente con la salida de comandos. Da mucho juego \n```bash\nfor archivo in $(ls ~); do\n echo \"$archivo\"\ndone\n```\n \n\u0026nbsp; \nTambién puedes recorrer rangos de números\n```bash\necho \"Los números del 1 al 20 son:\"\nfor numero in {1..20}; do\n printf \"%d, \" $numero\ndone\n```\n \n\u0026nbsp; \nSi queremos omitir la última coma tras el 20, podemos usar un condicional: \n```bash\necho \"Los números del 1 al 20 son:\"\nfor numero in {1..20}; do\n if [ \"$numero\" -ne 20 ]; then\n printf \"%d, \" $numero\n else \n printf \"%d\" $numero\n fi\ndone\n```\n\nHay 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** \n```bash\nfor ((i=1; i \u003c= 10; i++)) do\n echo \"$i\"\ndone\n```\n\nAlgunos 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** \n```bash\ni=1\nwhile [ $i -le 10 ]; do\n echo \"$i\"\n ((++i))\ndone\n```\n\n##### select\nEl bucle **select** es un tipo de bucle ideal para hacer menus de forma sencilla.\n```bash\nopciones=\"Sumar Restar Multiplicar Dividir Salir\"\nselect opcion in $opciones; do\n if [ \"$opcion\" = \"Salir\" ]; then\n echo \"Adios\"\n break\n fi\n\n read -p \"Introduce el primer número: \" primerNumero\n read -p \"Introduce el segundo número: \" segundoNumero\n if [ \"$opcion\" = \"Sumar\" ]; then\n resultado=$(( $primerNumero + $segundoNumero ))\n elif [ \"$opcion\" = \"Restar\" ]; then\n resultado=$(( $primerNumero - $segundoNumero ))\n elif [ \"$opcion\" = \"Multiplicar\" ]; then\n resultado=$(( $primerNumero * $segundoNumero ))\n elif [ \"$opcion\" = \"Dividir\" ]; then\n resultado=$(( $primerNumero / $segundoNumero ))\n else\n resultado=\"Opcion incorrecta.\"\n fi\n\n echo \"El resultado es $resultado\";\ndone\n```\n\nEn este ejemplo podemos ver una calculadora simple en Bash. A destacar la palabra **break** que sirve para salir de cualquier tipo de bucle. \n\n##### funciones\nLas **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: \n \n```bash\nsaludar() {\n echo \"hola $1, bienvenido a mi programa\"\n}\n```\n\nDe 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.\n```bash\nsaludar() {\n echo \"hola $1, bienvenido a mi programa\"\n}\n\nsaludar \"Manolo\"\nsaludar \"Arturo\"\n```\n\nComo 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.\n\nSi quieres que quede mas claro que estás creando una función, puedes usar la palabra clave **function** y omitir los paréntesis:\n```bash\nfunction saludar {\n echo \"hola $1, bienvenido a mi programa\"\n}\n\nsaludar \"Manolo\"\nsaludar \"Arturo\"\n```\n\nPuedes 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:\n```bash\nsaludar() {\n echo \"Quiero dar la bienvenida a $1, $2 y $3\" \n}\n\nsaludar \"Manolo\" \"Arturo\" \"Jose\"\n```\n\n#### Miscelanea (otros operadores)\nBash 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. \n\n##### \u003e\nEl caracter **\u003e** nos permite enviar la salida de un comando hacia un fichero. Si el nombre del fichero no existe, se creará uno nuevo.\n```bash\necho -e \"Lista de la compra:\\n2 paquetes de letejas\\n1 cartón de leche\" \u003e ~/miListaDeLaCompra.txt\n```\n\nCon el **\u003e** 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 **\u003e** 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 \n \nAhora puedes imprimir su contenido cuando quieras\n```bash\ncat ~/miListaDeLaCompra.txt\n```\n\n\u003e 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. \n \nOtro uso común es ocultar la salida de un comando. Para ello redirigimos la salida a un archivo especial diseñado para ello.\n```bash\necho \"Hola\" \u003e /dev/null\n```\n\nRedirigir 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. \n\nAunque 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__ \n\n```bash\ncat esteArchicoNoExiste.txt 2\u003e/dev/null\n```\n\n##### \u003e\u003e\nQué pasa si quiesieses añadir un nuevo producto a tu lista de la compra sin eliminar el contenido del fichero? Se utiliza el operador **\u003e\u003e** en lugar de **\u003e**. Al igual que **\u003e**, 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.\n```bash\necho -e \"\\n6 latas de mejillones\" \u003e\u003e ~/miListaDeLaCompra.txt\n```\n \n\u003e Puedes redirigir la salida de cualquier comando, no solo de echo \n\n##### |\nEl operador **|** sirve para redirigir la salida de un comando hacia otro comando. \nExisten una multitud de utilidades que son perfectas para su uso con **|**\n```bash\necho \"Hola qué tal?\" | wc \n```\n\n\u003e 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 **|**\n\n\n##### ||\nEl operador **||** (OR) sirve para ejecutar un comando si el anterior falla.\n```bash\ncat esteArchivoNoExiste.txt || echo \"El archivo no existe\"\n```\n\nEs común redirigir los errores a __/dev/null__ y mostrar nuestros errores personalizados \n```bash\ncat archivoQueNoExiste 2\u003e/dev/null || echo \"No se pudo mostrar el contenido del archivo\"\n```\n\n##### \u0026\nEl operador **\u0026** 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.\n\n```bash\ndespedirse() {\n sleep 5s\n printf \"Adios\"\n sleep 5s\n printf \", ha sido un placer!\"\n}\n\ndespedirse \u0026\n```\n\n\u003e 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.\n\nPuedes ver los comandos que tengas corriendo en segundo plano (background) con el comando **jobs**, la salida para este ejemplo sería:\n```bash\n[1]+ Running despedirse \u0026\n```\n\nEl 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. \n \nPuedes 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) \n\n##### \u0026\u0026\nEl operador **\u0026\u0026** (AND) sirve para ejecutar un comando si el anterior funcionó correctamente.\n```bash\ncat archivoQueExista \u0026\u0026 echo \"El archivo existe y se imprimió correctamente\"\n```\n\nMuy útil cuando queramos que un comando solo se ejecute si el anterior funcionó\n```bash\npkg install tree \u0026\u0026 tree\n```\n\n##### ;\nEl 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 \n```bash\ncat archivo1.txt; cat archivo2.txt; echo \"Adios\"\n```\n\n#### help\nEl comando **help** nos proporciona ayuda con Bash. \n```bash\nhelp\n```\n\nSi 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. \n```bash\nhelp history\n```\n\n#### Extra\nPuedes reutilizar los comandos de una linea de la terminal navegando por el historial si le das a las flecha hacia arriba y hacia abajo. \n\nSi 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:\n```bash\n# La siguiente linea imprime un texto en pantalla saludando\necho \"Hola\"\necho \"Adios\" # Esta linea imprime Adios en pantalla\n```\n \nBash 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. \n \nSi 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. \n\n\u003e En Termux la tecla tab se representa por 2 flechas y esta ubicada entre **ESC** y **CTRL** \n \nEn lugar de utilizar secuencias de caracteres para saltos de linea, puedes usar comillas simples\n```bash\necho 'Hola\nLos saltos de linea también se imprimen asì\nNo es genial?'\n```\nSi utilizas comillas simples, todo lo que escribas dentro será interpretado como texto, entre otras cosas esto te inhabilita de utilizar variables dentro. Ejemplo:\n```bash\nnombre=Manolo\necho 'Mi nombre es $nombre'\n```\n\nSi utilizas **printf** en lugar de **echo**, si podrás insertar variables de la siguiente forma\n```bash\nnombre=Manolo\nprintf 'Mi nombre es %s' $nombre\n``` \n\n\n[Tabla de Contenidos](#tabla-de-contenidos)\n\n-----\n\n## Capítulo 6: Uso de VI y de VIM\nVI 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. \n \nDado 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. \n\n#### Instalar VIM\nVI suele venir instalado, pero VIM no. Es un paquete mas, asique usaremos el comando que ya conocemos para instalar paquetes en Termux\n```bash\npkg install vim\n```\n\n#### Abrir un fichero\n\nPara abrir un archivo que ya existe o crear uno nuevo, usaremos el siguiente comando\n```bash\nvim miListaDeLaCompra.txt\n```\n\nVerá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. \n \nSi 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. \n \n#### Escribir en un fichero\n\nSi 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. \n\nUna 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. \n \n#### Guardar los cambios\n\nHay 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. \n \nSi quieres guardar los cambios y cerrar VIM, en lugar de **:w**, debes utilizar **:x** \n\n#### Salir de VIM\n\nSi 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. \n \nSi 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** \n\n#### Cifrar un archivo\nEs 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**. \n\n#### Navegación\n\nEn 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** \n \nTambié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** \n\nA 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.\n\nSi 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.\n\nSi 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.\n\n#### Eliminar contenido\n\nTambié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:\n\n```bash\n# Recuerda que estos son comentarios, y su única finalidad es que tu los leas\n\ndd # Eliminar la linea en la que está el cursor\nd$ # Eliminar desde el cursor hasta el final de la linea\nd0 # Eliminar desde el cursor hasta el inicio de la linea\ndw # Eliminar desde el cursor hasta el final de la palabra\ndgg # Eliminar desde el cursor hasta el inicio del archivo\ndG # Eliminar desde el cursor hasta el final del archivo\nd16 # Eliminar desde el cursor 16 lineas\n```\n\n#### Substituir texto\n\nEn 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\n```bash\n:%s/hola/adios/g # substituye todos los hola por adios\n:%s/hola/adios/gi # substituye todos los hola por adios aunque tengan mayúsculas\n```\n\n\u003e Cuando la palabra/texto tenga caracteres especiales, debes __escaparlos__ usando la barra de escape **\\\\**. \n\nA 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. \n \n#### Modo Visual\n\nA 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**. \n \nUna 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. \n```bash\ny # Copia el texto seleccionado\np # Pega el texto \nx # Corta el texto seleccionado \n\u003e # Añade identación a las lineas (espacios)\n\u003c # Quita identación a las lineas (espacios)\nu # Convierte a minúsculas\nU # Convierte a mayúsculas\n```\n\n\u003e También puedes substituir palabras del texto seleccionado usando expresiones regulares\n\n#### Manejo de ventanas y pestañas\n\nEn 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. \n\nPuedes modificar el ancho de la ventana usando **CTRL w \u003e** para aumentar su ancho o **CTRL w \u003c** para reducirlo. \n\nPuedes modificar la altura de la ventana usando **CTRL w +** para aumentarla o **CTRL w -** para reducirla. \n \nSi 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. \n\nOtra 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** \n\nLa 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#**\n\n#### Realizar búsquedas\n\nPuedes buscar palabras si pones una **/**. Ejemplo:\n```bash\n/hola\n```\n\nUna 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**\n\n\n[Tabla de Contenidos](#tabla-de-contenidos)\n\n-----\n\n## Capitulo 7: Configuración de Bash\nBash tiene múltiples opciones de configuración y hay varias formas de configurarlo dependiendo del sistema. En Termux lo configuraremos utilizando el archivo .bashrc. \n \nEste archivo debemos crearlo en la carpeta Home. Usaremos vim para ello.\n```bash\nvim ~/.bashrc\n```\n\nTodos los comandos que escribamos en este archivo se ejecutarán cada vez que iniciemos Termux, o cuando iniciemos una nueva pestaña de Termux. \n \n\u003e 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. \n\nLo primero será añadir el siguiente texto en el archivo:\n```bash\n# Si Bash no es interactivo, detiene la lectura de este archivo\ncase $- in\n *i*) \n ;;\n \n *) \n return\n ;;\nesac\n```\n\nEste 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. \n \n##### EDITOR\nLa variable \"$EDITOR\" sirve para configurar un editor de texto como editor por defecto de Bash.\n```bash\nexport EDITOR='vim'\n```\n\nAl 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**. \n\n##### histappend\nEl 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: \n```bash\nshopt -s histappend\n```\n\n##### checkwinsize\nEl 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. \n```bash\nshopt -s checkwinsize\n```\n\n##### autocd\nEl argumento __autocd__ nos permite omitir cd para entrar en carpetas. Es útil para todas aquellas carpetas que no compartan nombre con comandos instalados.\n```bash\nshopt -s autocd\n```\n\nCon 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.\n\n##### cdable_vars\nEl 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.\n```bash\nshopt -s cdable_vars\n```\n\nCuando activemos el archivo __.bashrc__, podremos hacer lo siguiente para ir a la carpeta __ejemplo__ (si esta existe en HOME) desde cualquier lugar.\n```bash\nEJEMPLO=/data/data/com.termux/files/home/ejemplo\ncd EJEMPLO\n```\n\nSi 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.\n\n\n##### cdspell\nEl 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.\n```bash\nshopt -s cdspell\n```\n\n##### globstar\nEl argumento __globstar__ te permitirá utilizar **\\*\\*** para referenciar todos los archivos en el directorio y subdirectorios referenciados\n```bash\nshopt -s globstar\n```\n\nCon un ejemplo se entiende mejor. Digamos que tenemos la siguiente estructura de archivos:\n```bash\ntest/\n├── adios.txt\n├── carpeta\n│   └── numeros.txt\n└── hola.txt\n```\n\nSi utilizamos el comando **cat test/\\*\\*** sin tener __globstar__ activado, se imprimirá:\n```bash\nadios\ncat: test/carpeta: Is a directory\nhola\n```\n\nSi hemos activado __globstar__, el resultado será:\n```bash\ncat: test/: Is a directory\nadios\ncat: test/carpeta: Is a directory\n1\n2\n3\nhola\n```\n\n\n##### addPath\nLa 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.\n```bash\naddPath() {\n if [ -d \"$1\" ] \u0026\u0026 [[ \":$PATH:\" != *\":$1:\"* ]]; then\n PATH=\"${PATH:+\"$PATH:\"}$1\";\n fi\n}\n```\n\n##### extract\nLa función **extract** comprueba la extensión de un archivo comprimido y lo descomprime como corresponda según la extensión detectada\n```bash\nextract() {\n for archive in $*; do\n if [ -f $archive ]; then\n case $archive in\n *.tar.bz2)\n\t tar xvjf $archive\n\t;;\n\n *.tar.gz)\n\t tar xvzf $archive\n\t;;\n\n *.bz2)\n\t bunzip2 $archive\n\t;;\n\n *.rar)\n\t rar x $archive\n\t;;\n\n *.gz)\n\t gunzip $archive\n\t;;\n\n *.tar)\n\t tar xvf $archive\n\t;;\n\n *.tbz2)\n\t tar xvjf $archive\n\t;;\n\n *.tgz)\n\t tar xvzf $archive\n\t;;\n\n *.zip)\n\t unzip $archive\n\t;;\n\n *.Z)\n\t uncompress $archive\n\t;;\n\n *.7z)\n\t b7z x $archive\n\t;;\n\n *)\n\t echo \"don't know how to extract $archive...\"\n\t;;\n esac\n else\n echo \"$archive is not a valid file!\"\n fi\n done\n}\n```\n\n##### alias\nEn 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. \n```bash\nalias ls='ls --color=auto'\nalias dir='dir --color=auto'\nalias vdir='vdir --color=auto'\nalias grep='grep --color=auto'\nalias fgrep='fgrep --color=auto'\nalias egrep='egrep --color=auto'\n```\n\nAhora cuando escribas el comando **ls**, Bash le añadirá el argumento __--color=auto__ de forma transparente. \n\nMas alias útiles que suelo utilizar: \n```bash\nalias l='ls' # Utiliza l en lugar de ls\nalias la='ls -a' # Utiliza la para listar ficheros ocultos\nalias v='vim' # Utiliza v en lugar de vim\nalias c='clear' # Utiliza c en lugar de clear\nalias cl='clear \u0026\u0026 ls' # Utiliza cl para limpisr la pantalla y listar\nalias ..='cd ..' # Muevete a la carpeta 1 nivel superior\nalias ...='cd ../..' # Muevete a la carpeta 2 niveles superior\nalias ....='cd ../../..' # Muevete a la carpeta 3 niveles superior\nalias .....='cd ../../../..' # Muevete a la carpeta 4 niveles superiores\nalias pserv='python -m http.server' # Sirve la carpeta actual\nalias gitc='\"'\"'git clone'\"'\"' # Clona un repositorio\nalias 775='\"'\"'chmod +775'\"'\"' # Da permisos de ejecución \nalias folder='du -h --max-depth=1' # Muestra el tamaño de ficheros\nalias h='history' # Muestra el historial\nalias myip='curl http://ifconfig.me/ip' # Muestra tu ip pública\nalias quit='exit' # Cierra la terminal\nalias q='exit' # Cierra la terminal\nalias sb='source ~/.bashrc' # Actualiza los cambios en el archivo de Bash\n```\n\n\n##### colores\nExportar variables que guarden colores nos será muy útil. Por ejemplo para usarlos con echo u otros comandos. \n```bash\nexport red=$'\\e[1;31m' # rojo \nexport green=$'\\e[1;32m' # verde\nexport yellow=$'\\e[1;33m' # amarillo\nexport blue=$'\\e[1;34m' # azul\nexport cyan=$'\\e[1;35m' # cian\nexport white=$'\\e[1;37m' # blanco\nexport endc=$'\\e[0m' # finaliza el color (color normal)\nexport lightgray=$'\\e[0;37m' # gris claro\nexport black=$'\\e[0;30m' # negro\nexport darkgray=$'\\e[1;30m' # gris oscuro\nexport darkred=$'\\e[0;31m' # rojo oscuro\nexport darkgreen=$'\\e[0;32m' # verde oscuro\nexport darkyellow=$'\\e[0;33m' # amarillo oscuro\nexport darkblue=$'\\e[0;34m' # azul oscuro\nexport magenta=$'\\e[0;35m' # magenta \nexport darkcyan=$'\\e[0;36m' # cian oscuro\nexport underlinedarkgray=$'\\e[0;30m' # subrayado gris oscuro\n```\n\nAhora podemos usar los colores, por ejemplo para resaltar palabras de los manuales:\n```bash\nexport LESS_TERMCAP_mb=${green};\nexport LESS_TERMCAP_md=${green};\n```\n\n\u003e Estos colores se aplicarán a las páginas mostradas por el comando **man**\n\n##### prompts\nLa 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:\n```bash\nPS1='\\n\\n${underlinedarkgray}${darkgray}(${blue}$(date +%H${darkgray}:${blue}%M${darkgray}:${blue}%S${darkgray}:${blue}%4N)${darkgray}) ${green}$(pwd)${endc}\\n\u003e '\nPS2='${blue}.${endc} '\n```\n![Prompt de Bash, ps1](https://github.com/StringManolo/hackingTermux101/raw/master/imagenes/ps1.jpg)\n\nComo 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. \n \nPara que se apliquen inmediatamente todos los cambios usaremos el comando **source**\n```bash\nsource ~/.bashrc\n```\n\n[Tabla de Contenidos](#tabla-de-contenidos)\n\n-----\n\n## Capítulo 8: Sistema de Ficheros\nEn 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) \n\n###### com.termux/ \nCarpeta privada de la app Termux\n\n###### com.termux/files/\nArchivos de la aplicación\n\n###### com.termux/files/home/\nCarpeta principal del usuario\n\n###### com.termux/files/home/.termux/\nArchivos de configuración de la app como atajos de teclado de Termux\n\n###### com.termux/files/home/.termux/termux.properties\nArchivo 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. \n\n###### com.termux/files/home/storage/\nSe activa con el comando termux-setup-storage y te permite acceder a los archivos internos del dispositivo.\n\n###### com.termux/files/home/storage/dcim/\nLa usa la cámara para guardas las fotografías de la cámara\n\n###### com.termux/files/home/storage/downloads/\nCarpeta por defecto de Android para descargas\n\n###### com.termux/files/home/storage/movies/\nCarpeta para almacenar los videos del dispositivo\n\n###### com.termux/files/home/storage/music/\nLa música se puede almacenar aquì\n\n###### com.termux/files/home/storage/pictures/\nLas imágenes del dispositivo se pueden guardar aquí\n\n###### com.termux/files/home/storage/shared/\nCarpeta compartida de propósito general para todas las apps\n\n###### com.termux/files/usr/\nImita la carpeta / de GNU/Linux\n\n###### com.termux/files/usr/bin/\nCarpeta principal para ejecutables/comandos de Termux\n\n###### com.termux/files/usr/etc/\nArchivos de configuración diversos relacionados con el sistema o programas\n\n###### com.termux/files/usr/etc/alternatives\nSelecciona los ejecutables por defecto para trabajar con ciertos tipos de archivos. Por ejemplo el enlace directo al editor de texto de Termux por defecto.\n\n###### com.termux/files/usr/etc/apt/\nArchivos del gestor de paquetes APT\n\n###### com.termux/files/usr/etc/apt/apt.conf.d\nArchivos de configuración de APT\n\n###### com.termux/files/usr/etc/apt/preferences.d\nArchivos 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, ....\n\n###### com.termux/files/usr/etc/apt/sources.list\nEste 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.\n\n###### com.termux/files/usr/etc/apt/trusted.gpg\nArchivo 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. \n\n###### com.termux/files/usr/etc/apt/trusted.gpg.d\nTrusted.gpg.d es un directorio que contiene archivos adicionales de claves de confianza para repositorios específicos.\n\n###### com.termux/files/usr/etc/bash.bashrc\nEste 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.\n\n###### com.termux/files/usr/etc/bindresvport.blacklist\nSe 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.\n\n\n###### com.termux/files/usr/etc/inputrc\nEste 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.\n\n###### com.termux/files/usr/etc/motd\nArchivo de mensaje de bienvenida que se muestra al iniciar sesión en la terminal.\n\n###### com.termux/files/usr/etc/motd-playstore\nArchivo de mensaje de bienvenida que se muestra solo cuando se instala Termux desde Google Play Store.\n\n###### com.termux/files/usr/etc/nanorc\nArchivo 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.\n\n###### com.termux/files/usr/etc/netconfig\nEste 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.\n\n###### com.termux/files/usr/etc/profile\nArchivo 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.\n\n###### com.termux/files/usr/etc/profile.d\nDirectorio que contiene archivos de configuración adicionales que se ejecutan después de profile.\n\n###### com.termux/files/usr/etc/profile.d/gawk.csh\nEste 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.\n\n###### com.termux/files/usr/etc/profile.d/gawk.sh\nEste 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.\n\n###### com.termux/files/usr/etc/profile.d/init-termux-properties.sh\nScript 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. \n\n###### com.termux/files/usr/etc/termux-login.sh\nScript 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.\n\n###### com.termux/files/usr/etc/tls\nEste es un directorio que contiene archivos de configuración relacionados con TLS (Transport Layer Security), que se utiliza para cifrar las comunicaciones de red.\n\n###### com.termux/files/usr/etc/tls/cert.pem\nArchivo de certificado de seguridad que se utiliza para autenticar la identidad de otros sistemas en la red.\n\n###### com.termux/files/usr/etc/tls/openssl.cnf\nArchivo de configuración para OpenSSL, que es una biblioteca de cifrado utilizada por muchos programas de línea de comandos.\n\n###### com.termux/files/usr/etc/unbound\nDirectorio que contiene archivos de configuración para el servidor DNS Unbound, que se utiliza para resolver nombres de dominio en direcciones IP.\n\n###### com.termux/files/usr/etc/unbound/unbound.conf\nArchivo de configuración principal de Unbound.\n\n###### com.termux/files/usr/include\nGeneralmente 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.\n\n###### com.termux/files/usr/lib\nCarpeta 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.\n\n###### com.termux/files/usr/libexec\nContiene 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.\n\n###### com.termux/files/usr/opt\nDirectorio 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.\n\n###### com.termux/files/usr/share\nContiene una variedad de recursos compartidos que pueden ser utilizados por diferentes programas en el sistema.\n\n###### com.termux/files/usr/tmp\nDirectorio donde se almacenan archivos temporales creados por diferentes programas y procesos en ejecución en el sistema.\n\n###### com.termux/files/usr/var\nPuede contener registros de actividades del sistema, archivos temporales, archivos de caché, bases de datos de aplicaciones, entre otros.\n\n\n\n\n[Tabla de Contenidos](#tabla-de-contenidos)\n\n-----\n\n## Capítulo 9: Creando comandos\nLos 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**.\n```bash\n#!/usr/bin/env bash\n\necho \"Hola\"\n```\n\nPara poder ejecutar el archivo debes darle permisos:\n```bash\nchmod 775 saludar\n```\n\nSi 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**\n\nPara 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:\n```bash\nmv saludar ~/../usr/bin\n```\n\nAhora puedes ejecutar el comando saludar desde cualquier lugar y omitiendo el **./**\n```bash\nsaludar\n```\n\nLa 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: \n```bash\n#!/usr/bin/env bash\n\nargumentos=\"help,name:\"\nargumentosSimples=\"hn:\"\n\nprocesados=$(getopt --options=$argumentosSimples --longoptions=$argumentos --name \"$0\" -- \"$@\")\n\nayuda() {\n echo -e \"This commands says hi in spanish\\nExample: saludar --name Manolo\\n\";\n exit\n}\n\nwhile true; do\n case \"$1\" in\n -h | --help)\n ayuda;\n shift\n ;;\n\n -n | --name)\n name=\"$2\"\n shift 2\n ;;\n\n --)\n shift\n break\n ;;\n\n *)\n echo \"Error\"\n exit 3\n ;;\n esac\ndone\n\nif [ -n \"$name\" ]; then\n echo \"Hola $name\"\nelse\n echo \"Hola\"\nfi\n```\n\nEsta 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. \n\n \nExplicación del código: \n```bash\n#!/usr/bin/env bash\n```\nEl 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. \n \n```bash\nargumentos=\"help,name:\"\n```\nEn 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.\n \n```bash\nargumentosSimples=\"hn:\"\n``` \nEn 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. \n \n```bash\nprocesados=$(getopt --options=$argumentosSimples --longoptions=$argumentos --name \"$0\" -- \"$@\")\n```\nEn la variable procesados almacenamos el resultado de ejecutar el comando **getopt**. Este comando sirve para procesar argumentos en Bash. \nA **getopt** le pasamos los argumentos que hemos guardado previamente para que los procese. \n \nEl argumento --name de **getopt** sirve para indicarle a **getopt** el nombre de nuestro comando. En este caso utilizamos la variable **\"$0\"**. \n \n\u003e 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. \n \n\u003e 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**. \n \n\u003e La variable \"$@\" contiene todos los argumentos. Al igual que en **$#** se omite el nombre del comando. \n\nDentro del **switch case** verás 3 comandos nuevos. **shift**, **break** y **exit**:\n##### shift \nEl 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. \n \n##### break\nEl 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. \n \n##### exit\nEl 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**. \n \nEl 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). \n \nBash 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\n```bash\n#!/usr/bin/bash\n\nfor (( i=1; i \u003c= \"$#\"; i++ )) do # bucle for clásico\n next=$((i+1)) # Guarda el siguiente argumento en la variable next\n if [[ ${!i} == \"-h\" || ${!i} == \"--help\" ]]; then # Si el argumento es -h o --help\n echo \"Este es el mansaje de ayuda\" \n exit\n elif [[ ${!i} == \"-n\" || ${!i} == \"--name\" ]]; then\n echo \"Hola ${!next}\"\n exit\n fi\ndone\n```\n\nEsta 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. \n\n[Tabla de Contenidos](#tabla-de-contenidos)\n\n-----\n\n## Capítulo 10: Comandos Intermedios\nLos 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. \n\n\n### 7z\nComprime archivos en múltiples formatos con muy buena compresión.\n\n### apt\nDescarga paquetes de Gnu/Linux\n\n### apt-get\nDescarga paquetes de Gnu/Linux\n\n### awk\nLenguaje de programación orientado al manejo de texto\n\n### base64\nCodifica o decodifica base64\n\n### cal\nCalendario\n\n### clang \nCompilador de C/C++/Objective C\n\n### curl\nCliente de múltiples protolos. Principalmente utilizado por su capacidad como cliente HTTP\n\n### dialog\nUtiliza diálogos en la terminal\n\n### dig\nConsulta los registro DNS de un dominio\n\n### dpkg\nGestor de paquetes de Debian\n\n### espeak\nComando text-to-speach que reproduce el texto en el altavoz o crea un archivo reproducible\n\n### figlet\nCrea textos grandes a base de caracteres. \n\n### find\nBusca archivos en sistema de ficheros\n\n### file\nMueatra meta información a cerca de ub fichero. \n\n### gcc\nCompila un programa escrito en C\n\n### g++\nCompila un programa escrito en C++\n\n### gdb\nDebuger para encontrar erroes en programas\n\n### gh\nUtiliza github en la terminal\n\n### git\nManeja repositorios\n\n### grep\nEncuentra palabras y patrones en un texto\n\n### go\nCompila un programa escrito en Go\n\n### gotty\nComparte tu terminal para que otras personas puede ver lo mismo que tú\n\n### gzip\nComprime y descomprime archivos con extensión .z\n\n### head\nMuestra solo el número indicado de caracteres\n\n### htop\nMuestra información sobre procesos\n\n### httping\nMide la latencia de un servidor web/http\n\n### hugo\nGenerador de sitios estáticos\n\n### iverilog\nLenguaje de programación para modelado de circuitos electrónicos\n\n### jq\nComando para parsear JSON\n\n### less\nAbre archivos muy grandes rápidamente cargándolo en bloques\n\n### lighttpd\nServidor web rápido, pequeño y flexible\n\n### lua\nEjecuta código lua\n\n### luarocks\nInstala módulos de lua\n\n### logcat\nAccede al registro de mensajes de Android para debuggear aplicaciones\n\n### lynx\nNavegador Web de terminal\n\n### make\nCompila proyectos\n\n### md5sum\nObten un hash (utilizando el algoritmo md5) de un archivo/texto\n\n### more\nMuestra texto en pantalla, facilita la navegación\n\n### mongodb\nBase de datos NoSQL\n\n### mono\nCompila C# en GNU/Linux\n\n### mpg123\nReproductor de música\n\n### nc\nHerramienta con múltiples utiidades de red integradas\n\n### netlify\nManeja la creación de sitios web en netlify\n\n### nmap\nEscaner de puertos de red\n\n### ncat\nVersión mejorada de nc, se instala conjuntamente a nmap\n\n### nginx\nServidor Web y proxy web muy completo.\n\n### ngrok\nComparte tus servicios sin abrir puertos\n\n### nodejs\nEjecuta código javascript y crea aplicaciones de todo tipo.\n\n### npm\nInstala paquetes de node\n\n### openssl\nSuit de algorimtos criptográficos\n\n### openvpn\nEstablece un tunel VPN\n\n### perl\nIntérprete del lenguaje de programación Perl\n\n### php\nIntérprete del lenguaje de programación PHP\n\n### postgresql\nBase de datos SQL\n\n### pkill\nMata un proceso\n\n### proot\nEmula un entorno root\n\n### proxychains-ng\nUtiliza cadenas de proxies\n\n### python\nIntérprete del lenguaje python2\n\n### python3\nIntérprete del lenguaje python3\n\n### qemu\nEmula procesadores y sistemas operativos\n\n### quickjs\nPequeño motor y librería de javascript\n\n### radare2\nDesensamblador, debugger y editor hexadecimal para trabajar con binarios\n\n### ruby\nIntérprete para el lenguaje de programación Ruby\n\n### rust\nCompilador código Rust\n\n### scp\nCopia y sube archivos utilizando un tunel SSH\n\n### sed\nFiltra y remplaza texto\n\n### shasum\nObten un hash de un archivo/text utilizando sha\n\n### ssh\nIngresa a máquinas remotas m\n\n### steghide\nEsconde texto en imágenes y audios\n\n### strings\nImprime todo lo que pueda ser interpretado como texto de un archivo de bytes/caracteres\n\n### sqlite\nPequeña y potente base de datos SQL\n\n### tail\nMuestra el final de un fichero o texto\n\n### tar\nComprime y descomprime archivos en múltiples formatos\n\n### top\nMuestra un resumen de los procesos del sistema\n\n### tor\nEstablece un circuito virtual en la red Tor.\n\n### torsocks\nUtiliza un comando con Tor. \n\n### tsc\nCompilador del lenguaje Typescript\n\n### unrar\nComprime y descomprime archivos .rar\n\n### unzip\nComprime y descomprime archivos .zip\n\n### which\nMuestra la ruta de instalación de un archivo.\n\n### whois\nCliente que nuestra información sobre direcciones\n\n### xxd\nMuestra un fichero como hexadecimal\n\n### yes\nConfirma automáticamente las opciones interactivas de un comando\n\n\n[Tabla de Contenidos](#tabla-de-contenidos)\n\n----\n\n## Capítulo 11: Proot-Distro\nProot 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. \n \n### Lista las distribuciones disponibles\n```bash\nproot-distro list\n```\nMustra las distribuciones de GNU/Linux disponibles, su nombre, su alias y su estado de instalación\n\n### Instala una distribución\n```bash\nproot-distro install alpine\n```\nPara instalar una distribución, debes utilizar el alias correspondiente a la distribución que deseas instalar. \n\n### Arranca una distribución\n```bash\nproot-distro login alpine\n```\n\n### Haz copia de seguridad de una distribución \n```bash\nproot-distro backup alpine\n```\n\n### Elimina una distribución\n```bash\nproot-distro remove alpine\n```\n\n### Elimina y reinstala una distribución\n```bash\nproot-distro reset alpine\n```\n\n### Recupera un sistema mediante copia de seguridad\n```bash\nproot-distro restore alpine\n```\n\n### Arranca una distribución aislada de Termux\n```bash\nproot-distro login alpine --isolated\n```\n\n### Ejecuta un comando desde una distribución\n```bash\nproot-distro login alpine --isolated -- pwd\n```\n[Tabla de Contenidos](#tabla-de-contenidos)\n\n----\n\n## Capitulo 12: Introducción a Sistemas Linux\nLinux 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.\n\n#### ¿Qué es Linux?\nLinux 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.\n\n#### ¿Qué es una distribución de Linux?\nAunque 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.\n\n\n#### Distribuciones Linux\n+ [Ubuntu](https://help.ubuntu.com/) \nEs 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. \n+ [Debian](https://www.debian.org/doc/) \nEs 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.\n\n+ [Fedora](https://docs.fedoraproject.org/es/docs/) \nEs 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. \n\n+ [Arch Linux](https://wiki.archlinux.org/title/Arch_Linux_(Espa%C3%B1ol)) \nEs 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.\n\n+ [Kali Linux](https://kali-linux.net/) \nEs una distribución de Linux especializada en seguridad informática. Incluye una gran cantidad de herramientas de hacking ético y pruebas de penetración.\n\n+ [Alpine](https://docs.alpinelinux.org/) \nEstá diseñada para ser liviana y segura. Es popular en entornos de contenedores y en dispositivos de IoT.\n\nAl 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.\n\n[Tabla de Contenidos](#tabla-de-contenidos)\n\n----\n\n## Capitulo 13: Uso básico de Debian\n\n### Instalación de paquetes en Debian\n#### apt\n\n`apt` es el gestor de paquetes de Debian. Permite instalar, actualizar y desinstalar paquetes en el sistema. Aquí tienes algunos comandos útiles:\n\n- `apt update`: actualiza la lista de paquetes disponibles en los repositorios.\n- `apt upgrade`: actualiza todos los paquetes instalados en el sistema.\n- `apt install \u003cnombre_del_paquete\u003e`: instala un paquete en el sistema.\n- `apt remove \u003cnombre_del_paquete\u003e`: desinstala un paquete del sistema.\n- `apt search \u003cnombre_del_paquete\u003e`: busca un paquete en los repositorios disponibles.\n- `apt show \u003cnombre_del_paquete\u003e`: muestra información detallada sobre un paquete.\n\nEs importante tener en cuenta que necesitas ejecutar `apt update` para actualizar la lista de paquetes disponibles antes de instalar cualquier paquete.\n\n#### dpkg\n\n`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:\n\n- `dpkg -i \u003cnombre_del_paquete.deb\u003e`: instala un paquete .deb en el sistema.\n- `dpkg -r \u003cnombre_del_paquete\u003e`: desinstala un paquete del sistema.\n- `dpkg -L \u003cnombre_del_paquete\u003e`: muestra una lista de archivos que pertenecen a un paquete.\n- `dpkg -S \u003cnombre_del_archivo\u003e`: muestra el paquete que contiene un archivo en particular.\n- `dpkg-reconfigure \u003cnombre_del_paquete\u003e`: reconfigura un paquete ya instalado.\n\nTen 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í.\n\n\n[Tabla de Contenidos](#tabla-de-contenidos)\n\n----\n\n## Capítulo 14: Uso básico de Ubuntu\n\n### Instalación de paquetes en Ubuntu \n#### apt\n\n`apt` es el gestor de paquetes de Ubuntu. Permite instalar, actualizar y desinstalar paquetes en el sistema. Aquí tienes algunos comandos útiles:\n\n- `sudo apt update`: actualiza la lista de paquetes disponibles en los repositorios.\n- `sudo apt upgrade`: actualiza todos los paquetes instalados en el sistema.\n- `sudo apt install \u003cnombre_del_paquete\u003e`: instala un paquete en el sistema.\n- `sudo apt remove \u003cnombre_del_paquete\u003e`: desinstala un paquete del sistema.\n- `sudo apt search \u003cnombre_del_paquete\u003e`: busca un paquete en los repositorios disponibles.\n- `sudo apt show \u003cnombre_del_paquete\u003e`: muestra información detallada sobre un paquete.\n\nEs importante tener en cuenta que necesitas ejecutar `sudo apt update` para actualizar la lista de paquetes disponibles antes de instalar cualquier paquete.\n\n#### dpkg\n\n`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:\n\n- `sudo dpkg -i \u003cnombre_del_paquete.deb\u003e`: instala un paquete .deb en el sistema.\n- `sudo dpkg -r \u003cnombre_del_paquete\u003e`: desinstala un paquete del sistema.\n- `sudo dpkg -L \u003cnombre_del_paquete\u003e`: muestra una lista de archivos que pertenecen a un paquete.\n- `sudo dpkg -S \u003cnombre_del_archivo\u003e`: muestra el paquete que contiene un archivo en particular.\n- `sudo dpkg-reconfigure \u003cnombre_del_paquete\u003e`: reconfigura un paquete ya instalado.\n\nTen 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í.\n\n\n[Tabla de Contenidos](#tabla-de-contenidos)\n\n----\n\n## Capítulo 15: Uso básico de Alpine\n\n### Instalación de paquetes en Alpine\n#### apk\n\n`apk` es el gestor de paquetes de Alpine Linux. Permite instalar, actualizar y desinstalar paquetes en el sistema. Aquí tienes algunos comandos útiles:\n\n- `apk update`: actualiza la lista de paquetes disponibles en los repositorios.\n- `apk upgrade`: actualiza todos los paquetes instalados en el sistema.\n- `apk add \u003cnombre_del_paquete\u003e`: instala un paquete en el sistema.\n- `apk del \u003cnombre_del_paquete\u003e`: desinstala un paquete del sistema.\n- `apk search \u003cnombre_del_paquete\u003e`: busca un paquete en los repositorios disponibles.\n- `apk info \u003cnombre_del_paquete\u003e`: muestra información detallada sobre un paquete.\n\nEs importante tener en cuenta que necesitas ejecutar `apk update` para actualizar la lista de paquetes disponibles antes de instalar cualquier paquete.\n\n#### Otros comandos útiles\n\n- `apk add --no-cache \u003cnombre_del_paquete\u003e`: instala un paquete sin caché. Esto reduce la cantidad de espacio utilizado por el paquete.\n- `apk add --virtual \u003cnombre_del_paquete\u003e`: 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.\n- `apk cache clean`: limpia la caché de paquetes para liberar espacio en disco.\n\nTen en cuenta que `apk` también puede ser utilizado para","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fstringmanolo%2Fhackingtermux101","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fstringmanolo%2Fhackingtermux101","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fstringmanolo%2Fhackingtermux101/lists"}