在结构中读取可变大小的字节切片

目前golang学习网上已经有很多关于Golang的文章了，自己在初次阅读这些文章中，也见识到了很多学习思路；那么本文《在结构中读取可变大小的字节切片》，也希望能帮助到大家，如果阅读完后真的对你学习Golang有帮助，欢迎动动手指，评论留言并分享~

我正在尝试将一些依赖于 aws 加密 sdk 的 python 代码转换为 golang。 aws 不提供此开发工具包的 golang 版本。我的需求很有限，所以我只需要转换一些非常具体的函数。

sdk中定义的数据结构之一（我翻译成go）是：

type encryptionSDK_Header_v1 struct {
    Version     byte
    Type        byte
    AlgorithmID [2]byte
    MessageID   [16]byte
    AADLength   [2]byte //Really a little-endian uint16
    AAD         []byte
    KeyCount    [2]byte //Again, a little-endian uint16
    DataKeys    []byte
    ContentType byte
    Reserved    [4]byte
    IVLength    byte    //Maybe a uint8?
    FrameLength [4]byte //A little-endian uint32
    HeaderAuth  []byte
}

我从 base64 编码的字符串开始，我可以轻松地将其转换为需要解析到此结构中的字节切片。

我在读取固定长度字段方面取得了一定的成功，但我不知道如何读取可变长度字段。有人可以帮忙吗？

编码/二进制包可以帮助我将各种字段转换为 uint8/uint16/uint32，所以我不太关心获得这方面的帮助。

可以在 https://docs.aws.amazon.com/encryption-sdk/latest/developer-guide/message-format.htm 中找到结构格式的说明。

正确答案

我无法帮助阅读 headerauth，因为它取决于算法。

对于其他字段，我不会在最终结构中保留它们的长度和计数，因为它们是在实际切片长度中编码的。

我会创建一个类型来从读取器读取变量字段：

type bytefield []byte

func (bf *bytefield) readfrom(r io.reader) error {
    var length uint16
    err := binary.read(r, binary.littleendian, &length)
    if err != nil {
        return err
    }
    *bf = make([]byte, length)
    _, err = io.readfull(r, *bf)
    if err != nil {
        return err
    }
    return nil
}

如何使用它。让我们考虑一下 encrypted keys：

type encrypteddatakey struct {
    keyproviderid   bytefield
    keyproviderinfo bytefield
    encryptedkey    bytefield
}

func (k *encrypteddatakey) readfrom(r io.reader) error {
    if err := k.keyproviderid.readfrom(r); err != nil {
        return err
    }
    if err := k.keyproviderinfo.readfrom(r); err != nil {
        return err
    }
    if err := k.encryptedkey.readfrom(r); err != nil {
        return err
    }

    return nil
}

使用bytefield很容易解码AAD

type aad map[string][]byte

func (a *aad) readfrom(r io.reader) error {
    var key bytefield
    var value bytefield
    var err error

    for {
        if err = key.readfrom(r); err != nil {
            if err == io.eof {
                return nil
            } else {
                return err
            }
        }
        if err = value.readfrom(r); err != nil {
            return err
        }
        (*a)[string(key)] = []byte(value)
    }
}

方法 aad.readfrom 读取直到缓冲区末尾，这就是为什么我在这里检查 eof 在读取密钥时发生的原因。我将其视为输入流中不再有 k-v 对。

现在我们可以读取整个标题了：

type EncryptionSDK_Header_v1 struct {
    Version     byte
    Type        byte
    AlgorithmID uint16
    MessageID   [16]byte
    AAD         AAD
    DataKeys    []EncryptedDataKey
    ContentType byte
    Reserved    [4]byte
    IVLength    byte   //Maybe a uint8?
    FrameLength uint32 //A little-endian uint32
    HeaderAuth  []byte
}

func (h *EncryptionSDK_Header_v1) ReadFrom(r io.Reader) error {
    var err error
    if err = binary.Read(r, binary.LittleEndian, &h.Version); err != nil {
        return err
    }
    if err = binary.Read(r, binary.LittleEndian, &h.Type); err != nil {
        return err
    }
    if err = binary.Read(r, binary.LittleEndian, &h.AlgorithmID); err != nil {
        return err
    }
    if _, err = io.ReadFull(r, h.MessageID[:]); err != nil {
        return err
    }
    var aadLen uint16
    if err = binary.Read(r, binary.LittleEndian, &aadLen); err != nil {
        return err
    }

    h.AAD = make(AAD)
    if aadLen > 0 {
        aadBuf := make([]byte, aadLen)

        if _, err = io.ReadFull(r, aadBuf); err != nil {
            return err
        }
        aadReader := bytes.NewReader(aadBuf)
        if err = h.AAD.ReadFrom(aadReader); err != nil {
            return err
        }
    }

    var keyCount uint16
    if err = binary.Read(r, binary.LittleEndian, keyCount); err != nil {
        return err
    }
    h.DataKeys = make([]EncryptedDataKey, keyCount)

    for i := uint16(0); i < keyCount; i++ {
        if err = h.DataKeys[i].ReadFrom(r); err != nil {
            return err
        }
    }

    if err = binary.Read(r, binary.LittleEndian, &h.ContentType); err != nil {
        return err
    }

    if _, err = io.ReadFull(r, h.Reserved[:]); err != nil {
        return err
    }

    if err = binary.Read(r, binary.LittleEndian, &h.IVLength); err != nil {
        return err
    }
    if err = binary.Read(r, binary.LittleEndian, &h.FrameLength); err != nil {
        return err
    }

    // Stopped at Header Authentication
    return nil
}

到这里，我们也就讲完了《在结构中读取可变大小的字节切片》的内容了。个人认为，基础知识的学习和巩固，是为了更好的将其运用到项目中，欢迎关注golang学习网公众号，带你了解更多关于的知识点！