Java String to SHA1

C'est ma solution pour convertir une chaîne en sha1. Il fonctionne bien dans mon application Android:

private static String encryptPassword(String password)
{
    String sha1 = "";
    try
    {
        MessageDigest crypt = MessageDigest.getInstance("SHA-1");
        crypt.reset();
        crypt.update(password.getBytes("UTF-8"));
        sha1 = byteToHex(crypt.digest());
    }
    catch(NoSuchAlgorithmException e)
    {
        e.printStackTrace();
    }
    catch(UnsupportedEncodingException e)
    {
        e.printStackTrace();
    }
    return sha1;
}

private static String byteToHex(final byte[] hash)
{
    Formatter formatter = new Formatter();
    for (byte b : hash)
    {
        formatter.format("%02x", b);
    }
    String result = formatter.toString();
    formatter.close();
    return result;
}

utilisant classe de hachage de goyaves :

Hashing.sha1().hashString( "password", Charsets.UTF_8 ).toString()

SHA-1 (et tous les autres algorithmes de hachage) retourner des données binaires. Cela signifie que (en Java) ils produisent un byte[] . Ce tableau byte ne pas représente des caractères spécifiques, ce qui signifie que vous ne pouvez pas simplement le transformer en String comme vous l'avez fait.

si vous avez besoin d'un String , alors vous devez formater ce byte[] d'une manière qui peut être représentée comme un String (autrement, juste gardez le byte[] autour).

deux façons courantes de représenter arbitrairement byte[] en tant que caractères imprimables sont BASE64 ou simple hexadécimal Hex-Strings (i.e. représentant chaque byte par deux chiffres hexadécimaux). On dirait que vous essayez de produire une chaîne hexagonale.

il y a aussi un autre piège: si vous voulez obtenir le SHA-1 D'un Java String , alors vous devez convertir ce String en byte[] d'abord (comme l'entrée de SHA-1 est un byte[] ). Si vous utilisez simplement myString.getBytes() comme vous l'avez montré, alors il utilisera l'encodage par défaut de la plate-forme et en tant que tel dépendra de l'environnement dans lequel vous l'exécutez (par exemple, il pourrait retourner des données différentes basées sur le paramètre langue/locale de votre OS).

une meilleure solution est de spécifier le codage à utiliser pour la conversion String en byte[] comme ceci: myString.getBytes("UTF-8") . Choisir UTF-8 (ou un autre encodage qui peut représenter chaque caractère Unicode) est le choix le plus sûr ici.

utilisez simplement la bibliothèque codec Apache commons. Ils ont une classe d'utilité appelée DigestUtils

Pas besoin d'entrer dans les détails.

c'est une solution simple qui peut être utilisée lors de la conversion d'une chaîne de caractères au format hex:

private static String encryptPassword(String password) throws NoSuchAlgorithmException, UnsupportedEncodingException {

    MessageDigest crypt = MessageDigest.getInstance("SHA-1");
    crypt.reset();
    crypt.update(password.getBytes("UTF-8"));

    return new BigInteger(1, crypt.digest()).toString(16);
}

comme mentionné ci-dessus utilisez apache commons codec. Il est recommandé par les gars de printemps aussi bien (voir DigestUtils dans le Doc de printemps). Par exemple:

DigestUtils.sha1Hex(b);

N'utiliserait certainement pas la réponse la mieux notée ici.

ce n'est pas une impression correcte car vous devez utiliser L'encodage Base64. Avec Java 8, Vous pouvez encoder en utilisant la classe d'encodage Base64 .

public static String toSHA1(byte[] convertme) {
    md = MessageDigest.getInstance("SHA-1");
    return Base64.getEncoder().encodeToString((md.digest(convertme));
}

résultat

cela vous donnera votre production attendue de 5baa61e4c9b93f3f0682250b6cf8331b7ee68fd8

la raison pour laquelle cela ne fonctionne pas est que lorsque vous appelez String(md.digest(convertme)) , vous dites à Java d'interpréter une séquence d'octets cryptés comme une chaîne de caractères. Ce que vous voulez est de convertir les octets en caractères hexadécimaux.

convertissez la chaîne byte en chaîne hex.

public static String toSHA1(byte[] convertme) {
    final char[] HEX_CHARS = "0123456789ABCDEF".toCharArray();
    MessageDigest md = null;
    try {
        md = MessageDigest.getInstance("SHA-1");
    }
    catch(NoSuchAlgorithmException e) {
        e.printStackTrace();
    }
    byte[] buf = md.digest(convertme);
    char[] chars = new char[2 * buf.length];
    for (int i = 0; i < buf.length; ++i) {
        chars[2 * i] = HEX_CHARS[(buf[i] & 0xF0) >>> 4];
        chars[2 * i + 1] = HEX_CHARS[buf[i] & 0x0F];
    }
    return new String(chars);
}

Base 64 représentation de SHA1 Hash:

String hashedVal = Base64.getEncoder().encodeToString(DigestUtils.sha1(stringValue.getBytes(Charset.forName("UTF-8"))));