Comment chiffrer les champs de données dans la base de données MySQL en utilisant le langage Go

Alors que les problèmes de sécurité des bases de données deviennent de plus en plus importants, le cryptage des données est devenu une mesure nécessaire. L’efficacité et la simplicité du langage Go ont beaucoup retenu l’attention, notamment dans le domaine du développement web. Cet article explique comment utiliser le langage Go pour implémenter le traitement de cryptage des champs de données dans la base de données MySQL.

1. L'importance du cryptage des champs de base de données MySQL

Dans le contexte de l'ère de l'information moderne, les systèmes de bases de données sont devenus de plus en plus importants. Cependant, en raison des menaces croissantes, la sécurité des bases de données est devenue un défi majeur pour les entreprises et les organisations. Certaines études montrent que les attaques de bases de données et les violations de données sont devenues l'un des plus grands risques de sécurité pour les entreprises. Le cryptage des données est donc devenu l’un des moyens nécessaires pour résoudre ce problème.

L'importance du cryptage des champs de la base de données est de protéger les informations sensibles de la base de données, telles que les noms des utilisateurs, les numéros de téléphone, les adresses e-mail, les mots de passe, etc., afin d'empêcher les attaques de pirates informatiques et les fuites de données. En chiffrant ces données sensibles, les pirates peuvent résister à la traversée des données et au vol d'informations lorsque les données sont obtenues.

2. Comment implémenter le cryptage des champs de données d'une base de données MySQL à l'aide du langage Go

Le langage Go est un langage de programmation open source efficace, léger, compilé et largement utilisé dans le développement Web . Nous pouvons utiliser des bibliothèques en langage Go pour crypter et déchiffrer les champs de données dans la base de données MySQL. Nous utilisons ici la bibliothèque GORM du langage Go.

GORM est une excellente bibliothèque ORM en langage Go. Elle fournit un accès à la base de données en premier et prend en charge une variété de bases de données, notamment MySQL, SQLite, PostgreSQL, SQL Server, etc. Nous pouvons facilement implémenter le cryptage de la base de données MySQL en utilisant la bibliothèque GORM.

1. Importer les packages de dépendances

Ouvrez l'environnement de développement du langage Go et importez les packages de dépendances que vous devez utiliser :

import (
    "crypto/aes"
    "crypto/cipher"
    "encoding/base64"
    "fmt"
    "gorm.io/driver/mysql"
    "gorm.io/gorm"
)

# 🎜🎜#

Connexion à la base de données

Utilisez la fonction Open de GORM pour vous connecter à la base de données Le code est le suivant :

dsn := "user:password@tcp(127.0.0.1:3306)/database_name?charset=utf8mb4&parseTime=True&loc=Local"
db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})

. Enregistrez les clés de cryptage et de déchiffrement

Dans cet exemple, nous utiliserons le mécanisme de cryptage et de déchiffrement AES. Nous devons enregistrer les clés de cryptage et de décryptage dans le code pour une utilisation ultérieure. Le code est le suivant :

var key = []byte("the-key-has-to-be-32-bytes-long!")

Définir les fonctions de cryptage et de décryptage
4. #. 🎜🎜#Nous devons définir les fonctions de cryptage et de décryptage. Les modes de cryptage AES et CBC sont utilisés ici. Le code de la fonction de chiffrement est le suivant :

func encrypt(data []byte) ([]byte, error) {
    block, err := aes.NewCipher(key)
    if err != nil {
        return nil, err
    }

    plaintext := padData(data)

    // The IV needs to be unique, but not secure. Therefore it's common to
    // include it at the beginning of the ciphertext.
    ciphertext := make([]byte, aes.BlockSize+len(plaintext))
    iv := ciphertext[:aes.BlockSize]
    if _, err := rand.Read(iv); err != nil {
        return nil, err
    }

    mode := cipher.NewCBCEncrypter(block, iv)
    mode.CryptBlocks(ciphertext[aes.BlockSize:], plaintext)

    return []byte(base64.StdEncoding.EncodeToString(ciphertext)), nil
}

Le code de la fonction de décryptage est le suivant :

func decrypt(data []byte) ([]byte, error) {
    block, err := aes.NewCipher(key)
    if err != nil {
        return nil, err
    }

    ciphertext, err := base64.StdEncoding.DecodeString(string(data))
    if err != nil {
        return nil, err
    }

    if len(ciphertext) < aes.BlockSize {
        return nil, fmt.Errorf("ciphertext too short")
    }

    iv := ciphertext[:aes.BlockSize]
    ciphertext = ciphertext[aes.BlockSize:]

    // CBC mode always works in whole blocks.
    if len(ciphertext)%aes.BlockSize != 0 {
        return nil, fmt.Errorf("ciphertext is not a multiple of the block size")
    }

    mode := cipher.NewCBCDecrypter(block, iv)
    mode.CryptBlocks(ciphertext, ciphertext)

    return unpadData(ciphertext), nil
}

Exemple : Ajouter un champ chiffré dans la base de données MySQL #🎜 🎜#

5. Jetons un coup d'œil à un exemple complet. Supposons que nous souhaitions ajouter un champ chiffré à une table d'une base de données MySQL. Écrivez le code du modèle comme suit :

type User struct {
    ID      uint
    Name    string
    Email   string
    Passwd  []byte `gorm:"column:passwd"`
}

Ensuite, réécrivez les méthodes d'écriture et de lecture du nom de la table et du champ chiffré dans le modèle, le code est le suivant :

func (u *User) TableName() string {
    return "users"
}

func (u *User) BeforeSave(tx *gorm.DB) (err error) {
    pData, err := encrypt(u.Passwd)
    if err != nil {
        return
    }

    u.Passwd = pData
    return
}

func (u *User) AfterFind(tx *gorm.DB) (err error) {
    pData, err := decrypt(u.Passwd)
    if err != nil {
        return
    }

    u.Passwd = pData
    return
}

Dans BeforeSave() Dans la méthode, le mot de passe de l'utilisateur est crypté et stocké. Dans la méthode AfterFind(), déchiffrez le mot de passe crypté stocké et renvoyez-le. De cette façon, nous pouvons stocker le champ du mot de passe crypté dans la base de données MySQL.

Exemple : Interroger les champs cryptés dans la base de données MySQL

6. Lorsque nous utilisons des champs cryptés dans la table, les données doivent être traitées lors du requête Décrypter. Nous pouvons décrypter automatiquement les champs chiffrés dans les résultats de requête en utilisant le hook AfterFind. Voici l'exemple de code :

users := []User{}
result := db.Find(&users)

if result.Error != nil {
    panic(result.Error)
}

for _, user := range users {
    fmt.Println(user)
}

Dans l'exemple ci-dessus, nous interrogeons tous les enregistrements utilisateur et imprimons les résultats renvoyés sur la console. Lors de l'appel de la fonction Find(), GORM exécutera automatiquement la méthode AfterFind() pour décrypter le résultat.

3. Résumé

Dans cet article, nous présentons la méthode d'utilisation du langage Go et de la bibliothèque GORM pour implémenter le chiffrement de champ dans la base de données MySQL. Les principales étapes incluent la connexion à la base de données. , définition des fonctions de chiffrement et de déchiffrement, écriture des champs chiffrés dans les tables et opérations de déchiffrement lors de l'interrogation des données. Avec ces opérations, nous pouvons facilement crypter et protéger les informations sensibles dans la base de données MySQL.

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!