Learn the encryption and decryption functions in Go language and implement symmetric encryption algorithms

Learn the encryption and decryption functions in Go language and implement symmetric encryption algorithms

In the modern Internet era, data security is particularly important. In order to ensure the safe transmission and storage of sensitive data, encryption and decryption are essential core operations. As a modern programming language, Go language provides a variety of encryption and decryption functions. This article will introduce common encryption and decryption functions in Go language and implement symmetric encryption algorithms through sample codes.

Symmetric encryption algorithm refers to an encryption algorithm that uses the same key for encryption and decryption. Common symmetric encryption algorithms include DES, 3DES, AES, etc. In the Go language, the crypto package provides the implementation of symmetric encryption algorithms.

First, we need to generate a key. In Go language, you can use the crypto/rand package to generate a random key. The sample code is as follows:

package main

import (
    "crypto/rand"
    "fmt"
)

func generateKey() ([]byte, error) {
    key := make([]byte, 16) // 128位密钥
    _, err := rand.Read(key)
    if err != nil {
        return nil, err
    }
    return key, nil
}

func main() {
    key, err := generateKey()
    if err != nil {
        fmt.Println("密钥生成失败：", err)
        return
    }
    fmt.Println("生成的密钥：", key)
}

The above code generates a 16-byte key by calling the Read function of the crypto/rand package and prints it out.

Next, we use the generated key to perform data encryption and decryption operations. The crypto/cipher package is provided in the Go language, which defines standard interfaces for various symmetric block ciphers.

The sample code is as follows:

package main

import (
    "crypto/aes"
    "crypto/cipher"
    "fmt"
)

func encrypt(key, plaintext []byte) ([]byte, error) {
    block, err := aes.NewCipher(key)
    if err != nil {
        return nil, err
    }
    iv := make([]byte, aes.BlockSize)
    stream := cipher.NewCTR(block, iv)
    ciphertext := make([]byte, len(plaintext))
    stream.XORKeyStream(ciphertext, plaintext)
    return ciphertext, nil
}

func decrypt(key, ciphertext []byte) ([]byte, error) {
    block, err := aes.NewCipher(key)
    if err != nil {
        return nil, err
    }
    iv := make([]byte, aes.BlockSize)
    stream := cipher.NewCTR(block, iv)
    plaintext := make([]byte, len(ciphertext))
    stream.XORKeyStream(plaintext, ciphertext)
    return plaintext, nil
}

func main() {
    key := []byte("1234567812345678") // 替换为之前生成的密钥
    plaintext := []byte("Hello, World!")

    ciphertext, err := encrypt(key, plaintext)
    if err != nil {
        fmt.Println("加密失败：", err)
        return
    }
    fmt.Println("加密后的数据：", ciphertext)

    decrypted, err := decrypt(key, ciphertext)
    if err != nil {
        fmt.Println("解密失败：", err)
        return
    }
    fmt.Println("解密后的数据：", string(decrypted))
}

In the above code, we define the encrypt function and decrypt function to encrypt and decrypt data respectively. Among them, the encrypt function accepts the key and plaintext as parameters and returns the ciphertext; the decrypt function accepts the key and ciphertext as parameters and returns the plaintext.

In the main function, we use the previously generated key and a string to encrypt and print the result. Then, use the key and ciphertext to decrypt, and also print the result.

Through this sample code, we can understand the basic implementation principles and usage of symmetric encryption algorithms in Go language. Of course, in practical applications, it is also necessary to consider the secure transmission and storage of keys, as well as more complex encryption and decryption scenarios.

The above is the detailed content of Learn the encryption and decryption functions in Go language and implement symmetric encryption algorithms. For more information, please follow other related articles on the PHP Chinese website!