迁移AWS加密SDK至Go：字节切片解析可变成员结构体求助

我正在把依赖AWS Encryption SDK的Python代码迁移到Go，但AWS没有提供该SDK的Go版本。因为需求限制，我只需要转换部分特定功能。

我已经把SDK里定义的一个数据结构转换成了Go结构体：

type encryptionSDK_Header_v1 struct {
    Version     byte
    Type        byte
    AlgorithmID [2]byte
    MessageID   [16]byte
    AADLength   [2]byte // 实际是小端序uint16
    AAD         []byte
    KeyCount    [2]byte // 同样是小端序uint16
    DataKeys    []byte
    ContentType byte
    Reserved    [4]byte
    IVLength    byte    // 可能是uint8？
    FrameLength [4]byte // 小端序uint32
    HeaderAuth  []byte
}

我从Base64编码字符串开始，能轻松转成需要解析到该结构体的字节切片。已经成功解析了部分固定长度字段，但不知道怎么读取可变长度字段，求帮忙。

我知道encoding/binary包可以协助转换uint8/uint16/uint32，这部分不用帮忙。结构体格式参考AWS加密SDK的消息格式规范。

核心思路是通过偏移量游标跟踪当前读取位置，先解析可变字段的长度值，再根据长度截取对应字节。以下是具体实现步骤和示例代码：

1. 维护读取偏移量 #

定义一个offset变量记录当前在字节切片中的读取位置，每次读取字段后更新该值，确保按顺序解析。

2. 解析AAD字段 #

AAD的长度由AADLength（小端序uint16）指定，步骤如下：

• 把AADLength对应的2字节转成uint16，得到AAD的实际长度
• 从当前偏移量位置截取对应长度的字节，赋值给AAD
• 更新偏移量，加上AAD的长度

3. 解析DataKeys字段 #

DataKeys是多个密钥条目的集合，每个条目包含「密钥ID长度+密钥ID+加密密钥长度+加密密钥」，步骤如下：

• 把KeyCount对应的2字节转成uint16，得到密钥条目数量
• 循环读取每个密钥条目：依次读取密钥ID长度、密钥ID、加密密钥长度、加密密钥，将这些字节收集到DataKeys中
• 每次读取后更新偏移量

完整示例代码 #

import (
    "bytes"
    "encoding/binary"
    "errors"
)

type encryptionSDK_Header_v1 struct {
    Version     byte
    Type        byte
    AlgorithmID [2]byte
    MessageID   [16]byte
    AADLength   [2]byte // 实际是小端序uint16
    AAD         []byte
    KeyCount    [2]byte // 同样是小端序uint16
    DataKeys    []byte
    ContentType byte
    Reserved    [4]byte
    IVLength    byte    // 可能是uint8？
    FrameLength [4]byte // 小端序uint32
    HeaderAuth  []byte
}

func parseHeaderV1(data []byte) (*encryptionSDK_Header_v1, error) {
    header := &encryptionSDK_Header_v1{}
    offset := 0
    dataLen := len(data)

    // 解析固定长度字段
    if offset+1 > dataLen {
        return nil, errors.New("insufficient data for Version")
    }
    header.Version = data[offset]
    offset++

    if offset+1 > dataLen {
        return nil, errors.New("insufficient data for Type")
    }
    header.Type = data[offset]
    offset++

    if offset+2 > dataLen {
        return nil, errors.New("insufficient data for AlgorithmID")
    }
    copy(header.AlgorithmID[:], data[offset:offset+2])
    offset += 2

    if offset+16 > dataLen {
        return nil, errors.New("insufficient data for MessageID")
    }
    copy(header.MessageID[:], data[offset:offset+16])
    offset += 16

    // 解析AADLength和AAD
    if offset+2 > dataLen {
        return nil, errors.New("insufficient data for AADLength")
    }
    var aadLen uint16
    if err := binary.Read(bytes.NewReader(data[offset:offset+2]), binary.LittleEndian, &aadLen); err != nil {
        return nil, err
    }
    copy(header.AADLength[:], data[offset:offset+2])
    offset += 2

    if offset+int(aadLen) > dataLen {
        return nil, errors.New("insufficient data for AAD")
    }
    header.AAD = make([]byte, aadLen)
    copy(header.AAD, data[offset:offset+int(aadLen)])
    offset += int(aadLen)

    // 解析KeyCount和DataKeys
    if offset+2 > dataLen {
        return nil, errors.New("insufficient data for KeyCount")
    }
    var keyCount uint16
    if err := binary.Read(bytes.NewReader(data[offset:offset+2]), binary.LittleEndian, &keyCount); err != nil {
        return nil, err
    }
    copy(header.KeyCount[:], data[offset:offset+2])
    offset += 2

    dataKeysBuf := bytes.Buffer{}
    for i := 0; i < int(keyCount); i++ {
        // 读取Key ID Length
        if offset+2 > dataLen {
            return nil, errors.New("insufficient data for Key ID Length")
        }
        var keyIDLen uint16
        if err := binary.Read(bytes.NewReader(data[offset:offset+2]), binary.LittleEndian, &keyIDLen); err != nil {
            return nil, err
        }
        dataKeysBuf.Write(data[offset:offset+2])
        offset += 2

        // 读取Key ID
        if offset+int(keyIDLen) > dataLen {
            return nil, errors.New("insufficient data for Key ID")
        }
        dataKeysBuf.Write(data[offset:offset+int(keyIDLen)])
        offset += int(keyIDLen)

        // 读取Encrypted Data Key Length
        if offset+2 > dataLen {
            return nil, errors.New("insufficient data for Encrypted Data Key Length")
        }
        var edkLen uint16
        if err := binary.Read(bytes.NewReader(data[offset:offset+2]), binary.LittleEndian, &edkLen); err != nil {
            return nil, err
        }
        dataKeysBuf.Write(data[offset:offset+2])
        offset += 2

        // 读取Encrypted Data Key
        if offset+int(edkLen) > dataLen {
            return nil, errors.New("insufficient data for Encrypted Data Key")
        }
        dataKeysBuf.Write(data[offset:offset+int(edkLen)])
        offset += int(edkLen)
    }
    header.DataKeys = dataKeysBuf.Bytes()

    // 解析剩余固定长度字段
    if offset+1 > dataLen {
        return nil, errors.New("insufficient data for ContentType")
    }
    header.ContentType = data[offset]
    offset++

    if offset+4 > dataLen {
        return nil, errors.New("insufficient data for Reserved")
    }
    copy(header.Reserved[:], data[offset:offset+4])
    offset += 4

    if offset+1 > dataLen {
        return nil, errors.New("insufficient data for IVLength")
    }
    header.IVLength = data[offset]
    offset++

    if offset+4 > dataLen {
        return nil, errors.New("insufficient data for FrameLength")
    }
    copy(header.FrameLength[:], data[offset:offset+4])
    offset += 4

    // 解析HeaderAuth：根据AlgorithmID确定长度，比如AES-GCM对应16字节认证标签
    // 这里示例直接读取剩余所有字节，实际可根据算法调整
    if offset > dataLen {
        return nil, errors.New("insufficient data for HeaderAuth")
    }
    header.HeaderAuth = data[offset:]

    return header, nil
}

注意事项 #

• 加入了边界检查，避免因字节流长度不足导致panic
• HeaderAuth的长度需根据AlgorithmID对应的加密算法确定（如AES-GCM的认证标签长度为16字节），示例中直接读取剩余字节，实际需根据规范调整

内容的提问来源于stack exchange，提问作者Nevo