[原创]UE4.27SDK-Dump-逆向工程-看雪安全社区｜专业技术交流与安全研究论坛

# UE4.27 SDK Dump

近期学了学UE4相关知识，并且自己动手写了写SDK dump，特此记录一下。相关代码已传至<a href="elink@012K9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6Y4K9i4c8Z5N6h3u0Q4x3X3g2U0L8$3#2Q4x3V1k6&6M7X3W2F1k6#2)9J5k6r3#2W2i4K6u0r3N6s2y4Q4x3X3c8#2k6e0c8V1N6h3#2H3k6i4t1`.">github</a>，使用了`Frida`与`TypeScript`，解决了`Frida`在`Js`下代码挤压在同一个文件的问题，同时使用`C++`去写结构体并得到偏移，能够更好的维护。

## 命名约定

在阅读代码之前，就必须去了解一下<a href="elink@a97K9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6D9K9h3&6C8i4K6u0W2P5X3S2A6K9s2g2Q4x3X3g2U0L8$3#2Q4x3V1k6Q4x3@1k6@1j5i4u0Y4k6i4c8Q4x3@1c8Z5N6s2c8H3i4K6t1#2x3@1q4Q4x3V1k6Q4x3V1k6V1L8$3y4K6i4K6u0W2N6h3&6J5k6h3q4D9k6h3&6Y4K9h3&6W2i4K6u0W2j5$3!0E0i4K6u0r3L8r3q4@1k6i4y4@1i4K6u0r3d9f1&6f1i4K6u0r3f1s2u0G2k6%4u0S2L8h3#2A6L8X3N6Q4x3V1k6p5k6i4k6W2L8r3!0H3L8h3g2F1N6q4)9J5c8V1y4G2k6r3W2F1k6#2y4@1j5h3&6V1j5i4u0V1i4K6u0r3">UE4的命名约定</a>，具体的自己去查看官网文档，下面是一些基本需要知道的：

- 模版类以T作为前缀，比如TArray,TMap,TSet UObject派生类都以U前缀
- AActor派生类都以A前缀
- SWidget派生类都以S前缀
- 抽象接口以I前缀
- 枚举以E开头
- bool变量以b前缀，如bPendingDestruction
- 其他的大部分以F开头，如FString,FName
- typedef的以原型名前缀为准，如typedef TArray FArrayOfMyTypes;

## 关键类

### UWorld

在UE4引擎中全局定义了`UWorldProxy`对象，此对象在`Engine\Source\Runtime\Engine\Classes\Engine\World.h`定义，这个类中有一个变量`UWorld* World;`

在<a href="elink@770K9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6V1L8$3y4K6i4K6u0W2N6h3&6J5k6h3q4D9k6h3&6Y4K9h3&6W2i4K6u0W2j5$3!0E0i4K6u0r3y4q4)9J5k6e0t1%4i4K6u0r3k6h3&6Q4x3X3c8g2f1#2)9J5c8V1q4b7d9g2)9J5c8W2u0#2L8Y4c8A6L8h3g2Q4x3V1k6q4L8X3N6A6L8X3g2Q4x3V1k6q4L8X3N6A6L8X3g2Q4x3V1k6g2g2$3!0J5L8r3c8Q4x3V1j5`.">官网定义</a>中可以看到，`UWorld`是地图或沙盒的顶级对象，其中会有`Actor`等信息

![image-20240714172715346](upload/attach/202408/978803_UY98G8DK3TSBDCJ.png)

### UobjectBase

根据继承关系找到最顶级的类`UobjectBase`，此类在`Engine\Source\Runtime\CoreUObject\Public\UObject\UObjectBase.h`定义，在这个类中有一个成员变量`FName`，由注释可知此变量代表对象的名称。

![image-20240715111610611](upload/attach/202408/978803_97C6HWHF6BVGJKG.png)

其字段含义如下

```cpp
class UObjectBase
{
public:
	EObjectFlags ObjectFlags;			//对象属性
	int32_t InternalIndex;				//对象GUObjectArray序号
	UClass* ClassPrivate;				//对象的类
	FName NamePrivate;					//对象的名字
	UObject* OuterPrivate;				//对象所在UPackage
};
```

这里值得一提的是，普遍认为`UObject`是是UE4中所有对象的基类，但是从这里可以发现真正的基类是`UObjectBase`。认为`UObject`是基类也并无道理，因为继承自`UObjectBase`的`UObject`没有新增任何成员，从VS提供的内存视图可知，下文也会延续这一说法。

![image-20240723095540028](upload/attach/202408/978803_BF3FFVPJMQ5BKU6.png)

### FName

正是因为UE4中所有对象都继承自`UObject`，而`UObject`又有成员`FName`提供名字，因此UE4的反射系统才能方便得知一个对象的名字，甚至是字段、函数参数等名字。这也给逆向工作提供了可乘之机，那么就不得不研究一下UE4是怎么通过这个`FName`得到的名字的。

`FName`在`Engine\Source\Runtime\Core\Public\UObject\NameTypes.h`定义，这个类中有一个成员函数`ToString()`，还存储了字符串索引`FNameEntryId	ComparisonIndex;`

![image-20240715114813804](upload/attach/202408/978803_MJC555S9J8VD2ZY.png)

见名思义，调用`FName::ToString`即可得到名字，返回一个`FString`类型。

### FString

查看`FString`类，在`Engine\Source\Runtime\Core\Public\Containers\UnrealString.h`定义

![image-20240714173747698](upload/attach/202408/978803_4BEBRWXH6BV23UG.png)

可见字符串相关数据存储在`TArray`容器中，容器类型是`TCHAR`，而`TCHAR`类型就是`wchar_t`类型。

### TArray

TArray是一个模板类，定义也比较简单

```cpp
template <typename ElementType>
class TArray
{
public:
    ElementType *Allocator;
    int32_t ArrayNum;
    int32_t ArrayMax;
};

```

由此逻辑已经清晰，要在UE4中获得一个对象的名称，即该对象的字符串，只需要访问`UObjectBase`的成员变量`NamePrivate`，调用该变量的`ToString`函数，该函数返回一个`FSting`类型，这个类型里面就有所要字符串的地址。

以上过程是正向开发的调用过程，但在逆向的时候情况就不会有这么简单，当然也可以直接查找调用`ToString`函数偏移来得到对象名字，这一步可以通过`IDA`等手段完成。必要地，还是要看一下`ToString`函数是怎么实现的。这一点会在后文进行。

### FNamePool

此类型在`Engine\Source\Runtime\Core\Private\UObject\UnrealNames.cpp`中定义，这里只关注第一个成员

```cpp
class FNamePool
{
public:
    FNameEntryAllocator Entries;
    …………
};

```

这个类型定义了一个全局静态变量`NamePoolData`数组，这个`NamePoolData`就是常说的`GName`，因为它就存储了全局的字符串，相当于一个字符串池，后续的`ToString`函数也高度依赖这个数组。

### FNameEntryAllocator

此类型在`Engine\Source\Runtime\Core\Private\UObject\UnrealNames.cpp`中定义，这类中有四个相当重要的成员变量

```cpp
class FNameEntryAllocator 
{
public:
    enum
    {
        Stride = alignof(FNameEntry)
    };
    enum
    {
        BlockSizeByte = Stride * FNameBlockOffsets
    };

mutable PVOID Lock;
    uint32_t CurrenBlock;
    uint32_t CurrentByteCursor;
    FNameEntry *Blocks[FNameMaxBlocks];
};

```

### FNameEntry

此类型在`Engine\Source\Runtime\Core\Public\UObject\NameTypes.h`定义，用于存储实际的字符串。`FNameEntryHeader`结构比较简单，后面会有提及。

```cpp
class FNameEntry
{
public:
    FNameEntryHeader Header;
    union
    {
        char AnsiName[NAME_SIZE];
        wchar_t WideName[NAME_SIZE];
    };
};

```

### FNameEntryId

此类型中，只有一个`uint32`的类型变量，其余均是函数，因此可简单理解为`ComparisonIndex`就是一个`uint32`的值

![image-20240714212028986](upload/attach/202408/978803_M9JX7UDFE52XBKT.png)

这个类主要就是存放字符串在`GName`中的索引

还有一些关键类会在后续边解析边提及。

## 解析`ToString()`

### ToString

此函数实现于`Engine\Source\Runtime\Core\Private\UObject\UnrealNames.cpp`中

![image-20240729172018231](upload/attach/202408/978803_ST86E2ZFK4D4Z7A.png)

可知该函数先调用了`GetDisplayNameEntry`函数

### GetDisplayNameEntry

GetDisplayNameEntry此函数实现就在`ToString`函数上方

![image-20240729173300599](upload/attach/202408/978803_5P3DF5DJ9CBHCT4.png)

可知此函数调用了三个函数，依次查看

#### GetNamePool()

此函数在`Engine\Source\Runtime\Core\Private\UObject\UnrealNames.cpp`中定义

![image-20240714205547097](upload/attach/202408/978803_HV7KFZXR7R5CYWM.png)

这是一个单例模式的函数，即在So中存在唯一的全局静态变量`NamePoolData`，查看`NamePoolData`的类型`FNamePool`。

1. `static bool bNamePoolInitialized;`
   - 声明了一个静态布尔变量`bNamePoolInitialized`，用于跟踪`FNamePool`实例是否已经被初始化。
2. `alignas(FNamePool) static uint8 NamePoolData[sizeof(FNamePool)];`
   - 声明了一个静态数组`NamePoolData`，其大小等于`FNamePool`类的大小，并使用`alignas`关键字确保这个数组按照`FNamePool`的内存对齐要求进行对齐。这个数组将用作`FNamePool`实例的内存空间。
3. GetNamePool函数则是用于返回`FNamePool`的实例，如果未被初始化则初始化。

这个模式保证了即使在多线程环境下，`FNamePool`也只会被初始化一次。它不使用C++11中的魔法静态（magic statics）或单例模式中的锁，以减少运行时的开销。通过这种方式，`FNamePool`类的实例在第一次调用`GetNamePool`时被创建，并在随后的调用中直接返回，避免了重复初始化。

#### GetDisplayIndex()

此函数实现于`Engine\Source\Runtime\Core\Public\UObject\NameTypes.h`

![image-20240729173437588](upload/attach/202408/978803_JA8VMVT8RH68GWP.png)

##### GetDisplayIndexFast()

进入`GetDisplayIndexFast`函数，此函数定义在相同目录下

![image-20240729173455037](upload/attach/202408/978803_HWXRFC56D925VYF.png)

查看相关宏定义，

![image-20240714211337676](upload/attach/202408/978803_G4AGBKU9QS39EWQ.png)

由注释可知此宏只用于编辑器，而在实际运行中不会启用

因此`GetDisplayIndexFast`实际返回`ComparisonIndex`，`ComparisonIndex`有两处被定义，其中一处是作为`FName`的成员变量，`FNameEntryId`前文也有解析，它里面就只存储了`uint32_t`的值，作为字符串在`GName`中索引。

![image-20240715111926364](upload/attach/202408/978803_BRGQR54P66YCY7Y.png)

如果还没忘记的话，`FName`是基类`UObject`的成员之一，即可以通过`NamePrivate`获得此`Index`。

#### Resolve()

此函数定义于`Engine\Source\Runtime\Core\Private\UObject\UnrealNames.cpp`。在`ToString`函数中，`Resolve`参数是`GetDisplayIndex`函数的返回值，其类型是`FNameEntryId`

![image-20240714183707060](upload/attach/202408/978803_Y8X54GJN8BWAAMG.png)

而查看`Resolve`的定义

![image-20240715112332385](upload/attach/202408/978803_KFBVXPVSDSZFWN7.png)

其参数类型却是`FNameEntryHandle`，即说明`FNameEntryHandle`的构造函数存在相关转换

转至相关定义可以发现，确实有以`FNameEntryId`为参数的构造函数

![image-20240714212916118](upload/attach/202408/978803_8Q3QANWQBMGS5NF.png)

这里`FNameBlockOffsetBits`在上方也有定义，是常量

```cpp
static constexpr uint32 FNameMaxBlockBits = 13;
static constexpr uint32 FNameBlockOffsetBits = 16;
static constexpr uint32 FNameMaxBlocks = 1 << FNameMaxBlockBits;
static constexpr uint32 FNameBlockOffsets = 1 << FNameBlockOffsetBits;
```

##### Entries.Resolve()

查看`Resolve`相关实现

![image-20240715112302267](upload/attach/202408/978803_GZXDP5ZVNJTJBH5.png)

这里的`Blocks`就是前文提及的重要四个变量之一，位于`FNameEntrlAllocator`下，`FNameEntrlAllocator`则是`FNamePool`唯一成员。

稍微总结一下，调用`GetNamePool`得到`GName`，调用`GetDisplayIndex`得到索引，调用`Resolve`在`GName`上根据索引找到一个`FNameEntry`类型变量，最后返回此变量。

#### FNameEntry

查看`GetDisplayNameEntry`函数返回类型`FNameEntry`

![image-20240715123755799](upload/attach/202408/978803_TVN4CRHZVK26AET.png)

里同样有一个只在编译运行时才有效的宏，因此这里的成员只有`FNameEntryHeader Header`和一个联合体，这两个成员都会参与后续字符串转换。

#### FNameEntryHeader

![image-20240715124124435](upload/attach/202408/978803_SA9STYBQ7EPJC9G.png)

这里就指示了是否为宽字符以及字符长度。

### GetPlainNameString()

在调用完`GetDisplayNameEntry`就会接着调用`GetPlainNameString`，将`FNameEntry`类型转换为`FString`

![image-20240729174905865](upload/attach/202408/978803_7QKV9QPFTWQKF6S.png)

如下是`GetPlainNameString`函数定义

![image-20240729174848325](upload/attach/202408/978803_TEEKGEMQSUM8F5N.png)

这里的`Header`即为`FNameEntryHeader `中的`Header`，他用于判断是否为宽字符。再返回对应的类型字符串。

`GetUnterminatedName`也仅仅只是返回`FNameEntry`中存储的字符串而已。

![image-20240729175127534](upload/attach/202408/978803_Q5EDWXQ6JRHGD5W.png)

### 总结

`ToString`函数实现会调用两个关键函数`GetDisplayNameEntry`和`GetPlainNameString`，`GetDisplayNameEntry`又依次调用`GetNamePool`，`GetDisplayIndex`，`Resolve`三个函数。

`GetNamePool`函数主要用于初始化和返回`FNamePool NamePoolData`，其中`FNamePool`类的构造函数中会注册一大堆硬编码字符串，这里可通过搜索字符串并交叉引用的方式查找`NamePoolData`

`GetDisplayIndex`主要用于返回对象名称的索引，其返回类型是`FNameEntryId`，它的成员变量只有一个`uint32 Value`。此函数会继续调用`GetDisplayIndexFast`来得到`ComparisonIndex`，此变量也在`FName`中有存储。即可以通过`UobjectBase`下的`FName NamePrivate`成员来得到此`Index`。

`Resolve`根据返回的索引继续返回名称目录项，它的返回类型是`FNameEntry`，这个类有一个比特位域用于判断是否为宽字符，有一个联合体用于名称字符串。

最终调用`Resolve`返回类型`FNameEntry`的方法`GetPlainNameString`来返回`FString`字符串

## 利用Frida打印所有Actor的名字

### UWorld解析

在实际运行环境中`UWorld`自己的第一个成员就是`ULevel*	PersistentLevel`，可表示成这样

```cpp
class FNetworkNotify
{
    uint64_t VTable;
};
class UWorld : public UObject, public FNetworkNotify
{
public:
    /** Persistent level containing the world info, default brush and actors spawned during gameplay among other things			*/
    ULevel *PersistentLevel;
    …………
};

```

根据官方注释可知，`PersistentLevel`存储了`world`信息

### ULevel

继续跟进`ULevel`类

```cpp
class IInterface_AssetUserData
{
    uint64_t dummy;
};

template <typename ElementType>
class TArray
{
public:
    ElementType *Allocator;
    int32_t ArrayNum;
    int32_t ArrayMax;
};

class ULevel : public UObject, public IInterface_AssetUserData
{
public:
    char dummyURL[104];
    TArray<AActor *> Actors;
    …………
};

```

此时就可以看到存储了所有`Actors`的数组，根据以上关系就可以轻松得知当前`Level`有多少个`Actors`，`Actor`地址都在哪，Frida代码如下（`GWorld`需要通过其他手段得到）

```js
    var Level = GWorld.add(OFFSET.offset_UWorld_PersistentLevel).readPointer()
    console.log("Level :", Level)

var Actors = Level.add(OFFSET.offset_ULevel_Actors).readPointer()
    console.log("Actors Array :", Actors)

var Actors_Num = Level.add(OFFSET.offset_ULevel_Actors).add(8).readU32()
    console.log("Actors_num :", Actors_Num)

var Actors_Max = Level.add(OFFSET.offset_ULevel_Actors).add(0xc).readU32()
    console.log("Actors_Max :", Actors_Max)
```

在得到`Actor`之后，自然就是要从`Actor`开始解析，这也简单，因为`Actor`也是继承自`UObject`

![image-20240729185341826](upload/attach/202408/978803_3V3ADAREZE6AQD4.png)

而`UObject`中就存放了`FName NamePrivate`这一字段，通过他就可以得到名字，接下来要做的就是手动实现`ToString`这一函数。

首先需要获得`FName NamePrivate`这一字段，通过偏移很容易得到

```js
var FName_Offset = 0x18
var FName = actor.add(FName_Offset);
```

得到`FName`后就是实现那几个函数。这里稍微提一下为什么`actor.add(FName_Offset)`之后不用在`readPointer`，是因为`UObject`里面直接存放的就是`FName`这一结构，而不是`FName*`指针，所以不需要再`readPointer`

### GetNamePool实现

这一步有两种方式，第一种通过`IDA`等方式先找到全局变量`GName`，第二种通过特征码等方式在内存中找到。如何找不在这里展开，默认已经找到。找到之后需要使用的是`FNamePool`的第一个成员`FNameEntryAllocator`中的`Blocks`，

这里有一个点需要注意, `FNameEntryAllocator`第一个成员是`Lock`，这android平台对应的是`pthread_rwlock_t`类型，windows平台对应的是`SRWLOCK`类型，

在32位安卓平台上此成员大小应该是`0x28`，在64位安卓平台上应该是`0x38`，那么从`FNamePool`得到`Blocks`就是

```js
var FNameEntryAllocator = GNames  
var Blocks = GNames.add(0x40)
```

### GetDisplayIndex实现

这一步很简单

```js
var ComparisonIndex = FName.add(0).readU32()
```

### Resolve实现

第一步是将`FNameEntryId Id`即`ComparisonIndex`转化为`FNameEntryHandle`

![image-20240714212916118](upload/attach/202408/978803_8Q3QANWQBMGS5NF.png)

```js
var FNameBlockOffsetBits = 16
var FNameBlockOffsets = 65536

var Block = ComparisonIndex >> FNameBlockOffsetBits
var Offset = ComparisonIndex & (FNameBlockOffsets - 1)
```

前面已经得到`FNameEntryAllocator`的`Blocks`

```js
var Blocks = GNames.add(0x40)
var FNameEntryAllocator = GNames  
```

##### Entries.Resolve实现

查看`Resolve`相关实现

![image-20240715112302267](upload/attach/202408/978803_GZXDP5ZVNJTJBH5.png)

得到`FNameEntry`

```js
var FNameEntry = Blocks.add(Block * 8).readPointer().add(Offset * 2)
```

### GetPlayNameString实现

得到`FNameEntry`后，就相当于得到了真正的字符串

```cpp
class FNameEntry
{
public:
    FNameEntryHeader Header;
    union
    {
        char AnsiName[NAME_SIZE];
        wchar_t WideName[NAME_SIZE];
    };
};
```

`FNameEntryHeader`只是存储了字符串是否为宽字符，长度为多少而已，真正字符串就在后面的`AnsiName`或`WideName`中

```js
var FNameEntryHeader = FNameEntry.readU16()
var isWide = FNameEntryHeader & 1
var Len = FNameEntryHeader >> 6 //最大长度就是1024，所以需要右移6位

if (0 == isWide) {
	console.log(`\x1b[32m[+] actor ${actor}: ${FNameEntry.add(2).readCString(Len)}\x1b[0m`)
}
```

整合一下就是

```js
export function dumpActorName(GWorld: NativePointer, GNames: NativePointer) {
    var Level = GWorld.add(OFFSET.offset_UWorld_PersistentLevel).readPointer()
    console.log("Level :", Level)

var Actors = Level.add(OFFSET.offset_ULevel_Actors).readPointer()
    console.log("Actors Array :", Actors)

var Actors_Num = Level.add(OFFSET.offset_ULevel_Actors).add(8).readU32()
    console.log("Actors_num :", Actors_Num)

var Actors_Max = Level.add(OFFSET.offset_ULevel_Actors).add(0xc).readU32()
    console.log("Actors_Max :", Actors_Max)

for (var index = 0; index < Actors_Num; index++) {
        var actor = Actors.add(index * 8).readPointer()
        if (actor == NULL) { continue; }
        //console.log("actor", actor)
        //通过角色actor获取其成员变量FName

var FNameEntryAllocator = GNames

var FName_Offset = 0x18
        var FName = actor.add(FName_Offset);
        var ComparisonIndex = FName.add(0).readU32()

// console.log("ComparisonIndex:", ComparisonIndex);
        var FNameBlockOffsetBits = 16
        var FNameBlockOffsets = 65536

var Block = ComparisonIndex >> FNameBlockOffsetBits
        var Offset = ComparisonIndex & (FNameBlockOffsets - 1)

var Blocks_Offset = 0x40
        var Blocks = FNameEntryAllocator.add(Blocks_Offset)

var FNameEntry = Blocks.add(Block * 8).readPointer().add(Offset * 2)
        // console.log("FNameEntry:", FNameEntry)

var FNameEntryHeader = FNameEntry.readU16()

var isWide = FNameEntryHeader & 1
        var Len = FNameEntryHeader >> 6

if (0 == isWide) {
        console.log(`\x1b[32m[+] actor ${actor}: ${FNameEntry.add(2).readCString(Len)}\x1b[0m`)
    }
}
```

效果

![image-20240729194413303](upload/attach/202408/978803_PQ66JB4FPDZRVCN.png)

## FUObjectArray

名字解析只是最基本的，复杂的还是成员字段、函数签名等信息。在UE4中，还有一个关键全局变量`GUObjectArray`，这个全局变量存储了当前所有的对象

![image-20240729194922327](upload/attach/202408/978803_PJTRSDP4SBRTGW3.png)

`FUObjectArray`部分定义如下

```cpp
class FUObjectArray
{
public:
    uint32_t ObjFirstGCIndex;
    uint32_t ObjLastNonGCIndex;
    uint32_t MaxObjectsNotConsideredByGC;
    bool OpenForDisregardForGC;
    TUObjectArray TUObjectArray;
    …………
};
```

这里面重要的就是`TUObjectArray TUObjectArray`，`TUObjectArray类型`就是`FChunkedFixedUObjectArray`

![image-20240729195250191](upload/attach/202408/978803_Y5TSAHKYY59GJU5.png)

## TUObjectArray /FChunkedFixedUObjectArray

定义如下

```cpp
class FChunkedFixedUObjectArray
{
	enum
	{
		NumElementsPerChunk = 64 * 1024,
	};
	/** Master table to chunks of pointers **/
	FUObjectItem** Objects;
	/** If requested, a contiguous memory where all objects are allocated **/
	FUObjectItem* PreAllocatedObjects;
	/** Maximum number of elements **/
	int32 MaxElements;
	/** Number of elements we currently have **/
	int32 NumElements;
	/** Maximum number of chunks **/
	int32 MaxChunks;
	/** Number of chunks we currently have **/
	int32 NumChunks;
}
```

显然就存储了当前所有最大元素数量，当前存活的元素数量等信息

`FUObjectItem`就是一个一个具体的`Object`，定义也简单

```js
class FUObjectItem
{
    class UObject *Object;
    uint32_t Flags;
    // UObject Owner Cluster Index
    uint32_t ClusterRootIndex;
    // Weak Object Pointer Serial number associated with the object
    uint32_t SerialNumber;
};
```

从`GUOjbectArray`得到`MaxElements`就是

```js
export function getObjectCount(GUObjectArray: NativePointer) {
    var GUObjectElementCount = GUObjectArray.add(OFFSET.GAME_FUObjectArray_TUObjectArray_OFFSET).add(OFFSET.GAME_TUObjectArray_NumElements_OFFSET).readU32()
    console.log(`\x1b[32m[+] GUObjectElementCount: ${GUObjectElementCount}\x1b[0m`)
    return GUObjectElementCount;
}

```

然而UObject的储存并不是平坦的，而是分块的，这点从Chunked可以看出来，同样的可以查看虚幻引擎的源码(UObjectArray.h)来得知如何访问FChunkedFixedUObjectArray来获取UObject*

```cpp
FORCEINLINE_DEBUGGABLE FUObjectItem const* GetObjectPtr(int32 Index) const TSAN_SAFE
{
    const int32 ChunkIndex = Index / NumElementsPerChunk;
    const int32 WithinChunkIndex = Index % NumElementsPerChunk;
    FUObjectItem* Chunk = Objects[ChunkIndex];
    return Chunk + WithinChunkIndex;
	}
```

转成`Frida`

```js
export function getUObjectBaseObjectFromId(GUObjectArray: NativePointer, index: number): UObjectPointer {
    var FUObjectItem = GUObjectArray.add(OFFSET.GAME_FUObjectArray_TUObjectArray_OFFSET).readPointer();//定位到第一个chunk

var chunkIndex = Math.floor(index / 0x10000) * Process.pointerSize;
    var WithinChunkIndex = (index % 0x10000) * OFFSET.GAME_FUOBJECT_ITEM_SIZE;

var chunk = FUObjectItem.add(chunkIndex);
    var FUObjectItemObjects = chunk.readPointer();//定位到当前chunk的第一个位置

var UObjectBaseObject = FUObjectItemObjects.add(WithinChunkIndex).readPointer(); //这里直接返回Uobject
    return UObjectBaseObject;
}
```

在得到`UObejct`后就可以进一步开始解析，比如先解析得到所属类，这个对象名字。解析`FName`应该是很简单的事了·。

```js
    /**
     * 
     * @param obj 
     * @returns UClass* Returns the UClass that defines the fields of this object
     */
    getClass: function (obj: UObjectPointer) {
        var classPrivate = obj.add(OFFSET.offset_UObject_ClassPrivate).readPointer(); //得到所属类
        // console.log(`classPrivate: ${classPrivate}`);
        return classPrivate;
    },
        
    /**
     * 
     * @param GName 
     * @param obj 
     * @returns string Returns the logical name of this object
     */
    getName: function (GName: NativePointer, obj: UObjectPointer) {
        if (this.isValid(obj)) {
            return getFNameFromID(GName, this.getNameId(obj));
        } else {
            return "None";
        }
    },
```

在进一步之前，还需要了解更多的关键类。

## dumpSdk所需类

### UField

它继承自`UObject`，但仅仅只多一个`UField* Next`迭代指针，这个类主要是用于`UClass`等迭代方法

!<a href="elink@3ddK9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6&6M7X3W2F1k6#2)9J5k6r3#2W2i4K6u0W2L8%4y4K6i4K6u0V1j5$3&6Q4x3X3c8T1k6h3W2B7K9h3&6Y4i4K6u0W2j5h3I4A6P5i4g2F1j5%4y4Q4x3X3g2U0L8$3#2Q4x3V1k6@1k6i4y4@1i4K6u0r3x3U0l9J5y4o6l9^5x3e0p5I4z5e0t1J5y4U0V1H3i4K6u0W2M7r3&6Y4">image-20240723100142226</a>

### FField

在UE4.25以后，使用`UField`子集`FField`来描述属性信息，且`FField`没有继承任何一个类，这样大幅度减少了属性对象的占用。

```cpp
class FFieldClass
{
public:
    FName Name; //
    uint64_t Id;
    uint64_t CastFlags;
    uint64_t ClassFlags;
    FFieldClass *SuperClass;
    FField *DefaultObject;
};

class FFieldVariant
{
public:
    union FFieldObjectUnion
    {
        FField *Field;
        UObject *Object;
    } Container;
    uint64_t bIsUObject;
};

#pragma pack(4)
class FField
{
public:
    uint64_t VTable;
    FFieldClass *ClassPrivate; // 类名，用于区分FProperty类型
    FFieldVariant Owner;
    FField *Next;      // 指向下一个FField
    FName NamePrivate; // 属性名称
    uint32_t FlagsPrivate;
};
#pragma pack()
```

### FProperty

这个类继承`FField`，有更详细的信息描述

```cpp
class TEnumAsByte
{
public:
    uint8_t Value;
};
#pragma pack(8)
class FProperty : public FField
{
public:
    int32_t ArrayDim;             // 属性的维数
    int32_t ElementSize;          // 属性元素大小（属性整体大小为ElementSize*ArrayDim）
    EPropertyFlags PropertyFlags; // 属性Flag
    uint16_t RepIndex;
    TEnumAsByte BlueprintReplicationCondition;
    int32_t Offset_Internal; // 属性在结构体中的偏移
    FName RepNotifyFunc;
    FProperty *PropertyLinkNext;
    FProperty *NextRef;
    FProperty *DestructorLinkNext;
    FProperty *PostConstructLinkNext;
};
#pragma pack()
```

### UStruct

这个类比较重要，记录了成员、函数信息的指针，它继承于`UField`

主要关注Children，SuperStruct和ChildProperties

```cpp
class UStruct : public UField, private FStructBaseChain
{
public:
    UStruct *SuperStruct;    // 该结构体的超类
    UField *Children;        // 结构体中的方法
    FField *ChildProperties; // 结构体中的属性
    int32_t PropertiesSize;  // 属性占用大小
    int32_t MinAlignment;
    TArray<PVOID> Script;
    FProperty *PropertyLink;
    FProperty *RefLink;
    FProperty *DestructorLink;
    FProperty *PostConstructLink;
    TArray<PVOID> ScriptAndPropertyObjectReferences;
    TArray<PVOID> *UnresolvedScriptProperties;
    PVOID unknown;
};
```

![image-20240723101628057](upload/attach/202408/978803_8F4NGFCGF2S2ADB.png)

### UClass

这个类就是`UObject`中的成员，它继承`UStruct`，新增很多成员，不过实际使用的还是`UStruct`中已经定义的成员

![image-20240729203535618](upload/attach/202408/978803_G6A9Y5B53VK6GFA.png)

回顾一下，从`GUObjectArray`可以根据索引一步一步得到`UObject`，而`UObject`中又有`UClass`成员，它由继承自`UStruct`，那么从这个成员就可以得到`UStruct`，进一步得到    `UField *Children; // 结构体中的方法`和
    `FField *ChildProperties; // 结构体中的属性`

```js
export var UStruct = {
    /**
     * Struct this inherits from, may be null
     * @param structz
     * @returns UStruct*
     *  */
    getSuperClass: function (structz: UStructPointer) {//UStruct*
        // console.log(`UStruct.getSuperClass structz: ${structz}`);
        return structz.add(OFFSET.offset_UStruct_SuperStruct).readPointer()
    },

/**
     *  
     * @param structz
     * @returns UField* Children:该结构体的方法
     *  */
    getChildren: function (structz: UStructPointer) {//UField*
        // console.log(`UStruct.getChildren structz: ${structz}`);
        return structz.add(OFFSET.offset_UStruct_Children).readPointer();
    },

/**
     *  
     * @param structz 
     * @returns FField* ChildProperties:该结构体的属性
     */
    getChildProperties: function (structz: UStructPointer) {//FField*
        // console.log(`UStruct.getChildProperties structz: ${structz}`);
        return structz.add(OFFSET.offset_UStruct_ChildProperties).readPointer();
    },

getClassName: function (GName: NativePointer, clazz: UObjectPointer) {
        return UObject.getName(GName, clazz);
    },

/**
     *  getStructClassPath:获取当前所属类的完全类限定符
     *  */
    getClassPath: function (GName: NativePointer, object: UObjectPointer) {
        var clazz = UObject.getClass(object);
        var classname = UObject.getName(GName, clazz);
        var superclass = this.getSuperClass(clazz);
        while (UObject.isValid(superclass)) {
            if (classname == null)
                break;
            classname += ".";
            classname += UObject.getName(GName, superclass);

superclass = this.getSuperClass(superclass);
        }

return classname;
    },

/**
     *  getStructClassPath:获取当前的类完全类限定符
     *  */
    getStructClassPath: function (GName: NativePointer, clazz: UObjectPointer) {
        var classname = UObject.getName(GName, clazz);

var superclass = this.getSuperClass(clazz);
        while (UObject.isValid(superclass)) {
            if (classname == null)
                break;
            classname += ".";
            classname += UObject.getName(GName, superclass);

superclass = this.getSuperClass(superclass);
        }

return classname;
    }
}
```

##  FField *ChildProperties

得到` FField *ChildProperties`就可以根据具体的类型进行解析，在UE4中定义了许多具体的类型，如`FInterfaceProperty`，`FStructProperty`，`FEnumProperty`，`FIntProperty`等，他们均继承自`FField `

`FInterfaceProperty`

![image-20240729204945870](upload/attach/202408/978803_UVCSCNZU9VWP6NW.png)

`FStructProperty`

![image-20240729204757146](upload/attach/202408/978803_PNP8764GH9SMMGJ.png)

`FEnumProperty`

![image-20240729205045137](upload/attach/202408/978803_V5V97CC789F8PU8.png)

这些`Property`自身可能还会有字段比如`UStriptStruct* Struct`来进一步描述信息，也有可能仅依赖于`FProperty`而不需要新字段去描述信息。

实际上，在逆向中根据一步一步偏移得到的`FField`就已经是具体的每一个`Property`了，即通过这个函数

```js
    getChildProperties: function (structz: UStructPointer) {//FField*
        // console.log(`UStruct.getChildProperties structz: ${structz}`);
        return structz.add(OFFSET.offset_UStruct_ChildProperties).readPointer();
    },
```

得到的`FField`，要么已经是`FInterfaceProperty`，要么就是`FStructProperty`，总之是一种具体的类型。因此会在得到此指针后再增加一个`sizeof_FProperty`用于得到真正的`xproperty`

![image-20240729210426658](upload/attach/202408/978803_RMGHU2K3ZUEGB3J.png)

![image-20240729210441118](upload/attach/202408/978803_7ZYCFYVDFK784G7.png)

一些特殊`property`还多加了一个指针偏移，比如`FMapProperty`，则是有指针存储了不同信息

![image-20240729210637754](upload/attach/202408/978803_GU33TKEW32DHBA9.png)

![image-20240729210714428](upload/attach/202408/978803_HKRY7VPRDJQZEPS.png)

`FEnumProperty`则多存储了一个`UnderlyingProp`指针，需要加上这个指针大小才能指向`UEnum`

![image-20240729210856037](upload/attach/202408/978803_TUK3X8VJV5HS6AX.png)

![image-20240730092610660](upload/attach/202408/978803_MNMPDTPPMZT9PCJ.png)

而要在内存中区分这些`Property`，则依赖于`FField`中的字段` FFieldClass *ClassPrivate; // 类名，用于区分FProperty类型`。同样也能通过字段`FName NamePrivate`得到这个属性的名字

```js
export var FField = {
    /**
     * 
     * @param GName 
     * @param FField 
     * @returns Name of this field
     */
    getName: function (GName: NativePointer, FField: FFieldPointer) {
        return getFNameFromID(GName, FField.add(OFFSET.offset_FField_Name).readU32());
    },

/**
     * 
     * @param GName 
     * @param FField 
     * @returns  Name of the class object representing the type of this FField 
     */
    getClassName: function (GName: NativePointer, FField: FFieldPointer) {
        return getFNameFromID(GName, FField.add(OFFSET.offset_FField_Class).readPointer().readU32());
    },

/**
     * 
     * @param FField 
     * @returns UField* Next Field in the linked list
     */
    getNext: function (FField: FFieldPointer) {//UField*
        return FField.add(OFFSET.offset_FField_Next).readPointer();
    }
};
```

## property解析

在从`UStruct`得到`FField`后，就能通过`FField`中`FFieldClass *ClassPrivate`得到具体`property`类型，再强制转化为该`property`类型指针，这一强转正确性是由`FProperty`继承`FField`，而具体`property`又是`继承`自`FProperty`，相当于把父类指针强转为了子类指针。

### UEnum

`UEnum`继承自`UField`，`UField`则是继承自`UObject`，相比于`UObject`，`UField`仅仅是多了一个`UField* next`指针用于迭代，而`UEnum`相比于`UField`则是多了几个成员，其中最重要的是`TArray<TPair<FName, int64_t>> Names`，这是一个键值对，用于记录名字和值的对应。

![image-20240730094916263](upload/attach/202408/978803_W9GUTPC3H8ENKVR.png)

`TArray`是模板类，第一个成员是模板指针，第二第三个成员则分别描述当前有几个这样的模板指针，最大有多少个这样的模板指针。而这里的模板则是一个键值对。

```cpp
template <typename KeyType, typename ValueType>
struct TPair
{
    KeyType Key;
    ValueType Value;
};

class UEnum : public FField
{
public:
    FString CppType;
    TArray<TPair<FName, int64_t>> Names;
};

```

### ByteProperty

![image-20240730093944056](upload/attach/202408/978803_E4NVK8Q2QNERWSD.png)

从内存试图可以比较清楚得知`FByteProperty`仅仅只是比`FProperty`多一个`UENum*`指针，而关键也是要解析这个指针。第一步当然是要得到这个指针

```js
var enumObj = UByteProperty.getEnum(prop);

export var UByteProperty = {
    getEnum: function (prop: FFieldPointer) {
        return prop.add(OFFSET.offset_FProperty_size).readPointer();
    },
 	//得到类名字
    getName: function (Gname: NativePointer, prop: FFieldPointer) {
        return UObject.getName(Gname, this.getEnum(prop));
    }
}
//UEnum最终继承自UObject，自然是调用UObject的getName函数来解析名字
```

在得到`UEnum*`指针后就可以开始解析这个指针，也就是解析里面的`TArray`模板类，这也很简单。这里再贴出`TArray`定义

```cpp
template <typename ElementType>
class TArray
{
public:
    ElementType *Allocator;
    int32_t ArrayNum;
    int32_t ArrayMax;
};
```

大体步骤就是先得到`TArray<TPair<FName, int64_t>> Names`这个指针，读出他指向的数组起始地址，也就是一个个`TPair`组成的数组。通过数组元素大小即`TPair<FName, int64_t>`大小进行遍历，而元素数量上则是由

```js
var enumName = UByteProperty.getName(GName, prop);
        file.write(`\tenum ${enumName} ${thisFieldName} { //[Offset: ${ptr(FProperty.getOffset(prop))}, Size: ${FProperty.getElementSize(prop)}]\n`);

for (var count = 0; count < UEnum.getCount(enumObj); count++) {
            var index = UEnum.getNamesArray(enumObj).add(count * OFFSET.enumItemSize).readU32();
            var value = UEnum.getNamesArray(enumObj).add(count * OFFSET.enumItemSize + OFFSET.FName_Size).readU64();
            file.write(`\t\t${(getFNameFromID(GName, index) as string).replace(enumName + "::", "")} = ${value}\n`)
        }
        file.write("\t};\n")

export var UEnum = {
    /**
     * 
     * @param en UEnumPointer
     * @returns TArray<TPair<FName, int64_t>> Names
     */
    getNamesArray: function (en: UEnumPointer) {
        return en.add(OFFSET.offset_UEnum_Names).readPointer();
    },
    getCount: function (en: UEnumPointer) {
        return en.add(OFFSET.offset_UEnum_Count).readU32();
    }
}

//Class: UEnum
func = offset_so.findExportByName("get_UEnum_Names_Offset") as NativePointer;
getOffsets = new NativeFunction(func, 'int', []);
export var offset_UEnum_Names = getOffsets();
export var offset_UEnum_Count = offset_UEnum_Names + Process.pointerSize;
export var offset_UEnum_Max = offset_UEnum_Count + 4;

func = offset_so.findExportByName("get_UEnum_Names_Size") as NativePointer;
getOffsets = new NativeFunction(func, 'int', []);
export var enumItemSize = getOffsets();

```

### FMapProperty

对于一些符复合类型则可能需要走一下小递归，以`MapProperty`为例，他会有两个`FProperty`类型来分别描述`key`和`value`类型，这也就意味着如果需要知道`key`和`value`是什么类型，就必须再一次进行`FProperty`解析

```cpp
// FMapProperty
class FMapProperty : public FProperty
{
public:
    FProperty *KeyProp;
    FProperty *ValueProp;
    …………
};
```

这里以`resolveProp`来处理这种递归的解析

```js
else if (className === "MapProperty") {
            file.write(`\t<${resolveProp(GName, recurrce, UMapProperty.getKeyProp(prop))}, ${resolveProp(GName, recurrce, UMapProperty.getValueProp(prop))}> ${thiFieldName}; //[Offset: ${ptr(FProperty.getOffset(prop))}, Size: ${FProperty.getElementSize(prop)}]\n`);
        }
```

可以看到`resolveProp(GName, recurrce, UMapProperty.getKeyProp(prop))`就负责解析`key`的类型。而`resolveProp`大体上也是`Property`解析的流程

```js
export function resolveProp(GName: NativePointer, recurrce: UStructPointer[], prop: FPropertyPointer): string {
    if (prop == null) return "None";
    var className = FField.getClassName(GName, prop) as string;

if (UObjectPropertyList.includes(className)) {
        var propertyClass = UObjectProperty.getPropertyClass(prop);
        recurrce.push(...[propertyClass]);
        return UObject.getName(GName, propertyClass) + "*";
    }
    else if (MetaClassList.includes(className)) {
        var metaClass = UClassProperty.getMetaClass(prop);
        recurrce.push(...[metaClass]);
        return "class" + UObject.getName(GName, metaClass);
    }
    else if (className === "InterfaceProperty") {
        var interfaceClass = UInterfaceProperty.getInterfaceClass(prop);
        recurrce.push(...[interfaceClass]);
        return "interface class" + UObject.getName(GName, interfaceClass);
    }
    else if (className === "StructProperty") {
        var structClass = UStructProperty.getStruct(prop);
        recurrce.push(...[structClass]);
        return "struct" + UObject.getName(GName, structClass);
    }
    else if (className === "ArrayProperty") {
        return resolveProp(GName, recurrce, UArrayProperty.getInner(prop)) + "[]";
    }
    else if (className === "SetProperty") {
        return "<" + resolveProp(GName, recurrce, USetProperty.getElementProp(prop)) + ">";
    }
    else if (className === "MapProperty") {
        return "<" + resolveProp(GName, recurrce, UMapProperty.getKeyProp(prop)) + ", " + resolveProp(GName, recurrce, UMapProperty.getValueProp(prop)) + ">";
    }
    else if (className === "BoolProperty") {
        return "bool";
    }
    else if (className === "UByteProperty") {
        var enumObj = UByteProperty.getEnum(prop);
        return resolveProp_writeByteEnum(GName, enumObj);
    }
    else if (className === "IntProperty") {
        return "int";
    }
    else if (className === "Int8Property") {
        return "int8";
    }
    else if (className === "Int16Property") {
        return "int16";
    }
    else if (className === "Int64Property") {
        return "int64";
    }
    else if (className === "UInt16Property") {
        return "uint16";
    }
    else if (className === "UInt32Property") {
        return "uint32";
    }
    else if (className === "UInt64Property") {
        return "uint64";
    }
    else if (className === "FloatProperty") {
        return "float";
    }
    else if (className === "DoubleProperty") {
        return "double";
    }
    else if (className === "EnumProperty") {
        return resolveProp_writeEnumProperty(GName, prop);
    }
    else if (className === "StrProperty") {
        return "FString";
    }
    else if (className === "TextProperty") {
        return "FText";
    }
    else if (className === "NameProperty") {
        return "FName";
    }
    else if (className === "DelegateProperty" || className === "MulticastDelegateProperty") {
        return "delegate";
    }
    else {
        return FField.getName(GName, prop) + "(" + className + ")";
    }
}
```

其余的`Property`也是类似这样去解析即可。

## UFunction解析

除了类属性之外，还有类成员函数需要解析，这一步会简单许多，`UFunction`继承自`UStruct`，`UStruct`继承于`UField`，也就是说`UFunction`实际是继承于`UField`，这点与`property`继承于`FField`有所不同。

```cpp
class UFunction : public UStruct
{
public:
    EFunctionFlags FunctionFlags; // 函数属性
    uint16_t NumParms;            // 参数数量
    uint16_t ParmsSize;           // 参数大小
    uint16_t ReturnValueOffset;
    uint16_t RPCId;
    uint16_t RPCResponseId;
    FProperty *FirstPropertyToInit;
    UFunction *EventGraphFunction;
    int32_t EventGraphCallOffset;
    PVOID Func; // 函数指针
};
```

在`UStruct`中，也有字段存储`UField`

```cpp
class UStruct : public UField, private FStructBaseChain
{
public:
    UStruct *SuperStruct;    // 该结构体的超类
    UField *Children;        // 结构体中的方法
	…………
};
```

自然也是通过`UField`强转得到`UFuncion`指针。

既然`UFunction`最终继承自`UObject`，那么也自然是通过`UObject`得到函数名字

```ts
var thisFieldName = UObject.getName(GName, prop);
var className = UObject.getClassName(GName, prop);
```

在此之后则是通过类名字进行判断是否为函数

```js
 if (className?.startsWith("Function") || className === "DelegateFunction") 
```

如果是函数，则可以通过`UStruct`得到参数属性（`UStruct`继承自`UField`，故这里也是把`UField`给强转为了`UStruct`）

```js
var funcParmsProperties: FFieldPointer = UStruct.getChildProperties(prop);
```

那么参数解析自然走得就是之前`property`的解析步骤了。

当然`UE4`还定义了一些属性flag，用于标识函数类型或者参数类型，比如`native`函数，`out`型参数。

## 参考

1. <a href="elink@825K9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6Y4K9i4c8Z5N6h3u0Q4x3X3g2U0L8$3#2Q4x3V1k6Z5j5h3y4C8j5$3q4@1L8h3I4Q4x3V1k6X3M7X3W2V1j5g2)9J5k6s2g2W2y4r3c8#2L8i4l9`.">frida-ue4dumper</a>
2. <a href="elink@b25K9s2c8@1M7s2y4Q4x3@1q4Q4x3V1k6Q4x3V1k6%4N6%4N6Q4x3X3g2U0L8X3u0D9L8$3N6K6i4K6u0W2j5$3!0E0i4K6u0r3M7X3g2$3k6i4u0U0j5#2)9J5c8Y4m8Q4x3V1j5I4y4K6j5J5z5e0f1^5y4q4)9J5k6h3S2@1L8h3H3`.">ue4游戏逆向之GName内存解析（4.23版本及其以上)</a>
3. [[原创] UnrealEngine4恢复符号过程分析](https://bbs.kanxue.com/thread-278264.htm)

登录后可查看完整内容

传递专业知识、拓宽行业人脉——看雪讲师团队等你加入！！

最后于 2025-5-8 03:04 被yring编辑，原因：更正一个笔误

#调试逆向 #系统底层

最新回复 (8)
3cly 雪币： 225 活跃值： (802) 能力值： ( LV2，RANK：10 ) 在线值：发帖 0 回帖 25 粉丝 2 关注私信	3cly 2 楼顶顶顶 2025-1-24 14:45 0
littlepotato 雪币： 1 活跃值： (641) 能力值： ( LV2，RANK：10 ) 在线值：发帖 14 回帖 163 粉丝 1 关注私信	littlepotato 3 楼大佬，这个结构或者类的内存视图是vs里的哪个工具？没用过这个工具 2025-3-20 01:36 0
夺命黑裤衩雪币： 23 活跃值： (676) 能力值： ( LV2，RANK：10 ) 在线值：发帖 5 回帖 28 粉丝 5 关注私信	夺命黑裤衩 4 楼被大佬讲透了，屌 2025-4-25 01:44 0
K4NG 雪币： 533 活跃值： (2548) 能力值： ( LV2，RANK：10 ) 在线值：发帖 3 回帖 175 粉丝 1 关注私信	K4NG 5 楼 littlepotato 大佬，这个结构或者类的内存视图是vs里的哪个工具？没用过这个工具同问这个工具似乎很好用可以计算出每个成员偏移对于修复魔改过的应该会很方便 2025-5-21 10:27 0
K4NG 雪币： 533 活跃值： (2548) 能力值： ( LV2，RANK：10 ) 在线值：发帖 3 回帖 175 粉丝 1 关注私信	K4NG 6 楼 FInterfaceProperty FStructProperty FEnumProperty FIntProperty 均继承自FField ❌ (应该是FProperty) FInterfaceProperty 截图 FStructProperty ❌ 2025-5-22 15:01 0
yring 雪币： 201 活跃值： (225) 能力值： ( LV2，RANK：10 ) 在线值：发帖 1 回帖 3 粉丝 13 关注私信	yring 7 楼 K4NG FInterfaceProperty FStructProperty FEnumProperty FIntProperty 均继承自FField ❌ (应该是FProperty) FInterfac ... 感谢指正，工具是VS自带的，我的VS版本是2022，似乎只支持C/C++，只要把鼠标放在类名上就会有一个”内存布局“的东西，点这个就能看了 2025-5-23 15:55 0
yring 雪币： 201 活跃值： (225) 能力值： ( LV2，RANK：10 ) 在线值：发帖 1 回帖 3 粉丝 13 关注私信	yring 8 楼 littlepotato 大佬，这个结构或者类的内存视图是vs里的哪个工具？没用过这个工具踢踢，工具是VS自带的 2025-5-23 15:55 0
Imxz 雪币： 112 活跃值： (9435) 能力值： ( LV2，RANK：10 ) 在线值：发帖 6 回帖 754 粉丝 9 关注私信	Imxz 9 楼 tql 2026-2-23 11:15 0
	游客登录 \| 注册方可回帖回帖表情雪币赚取及消费高级回复