String Java para SHA1

Estou tentando fazer um simples conversor de String para SHA1 em Java e é isso que eu tenho ...

public static String toSHA1(byte[] convertme) {
    MessageDigest md = null;
    try {
        md = MessageDigest.getInstance("SHA-1");
    }
    catch(NoSuchAlgorithmException e) {
        e.printStackTrace();
    } 
    return new String(md.digest(convertme));
}

Quando passo toSHA1("password".getBytes()), [�a�ɹ??�%l�3~��.sei que provavelmente é uma correção de codificação simples como UTF-8, mas alguém poderia me dizer o que devo fazer para obter o que quero 5baa61e4c9b93f3f0682250b6cf8331b7ee68fd8? Ou estou fazendo isso completamente errado?

ATUALIZAÇÃO
Você pode usar o Apache Commons Codec (versão 1.7+) para fazer esse trabalho.

DigestUtils.sha1Hex (stringToConvertToSHexRepresentation)

Obrigado a Jon Onstott por esta sugestão.

Resposta antiga
Converta seu Byte Array em Hex String. O Real's How To diz como .

return byteArrayToHexString(md.digest(convertme))

e (copiado do Real's How To)

public static String byteArrayToHexString(byte[] b) {
  String result = "";
  for (int i=0; i < b.length; i++) {
    result +=
          Integer.toString( ( b[i] & 0xff ) + 0x100, 16).substring( 1 );
  }
  return result;
}

BTW, você pode obter uma representação mais compacta usando o Base64. O Apache Commons Codec API 1.4 , possui esse ótimo utilitário para remover toda a dor. consulte aqui

Esta é a minha solução de converter string para sha1. Funciona bem no meu aplicativo 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;
}

Usando a classe Guava Hashing :

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

SHA-1 (e todos os outros algoritmos de hash) retornam dados binários. Isso significa que (em Java) eles produzem a byte[]. Esse bytearray não representa nenhum caractere específico, o que significa que você não pode simplesmente transformá-lo Stringcomo você fez.

Se você precisar de um String, precisará formatá-lo byte[]de uma maneira que possa ser representada como um String(caso contrário, apenas mantenha o ambiente byte[]).

Duas maneiras comuns de representar byte[]caracteres arbitrários como imprimíveis são BASE64 ou Hex-Strings simples (ou seja, representando cada um bytepor dois dígitos hexadecimais). Parece que você está tentando produzir uma cadeia hexadecimal.

Há também outra armadilha: se você deseja obter o SHA-1 de um Java String, é necessário convertê-lo Stringem um byte[]primeiro (já que a entrada do SHA-1 também é byte[]). Se você simplesmente usar myString.getBytes()como mostrou, ele usará a codificação padrão da plataforma e, como tal, dependerá do ambiente em que a executar (por exemplo, pode retornar dados diferentes com base na configuração de idioma / localidade do seu sistema operacional).

A melhor solução é especificar a codificação utilizada para a StringPara- byte[]conversão como este: myString.getBytes("UTF-8"). Escolher UTF-8 (ou outra codificação que possa representar todos os caracteres Unicode) é a opção mais segura aqui.

Esta é uma solução simples que pode ser usada ao converter uma string para um formato hexadecimal:

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

Basta usar a biblioteca de codecs do apache commons. Eles têm uma classe de utilitário chamada DigestUtils

Não há necessidade de entrar em detalhes.

Como mencionado anteriormente, use o codec do apache commons. Também é recomendado pelos caras do Spring (consulte DigestUtils no documento do Spring). Por exemplo:

DigestUtils.sha1Hex(b);

Definitivamente não usaria a resposta mais votada aqui.

Não está imprimindo corretamente porque você precisa usar a codificação Base64. Com o Java 8, você pode codificar usando a classe de codificador Base64 .

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

Resultado

Isso fornecerá a saída esperada de 5baa61e4c9b93f3f0682250b6cf8331b7ee68fd8

O Resumo da Mensagem (hash) é byte [] in byte [] out

Um resumo da mensagem é definido como uma função que pega uma matriz de bytes brutos e retorna uma matriz de bytes brutos (aka byte[]). Por exemplo, o SHA-1 (algoritmo de hash seguro 1) tem um tamanho de resumo de 160 bits ou 20 bytes. Matrizes de bytes brutos geralmente não podem ser interpretadas como codificações de caracteres como UTF-8 , porque nem todos os bytes em cada ordem são uma codificação legal. Então, convertendo-os em um Stringcom:

new String(md.digest(subject), StandardCharsets.UTF_8)

pode criar algumas seqüências ilegais ou possui indicadores de código para mapeamentos Unicode indefinidos :

[�a�ɹ??�%l�3~��.

Codificação de binário para texto

Para essa codificação de binário para texto é usada. Com os hashes, o mais usado é a codificação HEX ou Base16 . Basicamente, um byte pode ter o valor de 0a 255(ou -128a 127assinatura), que é equivalente à representação de HEX 0x00- 0xFF. Portanto, hex dobrará o comprimento necessário da saída, o que significa que uma saída de 20 bytes criará uma cadeia hexadecimal de 40 caracteres, por exemplo:

2fd4e1c67a2d28fced849ee1bb76e7391b93eb12

Observe que não é necessário usar a codificação hexadecimal. Você também pode usar algo como base64 . O hex é frequentemente preferido porque é mais fácil de ser lido por humanos e tem um comprimento de saída definido sem a necessidade de preenchimento.

Você pode converter uma matriz de bytes em hexadecimal apenas com a funcionalidade JDK:

new BigInteger(1, token).toString(16)

Observe, no entanto, que BigIntegerinterpretará a matriz de bytes fornecida como número e não como uma sequência de bytes. Isso significa que os zeros à esquerda não serão gerados e a sequência resultante poderá ser menor que 40 caracteres.

Usando bibliotecas para codificar para HEX

Agora você pode copiar e colar um método não testado de bytes para hexa do Stack Overflow ou usar dependências massivas como o Guava .

Para ter uma solução básica para a maioria dos problemas relacionados a bytes, implementei um utilitário para lidar com estes casos: bytes-java (Github)

Para converter sua matriz de bytes de resumo da mensagem, você pode simplesmente fazer

String hex = Bytes.wrap(md.digest(subject)).encodeHex();

ou você pode simplesmente usar o recurso de hash embutido

String hex =  Bytes.from(subject).hashSha1().encodeHex();

Representação da Base 64 do SHA1Hash:

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

A razão pela qual isso não funciona é que, quando você liga String(md.digest(convertme)), está dizendo ao Java para interpretar uma sequência de bytes criptografados como uma String. O que você deseja é converter os bytes em caracteres hexadecimais.

Converter matriz de bytes em sequência hexadecimal.

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