go GCM gin中间件的加密解密文件流处理

GCM是一种加密方式，它能够提供认证和加密的安全性，并且应用范围广泛。在Go语言中，我们可以通过gin框架中的中间件来实现GCM加密解密文件流处理。

下面我们就来一步步讲解如何实现。

引入必要的包

在Go语言中，实现GCM加密解密流处理，我们需要使用到以下包：

import (
    "crypto/aes"
    "crypto/cipher"
    "crypto/rand"
    "encoding/binary"
    "io"
    "net/http"
    "strconv"
    "strings"

    "github.com/gin-gonic/gin"
)

其中，crypto/aes包提供了AES加密算法，crypto/cipher包提供了加密分组的实现，crypto/rand包提供了随机数生成器，encoding/binary包提供了二进制数据的编解码能力，io包提供了对输入输出的操作，net/http包提供了HTTP相关的操作，strconv包提供了数据类型转换的能力，strings包提供了对字符串的操作，gin框架则提供了Web应用的中间件。

实现GCM加密解密流处理的中间件

我们需要实现一个中间件，用于在上传文件时对文件流进行加密，并在下载文件时对文件流进行解密。下面是完整的中间件代码实现：

func gcmMiddleware(key []byte) gin.HandlerFunc {
    block, err := aes.NewCipher(key)
    if err != nil {
        panic(err.Error())
    }
    gcm, err := cipher.NewGCM(block)
    if err != nil {
        panic(err.Error())
    }
    nonceSize := gcm.NonceSize()
    return func(c *gin.Context) {
        if c.Request.Method == "POST" {
            file, header, err := c.Request.FormFile("file")
            if err != nil {
                c.AbortWithError(http.StatusBadRequest, err)
                return
            }
            defer file.Close()
            nonce := make([]byte, nonceSize)
            if _, err = io.ReadFull(rand.Reader, nonce); err != nil {
                c.AbortWithError(http.StatusInternalServerError, err)
                return
            }
            writer := &cipher.StreamWriter{
                S: cipher.NewCTR(block, nonce),
                W: c.Writer,
            }
            sizebuf := make([]byte, 8) // 存放文件大小的缓冲区
            binary.LittleEndian.PutUint64(sizebuf, header.Size)
            // 将nonce插入到文件头部，文件的前8个字节用于存放文件长度
            _, err = writer.Write(append(nonce, sizebuf...))
            if err != nil {
                c.AbortWithError(http.StatusInternalServerError, err)
                return
            }
            buf := make([]byte, 1024) // 读取文件缓冲区
            for {
                n, err := file.Read(buf)
                if err != nil {
                    if err == io.EOF {
                        break
                    }
                    c.AbortWithError(http.StatusInternalServerError, err)
                    return
                }
                // 加密并写入到输出流
                _, err = writer.Write(buf[:n])
                if err != nil {
                    c.AbortWithError(http.StatusInternalServerError, err)
                    return
                }
            }
            // 输出流写到文件中
            writer.Close()
        } else if c.Request.Method == "GET" {
            filename := c.Param("filename")
            file, err := os.Open(filename)
            if err != nil {
                c.AbortWithError(http.StatusNotFound, err)
                return
            }
            defer file.Close()
            // 读取文件头部的nonce和文件长度
            buf := make([]byte, nonceSize+8)
            if _, err := io.ReadFull(file, buf); err != nil {
                c.AbortWithError(http.StatusBadRequest, err)
                return
            }
            nonce := buf[:nonceSize]
            size := binary.LittleEndian.Uint64(buf[nonceSize:])

            reader := &cipher.StreamReader{
                S: cipher.NewCTR(block, nonce),
                R: file,
            }
            c.Header("Content-Disposition", "attachment; filename="+filename)
            c.Header("Content-Type", "application/octet-stream")
            c.Header("Content-Length", strconv.FormatUint(size, 10))
            if _, err := io.Copy(c.Writer, reader); err != nil {
                c.AbortWithError(http.StatusInternalServerError, err)
                return
            }
        }
    }
}

这个中间件能够处理HTTP的上传和下载请求，其中上传请求会对文件流进行加密处理，下载请求则会对文件流进行解密。

附：完整实现示例

下面是完整实现示例，我们以上传、下载图片为例。

package main

import (
    "crypto/aes"
    "crypto/cipher"
    "crypto/rand"
    "encoding/binary"
    "fmt"
    "io"
    "net/http"
    "os"
    "strconv"
    "strings"

    "github.com/gin-gonic/gin"
)

func main() {
    key := []byte("0123456789abcdef") // 密钥，必须为16字节
    r := gin.Default()
    r.Use(gcmMiddleware(key))
    r.POST("/upload", func(c *gin.Context) {
        file, header, err := c.Request.FormFile("file")
        if err != nil {
            c.AbortWithError(http.StatusBadRequest, err)
            return
        }
        defer file.Close()
        filename := header.Filename
        out, err := os.Create(filename)
        if err != nil {
            c.AbortWithError(http.StatusInternalServerError, err)
            return
        }
        defer out.Close()
        if _, err := io.Copy(out, file); err != nil {
            c.AbortWithError(http.StatusInternalServerError, err)
            return
        }
        c.String(http.StatusOK, fmt.Sprintf("File %s uploaded successfully.", filename))
    })
    r.GET("/download/:filename", func(c *gin.Context) {
        filename := c.Param("filename")
        c.File(filename)
    })
    r.Run(":8080")
}

func gcmMiddleware(key []byte) gin.HandlerFunc {
    block, err := aes.NewCipher(key)
    if err != nil {
        panic(err.Error())
    }
    gcm, err := cipher.NewGCM(block)
    if err != nil {
        panic(err.Error())
    }
    nonceSize := gcm.NonceSize()
    return func(c *gin.Context) {
        if c.Request.Method == "POST" {
            file, header, err := c.Request.FormFile("file")
            if err != nil {
                c.AbortWithError(http.StatusBadRequest, err)
                return
            }
            defer file.Close()
            nonce := make([]byte, nonceSize)
            if _, err = io.ReadFull(rand.Reader, nonce); err != nil {
                c.AbortWithError(http.StatusInternalServerError, err)
                return
            }
            writer := &cipher.StreamWriter{
                S: cipher.NewCTR(block, nonce),
                W: c.Writer,
            }
            sizebuf := make([]byte, 8) // 存放文件大小的缓冲区
            binary.LittleEndian.PutUint64(sizebuf, header.Size)
            // 将nonce插入到文件头部，文件的前8个字节用于存放文件长度
            _, err = writer.Write(append(nonce, sizebuf...))
            if err != nil {
                c.AbortWithError(http.StatusInternalServerError, err)
                return
            }
            buf := make([]byte, 1024) // 读取文件缓冲区
            for {
                n, err := file.Read(buf)
                if err != nil {
                    if err == io.EOF {
                        break
                    }
                    c.AbortWithError(http.StatusInternalServerError, err)
                    return
                }
                // 加密并写入到输出流
                _, err = writer.Write(buf[:n])
                if err != nil {
                    c.AbortWithError(http.StatusInternalServerError, err)
                    return
                }
            }
            // 输出流写到文件中
            writer.Close()
        } else if c.Request.Method == "GET" {
            filename := c.Param("filename")
            file, err := os.Open(filename)
            if err != nil {
                c.AbortWithError(http.StatusNotFound, err)
                return
            }
            defer file.Close()
            // 读取文件头部的nonce和文件长度
            buf := make([]byte, nonceSize+8)
            if _, err := io.ReadFull(file, buf); err != nil {
                c.AbortWithError(http.StatusBadRequest, err)
                return
            }
            nonce := buf[:nonceSize]
            size := binary.LittleEndian.Uint64(buf[nonceSize:])

            reader := &cipher.StreamReader{
                S: cipher.NewCTR(block, nonce),
                R: file,
            }
            c.Header("Content-Disposition", "attachment; filename="+filename)
            c.Header("Content-Type", "application/octet-stream")
            c.Header("Content-Length", strconv.FormatUint(size, 10))
            if _, err := io.Copy(c.Writer, reader); err != nil {
                c.AbortWithError(http.StatusInternalServerError, err)
                return
            }
        }
    }
}

上传图片可以使用curl命令：

curl -i -X POST -F file=@/path/to/your/image.jpg http://localhost:8080/upload

下载图片可以使用浏览器，或者使用wget命令：

wget http://localhost:8080/download/image.jpg

综上所述，我们已经成功实现了通过GCM加密解密文件流处理的中间件。