1 简介

加密在查询性能和数据隐私之间的折中。

在服务中实现加密，以提供在查询性能和数据隐私之间的折中。

加密 是一个在提供数据隐私的同时保证一定查询性能的技术。
它主要通过对加密列生成加密，在查询时匹配这些而不是直接解密数据来实现。

以下是一个在服务中实现索引加密的示例，以及如何在 MySQL 上实现它的完整过程。

2 基本思路

主数据加密：

使用强加密（如 AES-256）加密敏感数据列。
加密的数据不可直接被用作查询条件。

加密索引：

对敏感列生成一个加密的索引列（通常使用单向哈希，如 SHA256）。
加密索引可以支持等值查询，但难以支持范围查询。

查询机制：

插入时，同时插入加密数据和加密索引。
查询时，对查询条件进行相同的加密操作，然后匹配加密索引列。

• MySQL 表设计

假设我们有一张 users 表，敏感数据是 email，我们对其加密存储，并为查询创建一个加密索引。

	CREATE TABLE users (
	    id INT AUTO_INCREMENT PRIMARY KEY,
	    username VARCHAR(255) NOT NULL,
	    email VARBINARY(255) NOT NULL,         -- 加密存储的邮箱
	    email_hash VARBINARY(255) NOT NULL,   -- 邮箱的加密索引（哈希值）
	    INDEX (email_hash)                    -- 索引加速查询
	);

3 web服务的实现：索引加密查询和插入

依赖安装

	go get -u github.com/gin-gonic/gin
	go get -u github.com/go-sql-driver/mysql
	go get -u golang.org/x/crypto

完整代码示例

	const (
		dbDSN        = "username:password@tcp(127.0.0.1:3306)/testdb"
		encryptionKey = "my_secret_key_32_byte" // 32 字节的 AES 密钥
	)

	var db *sql.DB

	func init() {
		var err error
		db, err = sql.Open("mysql", dbDSN)
		if err != nil {
			log.Fatalf("Failed to connect to MySQL: %v", err)
		}
		if err := db.Ping(); err != nil {
			log.Fatalf("Failed to ping MySQL: %v", err)
		}
		fmt.Println("Connected to MySQL!")
	}

	// AES 加密函数
	func encryptAES(plainText string, key string) (string, error) {
		block, err := aes.NewCipher([]byte(key))
		if err != nil {
			return "", err
		}

		plainBytes := []byte(plainText)
		cipherText := make([]byte, aes.BlockSize+len(plainBytes))
		iv := cipherText[:aes.BlockSize]

		stream := cipher.NewCFBEncrypter(block, iv)
		stream.XORKeyStream(cipherText[aes.BlockSize:], plainBytes)

		return hex.EncodeToString(cipherText), nil
	}

	// AES 解密函数
	func decryptAES(cipherHex string, key string) (string, error) {
		block, err := aes.NewCipher([]byte(key))
		if err != nil {
			return "", err
		}

		cipherBytes, _ := hex.DecodeString(cipherHex)
		plainBytes := make([]byte, len(cipherBytes[aes.BlockSize:]))
		iv := cipherBytes[:aes.BlockSize]

		stream := cipher.NewCFBDecrypter(block, iv)
		stream.XORKeyStream(plainBytes, cipherBytes[aes.BlockSize:])

		return string(plainBytes), nil
	}

	// 生成 SHA256 索引哈希
	func generateHash(data string) string {
		hash := sha256.Sum256([]byte(data))
		return hex.EncodeToString(hash[:])
	}

	// 插入加密数据
	func insertEncryptedUser(username, email string) error {
		encryptedEmail, err := encryptAES(email, encryptionKey)
		if err != nil {
			return err
		}
		emailHash := generateHash(email)

		query := `INSERT INTO users (username, email, email_hash) VALUES (?, ?, ?)`
		_, err = db.Exec(query, username, encryptedEmail, emailHash)
		return err
	}

	// 查询解密数据
	func getUserByEmail(email string) (string, string, error) {
		emailHash := generateHash(email)
		var username, encryptedEmail string
		query := `SELECT username, email FROM users WHERE email_hash = ?`

		err := db.QueryRow(query, emailHash).Scan(&username, &encryptedEmail)
		if err != nil {
			return "", "", err
		}

		decryptedEmail, err := decryptAES(encryptedEmail, encryptionKey)
		if err != nil {
			return "", "", err
		}

		return username, decryptedEmail, nil
	}

	func main() {
		r := gin.Default()

		// 插入数据接口
		r.POST("/insert", func(c *gin.Context) {
			var req struct {
				Username string `json:"username" binding:"required"`
				Email    string `json:"email" binding:"required"`
			}
			if err := c.ShouldBindJSON(&req); err != nil {
				c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
				return
			}

			if err := insertEncryptedUser(req.Username, req.Email); err != nil {
				c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to insert user"})
				return
			}

			c.JSON(http.StatusOK, gin.H{"message": "User inserted successfully"})
		})

		// 查询数据接口
		r.GET("/query", func(c *gin.Context) {
			email := c.Query("email")
			if email == "" {
				c.JSON(http.StatusBadRequest, gin.H{"error": "Email is required"})
				return
			}

			username, decryptedEmail, err := getUserByEmail(email)
			if err != nil {
				c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to find user"})
				return
			}

			c.JSON(http.StatusOK, gin.H{"username": username, "email": decryptedEmail})
		})

		r.Run(":8080")
	}

测试与验证，插入数据

请求：

	POST http://localhost:8080/insert
	{
	  "username": "john_doe",
	  "email": "john.doe@example.com"
	}

数据存储：

email 存储加密后的数据。
email_hash 存储 SHA256 哈希值。

查询数据

请求：

	GET http://localhost:8080/query?email=john.doe@example.com

响应：

	{
	  "username": "john_doe",
	  "email": "john.doe@example.com"
	}

索引加密的优势，隐私保护：

敏感数据加密存储，防止直接暴露。
索引哈希不可逆，难以通过数据库直接猜测原始数据。

查询性能：

支持基于哈希的快速查询，性能接近原始索引。
避免频繁的解密操作。

灵活性：

支持等值查询，适合特定场景（如用户登录验证）。

4 小结

限制与注意事项，范围查询支持有限：

哈希索引无法直接支持范围查询（如日期范围、数值范围）。
需要针对特定场景设计更复杂的方案。

密钥管理：

加密密钥必须安全存储，可使用如 AWS KMS、Vault 等工具。

性能开销：

数据插入或查询时需要额外计算哈希和加解密，需平衡性能需求。
通过以上方案，可以在 Gin 中实现索引加密，兼顾查询性能和数据隐私保护，是处理敏感数据的有效解决方案之一。