常用的安全算法——摘要算法

转载地址：http://blog.csdn.net/yen_csdn/article/details/55806024

《大型分布式网站架构设计与实践》

数字摘要

数字摘要也称消息摘要，他是一个唯一对应一个消息或文本固定长度的值，它由一个单向Hash函数对消息进行计算而产生。如果消息在传递的途中发生了改变，接收者通过对收到的消息采用相同的Hash重新计算，新产生的摘要与原摘要进行比较，就可以知道消息是否被篡改了，因此消息摘要能够验证消息的完整性。消息摘要采用单向Hash函数，将需要计算的内容“摘要”成固定长度的串，这个串也称为数字指纹。这个串有固定的长度，且不同的明文摘要成密文，其结果总是不相同的，而同样的明文摘要必定一致。

MD5码

MD5码即Message Digest Algorithm 5(信息摘要算法5)，是数字摘要算法的一种实现，用于确保信息传输完整性和一致性，摘要长度为128位。

public class MD5demo {
    public static void main(String[] args) throws NoSuchAlgorithmException, UnsupportedEncodingException {
        String content="yangenneng";
        MessageDigest md5=MessageDigest.getInstance("MD5");
        byte[] bytes=md5.digest(content.getBytes("utf-8"));

        for (byte b:bytes){
            System.out.print(b);
        }

    }
}

 
 
1
2
3
4
5
6
7
8
9
10
11
12
13

SHA

SHA的全称为Secure Hash Algorithm，即安全散列算法。SHA-1算法生成的摘要信息长度为160位，由于生成的摘要信息更长，运算的过程更加复杂，在相同的硬件下，SHA-1的运算速度比MD5更慢，但也更安全。

public class MD5demo {
    public static void main(String[] args) throws NoSuchAlgorithmException, UnsupportedEncodingException {
        String content="yangenneng";
        MessageDigest md5=MessageDigest.getInstance("SHA-1");
        byte[] bytes=md5.digest(content.getBytes("utf-8"));

        for (byte b:bytes){
            System.out.print(b);
        }

    }
}
 
 
1
2
3
4
5
6
7
8
9
10
11
12

十六进制编码

package md5;

/**
 * Created by yangenneng on 2017-02-19 16:57.
 * 功能说明：
 */
public class Bytes2Hex {
    public static void main(String[] args) {

        String content="yangenneng";
        byte[] bytes=content.getBytes();
        showBytes(bytes);
        System.out.println("\n--------------------------------");
        String getHex=bytes2hex(bytes);
        System.out.println(getHex);
        System.out.println("\n--------------------------------");
        byte[] bytes1=hex2bytes(getHex);
        showBytes(bytes1);

    }

    /**
     * 十六进制编码
     * @param bytes
     * @return
     */
    private static String bytes2hex(byte[] bytes){
        StringBuffer hex=new StringBuffer();
        for (int i = 0; i < bytes.length; i++) {
            byte b=bytes[i];
            boolean negative=false;//判断是否为负数
            if(b<0) negative=true;

            int inte=Math.abs(b);

            if(negative)inte=inte | 0x80;//负数转为正数（最高位的负号变为数字计算），在转为16进制

            String temp=Integer.toHexString(inte & 0xFF);
            if(temp.length()==1){
                hex.append("0");
            }
            hex.append(temp.toLowerCase());

        }
        return hex.toString();
    }

    /**
     * 十六进制解码
     * @param hex
     * @return
     */
    private static byte[] hex2bytes(String hex){
        byte[] bytes=new byte[hex.length()/2];
        for (int i = 0; i < hex.length(); i=i+2) {
            String subStr=hex.substring(i,i+2);
            boolean negative=false;//是否为负数
            int inte=Integer.parseInt(subStr,16);
            if(inte>127)negative=true;
            if(inte==128){
                inte=-128;
            }else if (negative){
                inte = 0- (inte & 0x7f);
            }
            byte b= (byte) inte;
            bytes[i/2]=b;
        }

        return bytes;
    }


    private static void showBytes(byte[] bytes){
        for (int i = 0; i < bytes.length; i++) {
            System.out.print(bytes[i]);
        }
    }

}

 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

每一个byte包含8位二进制数据，由于java没有无符号整型，因此8位中有一位为符号位，需要将符号位转化为相应的数字，然后转为对应的16进制。8位二进制可以转化为2位16进制，不足两位的进行补0，而解码时，需要先将符号位进行还原，再对数值进行转换，然后判断正负，计算出符号位，将剩余的还原为byte的数值。

Base64编码

Base64仅是一种编码算法，而不是一种加密算法。

package base64;

import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

import java.io.IOException;

/**
 * Created by yangenneng on 2017-02-19 17:24.
 * 功能说明：
 */
public class Base64Demo {
    public static void main(String[] args) throws IOException {
        String content="yangenneng";
        byte[] bytes=content.getBytes();
        showBytes(bytes);
        System.out.println("\n--------------------------------");
        String getHex=byte2base64(bytes);
        System.out.println(getHex);
        System.out.println("\n--------------------------------");
        byte[] bytes1=base642byte(getHex);
        showBytes(bytes1);
    }

    private static String byte2base64(byte[] bytes){
        BASE64Encoder base64Encoder=new BASE64Encoder();
        return base64Encoder.encode(bytes);
    }

    private static byte[] base642byte(String base64) throws IOException {
        BASE64Decoder base64Decoder=new BASE64Decoder();
        return base64Decoder.decodeBuffer(base64);
    }

    private static void showBytes(byte[] bytes){
        for (int i = 0; i < bytes.length; i++) {
            System.out.print(bytes[i]);
        }
    }

}

 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

彩虹表破解Hash算法

彩虹表（Rainbow Table）法是一种破解哈希算法的技术，从理论上来说能够对任何一种Hash算法进行攻击。简单的来说，彩虹表就是一张采用各种Hash算法生成的明文和密文的对照表，在表内的每一条记录都是一串明文对应一种Hash算法生成的一串密文。