Pangkalan data MySQL dan bahasa Go: Bagaimana untuk memastikan penyulitan dalaman data?

Dengan perkembangan berterusan teknologi Internet, keselamatan data telah menjadi topik yang sangat penting. Dalam operasi pangkalan data, memastikan keselamatan dan kerahsiaan data adalah sangat kritikal. Sebagai pangkalan data yang popular, MySQL mempunyai keupayaan tetapan keselamatan yang lemah, tetapi ia boleh memastikan penyulitan data dalaman melalui beberapa cara teknikal, dan bahasa Go ialah bahasa yang sangat sesuai untuk penyulitan data. Seterusnya, mari kita bincangkan bagaimana pangkalan data MySQL dan bahasa Go memastikan penyulitan data dalaman.

1. Penyulitan Data MySQL

1.1 Penyulitan Kata Laluan

Secara lalai dalam pangkalan data MySQL, kata laluan log masuk pengguna disimpan dalam teks yang jelas, yang menjadikannya sangat mudah untuk dicuri oleh penggodam. Untuk mengelakkan ini daripada berlaku, kami perlu menyulitkan kata laluan.

MySQL menyediakan pelbagai kaedah penyulitan, seperti MD5, SHA, dll. Antaranya, SHA-2 dianggap sebagai kaedah penyulitan yang agak kuat. Menyulitkan kata laluan pengguna melalui SHA-2 dan menyimpannya dalam pangkalan data boleh meningkatkan keselamatan kata laluan pengguna dengan berkesan.

Anda boleh menggunakan fungsi PASSWORD MySQL untuk melaksanakan penyulitan SHA-2, seperti yang ditunjukkan di bawah:

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

1.2 Penyulitan pangkalan data

Selain penyulitan kata laluan, kami juga boleh menyulitkan keseluruhan Pangkalan data disulitkan. MySQL menyediakan kaedah penyulitan, Penyulitan Data Telus (TDE), yang boleh memastikan keselamatan data yang disimpan tanpa menjejaskan prestasi pangkalan data.

TDE menggunakan algoritma penyulitan yang dipanggil "Advanced Encryption Standard (AES)" untuk menyulitkan keseluruhan pangkalan data, dengan itu berkesan menghalang risiko pencerobohan pangkalan data dan kecurian data.

Penyulitan TDE boleh dicapai melalui langkah berikut:

1. Tambah dua baris berikut dalam fail my.cnf dalam direktori pemasangan MySQL:

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

2. Laksanakan pernyataan SQL berikut dalam baris arahan 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. Sulitkan jadual sedia ada:

ALTER TABLE table_name ENCRYPTION='Y';

2. Penyulitan data bahasa Go

2.1 Penyulitan simetri

Penyulitan simetri ialah kaedah penyulitan biasa Ia menggunakan kunci yang sama untuk penyulitan dan penyahsulitan semasa proses penyulitan dan penyahsulitan. Pakej crypto digunakan dalam bahasa Go untuk melaksanakan penyulitan simetri yang biasa digunakan termasuk AES, DES, Blowfish, dsb.

Berikut ialah contoh penggunaan penyulitan simetri 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 Penyulitan asimetri

Penyulitan asimetri menggunakan sepasang kunci untuk penyulitan dan penyahsulitan, salah satunya Satu kunci adalah awam dan dipanggil kunci awam, manakala kunci lain adalah peribadi dan dipanggil kunci peribadi. Pakej crypto/rsa digunakan dalam bahasa Go untuk melaksanakan penyulitan asimetri Algoritma penyulitan asimetri lebih selamat daripada algoritma penyulitan simetri, tetapi lebih perlahan, jadi ia biasanya digunakan untuk menyulitkan sejumlah kecil data atau digunakan bersama dengan simetri. penyulitan.

Berikut ialah contoh penggunaan penyulitan asimetri 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 Ringkasan

Pangkalan data MySQL dan bahasa Go kedua-duanya menyediakan penyelesaian yang berbeza dalam penyulitan data. Penyulitan kata laluan dan penyulitan pangkalan data boleh digunakan untuk perlindungan data dalam MySQL, manakala penyulitan simetri dan penyulitan asimetri boleh digunakan untuk penyulitan data dalam bahasa Go. Seperti yang diperlukan, penyelesaian yang berbeza boleh digabungkan untuk mencapai kesan perlindungan data yang lebih berkuasa.

Atas ialah kandungan terperinci Pangkalan data MySQL dan bahasa Go: Bagaimana untuk memastikan penyulitan dalaman data?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!