Redis（94）如何启用Redis的数据加密？

启用Redis的数据加密通常涉及两个主要方面：传输层加密（TLS/SSL）和存储层加密。以下是详细的步骤和代码示例，以帮助您在Redis中实现数据加密。

1. 传输层加密（TLS/SSL）

传输层加密确保在客户端和Redis服务器之间传输的数据是加密的。Redis 6.0及以上版本支持TLS/SSL。

步骤 1: 生成证书和密钥

可以使用OpenSSL生成自签名证书和密钥：

1# 生成CA私钥
2openssl genpkey -out ca.key -algorithm RSA -pkeyopt rsa_keygen_bits:2048
3
4# 生成CA证书
5openssl req -x509 -new -nodes -key ca.key -sha256 -days 3650 -out ca.crt -subj '/CN=MyRedisCA'
6
7# 生成Redis服务器私钥
8openssl genpkey -out redis.key -algorithm RSA -pkeyopt rsa_keygen_bits:2048
9
10# 生成CSR（证书签名请求）
11openssl req -new -key redis.key -out redis.csr -subj '/CN=MyRedisServer'
12
13# 使用CA签署Redis服务器证书
14openssl x509 -req -in redis.csr -CA ca.crt -CAkey ca.key -CAcreateserial -out redis.crt -days 3650 -sha256
15

步骤 2: 配置Redis服务器

修改 redis.conf 文件以启用TLS：

1# redis.conf
2
3# 启用TLS
4tls-port 6379
5port 0
6
7# 证书和密钥文件
8tls-cert-file /path/to/redis.crt
9tls-key-file /path/to/redis.key
10tls-ca-cert-file /path/to/ca.crt
11
12# 可选：要求客户端证书验证
13# tls-auth-clients yes
14

步骤 3: 配置客户端

使用 redis-cli 连接启用了TLS的Redis服务器：

1redis-cli --tls --cert /path/to/redis.crt --key /path/to/redis.key --cacert /path/to/ca.crt -h redis-server-host -p 6379
2

使用 Jedis Java 客户端连接启用了TLS的Redis服务器：

1import redis.clients.jedis.Jedis;
2import redis.clients.jedis.JedisShardInfo;
3
4public class RedisTLSDemo {
5    public static void main(String[] args) {
6        // 配置JedisShardInfo以使用TLS
7        JedisShardInfo shardInfo = new JedisShardInfo("rediss://redis-server-host:6379");
8        shardInfo.setTls(true);
9        shardInfo.setSslSocketFactory(SSLSocketFactory.getDefault());
10        shardInfo.setPassword("yourpassword"); // 如果有密码保护
11
12        try (Jedis jedis = new Jedis(shardInfo)) {
13            // 测试连接
14            String response = jedis.ping();
15            System.out.println(response);  // 应该输出 "PONG"
16        }
17    }
18}
19

2. 应用层加密

应用层加密是在将数据存储到Redis之前，在应用程序中对数据进行加密和解密。

Java示例：加密和解密

1import javax.crypto.Cipher;
2import javax.crypto.KeyGenerator;
3import javax.crypto.SecretKey;
4import javax.crypto.spec.GCMParameterSpec;
5import javax.crypto.spec.SecretKeySpec;
6import java.util.Base64;
7
8public class AESEncryption {
9    private static final String AES = "AES";
10    private static final String AES_GCM_NO_PADDING = "AES/GCM/NoPadding";
11    private static final int GCM_TAG_LENGTH = 16;
12    private static final int GCM_IV_LENGTH = 12;
13    private static final int AES_KEY_SIZE = 256;
14
15    public static SecretKey generateKey() throws Exception {
16        KeyGenerator keyGen = KeyGenerator.getInstance(AES);
17        keyGen.init(AES_KEY_SIZE);
18        return keyGen.generateKey();
19    }
20
21    public static String encrypt(String plainText, SecretKey key, byte[] iv) throws Exception {
22        Cipher cipher = Cipher.getInstance(AES_GCM_NO_PADDING);
23        GCMParameterSpec parameterSpec = new GCMParameterSpec(GCM_TAG_LENGTH * 8, iv);
24        cipher.init(Cipher.ENCRYPT_MODE, key, parameterSpec);
25        byte[] cipherText = cipher.doFinal(plainText.getBytes());
26        return Base64.getEncoder().encodeToString(cipherText);
27    }
28
29    public static String decrypt(String cipherText, SecretKey key, byte[] iv) throws Exception {
30        Cipher cipher = Cipher.getInstance(AES_GCM_NO_PADDING);
31        GCMParameterSpec parameterSpec = new GCMParameterSpec(GCM_TAG_LENGTH * 8, iv);
32        cipher.init(Cipher.DECRYPT_MODE, key, parameterSpec);
33        byte[] plainText = cipher.doFinal(Base64.getDecoder().decode(cipherText));
34        return new String(plainText);
35    }
36
37    public static void main(String[] args) {
38        try {
39            SecretKey key = generateKey();
40            byte[] iv = new byte[GCM_IV_LENGTH];
41            // 初始化IV（可以使用随机生成的IV）
42
43            String originalData = "Sensitive data";
44
45            // 加密
46            String encryptedData = encrypt(originalData, key, iv);
47            System.out.println("Encrypted Data: " + encryptedData);
48
49            // 解密
50            String decryptedData = decrypt(encryptedData, key, iv);
51            System.out.println("Decrypted Data: " + decryptedData);
52        } catch (Exception e) {
53            e.printStackTrace();
54        }
55    }
56}
57

使用加密数据与Redis交互

1import redis.clients.jedis.Jedis;
2
3public class RedisEncryptedDemo {
4    public static void main(String[] args) {
5        try (Jedis jedis = new Jedis("localhost", 6379)) {
6            // 生成密钥和IV
7            SecretKey key = AESEncryption.generateKey();
8            byte[] iv = new byte[12]; // 示例IV
9
10            // 加密数据
11            String originalData = "Sensitive data";
12            String encryptedData = AESEncryption.encrypt(originalData, key, iv);
13
14            // 存储加密数据到Redis
15            jedis.set("encrypted_key", encryptedData);
16
17            // 从Redis读取加密数据
18            String retrievedEncryptedData = jedis.get("encrypted_key");
19
20            // 解密数据
21            String decryptedData = AESEncryption.decrypt(retrievedEncryptedData, key, iv);
22            System.out.println("Decrypted Data: " + decryptedData);  // 应该输出 "Sensitive data"
23        } catch (Exception e) {
24            e.printStackTrace();
25        }
26    }
27}
28

总结

通过以下步骤可以启用Redis的数据加密：

传输层加密（TLS/SSL）：
- 生成证书和密钥
- 配置redis.conf文件
- 配置客户端
应用层加密：
- 在客户端应用程序中实现数据的加密和解密
- 将加密后的数据存储到Redis中，并在读取数据时进行解密

通过结合传输层加密和应用层加密，可以有效地提高Redis中数据的安全性。上述示例代码展示了如何实现这些加密技术，并将其应用于实际的Redis交互中。

《Redis（94）如何启用Redis的数据加密？》是转载文章，点击查看原文。