Utilisez le framework Gin pour implémenter les fonctions de cryptage et de décryptage des données

Dans le domaine Internet moderne, la sécurité des données a toujours été un sujet important. Lors de la transmission, du stockage et du traitement des données, nous devons utiliser divers moyens techniques pour garantir la sécurité des données. L'un des moyens techniques les plus importants est le cryptage des données. Gin est un framework web basé sur le langage Go. Sa simplicité, sa facilité d'utilisation, son efficacité et sa stabilité ont été privilégiées par de nombreux développeurs. Cet article expliquera comment utiliser le framework Gin pour implémenter des fonctions de cryptage et de décryptage de données. Apprenons-en ensemble.

Tout d'abord, nous devons comprendre quelques connaissances de base sur les algorithmes de chiffrement. Les algorithmes de chiffrement sont généralement divisés en deux catégories : le chiffrement symétrique et le chiffrement asymétrique. Le chiffrement symétrique est une méthode de chiffrement qui utilise la même clé pour chiffrer et déchiffrer les données. Le chiffrement asymétrique est également une méthode de chiffrement qui utilise des paires de clés publiques et privées pour chiffrer et déchiffrer les données. Ensuite, nous prendrons l'exemple de l'algorithme de chiffrement symétrique AES et utiliserons le framework Gin pour implémenter les fonctions de chiffrement et de déchiffrement.

La première étape consiste à configurer le framework Gin. Dans le framework Gin, vous pouvez utiliser les modules middleware gin.Recovery() et gin.Logger() fournis avec le framework Gin pour enregistrer les journaux et récupérer après une panne de serveur. Nous devons également connecter le serveur à la base de données. Ici, nous utilisons la bibliothèque GORM pour nous connecter à la base de données (la bibliothèque GORM doit d'abord être installée).

package main

import (
    "github.com/gin-gonic/gin"
    "github.com/jinzhu/gorm"
    _ "github.com/jinzhu/gorm/dialects/mysql"
)

func main() {
    router := gin.Default()
    router.Use(gin.Recovery(), gin.Logger())

    db, err := gorm.Open("mysql", "username:password@tcp(host:port)/database?charset=utf8mb4&parseTime=True&loc=Local")
    if err != nil {
        panic("failed to connect database")
    }
    defer db.Close()

    router.Run(":8080")
}

Dans un deuxième temps, nous définirons une fonction middleware pour chiffrer les données. Ici, nous utiliserons l'algorithme de chiffrement symétrique AES que nous venons de mentionner pour chiffrer les données à l'aide d'une clé et d'un vecteur d'initialisation. Nous pouvons utiliser le package crypto/aes pour implémenter l'algorithme de chiffrement AES, mettre la fonction de chiffrement dans un middleware, et l'opération de chiffrement sera automatiquement effectuée à chaque requête.

package main

import (
    "crypto/aes"
    "crypto/cipher"
    "encoding/base64"
    "io/ioutil"

    "github.com/gin-gonic/gin"
)

func EncryptMiddleware(key, iv string) gin.HandlerFunc {
    // Convert key and iv to byte arrays.
    keyBytes := []byte(key)
    ivBytes := []byte(iv)

    // Create a new AES cipher block.
    block, err := aes.NewCipher(keyBytes)
    if err != nil {
        panic(err)
    }

    return func(c *gin.Context) {
        // Read the request body.
        data, _ := ioutil.ReadAll(c.Request.Body)

        // Create a new cipher block mode with CBC.
        blockMode := cipher.NewCBCEncrypter(block, ivBytes)

        // Pad the data with PKCS7.
        data = pkcs7Pad(data, block.BlockSize())

        // Encrypt the data.
        blockMode.CryptBlocks(data, data)

        // Set the response to the encrypted data.
        c.Writer.Write([]byte(base64.StdEncoding.EncodeToString(data)))
        c.Next()
    }
}

func pkcs7Pad(data []byte, blockSize int) []byte {
    padding := blockSize - len(data)%blockSize
    padText := bytes.Repeat([]byte{byte(padding)}, padding)
    return append(data, padText...)
}

Dans la troisième étape, nous définirons une fonction middleware pour décrypter les données. Le processus de décryptage est à l’opposé du processus de cryptage et l’algorithme AES est également utilisé pour le décryptage. L’opération de décryptage sera également effectuée automatiquement à chaque fois qu’une demande arrivera.

package main

import (
    "crypto/aes"
    "crypto/cipher"
    "encoding/base64"
    "io/ioutil"

    "github.com/gin-gonic/gin"
)

func DecryptMiddleware(key, iv string) gin.HandlerFunc {
    // Convert key and iv to byte arrays.
    keyBytes := []byte(key)
    ivBytes := []byte(iv)

    // Create a new AES cipher block.
    block, err := aes.NewCipher(keyBytes)
    if err != nil {
        panic(err)
    }

    return func(c *gin.Context) {
        // Read the request body.
        data, _ := ioutil.ReadAll(c.Request.Body)

        // Create a new cipher block mode with CBC.
        blockMode := cipher.NewCBCDecrypter(block, ivBytes)

        // Decode the data from base64.
        data, err = base64.StdEncoding.DecodeString(string(data))
        if err != nil {
            panic(err)
        }

        // Decrypt the data.
        blockMode.CryptBlocks(data, data)

        // Remove any padding.
        data = pkcs7Unpad(data)

        // Set the request body to the decrypted data.
        c.Request.Body = ioutil.NopCloser(bytes.NewReader(data))
        c.Next()
    }
}

func pkcs7Unpad(data []byte) []byte {
    padding := data[len(data)-1]
    return data[:len(data)-int(padding)]
}

Dans la quatrième étape, nous utiliserons le middleware défini pour crypter et décrypter les données. Nous pouvons définir plusieurs middlewares de chiffrement et de déchiffrement pour traiter les données pour différents itinéraires. Par exemple, nous utiliserons le middleware de chiffrement pour chiffrer les données de la requête et le middleware de décryptage pour décrypter les données de réponse :

func main() {
    router := gin.Default()
    router.Use(gin.Recovery(), gin.Logger())

    db, err := gorm.Open("mysql", "username:password@tcp(host:port)/database?charset=utf8mb4&parseTime=True&loc=Local")
    if err != nil {
        panic("failed to connect database")
    }
    defer db.Close()

    // Encrypt and Decrypt middlewares.
    key, iv := "0123456789abcdef", "0123456789abcdef"
    router.POST("/encrypt", EncryptMiddleware(key, iv))
    router.POST("/decrypt", DecryptMiddleware(key, iv))

    router.Run(":8080")
}

Maintenant, nous avons implémenté avec succès les fonctions de cryptage et de décryptage des données à l'aide du framework Gin. Lors du développement d'applications Web, il est crucial d'assurer la sécurité des données, et en utilisant le framework Gin et les algorithmes de cryptage, la protection des données sensibles peut être facilement réalisée.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!