Hash MD5 en Android

Tengo un cliente de Android simple que necesita 'hablar' con un oyente HTTP de C # simple. Quiero proporcionar un nivel básico de autenticación pasando el nombre de usuario / contraseña en las solicitudes POST.

El hash MD5 es trivial en C # y proporciona suficiente seguridad para mis necesidades, pero parece que no puedo encontrar cómo hacerlo en el extremo de Android.

EDITAR: Solo para abordar las preocupaciones planteadas sobre la debilidad de MD5: el servidor C # se ejecuta en las PC de los usuarios de mi cliente Android. En muchos casos, accederán al servidor usando wi-fi en sus propias LAN pero, bajo su propio riesgo, pueden optar por acceder a él desde Internet. Además, el servicio en el servidor debe utilizar el paso a través del MD5 a una aplicación de terceros sobre la que no tengo control.

Aquí hay una implementación que puede usar (actualizada para usar convenciones Java más actualizadas - for:eachbucle, en StringBuilderlugar de StringBuffer):

public static String md5(final String s) {
    final String MD5 = "MD5";
    try {
        // Create MD5 Hash
        MessageDigest digest = java.security.MessageDigest
                .getInstance(MD5);
        digest.update(s.getBytes());
        byte messageDigest[] = digest.digest();

        // Create Hex String
        StringBuilder hexString = new StringBuilder();
        for (byte aMessageDigest : messageDigest) {
            String h = Integer.toHexString(0xFF & aMessageDigest);
            while (h.length() < 2)
                h = "0" + h;
            hexString.append(h);
        }
        return hexString.toString();

    } catch (NoSuchAlgorithmException e) {
        e.printStackTrace();
    }
    return "";
}

Aunque no se recomienda para sistemas que involucran incluso el nivel básico de seguridad (MD5 se considera roto y se puede explotar fácilmente ), a veces es suficiente para tareas básicas.

La respuesta aceptada no funcionó para mí en Android 2.2. No sé por qué, pero se estaba "comiendo" algunos de mis ceros (0). Apache commons tampoco funcionaba en Android 2.2, porque utiliza métodos que solo son compatibles a partir de Android 2.3.x. Además, si solo desea MD5 una cadena, Apache commons es demasiado complejo para eso. Por qué uno debería mantener una biblioteca completa para usar solo una pequeña función de ella ...

Finalmente encontré el siguiente fragmento de código aquí que funcionó perfectamente para mí. Espero que sea de utilidad para alguien ...

public String MD5(String md5) {
   try {
        java.security.MessageDigest md = java.security.MessageDigest.getInstance("MD5");
        byte[] array = md.digest(md5.getBytes("UTF-8"));
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < array.length; ++i) {
          sb.append(Integer.toHexString((array[i] & 0xFF) | 0x100).substring(1,3));
       }
        return sb.toString();
    } catch (java.security.NoSuchAlgorithmException e) {
    } catch(UnsupportedEncodingException ex){
    }
    return null;
}

El código de androidsnippets.com no funciona de manera confiable porque los ceros parecen cortarse del hash resultante.

Una mejor implementación está aquí .

public static String MD5_Hash(String s) {
    MessageDigest m = null;

    try {
            m = MessageDigest.getInstance("MD5");
    } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
    }

    m.update(s.getBytes(),0,s.length());
    String hash = new BigInteger(1, m.digest()).toString(16);
    return hash;
}

Si usar Apache Commons Codec es una opción, entonces esta sería una implementación más corta:

String md5Hex = new String(Hex.encodeHex(DigestUtils.md5(data)));

O SHA:

String shaHex= new String(Hex.encodeHex(DigestUtils.sha("textToHash")));

Fuente de arriba.

Siga el enlace y vote a favor de su solución para adjudicar a la persona correcta.

Enlace de repositorio de Maven: https://mvnrepository.com/artifact/commons-codec/commons-codec

Dependencia actual de Maven (a partir del 6 de julio de 2016):

<!-- https://mvnrepository.com/artifact/commons-codec/commons-codec -->
<dependency>
    <groupId>commons-codec</groupId>
    <artifactId>commons-codec</artifactId>
    <version>1.10</version>
</dependency>

Una solución anterior usando DigestUtils no funcionó para mí. En mi versión de Apache commons (la última de 2013) no existe tal clase.

Encontré otra solución aquí en un blog . Funciona perfectamente y no necesita Apache commons. Parece un poco más corto que el código en la respuesta aceptada anterior.

public static String getMd5Hash(String input) {
    try {
        MessageDigest md = MessageDigest.getInstance("MD5");
        byte[] messageDigest = md.digest(input.getBytes());
        BigInteger number = new BigInteger(1, messageDigest);
        String md5 = number.toString(16);

        while (md5.length() < 32)
            md5 = "0" + md5;

        return md5;
    } catch (NoSuchAlgorithmException e) {
        Log.e("MD5", e.getLocalizedMessage());
        return null;
    }
}

Necesitará estas importaciones:

import java.math.BigInteger;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

Esta es una ligera variación de las respuestas de Andranik y Den Delimarsky anteriores, pero es un poco más concisa y no requiere ninguna lógica bit a bit. En su lugar, utiliza el String.formatmétodo incorporado para convertir los bytes en cadenas hexadecimales de dos caracteres (no elimina los ceros). Normalmente, solo comentaría sus respuestas, pero no tengo la reputación de hacerlo.

public static String md5(String input) {
    try {
        MessageDigest md = MessageDigest.getInstance("MD5");

        StringBuilder hexString = new StringBuilder();
        for (byte digestByte : md.digest(input.getBytes()))
            hexString.append(String.format("%02X", digestByte));

        return hexString.toString();
    } catch (NoSuchAlgorithmException e) {
        e.printStackTrace();
        return null;
    }
}

Si en su lugar desea devolver una cadena en minúsculas, simplemente cambie %02Xa %02x.

Editar: usando BigInteger como con la respuesta de wzbozon, puede hacer que la respuesta sea aún más concisa:

public static String md5(String input) {
    try {
        MessageDigest md = MessageDigest.getInstance("MD5");
        BigInteger md5Data = new BigInteger(1, md.digest(input.getBytes()));
        return String.Format("%032X", md5Data);
    } catch (NoSuchAlgorithmException e) {
        e.printStackTrace();
        return null;
    }
}

Hice una biblioteca simple en Kotlin.

Agregar en Root build.gradle

allprojects {
        repositories {
            ...
            maven { url 'https://jitpack.io' }
        }
    }

en App build.gradle

implementation 'com.github.1AboveAll:Hasher:-SNAPSHOT'

Uso

En Kotlin

val ob = Hasher()

Luego use el método hash ()

ob.hash("String_You_Want_To_Encode",Hasher.MD5)

ob.hash("String_You_Want_To_Encode",Hasher.SHA_1)

Devolverá MD5 y SHA-1 respectivamente.

Más sobre la biblioteca

https://github.com/ihimanshurawat/Hasher

Aquí está la versión de Kotlin de la respuesta de @Andranik. Necesitamos cambiar getBytesa toByteArray(no es necesario agregar el juego de caracteres UTF-8 porque el toByteArrayjuego de caracteres predeterminado es UTF-8) y convertir la matriz [i] a un entero

fun String.md5(): String? {
    try {
        val md = MessageDigest.getInstance("MD5")
        val array = md.digest(this.toByteArray())
        val sb = StringBuffer()
        for (i in array.indices) {
            sb.append(Integer.toHexString(array[i].toInt() and 0xFF or 0x100).substring(1, 3))
        }
        return sb.toString()
    } catch (e: java.security.NoSuchAlgorithmException) {
    } catch (ex: UnsupportedEncodingException) {
    }
    return null
}

Espero que ayude

En nuestra aplicación MVC generamos param largo

using System.Security.Cryptography;
using System.Text;
    ...
    public static string getMD5(long id)
    {
        // convert
        string result = (id ^ long.MaxValue).ToString("X") + "-ANY-TEXT";
        using (MD5 md5Hash = MD5.Create())
        {
            // Convert the input string to a byte array and compute the hash. 
            byte[] data = md5Hash.ComputeHash(Encoding.UTF8.GetBytes(result));

            // Create a new Stringbuilder to collect the bytes and create a string.
            StringBuilder sBuilder = new StringBuilder();
            for (int i = 0; i < data.Length; i++)
                sBuilder.Append(data[i].ToString("x2"));

            // Return the hexadecimal string. 
            result = sBuilder.ToString().ToUpper();
        }

        return result;
    }

y lo mismo en la aplicación de Android (thenk ayuda a Andranik)

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
...
public String getIdHash(long id){
    String hash = null;
    long intId = id ^ Long.MAX_VALUE;
    String md5 = String.format("%X-ANY-TEXT", intId);
    try {
        MessageDigest md = java.security.MessageDigest.getInstance("MD5");
        byte[] arr = md.digest(md5.getBytes());
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < arr.length; ++i)
            sb.append(Integer.toHexString((arr[i] & 0xFF) | 0x100).substring(1,3));

        hash = sb.toString();
    } catch (NoSuchAlgorithmException e) {
        Log.e("MD5", e.getMessage());
    }

    return hash.toUpperCase();
}

He utilizado el método siguiente para darme md5 pasando la cadena para la que desea obtener md5

public static String getMd5Key(String password) {

//        String password = "12131123984335";

        try {
            MessageDigest md = MessageDigest.getInstance("MD5");
            md.update(password.getBytes());

            byte byteData[] = md.digest();

            //convert the byte to hex format method 1
            StringBuffer sb = new StringBuffer();
            for (int i = 0; i < byteData.length; i++) {
                sb.append(Integer.toString((byteData[i] & 0xff) + 0x100, 16).substring(1));
            }

            System.out.println("Digest(in hex format):: " + sb.toString());

            //convert the byte to hex format method 2
            StringBuffer hexString = new StringBuffer();
            for (int i = 0; i < byteData.length; i++) {
                String hex = Integer.toHexString(0xff & byteData[i]);
                if (hex.length() == 1) hexString.append('0');
                hexString.append(hex);
            }
            System.out.println("Digest(in hex format):: " + hexString.toString());

            return hexString.toString();

        } catch (Exception e) {
            // TODO: handle exception
        }

        return "";
}

Utilice SHA-512, MD5 no es seguro

public static String getSHA512SecurePassword(String passwordToHash) {
    String generatedPassword = null;
    try {
        MessageDigest md = MessageDigest.getInstance("SHA-512");
        md.update("everybreathyoutake".getBytes());
        byte[] bytes = md.digest(passwordToHash.getBytes());
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < bytes.length; i++) {
            sb.append(Integer.toString((bytes[i] & 0xff) + 0x100, 16).substring(1));
        }
        generatedPassword = sb.toString();
    } catch (NoSuchAlgorithmException e) {
        e.printStackTrace();
    }
    return generatedPassword;
}

MD5 es un poco antiguo, SHA-1 es un algoritmo mejor, aquí hay un ejemplo .

( Además, como señalan en esa publicación, Java maneja esto por sí solo, sin código específico de Android ) .

La conversión de toHex () demasiado derrochadora prevalece en otras sugerencias, de verdad.

private static final char[] HEX_ARRAY = "0123456789ABCDEF".toCharArray();

public static String md5string(String s) {
    return toHex(md5plain(s));
}

public static byte[] md5plain(String s) {
    final String MD5 = "MD5";
    try {
        // Create MD5 Hash
        MessageDigest digest = java.security.MessageDigest.getInstance(MD5);
        digest.update(s.getBytes());
        return digest.digest();
    } catch (NoSuchAlgorithmException e) {
        // never happens
        e.printStackTrace();
        return null;
    }
}

public static String toHex(byte[] buf) {
    char[] hexChars = new char[buf.length * 2];
    int v;
    for (int i = 0; i < buf.length; i++) {
        v = buf[i] & 0xFF;
        hexChars[i * 2] = HEX_ARRAY[v >>> 4];
        hexChars[i * 2 + 1] = HEX_ARRAY[v & 0x0F];
    }
    return new String(hexChars);
}

esto funciona perfectamente para mí, lo usé para obtener MD5 en LIST Array (luego convertirlo en un objeto JSON), pero si solo necesita aplicarlo en sus datos. escriba formato, reemplace JsonObject con el suyo.

¡Especialmente si tiene una discrepancia con la implementación de Python MD5, use esto!

private static String md5(List<AccelerationSensor> sensor) {

    Gson gson= new Gson();
    byte[] JsonObject = new byte[0];
    try {
        JsonObject = gson.toJson(sensor).getBytes("UTF-8");
    } catch (UnsupportedEncodingException e) {
        e.printStackTrace();
    }

    MessageDigest m = null;

    try {
        m = MessageDigest.getInstance("MD5");
    } catch (NoSuchAlgorithmException e) {
        e.printStackTrace();
    }

    byte[] thedigest = m.digest(JsonObject);
    String hash = String.format("%032x", new BigInteger(1, thedigest));
    return hash;


}

Las soluciones proporcionadas para el lenguaje Scala (un poco más corto):

def getMd5(content: Array[Byte]) =
    try {
        val md = MessageDigest.getInstance("MD5")
        val bytes = md.digest(content)
        bytes.map(b => Integer.toHexString((b + 0x100) % 0x100)).mkString
    } catch {
        case ex: Throwable => null
    }