How to deal with the encryption and decryption of concurrent files in Go language?

How to deal with the encryption and decryption of concurrent files in Go language?

Introduction:
With the development of the Internet and the popularization of information transmission, file encryption and decryption have become important means to protect data security. Moreover, as computer processing power and storage capacity increase, the need to process multiple files simultaneously increases. In the Go language, we can use the concurrency feature to implement encryption and decryption operations of multiple files at the same time.

1. Basic knowledge of cryptography:
   Before encrypting and decrypting files, we need to understand some basic knowledge of cryptography. Common symmetric encryption algorithms include DES, 3DES, AES, etc., while asymmetric encryption algorithms include RSA, DSA, etc. In this article, we take the AES algorithm as an example to explain in detail.
2. Implementation code example:
   The following is a simple implementation code example for encrypting and decrypting multiple files at the same time:

package main

import (
    "crypto/aes"
    "crypto/cipher"
    "fmt"
    "io"
    "os"
    "path/filepath"
    "sync"
)

// 加密文件
func encryptFile(inPath, outPath string, key []byte) error {
    inFile, err := os.Open(inPath)
    if err != nil {
        return err
    }
    defer inFile.Close()

    outFile, err := os.OpenFile(outPath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0666)
    if err != nil {
        return err
    }
    defer outFile.Close()

    block, err := aes.NewCipher(key)
    if err != nil {
        return err
    }

    iv := make([]byte, aes.BlockSize)
    stream := cipher.NewCTR(block, iv)

    writer := &cipher.StreamWriter{S: stream, W: outFile}
    if _, err := io.Copy(writer, inFile); err != nil {
        return err
    }

    return nil
}

// 解密文件
func decryptFile(inPath, outPath string, key []byte) error {
    inFile, err := os.Open(inPath)
    if err != nil {
        return err
    }
    defer inFile.Close()

    outFile, err := os.OpenFile(outPath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0666)
    if err != nil {
        return err
    }
    defer outFile.Close()

    block, err := aes.NewCipher(key)
    if err != nil {
        return err
    }

    iv := make([]byte, aes.BlockSize)
    stream := cipher.NewCTR(block, iv)

    reader := &cipher.StreamReader{S: stream, R: inFile}
    if _, err := io.Copy(outFile, reader); err != nil {
        return err
    }

    return nil
}

func main() {
    var wg sync.WaitGroup
    key := []byte("YOUR_KEY")

    // 要加密的文件列表
    files := []string{"file1.txt", "file2.txt", "file3.txt"}

    wg.Add(len(files))
    for _, file := range files {
        go func(f string) {
            defer wg.Done()
            inPath := filepath.Join("input", f)
            outPath := filepath.Join("output", "encrypted_"+f)

            if err := encryptFile(inPath, outPath, key); err != nil {
                fmt.Printf("Error encrypting file %s: %s
", inPath, err.Error())
            }
        }(file)
    }

    wg.Wait()

    // 要解密的文件列表
    files = []string{"encrypted_file1.txt", "encrypted_file2.txt", "encrypted_file3.txt"}

    wg.Add(len(files))
    for _, file := range files {
        go func(f string) {
            defer wg.Done()
            inPath := filepath.Join("output", f)
            outPath := filepath.Join("output", "decrypted_"+f[len("encrypted_"):])

            if err := decryptFile(inPath, outPath, key); err != nil {
                fmt.Printf("Error decrypting file %s: %s
", inPath, err.Error())
            }
        }(file)
    }

    wg.Wait()

    fmt.Println("All files encrypted and decrypted successfully.")
}

The above code implements a concurrent processing file Examples of encryption and decryption. In the example, we first define a sync.WaitGroup object that waits for all concurrent tasks to complete, then specify the list of files to be encrypted and decrypted, and perform encryption and decryption operations in a concurrent manner.

In the encryptFile and decryptFile functions, we first open the input file and the output file, then create an AES block and initialize it with a 16-byte IV . Next, we associate the generated stream with the input file or output file, and then use the io.Copy function to copy the data and complete the file encryption and decryption operations.

Finally, in the main function, we use the filepath.Join function to build the file path and start concurrent encryption and decryption tasks. Wait until all tasks are completed and print a success message.

3. Conclusion:
   Through concurrent processing of file encryption and decryption issues in Go language, multiple files can be processed at the same time to improve processing efficiency. In this article, we take the AES algorithm as an example and introduce a simple implementation code example to demonstrate how to use concurrency for file encryption and decryption operations. I hope this article will be helpful to readers when dealing with concurrent file encryption and decryption issues in the Go language.

The above is the detailed content of How to deal with the encryption and decryption of concurrent files in Go language?. For more information, please follow other related articles on the PHP Chinese website!