文本加密工具类-支持MD5、SHA1、SHA256、SHA224、SHA512、SHA384、SHA3、RIPMD160算法

1.算法简介

1.1 MD5

MD5 (Message-Digest Algorithm 5)

• 描述：MD5 是一种广泛使用的哈希算法，它生成一个 128 位（16 字节）的散列值。
• 用途：最初用于数据完整性检查、密码散列等。
• 安全性：由于已知的安全漏洞，MD5 不再推荐用于安全性要求高的场景，例如密码存储。但仍然用于某些非安全相关的情景，如数据校验。

1.2 SHA-1

SHA-1 (Secure Hash Algorithm 1)

• 描述：SHA-1 生成一个 160 位（20 字节）的散列值。
• 用途：广泛应用于数字签名标准（Digital Signature Standard, DSS）以及其他需要数据完整性的场合。
• 安全性：由于存在碰撞攻击的风险，SHA-1 已不再被认为是安全的，特别是在密码学安全方面。

1.3 SHA-2（推荐使用）

SHA-2 (Secure Hash Algorithm 2)

• 描述：SHA-2 是一组散列函数，包括 SHA-224、SHA-256、SHA-384 和 SHA-512，分别生成 224、256、384 和 512 位的散列值。
• 用途：用于密码存储、数字签名、安全协议等。
• 安全性：SHA-2 被认为是目前比较安全的散列算法之一，尤其是 SHA-256 和 SHA-512，在大多数安全应用中被广泛推荐使用。

1.4 SHA-3（推荐使用）

SHA-3 (Keccak)

• 描述：SHA-3 是 NIST 于 2012 年公布的一种新的哈希函数标准，基于 Keccak 算法，提供了多种输出长度（224、256、384 和 512 位）。
• 用途：SHA-3 被设计用于替代 SHA-2，提供更高的安全性保证。
• 安全性：SHA-3 被认为是非常安全的，适用于各种密码学安全场景。

1.5 RIPEMD-160

RIPEMD-160 (RACE Integrity Primitives Evaluation Message Digest)

• 描述：RIPEMD-160 生成一个 160 位（20 字节）的散列值。
• 用途：常用于比特币等加密货币中，用于地址生成。
• 安全性：虽然 RIPEMD-160 在加密货币领域被广泛应用，但在其他领域，特别是需要高度安全性的场合，它的使用较少

2.工具类案例

2.1POM导入

	<dependency>
            <groupId>org.bouncycastle</groupId>
            <artifactId>bcprov-jdk15on</artifactId>
            <version>1.70</version>
        </dependency>
        <dependency>
            <groupId>org.bouncycastle</groupId>
            <artifactId>bcpkix-jdk15on</artifactId>
            <version>1.70</version>
        </dependency>
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>33.2.1-jre</version>
        </dependency>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2.2代码编写

package cn.zhangsan.tools.enums;

/**
 * @ClassName Algorithm
 * @Description TODO
 * @Author ZhangSan_Plus
 * @Date 2024/7/29 20:45
 * @Version 1.0
 **/
public enum Algorithm {
    MD5, SHA1, SHA256, SHA512, RIPEMD160, SHA224, SHA384, SHA3;
}



package cn.zhangsan.tools.utils;

import cn.zhangsan.tools.enums.Algorithm;
import com.google.common.collect.Maps;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.bouncycastle.util.encoders.Hex;

import java.net.MalformedURLException;
import java.net.URL;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.NoSuchProviderException;
import java.security.Security;
import java.util.Base64;
import java.util.Map;

/**
 * @ClassName HashGeneratorUtils
 * @Description TODO
 * @Author ZhangSan_Plus
 * @Date 2024/7/29 20:04
 * @Version 1.0
 **/
public class HashGeneratorUtils {
    static Map<Object, String> map = Maps.newLinkedHashMap();
    static {
        Security.addProvider(new BouncyCastleProvider());
    }
    public static void main(String[] args) {
        String input = "张三";
        try {
            Map<Object, String> hashText = getHashText(input, 4);
            hashText.forEach((k, v) -> System.out.println(k + ":" + v));
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException(e);
        }
    }

    public static String extractDomain(String urlString) {
            try {
                URL url = new URL(urlString);
                return url.getHost();
            } catch (MalformedURLException e) {
                e.printStackTrace();
                return null;
            }
    }
    private static Map<Object, String> getHashText(String text, int digest) throws NoSuchAlgorithmException {
        map.put(Algorithm.MD5, encryption(md5(text), digest));
        map.put(Algorithm.SHA1, encryption(sha1(text), digest));
        map.put(Algorithm.SHA256, encryption(sha224(text), digest));
        map.put(Algorithm.SHA224, encryption(sha256(text), digest));
        map.put(Algorithm.SHA512, encryption(sha384(text), digest));
        map.put(Algorithm.SHA384, encryption(sha512(text), digest));
        map.put(Algorithm.SHA3, encryption(sha3_256(text), digest));
        map.put(Algorithm.RIPEMD160, encryption(ripemd160(text), digest));
        return map;
    }
    private static byte[] md5(String input) throws NoSuchAlgorithmException {
        MessageDigest digest = MessageDigest.getInstance("MD5");
        return digest.digest(input.getBytes());
    }

    private static byte[] sha1(String input) throws NoSuchAlgorithmException {
        MessageDigest digest = MessageDigest.getInstance("SHA-1");
        return digest.digest(input.getBytes());
    }

    private static byte[] sha224(String input) throws NoSuchAlgorithmException {
        MessageDigest digest = MessageDigest.getInstance("SHA-224");
        return digest.digest(input.getBytes());
    }

    private static byte[] sha256(String input) throws NoSuchAlgorithmException {
        MessageDigest digest = MessageDigest.getInstance("SHA-256");
        return digest.digest(input.getBytes());
    }

    private static byte[] sha384(String input) throws NoSuchAlgorithmException {
        MessageDigest digest = MessageDigest.getInstance("SHA-384");
        return digest.digest(input.getBytes());
    }

    private static byte[] sha512(String input) throws NoSuchAlgorithmException {
        MessageDigest digest = MessageDigest.getInstance("SHA-512");
        return digest.digest(input.getBytes());
    }

    private static byte[] sha3_256(String input) throws NoSuchAlgorithmException {
        MessageDigest digest = null;
        try {
            digest = MessageDigest.getInstance("SHA3-256", "BC");
        } catch (NoSuchProviderException e) {
            throw new RuntimeException(e);
        }
        return digest.digest(input.getBytes());
    }

    private static byte[] ripemd160(String input) throws NoSuchAlgorithmException {
        MessageDigest digest = MessageDigest.getInstance("RIPEMD160");
        return digest.digest(input.getBytes());
    }

    private static String toHexString(byte[] bytes) {
        return Hex.toHexString(bytes);
    }

    private static String toBase64(byte[] bytes) {
        return Base64.getEncoder().encodeToString(bytes);
    }

    private static String toBase64Url(byte[] bytes) {
        return Base64.getUrlEncoder().withoutPadding().encodeToString(bytes);
    }

    private static String toBinary(byte[] bytes) {
        StringBuilder binaryString = new StringBuilder();
        for (byte b : bytes) {
            for (int i = 7; i >= 0; i--) {
                binaryString.append(((b >> i) & 1) == 1 ? '1' : '0');
            }
            binaryString.append("");
        }
        return binaryString.toString().trim();
    }

    private static String encryption(byte[] bytes, int encoding) {
        switch (encoding) {
            case 1:
                return toHexString(bytes);
            case 2:
                return toBinary(bytes);
            case 3:
                return toBase64(bytes);
            case 4:
                return toBase64Url(bytes);
            default:
                return "";
        }
    }
}

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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

2.3 输出示例