Base de données MySQL et langage Go : Comment assurer le chiffrement interne des données ?

Avec le développement continu de la technologie Internet, la sécurité des données est devenue un sujet très important. Dans les opérations de bases de données, garantir la sécurité et la confidentialité des données est très critique. En tant que base de données populaire, MySQL a de faibles capacités de configuration de sécurité, mais il peut assurer le cryptage interne des données grâce à certains moyens techniques, et le langage Go est un langage très approprié pour le cryptage des données. Voyons ensuite comment la base de données MySQL et le langage Go assurent le cryptage interne des données.

1. Cryptage des données MySQL

1.1 Cryptage des mots de passe

Par défaut, les mots de passe de connexion des utilisateurs sont stockés en texte clair dans la base de données MySQL, ce qui les rend très faciles à voler par les pirates. Pour éviter que cela ne se produise, nous devons crypter le mot de passe.

MySQL fournit une variété de méthodes de cryptage, telles que MD5, SHA, etc. Parmi eux, SHA-2 est considéré comme une méthode de cryptage relativement puissante. Le cryptage du mot de passe de l'utilisateur via SHA-2 et son stockage dans la base de données peuvent améliorer efficacement la sécurité du mot de passe de l'utilisateur.

Vous pouvez utiliser la fonction PASSWORD de MySQL pour le cryptage SHA-2, comme indiqué ci-dessous :

UPDATE users SET password=PASSWORD('123456') WHERE name='zhangsan';

1.2 Cryptage de la base de données

En plus du cryptage du mot de passe, nous pouvons également crypter l'intégralité de la base de données. MySQL fournit une méthode de cryptage, Transparent Data Encryption (TDE), qui peut garantir la sécurité des données stockées sans affecter les performances de la base de données.

TDE utilise un algorithme de cryptage appelé « Advanced Encryption Standard (AES) » pour crypter l'intégralité de la base de données, empêchant ainsi efficacement le risque d'intrusion de la base de données et de vol de données par des pirates.

Le cryptage TDE peut être réalisé en suivant les étapes suivantes :

1. Ajoutez les deux lignes suivantes au fichier my.cnf dans le répertoire d'installation de MySQL :

[mysqld]
plugin-load-add=innodb_engine.so

2. Exécutez l'instruction SQL suivante dans la ligne de commande de MySQL :

INSTALL PLUGIN INNODB_TRX; 
INSTALL PLUGIN INNODB_LOCKS; 
INSTALL PLUGIN INNODB_LOCK_WAITS; 
INSTALL PLUGIN INNODB_CMP; 
INSTALL PLUGIN INNODB_CMP_RESET; 
INSTALL PLUGIN INNODB_CMPMEM; 
INSTALL PLUGIN INNODB_CMPMEM_RESET; 
SET GLOBAL innodb_file_per_table=1;
SET GLOBAL innodb_file_format=Barracuda;

3. Crypter les tables existantes :

ALTER TABLE table_name ENCRYPTION='Y';

2. Allez au cryptage des données de langue

2.1 Cryptage symétrique

Le cryptage symétrique est une méthode de cryptage courante. Il utilise la même clé pour le cryptage et le déchiffrement. Pendant le processus, la clé doit être utilisée. rester cohérent. Le package crypto est utilisé dans le langage Go pour implémenter le cryptage symétrique. Les algorithmes de cryptage couramment utilisés incluent AES, DES, Blowfish, etc.

Ce qui suit est un exemple d'utilisation du cryptage symétrique AES :

package main

import (
    "crypto/aes"
    "crypto/cipher"
    "crypto/rand"
    "encoding/base64"
    "fmt"
    "io"
)

func encrypt(key []byte, text string) (string, error) {
    // Create the AES cipher
    cipherBlock, err := aes.NewCipher(key)
    if err != nil {
        return "", err
    }

    // Create a new IV with random data
    iv := make([]byte, aes.BlockSize)
    if _, err = io.ReadFull(rand.Reader, iv); err != nil {
        return "", err
    }

    // Create a new Cipher Block Chaining (CBC) mode encrypter
    encrypter := cipher.NewCBCEncrypter(cipherBlock, iv)

    // Encrypt the text
    plaintext := []byte(text)
    ciphertext := make([]byte, len(plaintext))
    encrypter.CryptBlocks(ciphertext, plaintext)

    // Base64 encode the IV and ciphertext
    result := base64.StdEncoding.EncodeToString(iv)
    result += ":"
    result += base64.StdEncoding.EncodeToString(ciphertext)
    return result, nil
}

func decrypt(key []byte, text string) (string, error) {
    // Split the data into IV and ciphertext
    parts := strings.Split(text, ":")
    if len(parts) != 2 {
        return "", fmt.Errorf("invalid encrypted text format")
    }

    // Base64 decode the IV and ciphertext
    iv, err := base64.StdEncoding.DecodeString(parts[0])
    if err != nil {
        return "", err
    }
    ciphertext, err := base64.StdEncoding.DecodeString(parts[1])
    if err != nil {
        return "", err
    }

    // Create the AES cipher
    cipherBlock, err := aes.NewCipher(key)
    if err != nil {
        return "", err
    }

    // Create a new Cipher Block Chaining (CBC) mode decrypter
    decrypter := cipher.NewCBCDecrypter(cipherBlock, iv)

    // Decrypt the ciphertext
    plaintext := make([]byte, len(ciphertext))
    decrypter.CryptBlocks(plaintext, ciphertext)

    return string(plaintext), nil
}

func main() {
    key := []byte("thisisasamplekey")
    encryptedText, err := encrypt(key, "Hello World!")
    if err != nil {
        panic(err)
    }
    fmt.Println("Encrypted Text:", encryptedText)

    decryptedText, err := decrypt(key, encryptedText)
    if err != nil {
        panic(err)
    }
    fmt.Println("Decrypted Text:", decryptedText)
}

2.2 Cryptage asymétrique

Le cryptage asymétrique utilise une paire de clés pour le cryptage et le déchiffrement, dont l'une est publique, appelée clé publique, et l'autre clé A est privée et est appelée clé privée. Le package crypto/rsa est utilisé dans le langage Go pour implémenter le chiffrement asymétrique. L'algorithme de chiffrement asymétrique est plus sécurisé que l'algorithme de chiffrement symétrique, mais plus lent, il est donc généralement utilisé pour chiffrer une petite quantité de données ou utilisé conjointement avec le chiffrement symétrique. cryptage.

Ce qui suit est un exemple d'utilisation du cryptage asymétrique RSA :

package main

import (
    "crypto/rand"
    "crypto/rsa"
    "crypto/sha256"
    "encoding/hex"
    "fmt"
)

func generateRSAKeys() (*rsa.PrivateKey, *rsa.PublicKey, error) {
    privateKey, err := rsa.GenerateKey(rand.Reader, 2048)
    if err != nil {
        return nil, nil, err
    }

    return privateKey, &privateKey.PublicKey, nil
}

func encrypt(message string, publicKey *rsa.PublicKey) (string, error) {
    hashed := sha256.Sum256([]byte(message))

    ciphertext, err := rsa.EncryptPKCS1v15(rand.Reader, publicKey, hashed[:])
    if err != nil {
        return "", err
    }

    return hex.EncodeToString(ciphertext), nil
}

func decrypt(ciphertext string, privateKey *rsa.PrivateKey) (string, error) {
    data, err := hex.DecodeString(ciphertext)
    if err != nil {
        return "", err
    }

    hash := make([]byte, len(data))
    err = rsa.DecryptPKCS1v15(rand.Reader, privateKey, data, hash)
    if err != nil {
        return "", err
    }

    return string(hash), nil
}

func main() {
    privateKey, publicKey, err := generateRSAKeys()
    if err != nil {
        panic(err)
    }

    encryptedText, err := encrypt("Hello World!", publicKey)
    if err != nil {
        panic(err)
    }
    fmt.Println("Encrypted Text:", encryptedText)

    decryptedText, err := decrypt(encryptedText, privateKey)
    if err != nil {
        panic(err)
    }
    fmt.Println("Decrypted Text:", decryptedText)
}

3. Résumé

La base de données MySQL et le langage Go fournissent tous deux des solutions différentes en matière de cryptage des données. Le cryptage des mots de passe et le cryptage des bases de données peuvent être utilisés pour la protection des données dans MySQL, tandis que le cryptage symétrique et le cryptage asymétrique peuvent être utilisés pour le cryptage des données dans le langage Go. Selon les besoins, différentes solutions peuvent être combinées pour obtenir un effet de protection des données plus puissant.

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!