MySQL 데이터베이스와 Go 언어: 데이터의 내부 암호화를 보장하는 방법은 무엇입니까?

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

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

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;

ALTER TABLE table_name ENCRYPTION='Y';

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)
}

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)
}