Hashing MD5 no Android

Eu tenho um cliente Android simples que precisa 'conversar' com um ouvinte HTTP C # simples. Desejo fornecer um nível básico de autenticação passando nome de usuário / senha em solicitações POST.

O hashing MD5 é trivial em C # e fornece segurança suficiente para minhas necessidades, mas não consigo descobrir como fazer isso no final do Android.

EDIT: Apenas para resolver as preocupações levantadas sobre a fraqueza do MD5 - o servidor C # é executado nos PCs dos usuários do meu cliente Android. Em muitos casos, eles acessarão o servidor usando wi-fi em suas próprias LANs, mas, por sua própria conta e risco, eles podem optar por acessá-lo da Internet. Além disso, o serviço no servidor precisa usar passagem do MD5 para um aplicativo de terceiros sobre o qual não tenho controle.

Aqui está uma implementação que você pode usar (atualizada para usar convenções Java mais atualizadas - for:eachloop, em StringBuildervez 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 "";
}

Embora não seja recomendado para sistemas que envolvem até mesmo o nível básico de segurança (MD5 é considerado quebrado e pode ser facilmente explorado ), às vezes é suficiente para tarefas básicas.

A resposta aceita não funcionou para mim no Android 2.2. Não sei por que, mas ele estava "comendo" alguns dos meus zeros (0). O Apache commons também não funcionou no Android 2.2, porque ele usa métodos compatíveis apenas a partir do Android 2.3.x. Além disso, se você deseja apenas MD5 uma string, o Apache commons é muito complexo para isso. Por que se deve manter uma biblioteca inteira para usar apenas uma pequena função dela ...

Finalmente eu encontrei o seguinte trecho de código aqui que funcionou perfeitamente para mim. Espero que seja útil para alguém ...

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;
}

O código androidsnippets.com não funciona de maneira confiável porque os 0s parecem ter sido cortados do hash resultante.

Uma implementação melhor está aqui .

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;
}

Se usar o Apache Commons Codec for uma opção, esta seria uma implementação mais curta:

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

Ou SHA:

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

Fonte para acima.

Siga o link e vote positivamente na solução para premiar a pessoa correta.

Link do repositório Maven: https://mvnrepository.com/artifact/commons-codec/commons-codec

Dependência atual do Maven (em 6 de julho de 2016):

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

Uma solução acima usando DigestUtils não funcionou para mim. Na minha versão do Apache commons (a mais recente para 2013) não existe tal classe.

Encontrei outra solução aqui em um blog . Ele funciona perfeitamente e não precisa de recursos comuns do Apache. Parece um pouco mais curto do que o código na resposta aceita acima.

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;
    }
}

Você precisará destas importações:

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

Esta é uma pequena variação das respostas de Andranik e Den Delimarsky acima, mas é um pouco mais conciso e não requer nenhuma lógica bit a bit. Em vez disso, ele usa o String.formatmétodo interno para converter os bytes em cadeias hexadecimais de dois caracteres (não tira 0's). Normalmente, eu apenas comentaria as respostas, mas não tenho reputação para fazer isso.

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;
    }
}

Se você quiser retornar uma string minúscula, basta mudar %02Xpara %02x.

Edit: Usando BigInteger como com a resposta de wzbozon, você pode tornar a resposta ainda mais 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;
    }
}

Eu fiz uma biblioteca simples em Kotlin.

Adicionar na raiz build.gradle

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

em App build.gradle

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

Uso

Em Kotlin

val ob = Hasher()

Então use o método hash ()

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

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

Ele retornará MD5 e SHA-1 respectivamente.

Mais sobre a Biblioteca

https://github.com/ihimanshurawat/Hasher

Aqui está a versão Kotlin da resposta de @Andranik. Precisamos mudar getBytespara toByteArray(não é necessário adicionar charset UTF-8 porque o charset padrão de toByteArrayé UTF-8) e converter array [i] para inteiro

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 ajude

MD5 é um pouco antigo, SHA-1 é um algoritmo melhor, há um exemplo aqui .

( Além disso, como eles observaram nessa postagem, Java trata disso por conta própria, sem código específico do Android. )

Em nosso aplicativo MVC, geramos para long param

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;
    }

e o mesmo no aplicativo Android (thenk ajuda 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();
}

Eu usei o método abaixo para me fornecer MD5 passando a string para a qual você deseja obter 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 "";
}

Use SHA-512, MD5 não é 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;
}

A conversão toHex () muito desperdiçadora prevalece em outras sugestões.

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);
}

Isso está funcionando perfeitamente para mim, eu usei isso para obter MD5 no Array LIST (em seguida, convertê-lo em objeto JSON), mas se você só precisa aplicá-lo em seus dados. digite o formato, substitua JsonObject pelo seu.

Especialmente se você tiver uma incompatibilidade com a implementação do python MD5, use isso!

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;


}

As soluções fornecidas para a linguagem Scala (um pouco mais curtas):

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
    }