第一部分 概述

数据加解密算法是信息安全领域的重要组成部分，它们用于保护数据的机密性、完整性和真实性。在实际应用中，综合使用数据加解密算法以构建多层次的安全防护体系。例如，HTTPS协议结合了对称加密（如AES）用于快速数据传输加密，以及非对称加密（如RSA）用于安全地交换对称密钥。同时，使用摘要算法确保数据完整性，并通过数字签名验证消息来源的合法性。这种组合方式既解决了数据的机密性问题，又保障了通信的完整性和认证性，是现代网络安全架构的基石。

算法分类

• 随机数生成算法：在加密过程中，随机数用于生成密钥、初始化向量（IV）等，以增加加密的安全性。
• 信息编码算法：信息编码算法将数据转换为另一种格式，使其在传输或存储过程中更容易处理或更安全。
• 摘要运算算法（哈希算法）：摘要运算算法将输入的数据转换为固定长度的哈希值（摘要），通常不可逆。相同的输入将产生相同的哈希值。
• 消息认证码算法：MAC的主要目的是提供消息的完整性和认证。它不仅验证数据是否被篡改，还确保接收者能够验证消息确实来自已知的发送者。
• 对称加密算法：对称加密算法使用相同的密钥对数据进行加密和解密。加密和解密都使用相同的密钥，因此速度较快。
• 非对称加密算法：非对称加密算法使用一对密钥（公钥和私钥）进行加密和解密。公钥用于加密，私钥用于解密。公钥可以公开，私钥保密。

作用

• 保护数据的机密性：防止未授权的个人或实体读取敏感信息。
• 确保数据的完整性：确保数据在传输或存储过程中未被篡改。
• 验证数据的真实性：确认数据确实来自声称的发送者，并且是可信的。

使用场景

• 个人隐私保护：如电子邮件加密、个人文件加密。
• 企业数据安全：保护商业机密、客户信息等。
• 在线交易：确保交易数据的安全和完整性。
• 云存储：保护存储在远程服务器上的敏感数据。
• 通信安全：如VPN、SSL/TLS加密通信。
• 身份验证：如使用数字签名验证身份和数据来源。

解决的问题

• 防止数据泄露：通过加密手段保护数据不被未授权访问。
• 防止数据篡改：使用哈希算法和数字签名确保数据的完整性和真实性。
• 安全密钥交换：使用非对称加密技术安全地交换用于对称加密的密钥。
• 密码存储：使用密码哈希算法安全地存储用户密码，即使数据库被泄露，也不会暴露原始密码。

第二部分 随机数生成算法

随机数生成算法是指用于生成看似随机数列的一系列算法，这些数列虽然在计算机中被称为“伪随机数”，因为它们实际上是通过确定性的算法计算出来的，但它们在统计特性上足够接近真正的随机性，从而适用于多种应用场景。计算机生成的随机数依赖于初始种子值，一个好的种子来源（如系统时间、硬件噪声等）能够增加随机数序列的不可预测性。

使用场景

• 密钥生成：为加密算法生成安全的密钥。
• 加密算法的初始化向量：确保加密过程中的每个块都不同，提高安全性。
• 密码重置：生成一次性密码（OTP）用于账户安全。
• 挑战响应认证：如在SSL/TLS握手过程中生成随机数。
• 数字签名：生成用于签名算法的随机数。
• 随机抽样：在需要随机选择的场合，如在线调查或随机分配任务。

解决的问题

• 不可预测性：确保生成的序列对观察者来说是不可预测的。
• 均匀性：确保在一定范围内生成的随机数分布均匀。
• 周期性：减少伪随机数序列的周期性，使得序列在实际应用中不重复。
• 独立性：保证序列中的每个数与其他数相互独立。

代表性算法

• 伪随机数生成器（PRNG）

  ：基于确定性算法，从一个随机种子开始生成看似随机的数列。常见的PRNG包括：

  • Mersenne Twister：一种广泛使用的PRNG，以其周期长和随机性良好而著称。
  • Yarrow：一种使用SHA-1哈希函数的PRNG，曾被用于生成加密密钥。

• 真随机数生成器（TRNG）

  ：基于物理过程的随机性，如电子噪声或量子效应，来生成随机数。例如：

  • 基于热噪声的随机数芯片：使用电子元件的热噪声来生成随机比特。
  • 量子随机数生成器：利用量子力学的原理，如光子的量子纠缠或量子隧道效应，来生成真正的随机数。

2.1 SHA-1 PRNG（伪随机数生成器）

SHA-1 PRNG（Pseudorandom Number Generator）是一种基于SHA-1哈希算法的伪随机数生成器。它使用 SHA-1算法对种子值进行哈希，并使用哈希结果生成伪随机数序列。

特点

• 安全性：SHA-1 PRNG使用SHA-1哈希算法作为其核心算法，SHA-1在安全性上已经有一定的破解风险，因此SHA-1 PRNG也可能存在安全性问题。在对安全性要求较高的场景下，建议使用更安全的算法。
• 周期性：SHA-1 PRNG生成的随机数序列具有很长的周期，通常情况下可以满足大多数应用的需求。但是，由于其基于SHA-1算法的特性，周期长度可能受到SHA-1哈希算法的限制。
• 速度：SHA-1 PRNG的速度较快，生成随机数的效率高，适用于大部分需要高质量随机数的应用场景。

示例代码

​x
1
public void testSHA1PRNG() throws NoSuchAlgorithmException {
2
    SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG");
3
    byte[] randomBytes;
4
    for (int i = 0; i < 5; i++) {
5
        randomBytes = new byte[16];
6
        secureRandom.nextBytes(randomBytes);
7
        System.out.println("Random bytes: " + this.byteArrayToHexString(randomBytes));
8
    }
9
}
10
11
private String byteArrayToHexString(byte[] bytes) {
12
    StringBuilder stringBuilder = new StringBuilder();
13
    for (byte b : bytes) {
14
        stringBuilder.append(String.format("%02x", b));
15
    }
16
    return stringBuilder.toString();
17
}

在上述示例代码中，使用SHA1PRNG生成随机字节数组，然后将其转换为十六进制字符串后输出，运行并观察控制台输出：

xxxxxxxxxx
5
1
Random bytes: f5b548d8527a02de15492034499ea476
2
Random bytes: 7009d835283685b8a06b75eeeac2ea49
3
Random bytes: 9eb62777f5ad603c5c9feb509e7545a6
4
Random bytes: fb402efe9c121183ec7bee8529da49dd
5
Random bytes: d5060453969d094461d0d8823af13b45

默认情况下，使用SHA1PRNG算法生成的数据都是随机的，重复执行上述的示例代码，每次生成的数据都是不同的，这是因为生成随机数的种子是变化的，如果对其设置一个固定的种子数据，同一个SecureRandom对象可以生成不同的随机数据，但是使用相同的种子重新创建SecureRandom对象后，生成的数据是一致的，即固定种子的随机数生成序列是固定的。

xxxxxxxxxx
16
1
public void testSHA1PRNG() throws NoSuchAlgorithmException {
2
    for (int i = 0; i < 3; i++) {
3
        SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG");
4
        byte[] randomBytes = new byte[16];
5
        secureRandom.nextBytes(randomBytes);
6
        System.out.println("Random bytes: " + this.byteArrayToHexString(randomBytes));
7
    }
8
    System.out.println("==================");
9
    for (int i = 0; i < 3; i++) {
10
        SecureRandom secureRandom = SecureRandom.getInstance("SHA1PRNG");
11
        secureRandom.setSeed("jianggujin".getBytes());
12
        byte[] randomBytes = new byte[16];
13
        secureRandom.nextBytes(randomBytes);
14
        System.out.println("Random bytes: " + this.byteArrayToHexString(randomBytes));
15
    }
16
}

运行调整后的示例代码，观察控制台输出可以看出固定种子后的数据变化。

xxxxxxxxxx
7
1
Random bytes: a1c88f17dec80195a2eeafbbee530a47
2
Random bytes: a52dec60e560c48bcd7a5127948e531d
3
Random bytes: 52ab81956c4e097969dc4615ed20ad04
4
==================
5
Random bytes: e929c5d3c2e8d63ed03c86bf2ec514c5
6
Random bytes: e929c5d3c2e8d63ed03c86bf2ec514c5
7
Random bytes: e929c5d3c2e8d63ed03c86bf2ec514c5

第三部分 信息编码算法

信息编码算法是将信息（包括文本、图像、音频、视频等）转换成适合存储、处理、传输的数字形式的过程。编码的目标在于有效地利用有限的资源（如带宽、存储空间）并确保信息的完整性、安全性和高效性。编码不仅仅是简单的二进制转换，还涉及到数据压缩、错误检测与纠正、安全性增强等多个方面。

使用场景

• 数据存储：将数据编码为适合存储系统的格式。
• 数据传输：在网络中传输数据时，编码可以减少传输错误。
• 数据表示：在不同的计算机系统或程序之间交换数据时，需要统一的编码标准。
• 国际化：支持多语言文本的编码，如UTF-8。
• 数据压缩：减少数据的存储或传输大小。

解决的问题

• 效率：通过数据压缩技术减少数据量，提高存储和传输效率。
• 可靠性：利用信道编码技术（如汉明码、里德-所罗门码）增加数据的容错能力，纠正传输中的错误。
• 兼容性：确保不同系统和设备间信息的正确解读，如通过统一的字符编码标准。
• 安全性：加密编码保护数据免受窃听和篡改，确保信息安全传输。
• 可读性与处理性：对特定类型的数据（如图像、声音）进行格式化编码，便于计算机处理和显示。

代表性算法

• ASCII（美国信息交换标准代码）：一种基于英文字符的编码系统，使用7位或8位二进制数表示字符。
• UTF-8（8-bit Unicode Transformation Format）：一种变长的Unicode字符编码，它可以使用1到4个字节表示一个字符，广泛用于互联网和多语言支持。
• Base64：一种基于64个可打印字符的编码方法，用于在网络上安全地传输二进制数据。
• 霍夫曼编码：一种基于符号出现频率进行编码的算法，常用于数据压缩。

3.1 URL编码

URL编码是一种将URL中的特殊字符转换为可安全传输的ASCII字符串的方法。它将非 ASCII字符和特殊字符转换成%后跟两位十六进制数字的形式，以便在URL中进行传输。

使用场景

• 传输数据：在URL中传输包含特殊字符的数据时，需要进行URL编码以确保传输的安全性和准确性。
• 构建查询字符串：在构建包含查询参数的URL时，需要对参数值进行URL编码，以避免解析错误和安全问题。
• 处理表单数据：在Web表单提交中，对表单数据进行URL编码可以确保数据的完整性和正确性。

示例代码

• Java

xxxxxxxxxx
5
1
String str = "蒋固金";
2
String encoded = URLEncoder.encode(str, "UTF-8");
3
System.out.println("Encoded URL: " + encoded);
4
String decoded = URLDecoder.decode(encoded, "UTF-8");
5
System.out.println("Decoded URL: " + decoded);

• Go

xxxxxxxxxx
5
1
str := "蒋固金"
2
encoded := url.QueryEscape(str)
3
fmt.Println("Encoded URL:", encoded)
4
decoded, _ := url.QueryUnescape(encoded)
5
fmt.Println("Decoded URL:", decoded)

运行并观察控制台输出：

xxxxxxxxxx
2
1
Encoded URL: %E8%92%8B%E5%9B%BA%E9%87%91
2
Decoded URL: 蒋固金

3.2 Base32编码

Base32是一种基于32个字符的编码方式，用于将二进制数据转换为可打印的ASCII字符串。它将每5个比特的二进制数据转换为一个字符，因此每个字符表示32种可能性，Base32字符集通常由大写字母A-Z和数字2-7组成。

特点

• 可打印性：Base32编码生成的字符串只包含可打印字符，适用于将二进制数据表示为文本格式。
• 容错性：Base32编码可以容忍少量数据损坏或错误，因为每个字符只包含一部分原始数据。
• 数据密度低：由于Base32每个字符只能表示5个比特的数据，因此它的数据密度较低，编码后的字符串长度较长。

使用场景：

• URL编码：Base32编码可用于URL中传输二进制数据，尤其是在需要避免使用非 ASCII字符的情况下。
• 二进制数据存储：Base32编码可以将二进制数据以文本形式存储在文件或数据库中。
• 校验和计算：Base32编码常用于计算数据的校验和，如CRC32校验等。

示例代码

• Java

xxxxxxxxxx
6
1
String str = "jianggujin";
2
Base32 base32 = new Base32();
3
String encoded = base32.encodeAsString(str.getBytes(StandardCharsets.UTF_8));
4
System.out.println("Encoded string: " + encoded);
5
String decoded = new String(base32.decode(encoded), StandardCharsets.UTF_8);
6
System.out.println("Decoded string: " + decoded);

注

Base32使用commons-codec提供的实现。

xxxxxxxxxx
5
1
<dependency>
2
    <groupId>commons-codec</groupId>
3
    <artifactId>commons-codec</artifactId>
4
    <version>1.15</version>
5
</dependency>

• Go

xxxxxxxxxx
5
1
str := "jianggujin"
2
encoded := base32.StdEncoding.EncodeToString([]byte(str))
3
fmt.Println("Encoded string:", encoded)
4
decoded, _ := base32.StdEncoding.DecodeString(encoded)
5
fmt.Println("Decoded string:", string(decoded))

运行并观察控制台输出：

xxxxxxxxxx
2
1
Encoded string: NJUWC3THM52WU2LO
2
Decoded string: jianggujin

3.3 Base62编码

Base62编码是一种基于62个字符的编码方式，用于将二进制数据转换为可打印的ASCII字符串。它将每6个比特的二进制数据转换为一个字符，因此每个字符表示62种可能性，Base62字符集通常由大小写字母A-Z和数字0-9组成，共62个字符。。

特点

• 高效性：Base62编码生成的字符串长度相对较短，数据密度高，适用于需要短字符串表示较长数据的场景。
• 可读性：Base62编码生成的字符串包含大小写字母和数字，易于人类阅读和理解。
• 数据密度高：相较于Base64编码。由于Base62使用了更少的字符，因此在编码相同数量的二进制数据时，理论上可以产生更短的文本字符串。这意味着Base62的数据密度更高，因为它可以用更少的字符表示更多的信息。

使用场景

• URL编码：Base62编码可用于URL中传输二进制数据，尤其是在需要短链接的场景下。
• 短链接服务：Base62编码常用于短链接服务，将长URL转换为短字符串以便分享和传播。
• 数据存储：Base62编码可用于将二进制数据以文本形式存储在文件或数据库中，节省存储空间并提高可读性。

示例代码

• Java

xxxxxxxxxx
5
1
String str = "jianggujin";
2
String encoded =  Base62.encode(str);
3
System.out.println("Encoded string: " + encoded);
4
String decoded = Base62.decodeStr(encoded);
5
System.out.println("Decoded string: " + decoded);

注

Base62使用hutool提供的实现。

xxxxxxxxxx
5
1
<dependency>
2
    <groupId>cn.hutool</groupId>
3
    <artifactId>hutool-all</artifactId>
4
    <version>5.8.9</version>
5
</dependency>

• Go

xxxxxxxxxx
5
1
str := "jianggujin"
2
encoded := base62.StdEncoding.EncodeToString([]byte(str))
3
fmt.Println("Encoded string:", encoded)
4
decoded, _ := base62.StdEncoding.DecodeString(encoded)
5
fmt.Println("Decoded string:", string(decoded))

Go语言中未提供base62实现，可使用如下自定义实现。

xxxxxxxxxx
149
1
package base62
2
3
import (
4
    "math"
5
    "reflect"
6
    "strconv"
7
    "unsafe"
8
)
9
10
const encodeStd = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
11
12
// StdEncoding is the standard base62 encoding.
13
var StdEncoding = NewEncoding(encodeStd)
14
15
type CorruptInputError int64
16
17
func (e CorruptInputError) Error() string {
18
    return "illegal base62 data at input byte " + strconv.FormatInt(int64(e), 10)
19
}
20
21
/*
22
 * Encodings
23
 */
24
25
// An Encoding is a radix 62 encoding/decoding scheme, defined by a 62-character alphabet.
26
type Encoding struct {
27
    encode    [62]byte
28
    decodeMap [256]byte
29
}
30
31
// NewEncoding returns a new padded Encoding defined by the given alphabet,
32
// which must be a 62-byte string that does not contain the padding character
33
// or CR / LF ('\r', '\n').
34
func NewEncoding(encoder string) *Encoding {
35
    if len(encoder) != 62 {
36
        panic("encoding alphabet is not 62-bytes long")
37
    }
38
    for i := 0; i < len(encoder); i++ {
39
        if encoder[i] == '\n' || encoder[i] == '\r' {
40
            panic("encoding alphabet contains newline character")
41
        }
42
    }
43
44
    e := new(Encoding)
45
    copy(e.encode[:], encoder)
46
47
    for i := 0; i < len(e.decodeMap); i++ {
48
        e.decodeMap[i] = 0xFF
49
    }
50
    for i := 0; i < len(encoder); i++ {
51
        e.decodeMap[encoder[i]] = byte(i)
52
    }
53
    return e
54
}
55
56
/*
57
 * Encoder
58
 */
59
60
// Encode encodes src using the encoding enc.
61
func (enc *Encoding) Encode(src []byte) []byte {
62
    if len(src) == 0 {
63
        return nil
64
    }
65
66
    // enc is a pointer receiver, so the use of enc.encode within the hot
67
    // loop below means a nil check at every operation. Lift that nil check
68
    // outside of the loop to speed up the encoder.
69
    _ = enc.encode
70
71
    rs := 0
72
    cs := int(math.Ceil(math.Log(256) / math.Log(62) * float64(len(src))))
73
    dst := make([]byte, cs)
74
    for i := range src {
75
        c := 0
76
        v := int(src[i])
77
        for j := cs - 1; j >= 0 && (v != 0 || c < rs); j-- {
78
            v += 256 * int(dst[j])
79
            dst[j] = byte(v % 62)
80
            v /= 62
81
            c++
82
        }
83
        rs = c
84
    }
85
    for i := range dst {
86
        dst[i] = enc.encode[dst[i]]
87
    }
88
    if cs > rs {
89
        return dst[cs-rs:]
90
    }
91
    return dst
92
}
93
94
// EncodeToString returns the base62 encoding of src.
95
func (enc *Encoding) EncodeToString(src []byte) string {
96
    buf := enc.Encode(src)
97
    return string(buf)
98
}
99
100
/*
101
 * Decoder
102
 */
103
104
// Decode decodes src using the encoding enc.
105
// If src contains invalid base62 data, it will return the
106
// number of bytes successfully written and CorruptInputError.
107
// New line characters (\r and \n) are ignored.
108
func (enc *Encoding) Decode(src []byte) ([]byte, error) {
109
    if len(src) == 0 {
110
        return nil, nil
111
    }
112
113
    // Lift the nil check outside of the loop. enc.decodeMap is directly
114
    // used later in this function, to let the compiler know that the
115
    // receiver can't be nil.
116
    _ = enc.decodeMap
117
118
    rs := 0
119
    cs := int(math.Ceil(math.Log(62) / math.Log(256) * float64(len(src))))
120
    dst := make([]byte, cs)
121
    for i := range src {
122
        if src[i] == '\n' || src[i] == '\r' {
123
            continue
124
        }
125
        c := 0
126
        v := int(enc.decodeMap[src[i]])
127
        if v == 255 {
128
            return nil, CorruptInputError(src[i])
129
        }
130
        for j := cs - 1; j >= 0 && (v != 0 || c < rs); j-- {
131
            v += 62 * int(dst[j])
132
            dst[j] = byte(v % 256)
133
            v /= 256
134
            c++
135
        }
136
        rs = c
137
    }
138
    if cs > rs {
139
        return dst[cs-rs:], nil
140
    }
141
    return dst, nil
142
}
143
144
// DecodeString returns the bytes represented by the base62 string s.
145
func (enc *Encoding) DecodeString(s string) ([]byte, error) {
146
    sh := (*reflect.StringHeader)(unsafe.Pointer(&s))
147
    bh := reflect.SliceHeader{Data: sh.Data, Len: sh.Len, Cap: sh.Len}
148
    return enc.Decode(*(*[]byte)(unsafe.Pointer(&bh)))
149
}

注

上述实现摘自https://github.com/deatil/go-encoding/blob/main/base62/base62.go

运行并观察控制台输出：

xxxxxxxxxx
2
1
Encoded string: 2VkxGnG6YAPIP0
2
Decoded string: jianggujin

3.4 Base64编码

Base64编码是一种将二进制数据转换为可打印ASCII字符串的编码方式。它将每6个比特的输入数据转换为一个可打印字符，以便于传输和存储，Base64字符集通常由大小写字母A-Z、a-z、数字0-9和两个额外的字符（通常是+和/）组成，共64个字符。

特点

• 可打印性：Base64编码生成的字符串只包含可打印字符，适用于将二进制数据表示为文本格式。
• 数据密度低：由于Base64每个字符只能表示6个比特的数据，因此它的数据密度较低，编码后的字符串长度较长。
• 容错性：Base64编码可以容忍少量数据损坏或错误，因为每个字符只包含一部分原始数据。

使用场景

• 数据传输：Base64编码常用于在网络上传输二进制数据，如在邮件附件、图像、音频等数据的传输中。
• 数据存储：Base64编码可以将二进制数据以文本形式存储在文件或数据库中，方便存储和读取。
• 加密算法：在一些加密算法中，Base64编码被用于表示密钥和签名等数据。

示例代码

• Java

xxxxxxxxxx
5
1
String str = "jianggujin";
2
String encoded = Base64.getEncoder().encodeToString(str.getBytes(StandardCharsets.UTF_8));
3
System.out.println("Encoded string: " + encoded);
4
String decoded = new String(Base64.getDecoder().decode(encoded));
5
System.out.println("Decoded string: " + decoded);

• Go

xxxxxxxxxx
5
1
str := "jianggujin"
2
encoded := base64.StdEncoding.EncodeToString([]byte(str))
3
fmt.Println("Encoded string:", encoded)
4
decoded, _ := base64.StdEncoding.DecodeString(encoded)
5
fmt.Println("Decoded string:", string(decoded))

运行并观察控制台输出：

xxxxxxxxxx
2
1
Encoded string: amlhbmdndWppbg==
2
Decoded string: jianggujin

提示

上述示例中使用的是标准的Base64模式，除了标准的Base64编码模式外，还有一些常见的变体模式，包括URL安全模式、MIME类型模式和无填充模式。这些模式在编码过程中会对字符集、填充方式等进行调整，以适应不同的使用场景。以下是它们之间的区别：

• URL安全模式：在标准的Base64编码中，使用字符+和/分别表示62和63，这些字符在URL中有特殊含义，需要进行转义。因此，URL安全模式将+和/替换为-和 _，以避免在URL中引起歧义。常用于在URL中传输Base64编码的数据，以避免URL转义和解码的问题。
• MIME类型模式：MIME类型模式在标准的Base64编码基础上，使用字符+和/表示 62和63，但是会在编码后的字符串末尾添加一个或两个=作为填充字符。常用于表示 MIME类型的数据，如邮件附件等。
• 无填充模式：无填充模式在标准的Base64编码中不使用填充字符=。这意味着编码后的字符串长度可能不是4的倍数。在一些特定场景下，需要节省空间或者不需要严格的长度要求时可以使用无填充模式。

这些变体模式在编码和解码过程中的基本原理与标准的Base64编码相同，只是在字符集和填充方式上有所不同，以适应不同的使用场景。

3.5 十六进制编码

十六进制编码是一种将数据转换为十六进制表示的编码方式。它将数据中的每个字节转换为两位十六进制数字表示，以便于传输和存储。在十六进制编码中，每个字节的高四位和低四位分别转换为对应的十六进制数字，例如，字节值0xAB被表示为AB。

特点

• 可打印性：十六进制编码生成的字符串只包含十六进制数字和可能的分隔符，适用于将二进制数据表示为文本格式。
• 数据密度低：每个字节转换为两位十六进制数字，因此编码后的字符串长度是原始数据长度的两倍。
• 简单直观：十六进制编码使用简单直观的表示方式，易于人类阅读和理解。

使用场景

• 调试和日志记录：十六进制编码常用于调试和日志记录中，以便查看和分析二进制数据。
• 网络传输：在一些网络协议中，如·HTTP·、·TCP/IP·，十六进制编码可用于传输二进制数据。
• 数据存储：十六进制编码可以将二进制数据以文本形式存储在文件或数据库中，方便存储和读取。

示例代码

• Java

xxxxxxxxxx
46
1
private final char[] DIGITS_LOWER = { '0', '1', '2', '3', '4', '5', '6', '7', '8',
2
        '9', 'a', 'b', 'c', 'd', 'e', 'f' };
3
4
@Test
5
public void testHex() throws Exception {
6
    String str = "jianggujin";
7
    String encoded = new String(encodeHex(str.getBytes(StandardCharsets.UTF_8)));
8
    System.out.println("Encoded string: " + encoded);
9
    String decoded = new String(decodeHex(encoded));
10
    System.out.println("Decoded string: " + decoded);
11
}
12
13
private char[] encodeHex(byte[] data) {
14
    int l = data.length;
15
    char[] out = new char[l << 1];
16
    for (int i = 0, j = 0; i < l; i++) {
17
        out[j++] = DIGITS_LOWER[(0xF0 & data[i]) >>> 4];
18
        out[j++] = DIGITS_LOWER[0x0F & data[i]];
19
    }
20
    return out;
21
}
22
23
private byte[] decodeHex(String data) {
24
    int len = data.length();
25
    if ((len & 0x01) != 0) {
26
        throw new IllegalArgumentException("Odd number of characters.");
27
    }
28
    byte[] out = new byte[len >> 1];
29
    for (int i = 0, j = 0; j < len; i++) {
30
        int f = toDigit(data.charAt(j), j) << 4;
31
        j++;
32
        f = f | toDigit(data.charAt(j), j);
33
        j++;
34
        out[i] = (byte) (f & 0xFF);
35
    }
36
    return out;
37
}
38
39
private static int toDigit(char ch, int index) {
40
    final int digit = Character.digit(ch, 16);
41
    if (digit == -1) {
42
        throw new IllegalArgumentException("Illegal hexadecimal character " 
43
            + ch + " at index " + index);
44
    }
45
    return digit;
46
}

• Go

xxxxxxxxxx
5
1
str := "jianggujin"
2
encoded := hex.EncodeToString([]byte(str))
3
fmt.Println("Encoded string:", encoded)
4
decoded, _ := hex.DecodeString(encoded)
5
fmt.Println("Decoded string:", string(decoded))

运行并观察控制台输出：

xxxxxxxxxx
2
1
Encoded string: 6a69616e6767756a696e
2
Decoded string: jianggujin

第四部分 摘要运算算法（哈希算法）

哈希算法，也称为散列函数或摘要算法，是一种将任意长度的输入数据（消息）映射为固定长度输出值（哈希值或摘要）的数学函数。哈希值通常较小，具有以下特性：输入敏感性（即使是微小的输入变化也会导致哈希值的巨大不同）、不可逆性（从哈希值很难或几乎不可能复原原始输入数据）、确定性（相同输入总是产生相同输出）、高效性（计算速度快）。哈希算法在设计上应尽量避免冲突，即不同的输入产生相同的输出（哈希碰撞），但实际上完全避免碰撞在数学上是不可能的，只能尽量降低其发生的概率。

使用场景

• 数据完整性验证：通过比较文件的哈希值来检测数据是否被篡改。
• 密码存储：存储密码的哈希值而非明文，提高安全性。
• 数字签名：与非对称加密结合使用，验证数据的完整性和来源。
• 数据索引：快速检索数据库中的记录。
• 负载均衡：在分布式系统中，使用哈希值将请求分配到不同的服务器。
• 唯一性校验：确保数据的唯一性，如通过哈希值检查重复的记录。

解决的问题

• 快速验证：快速检测数据是否被篡改。
• 安全性：在不暴露原始数据的情况下，验证数据的完整性。
• 存储效率：使用固定长度的哈希值代替可变长度的原始数据，节省存储空间。
• 分布式系统的一致性：通过哈希算法实现数据的均匀分布。

代表性算法

• MD5（Message Digest Algorithm 5）：曾广泛使用，但因为发现多种哈希碰撞而被认为不安全，不再推荐用于安全敏感的应用。
• SHA-1（Secure Hash Algorithm 1）：被广泛使用，但后来也发现了碰撞，因此不再被认为是安全的。
• SHA-2（Secure Hash Algorithm 2）：包括SHA-256、SHA-512等，是目前广泛使用的一系列安全哈希算法。
• SHA-3（Secure Hash Algorithm 3）：是SHA-2的后继者，基于不同的数学基础，旨在提供更长远的安全性。
• BLAKE2：是一个快速、安全的哈希算法，设计用于替代旧的SHA-2算法。
• RIPEMD（RACE Integrity Primitives Evaluation Message Digest）：一系列哈希函数，包括RIPEMD-160，曾被用在某些加密货币中。

4.1 MD5

MD5（Message Digest Algorithm 5）是一种常用的哈希算法，用于产生消息摘要。它将任意长度的消息作为输入，经过一系列操作生成固定长度（128比特或16字节）的哈希值。MD5算法的核心原理是将输入的消息按照一定的规则分成若干个块，并对每个块进行一系列的位操作和模运算，最终生成一个128比特（16字节）的哈希值。MD5算法的设计是为了保证输入消息的微小变化会导致输出哈希值的大幅度变化，从而提高了哈希值的唯一性。

特点

• 固定长度输出：MD5算法生成的哈希值固定长度为128比特，无论输入消息的长度如何。
• 不可逆性：MD5算法是单向哈希算法，不可逆，即无法从哈希值反推出原始消息。
• 高效性：MD5算法在计算哈希值时非常高效，适用于对大量数据进行哈希计算。
• 碰撞概率：由于哈希值的固定长度和输入消息的无限长度，MD5算法存在碰撞（两个不同的消息产生相同的哈希值）的概率。

使用场景

• 数据完整性校验：MD5常用于校验文件完整性，通过比对文件的MD5哈希值来验证文件是否被篡改。
• 密码存储：MD5可以用于存储用户密码的哈希值，以增加密码的安全性。
• 数字签名：MD5可以用于生成消息摘要，用于数字签名和身份验证等场景。

示例代码

• Java

xxxxxxxxxx
4
1
String str = "jianggujin";
2
MessageDigest md = MessageDigest.getInstance("MD5");
3
byte[] messageDigest = md.digest(str.getBytes(StandardCharsets.UTF_8));
4
System.out.println("MD5 hash: " + new String(encodeHex(messageDigest)));

• Go

xxxxxxxxxx
3
1
str := "jianggujin"
2
encoded := md5.Sum([]byte(str))
3
fmt.Println("MD5 hash:", hex.EncodeToString(encoded[:]))

运行并观察控制台输出：

xxxxxxxxxx
1
1
MD5 hash: acab4efdfd3b8efcdec37fe160d7be0e

4.2 SHA

SHA（安全哈希算法）是一组密码哈希函数，用于产生消息的哈希值。SHA算法家族包括了多个版本，如SHA-1、SHA-256、SHA-512等，它们都是在输入数据上执行相似操作但输出长度不同的哈希函数。SHA算法基于密集型的位操作、逻辑运算和模运算。它将输入数据按照一定的方式分块，然后对每个块进行一系列的位运算和置换，最终产生一个固定长度的哈希值。

特点

• 固定长度输出：不同版本的SHA算法生成的哈希值长度不同，但每个版本的输出长度是固定的。
• 不可逆性：SHA算法是单向哈希函数，不可逆，即无法从哈希值反推出原始消息。
• 抗碰撞能力：SHA算法在设计上具有很高的碰撞概率，即使输入数据发生微小变化，输出哈希值也会有显著差异。
• 安全性：SHA算法是一种被广泛使用且安全可靠的哈希算法，通常用于数字签名、消息完整性校验等安全领域。

使用场景

• 数字签名：SHA算法常用于生成数字签名，用于验证数据的完整性和真实性。
• 密码存储：SHA算法可用于存储用户密码的哈希值，增加密码的安全性。
• 消息认证：SHA算法可用于消息认证码（HMAC）的计算，用于验证消息的真实性和完整性。
• 数据完整性校验：SHA算法可用于校验文件完整性，如下载文件的哈希值与预期值进行比对。

示例代码

• Java

xxxxxxxxxx
10
1
String str = "jianggujin";
2
MessageDigest md = MessageDigest.getInstance("SHA1");
3
byte[] messageDigest = md.digest(str.getBytes(StandardCharsets.UTF_8));
4
System.out.println("SHA1 hash: " + new String(encodeHex(messageDigest)));
5
md = MessageDigest.getInstance("SHA-256");
6
messageDigest = md.digest(str.getBytes(StandardCharsets.UTF_8));
7
System.out.println("SHA256 hash: " + new String(encodeHex(messageDigest)));
8
md = MessageDigest.getInstance("SHA-512");
9
messageDigest = md.digest(str.getBytes(StandardCharsets.UTF_8));
10
System.out.println("SHA512 hash: " + new String(encodeHex(messageDigest)));

• Go

xxxxxxxxxx
7
1
str := "jianggujin"
2
encoded := sha1.Sum([]byte(str))
3
fmt.Println("SHA1 hash:", hex.EncodeToString(encoded[:]))
4
encoded256 := sha256.Sum256([]byte(str))
5
fmt.Println("SHA256 hash:", hex.EncodeToString(encoded256[:]))
6
encoded512 := sha512.Sum512([]byte(str))
7
fmt.Println("SHA512 hash:", hex.EncodeToString(encoded512[:]))

运行并观察控制台输出：

xxxxxxxxxx
3
1
SHA1 hash: 26635165490065775f7edee885392424852da15a
2
SHA256 hash: e99631966983730acf4c1fa45669227980c19ef1f7fbea8fab2dc897b881cd30
3
SHA512 hash: 6a677109e89384062e6078767417ed3176128451ecb91fae59bb3f407a2752579e6c99de14af00c7d8abacc78395cd587bfd945b9045f8ca227bb2fc8b140cda

4.3 SM3

SM3是中国国家密码管理局（中国密码学会）制定的一种密码哈希算法，用于产生消息的哈希值。它是中国政府采用的国家密码算法标准之一，具有自主知识产权。SM3算法基于分组密码结构，采用了类似于SHA-256的分组运算、置换运算和轮函数等步骤，但在设计上有一些独特之处。它将消息按照一定的规则分组，然后对每个分组进行一系列的位运算和置换操作，最终生成一个256位（32字节）的哈希值。

特点

• 固定长度输出：SM3算法生成的哈希值长度固定为256比特（32字节）。
• 抗碰撞能力：SM3算法在设计上考虑了碰撞攻击，具有很高的抗碰撞能力。
• 国家密码算法标准：SM3是中国政府采用的国家密码算法标准，具有自主知识产权，被广泛应用于政府和企业信息安全领域。
• 性能高效：SM3算法在计算哈希值时性能高效，适用于大规模数据的哈希计算。

使用场景

• 数据完整性校验：SM3算法可用于校验文件完整性，验证数据在传输过程中是否被篡改。
• 数字签名：SM3算法可用于生成数字签名，用于验证数据的完整性和真实性。
• 密码学应用：SM3算法可用于密码学应用中的哈希计算和消息认证等场景。

示例代码

• Java

xxxxxxxxxx
5
1
Security.addProvider(new BouncyCastleProvider());
2
String str = "jianggujin";
3
MessageDigest md = MessageDigest.getInstance("SM3");
4
byte[] messageDigest = md.digest(str.getBytes(StandardCharsets.UTF_8));
5
System.out.println("SM3 hash: " + new String(encodeHex(messageDigest)));

注

Java默认未提供SM3实现，示例代码依赖bouncycastle。

xxxxxxxxxx
5
1
<dependency>
2
    <groupId>org.bouncycastle</groupId>
3
    <artifactId>bcprov-jdk15to18</artifactId>
4
    <version>1.72</version>
5
</dependency>

• Go

xxxxxxxxxx
3
1
str := "jianggujin"
2
encoded := sm3.Sm3Sum([]byte(str))
3
fmt.Println("SM3 hash:", hex.EncodeToString(encoded))

注

Go默认未提供SM3实现，示例代码依赖github.com/tjfoc/gmsm/sm3。

运行并观察控制台输出：

xxxxxxxxxx
1
1
SM3 hash: 26b306b040c8b1a31728baf37ac7fb88285356eb20f762a0e2ae9e00ff338dad

第五部分 消息认证码

消息认证码通常使用对称密钥加密算法，如HMAC（基于哈希的消息认证码）或CMAC（Cipher-based MAC）。消息认证码通常用于保护数据的完整性，防止篡改和伪造攻击。它可以确保消息在传输过程中没有被篡改或伪造，并且只有知道密钥的合法用户才能够验证消息的真实性。

使用场景

• 数据传输安全：在网络通信中，消息认证码用于保护数据的完整性和真实性，防止数据被篡改或伪造。
• 身份验证：在身份验证过程中，消息认证码用于验证用户的身份信息的真实性，防止身份信息被伪造或篡改。
• 数字签名：在数字签名过程中，消息认证码用于生成数字签名，验证签名者的身份并保护签名的完整性和真实性。
• 存储安全：在存储过程中，消息认证码用于保护数据的完整性和真实性，防止数据在存储过程中被篡改或损坏。

解决的问题

• 数据完整性：MAC可以确保数据在传输过程中没有被篡改或损坏。接收方可以使用相同的密钥和MAC算法对接收到的消息计算出一个认证标签，如果接收到的消息的认证标签与计算出的认证标签不一致，说明消息可能已经被篡改，从而保证了数据的完整性。
• 数据真实性：MAC可以验证消息的真实性，确保消息来自于合法的发送方，并且没有被伪造。只有知道密钥的合法用户才能够计算出正确的MAC，从而验证消息的真实性。
• 防止重放攻击：MAC通常与时间戳或随机数结合使用，以防止重放攻击。通过在消息中包含时间戳或随机数，并将其作为输入计算MAC，可以确保每个消息都是唯一的，防止攻击者重放之前的消息来欺骗系统。
• 身份验证：MAC可以用于验证用户的身份信息的真实性，确保用户具有相应的权限和权限。

代表性算法

• HMAC（Hash-based Message Authentication Code）：基于哈希函数的消息认证码算法，结合了哈希函数和密钥进行加密运算，生成认证标签。
• CMAC（Cipher-based Message Authentication Code）：基于对称加密算法的消息认证码算法，使用块密码和密钥对消息进行加密运算，生成认证标签。
• Poly1305：一种快速的消息认证码算法，常与加密算法如ChaCha20结合使用，用于实现高性能的加密和认证。

5.1 HMAC

HMAC（基于哈希的消息认证码）是一种用于验证消息完整性和真实性的密码学算法。它结合了哈希函数和密钥，用于生成一个固定长度的认证码，以确保消息的完整性和真实性。HMAC算法基于哈希函数和密钥的组合。它将消息和密钥作为输入，通过一系列的哈希计算生成一个固定长度的认证码。在计算过程中，消息被与一个内部的固定值（称为ipad）进行异或操作，然后再与另一个内部固定值（称为opad）进行连接，并且再次进行哈希计算，最终生成认证码。

特点

• 数据完整性：HMAC可以验证消息的完整性，确保消息在传输过程中没有被篡改。
• 密钥认证：HMAC使用密钥来生成认证码，只有持有正确密钥的一方才能验证消息的真实性。
• 抗碰撞能力：HMAC基于哈希函数，具有很高的抗碰撞能力，即使输入消息发生微小变化，也会导致认证码的变化。
• 灵活性：HMAC可以使用多种哈希函数和不同长度的密钥，具有一定的灵活性和可配置性。

使用场景

• 消息认证：HMAC用于验证消息的真实性和完整性，防止消息被篡改或伪造。
• 身份验证：HMAC可以用于身份验证系统中生成和验证令牌，确保只有持有正确密钥的用户才能访问受保护的资源。
• 数字签名：HMAC可以用于生成数字签名，用于证明数据的来源和完整性。
• API认证：HMAC可以用于API认证中，确保只有经过授权的客户端才能访问API。

示例代码

• Java

xxxxxxxxxx
20
1
byte[] key = "hmackey".getBytes(StandardCharsets.UTF_8);
2
String str = "jianggujin";
3
Mac mac = Mac.getInstance("HmacSHA1");
4
SecretKeySpec secretKeySpec = new SecretKeySpec(key, "HmacSHA1");
5
mac.init(secretKeySpec);
6
byte[] macBytes = mac.doFinal(str.getBytes(StandardCharsets.UTF_8));
7
String encoded = Base64.getEncoder().encodeToString(macBytes);
8
System.out.println("HMAC-SHA1: " + encoded);
9
mac = Mac.getInstance("HmacSHA256");
10
secretKeySpec = new SecretKeySpec(key, "HmacSHA256");
11
mac.init(secretKeySpec);
12
macBytes = mac.doFinal(str.getBytes(StandardCharsets.UTF_8));
13
encoded = Base64.getEncoder().encodeToString(macBytes);
14
System.out.println("HMAC-SHA256: " + encoded);
15
mac = Mac.getInstance("HmacSHA512");
16
secretKeySpec = new SecretKeySpec(key, "HmacSHA512");
17
mac.init(secretKeySpec);
18
macBytes = mac.doFinal(str.getBytes(StandardCharsets.UTF_8));
19
encoded = Base64.getEncoder().encodeToString(macBytes);
20
System.out.println("HMAC-SHA512: " + encoded);

• Go

xxxxxxxxxx
14
1
key := []byte("hmackey")
2
str := "jianggujin"
3
hasher := hmac.New(sha1.New, key)
4
hasher.Write([]byte(str))
5
encoded := hasher.Sum(nil)
6
fmt.Println("HMAC-SHA1:", base64.StdEncoding.EncodeToString(encoded))
7
hasher = hmac.New(sha256.New, key)
8
hasher.Write([]byte(str))
9
encoded = hasher.Sum(nil)
10
fmt.Println("HMAC-SHA256:", base64.StdEncoding.EncodeToString(encoded))
11
hasher = hmac.New(sha512.New, key)
12
hasher.Write([]byte(str))
13
encoded = hasher.Sum(nil)
14
fmt.Println("HMAC-SHA512:", base64.StdEncoding.EncodeToString(encoded))

运行并观察控制台输出：

xxxxxxxxxx
3
1
HMAC-SHA1: ArjjXjWOC4/DUfH+H5kwx60dkac=
2
HMAC-SHA256: 3D77xOtAm6FWkQOKepGH7C8duj5WZQ0WBawPUYMzmbA=
3
HMAC-SHA512: jtK/TWbD6EzngWlxA0FdRixVZR2npb9b5MbgSReTei9cO1A0Jd1TWVQ9mWUSXI5cbdz+mvhuvikFkPcOBXbm2A==

相关信息

消息认证码（Message Authentication Code, MAC）算法与摘要运算（通常指的是哈希函数或散列函数）在表面上可能看起来相似，因为它们都从输入数据产生固定长度的输出，但实际上它们的设计目标和应用场景有所不同：

消息认证码（MAC）算法

• 目的：MAC的主要目的是提供消息的完整性和认证。它不仅验证数据是否被篡改，还确保接收者能够验证消息确实来自已知的发送者。
• 密钥使用：MAC算法在计算过程中需要使用一个密钥。这个密钥是预先共享的，只有合法的发送方和接收方知道，这使得MAC能够提供认证功能。
• 安全性属性：MAC提供机密性之外的认证服务，意味着即使消息被截获，没有密钥的第三方无法伪造有效的MAC值。

摘要运算（哈希函数）

• 目的：哈希函数主要用于提供数据的完整性校验。它将任意大小的数据映射为固定长度的输出（哈希值），任何对原始数据的修改都会导致哈希值的显著变化。
• 密钥使用：标准的哈希函数（如MD5、SHA-1、SHA-256）在计算时不涉及密钥，是无密钥的函数。
• 安全性属性：哈希函数主要关注抗碰撞性和非逆性，用于检测数据是否有变动，但不能提供认证，因为任何人都可以对任意数据计算哈希值。

MAC是带有密钥的，提供消息认证和完整性检查，适合于需要验证消息来源的场景。哈希函数是无密钥的，仅提供完整性校验，不涉及认证，适用于不需要识别发送方身份的情景，如文件完整性验证。两者虽都能检验数据完整性，但MAC通过密钥的加入，额外提供了认证功能，这是它们之间最本质的区别。

第六部分 对称加密算法

对称加密算法是一种加密和解密过程使用相同密钥的加密技术。这意味着发送方和接收方必须事先共享同一把密钥，并且在保密的前提下保存好这把密钥。加密时，发送方使用该密钥将明文（即未加密的信息）转换为密文（即加密后的信息）；解密时，接收方再利用相同的密钥将密文还原回明文。由于加解密使用的是相同的密钥，这类算法也被称作“秘密密钥算法”或“共享密钥算法”。

使用场景

• 数据加密传输：在网络通信中，对称加密算法常用于加密大量数据，如文件传输、视频流或数据库通信，因为它处理速度快，效率高。
• 存储数据加密：对敏感数据进行存储时，可以使用对称加密保证数据在静止状态下的安全。
• 内部系统通信：企业内部系统间的数据交换，尤其是在信任环境中，对称加密可以简化密钥管理并提高效率。
• 临时会话加密：在需要快速建立加密通道的场景，如即时通讯应用中，双方可以快速协商并使用一个临时的对称密钥进行通信。

解决的问题

• 数据机密性：防止未授权的第三方读取敏感信息。
• 数据完整性：确保数据在传输或存储过程中未被篡改。
• 效率：对称加密算法通常计算效率高，适合实时或大批量加密需求。

代表性算法

• AES（高级加密标准）：是目前最广泛使用的对称加密算法之一，以128位的块大小和多种密钥长度（128、192、256位）为特点。
• DES（数据加密标准）：曾经广泛使用，但由于其密钥长度较短（56位有效密钥长度），已不再被认为是安全的。
• 3DES（三重数据加密算法）：是DES的一个改进，使用三个密钥对数据进行三次加密，以提高安全性。
• Blowfish：由Bruce Schneier设计，是一个快速、高效的对称加密算法，适用于多种加密需求。
• Twofish：是Blowfish算法的后继者，提供更强的安全性和更大的密钥长度。
• ChaCha20：是一个相对较新的流加密算法，以其快速和安全性而受到关注。
• Salsa20：ChaCha20的前身，也是一个流加密算法，以其简单和高效而闻名。

6.1 异或加密

异或加密是一种简单而古老的加密技术，也称为异或运算加密。它使用异或运算对明文和密钥进行位级别的操作，以生成密文。异或加密的原理非常简单，就是对明文和密钥的每一个比特进行异或运算。异或运算的规则是：如果两个比特相同，则结果为0；如果两个比特不同，则结果为 1。因此，当明文和密钥进行异或运算时，可以得到密文。

特点

• 简单性：异或加密算法非常简单，只涉及到位操作，易于实现和理解。
• 单次密钥：异或加密算法使用单次密钥，同一个密钥只能用于加密一次消息。
• 对称性：异或加密算法是对称加密算法，加密和解密使用相同的密钥。
• 不安全性：异或加密算法容易受到攻击，特别是在密文和明文之间有较强的相关性时。

使用场景

• 教学演示：异或加密常用于教学演示中，帮助学生理解位操作和对称加密的基本原理。
• 简单加密需求：在一些低安全性要求的场景下，异或加密可以用于简单消息的加密和解密。

示例代码

• Java

xxxxxxxxxx
15
1
public void testXOR() throws Exception {
2
    byte[] key = "xorkey".getBytes(StandardCharsets.UTF_8);
3
    String str = "jianggujin";
4
    byte[] encoded = xor(str.getBytes(StandardCharsets.UTF_8), key);
5
    System.out.println("Encoded string: " + Base64.getEncoder().encodeToString(encoded));
6
    String decoded = new String(xor(encoded, key));
7
    System.out.println("Decoded string: " + decoded);
8
}
9
10
private byte[] xor(byte[] data, byte[] key) {
11
    for (int i = 0; i < data.length; i++) {
12
        data[i] ^= key[i % key.length];
13
    }
14
    return data;
15
}

• Go

xxxxxxxxxx
15
1
func TestXOR(t *testing.T) {
2
    key := []byte("xorkey")
3
    str := "jianggujin"
4
    encoded := XOR([]byte(str), key)
5
    fmt.Println("Encoded string:", base64.StdEncoding.EncodeToString(encoded))
6
    decoded := XOR(encoded, key)
7
    fmt.Println("Decoded string:", string(decoded))
8
}
9
10
func XOR(data, key []byte) []byte {
11
    for i, v := range data {
12
        data[i] = v ^ key[i%len(key)]
13
    }
14
    return data
15
}

运行并观察控制台输出：

xxxxxxxxxx
2
1
Encoded string: EgYTBQIeDQUbBQ==
2
Decoded string: jianggujin

6.2 AES

AES（Advanced Encryption Standard，高级加密标准）是一种对称密钥加密算法，被广泛应用于保护敏感数据的安全性。它是美国联邦政府采用的加密标准，也是目前最常用的对称加密算法之一。AES加密算法采用分组密码结构，将明文按照固定长度（128、192或256 位）进行分组，然后通过一系列的轮函数和密钥迭代，对每个分组进行加密处理，最终生成密文。AES共有10轮、12轮或14轮轮函数，取决于密钥长度（128、192或256 位）。

特点

• 安全性高：AES加密算法采用了先进的分组密码结构和多轮加密过程，具有较高的安全性，抵抗常见的密码攻击。
• 高效性：AES加密算法在硬件和软件上都有高效的实现，加密和解密速度快，适用于大规模数据的加密处理。
• 灵活性：AES支持多种密钥长度（128、192或256位），具有一定的灵活性和可配置性。
• 标准化：AES是美国联邦政府采用的加密标准，被广泛应用于政府、企业和个人的信息安全领域。

使用场景

• 数据加密：AES可用于保护敏感数据的机密性，如用户密码、支付信息、个人身份信息等。
• 通信加密：AES可用于保护网络通信的安全性，如HTTPS、SSL/TLS等协议中的数据加密。
• 存储加密：AES可用于加密存储介质中的数据，如硬盘、数据库、云存储等。
• 数字签名：AES可用于生成数字签名，用于验证数据的完整性和真实性。

在使用AES加密算法时，除了指定密钥长度外，还需要指定工作模式（Mode of Operation）和填充模式（Padding Scheme）。

工作模式（Mode of Operation）

工作模式定义了对待加密的数据块的方式，常见的工作模式包括：

• ECB（Electronic Codebook）：电子密码本模式，将每个明文块分别加密，适用于独立且不重复的数据块。ECB模式不提供数据的机密性和完整性保护。
• CBC（Cipher Block Chaining）：密文分组链接模式，每个明文块与前一个密文块进行异或操作后再加密，提供更好的数据保护性。
• CFB（Cipher Feedback）：密文反馈模式，将前一个密文块用作加密器的输入，适用于流式数据加密。
• OFB（Output Feedback）：输出反馈模式，类似于CFB模式，但是输出的是密钥流而不是密文块。
• CTR（Counter）：计数器模式，将初始向量（IV）与计数器相结合产生密钥流，然后将明文与密钥流进行异或操作来加密数据。

填充模式（Padding Scheme）

填充模式用于处理明文块的长度与加密算法要求的数据块长度不匹配的情况。常见的填充模式包括：

• NoPadding：不添加填充，要求明文长度必须是加密算法要求的数据块长度的整数倍，否则会出错。
• PKCS5Padding/PKCS7Padding：采用PKCS#5或PKCS#7标准的填充方案，将填充字节的值设置为填充的长度，解密时可通过填充长度来识别和去除填充。

相关信息

PKCS5Padding和PKCS7Padding都是填充方案，用于在加密过程中对明文进行填充，以满足加密算法要求的数据块长度的整数倍。

主要区别

• 填充字节的值

  ：

  • PKCS5Padding：填充的字节值固定为填充的长度。
  • PKCS7Padding：填充的字节值等于填充的长度。

• 适用范围

  ：

  • PKCS5Padding：规定了填充字节的长度必须为1到8字节之间（包含），因此适用于块长度为64位（8字节）的加密算法。
  • PKCS7Padding：没有对填充字节的长度做出限制，适用于块长度为1到255字节之间的加密算法。

总体来说，PKCS7Padding是PKCS5Padding的一个超集，它可以处理更广泛的块长度范围。在实践中，PKCS7Padding更常见，并且在大多数情况下，PKCS7Padding也适用于 PKCS5Padding所适用的情况。

示例代码（AES/CBC/PKCS5Padding）

• Java

xxxxxxxxxx
19
1
byte[] key = "AD42F6697B035B7580E4FEF93BE20BAD".getBytes(StandardCharsets.UTF_8);
2
byte[] iv = "AD42F6697B035B75".getBytes(StandardCharsets.UTF_8);
3
String str = "jianggujin";
4
Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
5
SecretKeySpec secretKey = new SecretKeySpec(key, "AES");
6
// 不需要设置向量的工作模式采用如下方式
7
// cipher.init(Cipher.ENCRYPT_MODE, secretKey);
8
cipher.init(Cipher.ENCRYPT_MODE, secretKey, new IvParameterSpec(iv));
9
byte[] encrypted = cipher.doFinal(str.getBytes(StandardCharsets.UTF_8));
10
System.out.println("Encrypted string: " + Base64.getEncoder().encodeToString(encrypted));
11
12
cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
13
secretKey = new SecretKeySpec(key, "AES");
14
// 不需要设置向量的工作模式采用如下方式
15
// cipher.init(Cipher.DECRYPT_MODE, secretKey);
16
cipher.init(Cipher.DECRYPT_MODE, secretKey, new IvParameterSpec(iv));
17
18
byte[] decrypted = cipher.doFinal(encrypted);
19
System.out.println("Decrypted string: " + new String(decrypted, StandardCharsets.UTF_8));

• Go

xxxxxxxxxx
64
1
func TestAESCBCPKCS5Padding(t *testing.T) {
2
    key := []byte("AD42F6697B035B7580E4FEF93BE20BAD")
3
    iv := []byte("AD42F6697B035B75")
4
    str := "jianggujin"
5
    block, _ := aes.NewCipher(key)
6
    encrypted, _ := CBC(block, iv, []byte(str), true, aes.BlockSize)
7
8
    fmt.Println("Encrypted string:", base64.StdEncoding.EncodeToString(encrypted))
9
    decoded, _ := CBC(block, iv, encrypted, false, aes.BlockSize)
10
    fmt.Println("Decrypted string:", string(decoded))
11
}
12
13
// cbc模式加解密
14
func CBC(block cipher.Block, iv []byte, in []byte, mode bool, blockSize int)
15
    (out []byte, err error) {
16
    var inData []byte
17
    if mode {
18
        inData = pkcs7Padding(in, blockSize)
19
    } else {
20
        inData = in
21
    }
22
    // 如后续出现IV受影响，则需要复制新的IV数据
23
    //iv := make([]byte, blockSize)
24
    //copy(iv, o.Iv)
25
    out = make([]byte, len(inData))
26
27
    if mode {
28
        cipher.NewCBCEncrypter(block, iv).CryptBlocks(out, inData)
29
    } else {
30
        cipher.NewCBCDecrypter(block, iv).CryptBlocks(out, inData)
31
        out, err = pkcs7UnPadding(out, blockSize)
32
    }
33
34
    return out, err
35
}
36
37
// PKCS7Padding
38
// 假设每个区块大小为blockSize
39
//   <1>已对齐，填充一个长度为blockSize且每个字节均为blockSize的数据。
40
//   <2>未对齐，需要补充的字节个数为n，则填充一个长度为n且每个字节均为n的数据。
41
func pkcs7Padding(src []byte, blockSize int) []byte {
42
    padding := blockSize - len(src)%blockSize
43
    padtext := bytes.Repeat([]byte{byte(padding)}, padding)
44
    return append(src, padtext...)
45
}
46
47
// 在解密后，需要将填充的字符去掉，取最后一位即知道存在多少个补充位
48
func pkcs7UnPadding(src []byte, blockSize int) ([]byte, error) {
49
    length := len(src)
50
    unpadding := int(src[length-1])
51
    if unpadding > blockSize || unpadding == 0 {
52
        return nil, errors.New("invalid pkcs7 padding (unpadding > BlockSize ||
53
            unpadding == 0)")
54
    }
55
56
    pad := src[len(src)-unpadding:]
57
    for i := 0; i < unpadding; i++ {
58
        if pad[i] != byte(unpadding) {
59
            return nil, errors.New("invalid pkcs7 padding (pad[i] != unpadding)")
60
        }
61
    }
62
63
    return src[:(length - unpadding)], nil
64
}

运行并观察控制台输出：

xxxxxxxxxx
2
1
Encrypted string: H8dXZjZthY6iw+6hmjY71A==
2
Decrypted string: jianggujin

6.3 DES

DES（Data Encryption Standard，数据加密标准）是一种对称密钥加密算法，是最早广泛应用的分组密码算法之一。DES使用64位密钥对64位的数据块进行加密和解密，经过多轮的置换和替换操作，生成密文。DES加密算法采用分组密码结构，将明文按照固定长度（64 位）进行分组，然后通过一系列的置换、替换和轮函数，对每个分组进行加密处理，最终生成密文。DES共有16轮轮函数，每轮使用不同的子密钥对数据进行处理。

特点

• 安全性：DES曾经是加密领域的标准，但随着计算能力的增强，现已不再安全，易受到穷举搜索等攻击。
• 固定密钥长度：DES的密钥长度固定为64位，其中8位用作奇偶校验，实际有效密钥长度为56位。
• 单一加密算法：DES只提供加密功能，没有提供完整性验证或认证功能。
• 性能高：DES的加密和解密速度相对较快，适用于对称加密领域。

使用场景

• 历史遗留系统：一些旧版系统或遗留系统可能仍在使用DES加密算法，需要维护和兼容。
• 教学和研究：DES曾经是密码学领域的研究热点，对于学习密码学的学生和研究人员具有一定的参考意义。
• 低安全性需求：在一些对安全性要求不高的场景下，仍可以使用DES进行数据加密，如某些内部通信或测试系统。

工作模式与填充模式参见AES部分内容.

示例代码（DES/CBC/PKCS5Padding）

• Java

xxxxxxxxxx
19
1
byte[] key = "12345678".getBytes(StandardCharsets.UTF_8);
2
byte[] iv = "12345678".getBytes(StandardCharsets.UTF_8);
3
String str = "jianggujin";
4
Cipher cipher = Cipher.getInstance("DES/CBC/PKCS5Padding");
5
SecretKeySpec secretKey = new SecretKeySpec(key, "DES");
6
// 不需要设置向量的工作模式采用如下方式
7
// cipher.init(Cipher.ENCRYPT_MODE, secretKey);
8
cipher.init(Cipher.ENCRYPT_MODE, secretKey, new IvParameterSpec(iv));
9
byte[] encrypted = cipher.doFinal(str.getBytes(StandardCharsets.UTF_8));
10
System.out.println("Encrypted string: " + Base64.getEncoder().encodeToString(encrypted));
11
12
cipher = Cipher.getInstance("DES/CBC/PKCS5Padding");
13
secretKey = new SecretKeySpec(key, "DES");
14
// 不需要设置向量的工作模式采用如下方式
15
// cipher.init(Cipher.DECRYPT_MODE, secretKey);
16
cipher.init(Cipher.DECRYPT_MODE, secretKey, new IvParameterSpec(iv));
17
18
byte[] decrypted = cipher.doFinal(encrypted);
19
System.out.println("Decrypted string: " + new String(decrypted, StandardCharsets.UTF_8));