将字节数组转换为托管结构体

Question

将字节数组转换为托管结构体

22

更新：此问题的答案帮助我编写了开源项目GitHub上的AlicanC's Modern Warfare 2 Tool。您可以在MW2Packets.cs中看到我如何读取这些数据包，以及我编写的用于读取大端数据的扩展 Extensions.cs 。

我在我的C#应用程序中使用 Pcap.Net 捕获Call of Duty：Modern Warfare 2的UDP数据包。我从库中收到一个byte[]数组。我试图像字符串一样解析它，但效果不佳。

我拥有的byte []具有通用数据包标头，然后是特定于数据包类型的另一个标头，然后是有关大厅中每个玩家的信息。

一位热心的人为我检查了一些数据包，并提供了这些结构：

// Fields are big endian unless specified otherwise.
struct packet_header
{
    uint16_t magic;
    uint16_t packet_size;
    uint32_t unknown1;
    uint32_t unknown2;
    uint32_t unknown3;
    uint32_t unknown4;
    uint16_t unknown5;
    uint16_t unknown6;
    uint32_t unknown7;
    uint32_t unknown8;
    cstring_t packet_type; // \0 terminated string
};

// Fields are little endian unless specified otherwise.
struct header_partystate //Header for the "partystate" packet type
{
    uint32_t unknown1;
    uint8_t unknown2;
    uint8_t player_entry_count;
    uint32_t unknown4;
    uint32_t unknown5;
    uint32_t unknown6;
    uint32_t unknown7;
    uint8_t unknown8;
    uint32_t unknown9;
    uint16_t unknown10;
    uint8_t unknown11;
    uint8_t unknown12[9];
    uint32_t unknown13;
    uint32_t unknown14;
    uint16_t unknown15;
    uint16_t unknown16;
    uint32_t unknown17[10];
    uint32_t unknown18;
    uint32_t unknown19;
    uint8_t unknown20;
    uint32_t unknown21;
    uint32_t unknown22;
    uint32_t unknown23;
};

// Fields are little endian unless specified otherwise.
struct player_entry
{
    uint8_t player_id;

    // The following fields may not actually exist in the data if it's an empty entry.
    uint8_t unknown1[3];
    cstring_t player_name;
    uint32_t unknown2;
    uint64_t steam_id;
    uint32_t internal_ip;
    uint32_t external_ip;
    uint16_t unknown3;
    uint16_t unknown4;
    uint32_t unknown5;
    uint32_t unknown6;
    uint32_t unknown7;
    uint32_t unknown8;
    uint32_t unknown9;
    uint32_t unknown10;
    uint32_t unknown11;
    uint32_t unknown12;
    uint16_t unknown13;
    uint8_t unknown14[???];     // Appears to be a bit mask, sometimes the length is zero, sometimes it's one. (First entry is always zero?)
    uint8_t unknown15;
    uint32_t unknown16;
    uint16_t unknown17;
    uint8_t unknown18[???];     // Most of the time this is 4 bytes, other times it is 3 bytes.
};

我在我的C#应用程序中重新创建了数据包头结构，如下所示：

[StructLayout(LayoutKind.Sequential, Pack=1)]
struct PacketHeader
{
    public UInt16 magic;
    public UInt16 packetSize;
    public UInt32 unknown1;
    public UInt32 unknown2;
    public UInt32 unknown3;
    public UInt32 unknown4;
    public UInt16 unknown5;
    public UInt16 unknown6;
    public UInt32 unknown7;
    public UInt32 unknown8;
    public String packetType;
}

然后我试图为“partystate”标题创建一个结构体，但是我收到了错误消息，提示fixed关键字是不安全的：

[StructLayout(LayoutKind.Sequential, Pack=1)]
struct PartyStateHeader
{
    UInt32 unknown1;
    Byte unknown2;
    Byte playerEntryCount;
    UInt32 unknown4;
    UInt32 unknown5;
    UInt32 unknown6;
    UInt32 unknown7;
    Byte unknown8;
    UInt32 unknown9;
    UInt16 unknown10;
    Byte unknown11;
    fixed Byte unknown12[9];
    UInt32 unknown13;
    UInt32 unknown14;
    UInt16 unknown15;
    UInt16 unknown16;
    fixed UInt32 unknown17[10];
    UInt32 unknown18;
    UInt32 unknown19;
    Byte unknown20;
    UInt32 unknown21;
    UInt32 unknown22;
    UInt32 unknown23;
}

因为unknown14和unknown18的大小不同，所以我无法对玩家条目做任何事情。（玩家条目是最重要的。）

现在，我必须将我拥有的byte[]转换为这些PacketHeader结构体。不幸的是，它不像(PacketHeader)bytes那样简单。我尝试了我在网上找到的这种方法，但它抛出了一个AccessViolationException：

GCHandle handle = GCHandle.Alloc(bytes, GCHandleType.Pinned);
PacketHeader packetHeader = (PacketHeader)Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(PacketHeader));

我该如何实现这个？

- AlicanC

1

我的答案在这里不直接编组结构，而是采用从网络读取的字节数组中提取字段值的方法。但是你可能需要自己翻转大端位。据我所知，.NET基类都是小端的。 - anton.burger

7个回答

9

我会将字节数组转换为内存流。然后在该流上实例化二进制读取器。接着定义帮助函数，这些函数需要接受二进制读取器并解析单个类。

内置的BinaryReader类总是使用小端序。

我会在这里使用类而不是结构体。

class PacketHeader 
{
    uint16_t magic;
    uint16_t packet_size;
    uint32_t unknown1;
    uint32_t unknown2;
    uint32_t unknown3;
    uint32_t unknown4;
    uint16_t unknown5;
    uint16_t unknown6;
    uint32_t unknown7;
    uint32_t unknown8;
    string packet_type; // replaced with a real string
};

PacketHeader ReadPacketHeader(BinaryReader reader)
{
  var result=new PacketHeader();
  result.magic = reader.ReadInt16();
  ...
  result.packet_type=ReadCString();//Some helper function you might need to define yourself
  return result;
}

- CodesInChaos

1

这不是我的问题的答案，而是我实际需要的。结构体（现在是类）具有动态大小。在某些情况下，玩家条目没有它们的最后一个字节，并且它们具有动态大小的字符串。最好的解决方案是逐个读取它们，而不是直接进行强制转换。 - AlicanC

7

这是我所做的方法：

using System;
using System.Runtime.InteropServices;
public static object GetObjectFromBytes(byte[] buffer, Type objType)
{
    object obj = null;
    if ((buffer != null) && (buffer.Length > 0))
    {
        IntPtr ptrObj = IntPtr.Zero;
        try
        {
            int objSize = Marshal.SizeOf(objType);
            if (objSize > 0)
            {
                if (buffer.Length < objSize)
                    throw new Exception(String.Format("Buffer smaller than needed for creation of object of type {0}", objType));
                ptrObj = Marshal.AllocHGlobal(objSize);
                if (ptrObj != IntPtr.Zero)
                {
                    Marshal.Copy(buffer, 0, ptrObj, objSize);
                    obj = Marshal.PtrToStructure(ptrObj, objType);
                }
                else
                    throw new Exception(String.Format("Couldn't allocate memory to create object of type {0}", objType));
            }
        }
        finally
        {
            if (ptrObj != IntPtr.Zero)
                Marshal.FreeHGlobal(ptrObj);
        }
    }
    return obj;
}

在结构定义中，我没有使用任何固定区域，而是使用了MarshalAs属性，如果标准的Marshalling无法使用，则使用该属性。这可能是您在处理字符串时需要的内容。

您可以像这样使用此函数：

PacketHeader ph = (PacketHeader)GetObjectFromBytes(buffer, typeof(PacketHeader));

编辑：我没有在代码示例中看到你的BigEndian“限制”。如果字节是LittleEndian，这个解决方案才能起作用。

编辑2：在你的示例字符串中，你可以使用以下方法进行修饰：

[MarshalAs(UnmanagedType.LPStr)]

在处理n大小的数组时，我会建议采用以下方式：

[MarshalAs(UnmanagedType.ByValArray, SizeConst = n)]

- Vladimir

6

对于那些可以访问C# 7.3功能的人，我使用这段不安全的代码将其“序列化”为字节：

public static class Serializer
{
    public static unsafe byte[] Serialize<T>(T value) where T : unmanaged
    {
        byte[] buffer = new byte[sizeof(T)];

        fixed (byte* bufferPtr = buffer)
        {
            Buffer.MemoryCopy(&value, bufferPtr, sizeof(T), sizeof(T));
        }

        return buffer;
    }

    public static unsafe T Deserialize<T>(byte[] buffer) where T : unmanaged
    {
        T result = new T();

        fixed (byte* bufferPtr = buffer)
        {
            Buffer.MemoryCopy(bufferPtr, &result, sizeof(T), sizeof(T));
        }

        return result;
    }
}

未管理类型可以是结构体（不带引用类型的简单结构体，这些被视为托管结构体）或本地类型，如int、short等。

- Philippe Paré

6

如果您想要快速的代码而不需要复制，这就是解决方案。我们在这里使用原始的byte[]进行操作，在unsafe代码中简单地将指针转换，就像在本地C/C++中一样。因此，没有调用昂贵框架方法、制作副本等等的开销。对非托管struct的任何更改都会反映在托管的byte[]中，反之亦然。

//FOR DEBUG/TEST ONLY
using System.Runtime.InteropServices;
namespace ByteStructCast1
{
    class Program
    {
        [StructLayout(LayoutKind.Sequential, Pack = 1)]
        unsafe struct StructTest//4B
        {
            [MarshalAs(UnmanagedType.U2)]
            public ushort item1; //2B
            public fixed byte item2[2]; //2B =2x 1B
        }
        static void Main(string[] args)
        {
            //managed byte array
            byte[] DB1 = new byte[7]; //7B more than we need. byte buffer usually is greater.
            DB1[0] = 2;//test data |> LITTLE ENDIAN
            DB1[1] = 0;//test data |
            DB1[2] = 3;//test data
            DB1[3] = 4;//test data
            unsafe //we'll now pin unmanaged struct over managed byte array
            {
                fixed(byte* db1 = DB1) //db1 is pinned pointer to DB1 byte[] array
                {
                    //StructTest t1 = *(StructTest*)db1;    //does not change DB1/db1
                    //t1.item1 = 11;                        //does not change DB1/db1
                    db1[0] = 22;                            //does CHANGE DB1/db1
                    DB1[0] = 33;                            //does CHANGE DB1/db1
                    StructTest* ptest = (StructTest*)db1;   //does CHANGE DB1/db1
                    ptest->item1 = 44;                      //does CHANGE DB1/db1
                    ptest->item2[0]++;                      //does CHANGE DB1/db1
                    ptest->item2[1]--;                      //does CHANGE DB1/db1
                }
            }
        }
    }
}

当您使用原始类型的fixed大小缓冲区并且需要将其元素作为具有成员的struct处理时，例如将64位的ulong转换为MyStruct，则可以使用此方法。

- MrHIDEn

3

好的，您有两个任务。第一个任务是将byte[]解释为结构体，第二个任务是处理可能不同的字节序。

因此，它们有些分歧。据我所知，如果要使用marshaling，则它将仅将字节解释为托管结构。因此，从一种字节序转换为另一种字节序由您自己来完成。这并不难做，但不会自动完成。

因此，要将byte[]解释为结构体，您需要像这样的东西：

[StructLayout(LayoutKind.Sequential)]
internal struct X
{
    public int IntValue;
    [MarshalAs(UnmanagedType.ByValArray, SizeConst = 3, ArraySubType = UnmanagedType.U1)] 
    public byte[] Array;
}

static void Main(string[] args)
{
    byte[] data = {1, 0, 0, 0, 9, 8, 7}; // IntValue = 1, Array = {9,8,7}
    IntPtr ptPoit = Marshal.AllocHGlobal(data.Length);
    Marshal.Copy(data, 0, ptPoit, data.Length);
    var x = (X) Marshal.PtrToStructure(ptPoit, typeof (X));
    Marshal.FreeHGlobal(ptPoit);

    Console.WriteLine("x.IntValue = {0}", x.IntValue);
    Console.WriteLine("x.Array = ({0}, {1}, {2})", x.Array[0], x.Array[1], x.Array[2]);
}

首先，前4个字节进入IntValue（1,0,0,0） -> [little endian] -> 1 接下来的3个字节直接进入数组。

如果你想要BigEndian，你需要自己处理：

int LittleToBigEndian(int littleEndian)
{
    byte[] buf = BitConverter.GetBytes(littleEndian).Reverse().ToArray();
    return BitConverter.ToInt32(buf, 0);
}

这有点混乱，所以对于您来说最好还是坚持使用自己编写的解析器，从源byte[]逐个取出字节并填充数据类，而不需要使用StructLayout和其他本地互操作。

- Ivan Danilov

在处理非托管结构体时，如果它们被紧密打包到一个字节中，最好声明该结构体为 [StructLayout(LayoutKind.Sequential), Pack = 1]。请注意这一点。 - Nedko

-1

将字节数组转换为字符串，可以这样做：

byte [] dBytes = ...
string str;
System.Text.UTF8Encoding enc = new System.Text.UTF8Encoding();
str = enc.GetString(dBytes);

将字符串转换回字节数组

public static byte[] StrToByteArray(string str)
{
    System.Text.UTF8Encoding  encoding=new System.Text.UTF8Encoding();
    return encoding.GetBytes(str);
}

现在读取你的字符串并查看你的数据是什么。

- KenL

我可以将它转换为字符串。但这样做并不好，因为这不是正确的方法。 - AlicanC

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- Roberto Santos · Accepted Answer

//我在这里找到了这个：http://code.cheesydesign.com/?p=572（我还没有测试，但乍一看它应该可以很好地工作。）

    /// <summary>
    /// Reads in a block from a file and converts it to the struct
    /// type specified by the template parameter
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="reader"></param>
    /// <returns></returns>
    private static T FromBinaryReader<T>(BinaryReader reader)
    {

        // Read in a byte array
        byte[] bytes = reader.ReadBytes(Marshal.SizeOf(typeof(T)));

        // Pin the managed memory while, copy it out the data, then unpin it
        GCHandle handle = GCHandle.Alloc(bytes, GCHandleType.Pinned);
        T theStructure = (T)Marshal.PtrToStructure(handle.AddrOfPinnedObject(), typeof(T));
        handle.Free();

        return theStructure;
    }