Quick Start: Use Go language functions to implement simple data encryption and decryption functions

Quick Start: Use Go language functions to implement simple data encryption and decryption functions

In today's information society, data confidentiality has become particularly important. In order to ensure the confidentiality of data, we usually use various encryption algorithms to encrypt the data. In this article, we will use Go language functions to implement a simple data encryption and decryption function.

First, we need to import the crypto/cipher package in order to use the encryption algorithm. We will use the AES (Advanced Encryption Standard) algorithm to encrypt and decrypt data. The code is as follows:

package main

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

// 加密函数
func encrypt(data []byte, key string) string {
    // 创建新的AES加密块
    block, _ := aes.NewCipher([]byte(key))

    // 创建一个长度为len(data) + aes.BlockSize的切片
    ciphertext := make([]byte, aes.BlockSize+len(data))
    // 初始化向量
    iv := ciphertext[:aes.BlockSize]
    if _, err := io.ReadFull(rand.Reader, iv); err != nil {
        panic(err)
    }

    // 加密数据
    stream := cipher.NewCFBEncrypter(block, iv)
    stream.XORKeyStream(ciphertext[aes.BlockSize:], data)

    // 返回加密后的数据，使用base64编码
    return base64.URLEncoding.EncodeToString(ciphertext)
}

// 解密函数
func decrypt(ciphertext string, key string) string {
    // 将密文解码为字节数组
    data, _ := base64.URLEncoding.DecodeString(ciphertext)

    // 分离向量和加密后的数据
    iv := data[:aes.BlockSize]
    data = data[aes.BlockSize:]

    // 创建新的AES解密块
    block, _ := aes.NewCipher([]byte(key))

    // 解密数据
    stream := cipher.NewCFBDecrypter(block, iv)
    stream.XORKeyStream(data, data)

    // 返回解密后的数据
    return string(data)
}

func main() {
    // 原始数据
    plaintext := "Hello, World!"

    // 密钥
    key := "password123"

    // 加密数据
    ciphertext := encrypt([]byte(plaintext), key)
    fmt.Printf("加密后的数据：%s
", ciphertext)

    // 解密数据
    decryptedText := decrypt(ciphertext, key)
    fmt.Printf("解密后的数据：%s
", decryptedText)
}

In the above code, we define two functions: encrypt and decrypt. The encrypt function accepts a byte array as input and returns a string representation of the encrypted data. The decrypt function accepts a string representation of ciphertext and returns the decrypted original data.

In the main function, we use these two functions to demonstrate the encryption and decryption process. We define a string plaintext as the original data and specify a key key. Then we call the encrypt function to encrypt the original data and print out the ciphertext. Then we call the decrypt function to decrypt the ciphertext and print out the decrypted original data.

Run the above code, we can see the encrypted data and decrypted data. This proves that our encryption and decryption functions are working properly.

In practical applications, we need to pay attention to the security of the key and the transmission security of the ciphertext. It is not safe to store keys in code, it is better to obtain keys from secure storage. At the same time, secure protocols such as HTTPS need to be used when transmitting ciphertext to ensure data confidentiality.

Summary:
In this article, we use Go language functions to implement a simple data encryption and decryption function. By calling the encryption function encrypt and the decryption function decrypt, we can encrypt the data and decrypt it when needed. Of course, this article is just a quick-start tutorial. In actual applications, more complex encryption algorithms and security mechanisms are needed to protect the confidentiality of data.

Code example: https://github.com/example/encryption-golang

The above is the detailed content of Quick Start: Use Go language functions to implement simple data encryption and decryption functions. For more information, please follow other related articles on the PHP Chinese website!