Cómo hash una cadena en Android?

Estoy trabajando en una aplicación de Android y tengo un par de cadenas que me gustaría encriptar antes de enviarlas a una base de datos. Me gustaría algo que sea seguro, fácil de implementar, generará lo mismo cada vez que pase los mismos datos, y preferiblemente dará como resultado una cadena que se mantendrá constante sin importar cuán grande sea la cadena que se le pase. Tal vez estoy buscando un hash.

Este fragmento calcula md5 para cualquier cadena dada

public String md5(String s) { try { // Create MD5 Hash MessageDigest digest = java.security.MessageDigest.getInstance("MD5"); digest.update(s.getBytes()); byte messageDigest[] = digest.digest(); // Create Hex String StringBuffer hexString = new StringBuffer(); for (int i=0; i 

Fuente: http://www.androidsnippets.com/snippets/52/index.html

Espero que esto sea útil para ti

La función anterior de ( http://www.androidsnippets.org/snippets/52/index.html ) tiene fallas. Si uno de los dígitos en el messageDigest no es un valor hexadecimal de dos caracteres (es decir, 0x09), no funciona correctamente porque no incluye un 0. Si busca alrededor, encontrará esa función y las quejas al respecto no funciona. Aquí encontré uno mejor en la sección de comentarios de esta página , que modifiqué ligeramente:

 public static String md5(String s) { MessageDigest digest; try { digest = MessageDigest.getInstance("MD5"); digest.update(s.getBytes(Charset.forName("US-ASCII")),0,s.length()); byte[] magnitude = digest.digest(); BigInteger bi = new BigInteger(1, magnitude); String hash = String.format("%0" + (magnitude.length << 1) + "x", bi); return hash; } catch (NoSuchAlgorithmException e) { e.printStackTrace(); } return ""; } 

no método de trabajo:

 public static String md5(String s) { try { // Create MD5 Hash MessageDigest digest = java.security.MessageDigest .getInstance("MD5"); digest.update(s.getBytes()); byte messageDigest[] = digest.digest(); // Create Hex String StringBuffer hexString = new StringBuffer(); for (int i = 0; i < messageDigest.length; i++) hexString.append(Integer.toHexString(0xFF & messageDigest[i])); return hexString.toString(); } catch (NoSuchAlgorithmException e) { e.printStackTrace(); } return ""; } 

resultado - 1865e62e7129927f6e4cd9bff104f0 (longitud 30)

método de trabajo:

 public static final String md5(final String toEncrypt) { try { final MessageDigest digest = MessageDigest.getInstance("md5"); digest.update(toEncrypt.getBytes()); final byte[] bytes = digest.digest(); final StringBuilder sb = new StringBuilder(); for (int i = 0; i < bytes.length; i++) { sb.append(String.format("%02X", bytes[i])); } return sb.toString().toLowerCase(); } catch (Exception exc) { return ""; // Impossibru! } } 

resultado - 1865e62e7129927f6e4c0d9bff1004f0 (longitud 32)

 private static char[] hextable = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' }; public static String byteArrayToHex(byte[] array) { String s = ""; for (int i = 0; i < array.length; ++i) { int di = (array[i] + 256) & 0xFF; // Make it unsigned s = s + hextable[(di >> 4) & 0xF] + hextable[di & 0xF]; } return s; } public static String digest(String s, String algorithm) { MessageDigest m = null; try { m = MessageDigest.getInstance(algorithm); } catch (NoSuchAlgorithmException e) { e.printStackTrace(); return s; } m.update(s.getBytes(), 0, s.length()); return byteArrayToHex(m.digest()); } public static String md5(String s) { return digest(s, "MD5"); } 

La respuesta anterior es casi 100% correcta. Fallará con Unicode.

  MessageDigest digest; try { digest = MessageDigest.getInstance("MD5"); byte utf8_bytes[] = tag_xml.getBytes(); digest.update(utf8_bytes,0,utf8_bytes.length); hash = new BigInteger(1, digest.digest()).toString(16); } catch (NoSuchAlgorithmException e) { e.printStackTrace(); } 

Necesita la longitud de la matriz de bytes, no la cadena.

Con la solución @Donut, con caracteres codificados en UTF-8 (por ej., É), debe usar getBytes("UTF-8") . Aquí está mi corrección del método de digestión:

 private static char[] hextable = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'}; public static String byteArrayToHex(byte[] array) { String s = ""; for (int i = 0; i < array.length; ++i) { int di = (array[i] + 256) & 0xFF; // Make it unsigned s = s + hextable[(di >> 4) & 0xF] + hextable[di & 0xF]; } return s; } public static String digest(String s, String algorithm) { MessageDigest m = null; try { m = MessageDigest.getInstance(algorithm); } catch (NoSuchAlgorithmException e) { e.printStackTrace(); return s; } try { m.update(s.getBytes("UTF-8")); } catch (UnsupportedEncodingException e) { e.printStackTrace(); m.update(s.getBytes()); } return byteArrayToHex(m.digest()); } public static String md5(String s) { return digest(s, "MD5"); } 

La solución de Donut en una sola función:

 private static char[] hextable = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' }; private static String md5(String s) { MessageDigest digest; try { digest = MessageDigest.getInstance("MD5"); digest.update(s.getBytes(), 0, s.length()); byte[] bytes = digest.digest(); String hash = ""; for (int i = 0; i < bytes.length; ++i) { int di = (bytes[i] + 256) & 0xFF; hash = hash + hextable[(di >> 4) & 0xF] + hextable[di & 0xF]; } return hash; } catch (NoSuchAlgorithmException e) { } return ""; } 

Lo siguiente funcionó para mí en Android sin truncar ningún 0 delante:

 MessageDigest md = null; String digest = null; try { md = MessageDigest.getInstance("MD5"); byte[] hash = md.digest(myStringToEncode.getBytes("UTF-8")); //converting byte array to Hexadecimal String StringBuilder sb = new StringBuilder(2*hash.length); for(byte b : hash){ sb.append(String.format("%02x", b&0xff)); } digest = sb.toString(); } catch (NoSuchAlgorithmException e) { e.printStackTrace(); } catch (UnsupportedEncodingException e) { e.printStackTrace(); } return digest; 
 MessageDigest md = MessageDigest.getInstance("MD5"); md.update('yourstring'); byte[] digest = md.digest(); StringBuffer sb = new StringBuffer(); for (byte b : digest) { sb.append(String.format("%02x", (0xFF & b))); } 

Es tarde para el autor, pero antes de esto, obtengo Integer.toHexString(0xff&b) , que elimina los 0 principales de la cadena hexadecimal. Me hace luchar por un largo tiempo. Espero que sea útil para algunos muchachos.

Esto no falta ‘0’

  public static String md5(String string) { if (TextUtils.isEmpty(string)) { return ""; } MessageDigest md5 = null; try { md5 = MessageDigest.getInstance("MD5"); byte[] bytes = md5.digest(string.getBytes()); String result = ""; for (byte b : bytes) { String temp = Integer.toHexString(b & 0xff); if (temp.length() == 1) { temp = "0" + temp; } result += temp; } return result; } catch (NoSuchAlgorithmException e) { e.printStackTrace(); } return ""; } 

si estás usando guayaba:

 public String generateMd5(String input) { HashFunction hf = Hashing.md5(); Hasher hasher = hf.newHasher(); HashCode hc = hasher.putString(input, StandardCharsets.UTF_8).hash(); return hc.toString(); } 

Si no tenía restricciones de seguridad y solo quería convertir String en un int único. Lo escribo porque eso es lo que busqué y alcancé aquí.

 String my_key int my_key.hashCode() 

si tiene hasta 10 caracteres, incluso será único. Consulte también https://stackoverflow.com/a/17583653/1984636