Java 计算字节数组的SHA-1

我正在寻找一种获取SHA-1校验和的方法，该校验和使用Java字节数组作为消息

我应该使用第三方工具，还是JVM内置了一些可以帮助我的工具？

那么：

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Formatter;

public static String SHAsum(byte[] convertme) throws NoSuchAlgorithmException{
    MessageDigest md = MessageDigest.getInstance("SHA-1"); 
    return byteArray2Hex(md.digest(convertme));
}

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

---

这是我们用来转换为SHA-1的一段代码，但它采用了

字符串

而不是

字节[]

有关详细信息，请参见此

        import java.io.UnsupportedEncodingException;
        import java.security.MessageDigest;
        import java.security.NoSuchAlgorithmException;

        public class DoSHA1 {

            private static String convToHex(byte[] data) {
                StringBuilder buf = new StringBuilder();
                for (int i = 0; i < data.length; i++) {
                    int halfbyte = (data[i] >>> 4) & 0x0F;
                    int two_halfs = 0;
                    do {
                        if ((0 <= halfbyte) && (halfbyte <= 9))
                            buf.append((char) ('0' + halfbyte));
                        else
                            buf.append((char) ('a' + (halfbyte - 10)));
                        halfbyte = data[i] & 0x0F;
                    } while(two_halfs++ < 1);
                }
                return buf.toString();
            }

            public static String SHA1(String text) throws NoSuchAlgorithmException,
UnsupportedEncodingException  {
            MessageDigest md = MessageDigest.getInstance("SHA-1");
            byte[] sha1hash = new byte[40];
            md.update(text.getBytes("iso-8859-1"), 0, text.length());
            sha1hash = md.digest();
            return convToHex(sha1hash);
            }
        }

import java.io.UnsupportedEncodingException；
导入java.security.MessageDigest；
导入java.security.NoSuchAlgorithmException；
公共类DoSHA1{
专用静态字符串convToHex（字节[]数据）{
StringBuilder buf=新的StringBuilder（）；
对于（int i=0；i>>4）&0x0F；
int two_halfs=0；
做{
如果（（0您可以自己做，但我建议使用一个已被证明有效的库，例如。类
DigestUtils
有几种方法来计算哈希。
从CommonCodec DigestUtils实现中，在摘要计算后使用十六进制转换，如前所示：

MessageDigest md = MessageDigest.getInstance("SHA-1"); 
return byteArray2Hex(md.digest(convertme));

应该是：

private static final char[]位\u LOWER=
{'0', '1', '2', '3', '4', '5', '6', '7',
‘8’、‘9’、‘a’、‘b’、‘c’、‘d’、‘e’、‘f’}；
私有静态最终字符[]位数\u上限=
{'0', '1', '2', '3', '4', '5', '6', '7',
‘8’、‘9’、‘A’、‘B’、‘C’、‘D’、‘E’、‘F’}；
受保护的静态字符[]encodeHex（字节[]数据，字符[]到数字）{
int l=数据长度；
char[]out=新字符[l>>4]；
out[j++]=toDigits[0x0F&data[i]；
}
返回；
}
受保护的静态int-toDigit（char-ch，int-index）抛出解码异常{
整数位数=字符位数（第16章）；
如果（数字==-1）{
抛出新的异常(
“非法十六进制字符”
+ch+“at指数”+指数）；
}
返回数字；
}
公共静态字符串示例SHA1（字符串转换器）{
MessageDigest md=MessageDigest.getInstance（“SHA-1”）；
字节[]encodeHex=md.digest（convertme））；
返回新字符串（encodeHex）；
}
…另一种选择是使用Spring：

<bean id="passwordEncoder" class="org.springframework.security.authentication.encoding.ShaPasswordEncoder">
     <constructor-arg value="256"/>
 </bean>



阅读更多

HTH
我只是用它来计算dex文件中的哈希和，并将其与保存在dex文件中的值进行比较

我知道这段代码没有很好的风格，但它更PoC，只需要一些不需要时间的研究。也许有人可以使用它

class CheckDex{
public boolean checkSHA1(File f) throws IOException, NoSuchAlgorithmException{
    RandomAccessFile raf = new RandomAccessFile(f, "r");
    byte[] sig = new byte[20];
    raf.seek(0xC);
    for(int i = 0; i < 20; i++){
        sig[i] = (byte) raf.readUnsignedByte();
    }

    MessageDigest md = MessageDigest.getInstance("SHA-1"); 

    byte[] code = new byte[(int) (raf.length()-32)];
    for(int i = 0; i < code.length; i++){
        code[i] = (byte) raf.readUnsignedByte();
    }
    byte[] comsig = md.digest(code);

    raf.close();
    return Arrays.equals(sig,comsig);
}
}

类CheckDex{
公共布尔校验SHA1（文件f）抛出IOException、NoSuchAlgorithmException{
RandomAccessFile raf=新的RandomAccessFile（f，“r”）；
字节[]sig=新字节[20]；
raf.seek（0xC）；
对于（int i=0；i<20；i++）{
sig[i]=（字节）raf.readUnsignedByte（）；
}
MessageDigest md=MessageDigest.getInstance（“SHA-1”）；
字节[]代码=新字节[（int）（raf.length（）-32）]；
for（int i=0；i
使用这个怎么样：

公共类sha1计算{

    public static void main(String[] args)throws Exception
    {
         File file = new File("D:\\Android Links.txt");
        String outputTxt= "";
        String hashcode = null;

        try {

            FileInputStream input = new FileInputStream(file);

            ByteArrayOutputStream output = new ByteArrayOutputStream ();
            byte [] buffer = new byte [65536];
            int l;

            while ((l = input.read (buffer)) > 0)
                output.write (buffer, 0, l);

            input.close ();
            output.close ();

            byte [] data = output.toByteArray ();


                MessageDigest digest = MessageDigest.getInstance( "SHA-1" ); 

            byte[] bytes = data;

            digest.update(bytes, 0, bytes.length);
            bytes = digest.digest();

            StringBuilder sb = new StringBuilder();

            for( byte b : bytes )
            {
                sb.append( String.format("%02X", b) );
            }

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


        }catch (FileNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (NoSuchAlgorithmException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

    }

}

以下代码将给定的
字节[]
转换为SHA-1哈希的
字符串

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

public static String hash(byte data[]) throws NoSuchAlgorithmException
{
   MessageDigest digest;
   BigInteger big;
   String result;
   byte hash[];

   digest = MessageDigest.getInstance("SHA-1"); 
   hash   = digest.digest(data);
   big    = new BigInteger(1, hash);
   result = big.toString(16);

   return result;
}

注意：前导零将被修剪。因此，这可能有效，也可能无效，这取决于您的用例。
我只是在寻找计算sha1的方法-该格式不适用matter@PascalThivent但是另一个程序员可能会停下来使用这个答案，包括错误（这毕竟是部分原因）.散列本身就有足够的模糊性（像“通过sha-1对这些串串进行散列来计算此签名”，而不提及如何对输入字符进行编码和对散列输出进行字符串化，这样的文档非常常见）。这甚至没有正确编译。我不知道两年前一个拥有152k rep的用户是如何写出这样一个答案的，直到现在还没有人编辑它。@jarnbjo感谢您指出了潜在的问题。但是为什么我看不到您的帖子“带有”正确的答案呢？它可能不会被接受为正确的答案，但它可能会被投票通过比目前的9票多y票。我相信提到答案错误的评论不再相关。答案经过编辑，转换为十六进制字符串看起来很好。如果对您来说足够快，您也可以使用String.format（“%02x”，b）将字节转换为十六进制字符串。分配新的40字节数组的行无效；数组对象来自md.digest（）调用。当您将该方法的返回值分配给sha1hash时，您将删除已创建的40字节空数组。此外，SHA-1摘要是20字节，而不是40字节。我正在寻找相同的内容。一种用Java计算SHA1的方法。我得到了什么？两个答案。有很多“这是错误的”，“这是可怕的”.然而，写这些评论的人并没有写出一个“好”的答案。这是惊人的开销：））
import java.math.BigInteger;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public static String hash(byte data[]) throws NoSuchAlgorithmException
{
   MessageDigest digest;
   BigInteger big;
   String result;
   byte hash[];

   digest = MessageDigest.getInstance("SHA-1"); 
   hash   = digest.digest(data);
   big    = new BigInteger(1, hash);
   result = big.toString(16);

   return result;
}