androidsecurity

Protegiendo datos, SHA-512

1 Star2 Stars3 Stars4 Stars5 Stars6 Stars7 Stars8 Stars9 Stars10 Stars (1 votes, average: 1,00 out of 10)
Loading ... Loading ...

Cuando programamos nuestra aplicación móvil, una de las cosas que nos viene a la mente es la seguridad. ¿Estarán a salvo los datos de mis usuarios? ¿Podrán registrar la información que envió y recibo?

“El único sistema realmente seguro es el que está apagado, en una caja fuerte de titanio, enterrado en una bóveda de hormigón en el fondo del mar y rodeado por guardias de seguridad muy bien remunerados…. y aun así tampoco podríamos garantizarlo” (de Eugene H. Spafford)

Asumimos entonces que una red abierta no puede ser segura, pero si que podemos complicarles las cosas a aquellos que intenten obtener beneficio de nuestros datos. Para ello existen ciertas herramientas, tanto físicas (en el caso de los “datacenters” por ejemplo, escáneres, tarjetas de identificación, etc.) como lógicas. En este último apartado se encuentra la que os voy a mostrar hoy, funciones de encriptación de datos.

Existen varios métodos de codificación como puede ser RSA (clave pública, clave privada) o algoritmos de “hasheo” como SHA o MD5. Cada algoritmo tiene sus particularidades y las que más nos interesan de estas son la facilidad para utilizarlos (rendimiento, facilidad de programación,…) y la fortaleza de la clave generada.

En nuestro ejemplo, usaremos el algoritmo SHA-512, que nos devolverá un “hash” de 512 bits. Suficiente por ahora para nuestra aplicación. En caso de necesitar algo más de robustez, podríamos optar por coger el algoritmo RSA aunque tendremos que tener cuidado con los recursos que este consume para generar la salida (tened en cuenta que estamos hablando de teléfonos móviles y que no todos los modelos disponen de un procesador bueno).

Para empezar este pequeño ejercicio, usaremos 2 clases, yo las he nombrado “Codificador” y “AndroSHA-512”. En la primera tendremos el código que nos generará el hash y en el segundo será el bloque principal. Desde ahí manejaremos los strings que queramos encriptar.

Clase Codificador:

Esta clase nos abstraerá de la acción de encriptar y todo lo que conlleva. Aquí os dejo un artículo muy interesante sobre el SHA-2 y sus variantes (SHA-224, 256, 512 y 384)
A nuestra clase “Codificador” le vamos a enviar 2 parámetros, el algoritmo (String) y el mensaje a encriptar (String). El método estático MessageDigest incluido en java.security interpreta varios algoritmos, en caso de que queramos interpretar alguno que no entiende, podemos decirle que nos muestre un “NoSuchAlgorithmException”. Para evitar esto podemos llamar a los métodos de codificación dentro de la misma llamada de la siguiente manera.

Codificador.getEncoded(Codificador.SHA512, text);"

Al final, nuestra función devolverá un String (output) con nuestro código hash.

package com.example.androisha512;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

import android.util.Log;

public class Codificador {

	public static final String SHA512 = “SHA-512”;

	public static String getEncoded(String texto, String algoritmo) throws NoSuchAlgorithmException {
		MessageDigest md;
		String output = "";
		try {
			md= MessageDigest.getInstance(algoritmo);
			md.update(texto.getBytes());
			byte[] mb = md.digest();
			for (int i = 0; i < mb.length; i++) {
				byte temp = mb[i];
				String s = Integer.toHexString(new Byte(temp));
				while (s.length() < 2) {
					s = "0" + s;
				}
				s = s.substring(s.length() - 2);
				output += s;
			}
		} catch (NoSuchAlgorithmException nsae) {
			nsae.printStackTrace();
		}
		Log.d("SHA","Output: "+output);
		return output;
	}
}

Clase AndroSHA512:

Desde esta clase manejaremos el texto a codificar y el algoritmo, así como la respuesta de la función getEncoded de la clase “Codificador”.

package com.example.androisha512;

import java.security.NoSuchAlgorithmException;

import com.example.andromd5.R;

import android.app.Activity;
import android.os.Bundle;
import android.widget.TextView;

public class AndroSHA512 extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        String texto = "Hola Android";

        TextView tv = new TextView(this);

        String resultado = "";
		try {
			resultado = Codificador.getEncoded(Codificador.SHA512, texto);
		} catch (NoSuchAlgorithmException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

        tv.setText("Texto normal: " + texto + "\n" + "Texto en SHA512: " + resultado);
        setContentView(tv);

    }
}

Como veréis lo primero que hemos hecho ha sido crear un TextView para poder mostrar el output codificado.. Tras este simple paso hemos creado 3 Strings, resultado, algoritmo y texto.
A la variable algoritmo le hemos asignado el valor “SHA-512” pero podríamos haberle dado cualquier otro siempre que MessageDigest lo entienda. En texto escribiremos lo que queramos codificar y después inicializaremos la variable resultado.
La función getEncoded nos lanzará un NoSuchAlgorithmException por lo tanto tendremos que hacer uso de un Try/Catch. Una vez asignado el output de la función a resultado, haremos un setText al TextView para mostrar la respuesta que es de tipo String.

Este es un ejemplo que podéis usar en vuestras aplicaciones, no es difícil de realizar y es bastante útil para encriptar datos importantes. De todos modos siempre influye el concepto de cada uno sobre lo importante que es la información con la que trabajamos y si pensáis que SHA-512 no os vale, probad con la librería RSA que trae Android.
¿Alguna vez habéis usado algoritmos de encriptación? ¿Cuáles? ¿Tenéis preferencias por alguno en concreto? Opinad y comentad, que siempre estaremos dispuestos a conversar en los comentarios del post.

Un saludo

  • jmarti

    Thanks por la info!

    Un reto… si quisiera guardar algun literal en mi android que luego necesitara recuperar (como contraseñas, etc), ¿android tiene algún mecanismo para guardarla de forma segura? ¿alguien sabe qué alternativas hay?

    Es decir, si encripto algo en una BD, y luego me roban el android, pueden recuperar lo que hay en la BD, ya que entiendo que la key también irá en la aplicación, y basta con decompilar la aplicación para recuperar la key.

    ¿alguien sabe qué opciones habría? podría ser un nuevo tema para un post :)

    • afernandez

      De forma segura no, puedes codificar primero y guardar después en Shared Preferences pero esto tampoco es seguro al 100%, conviene establecer el MODE_PRIVATE. Por otro lado si tienes el móvil con Root puede ser menos seguro aun.

      Buscando un poco por ahí, me he topado con CryptoIntents que tiene buena pinta, copy & paste

      “There’s a project called CryptoIntents that you could
      make use of to store the password encrypted. This requires the user to
      enter a master password whenever you want to access the unencrypted
      password (with some timeout). ”

      http://code.google.com/p/openintents/wiki/CryptoIntents

      Un saludete y thanks por comentar.

  • Edgardo B.

    Muy bueno el articulo pero tengo una pregunta: cuando quiera guardar en la base de datos que valor guardaria??? y cuando quiera comparar para iniciar sesion por ejemplo con que valor compararia ??? ayuda porfa que lo necesito para mi app en android