瓦Fname解密分享

xiatianwl

#include "GetNamePool.h"
#define HIDWORD(x) ((uint32_t)(((uint64_t)(x) >> 32) & 0xFFFFFFFF)) // 宏：从 64 位值中提取高 32 位
#define _DWORD unsigned int // 宏别名：将 _DWORD 当作 unsigned int 使用

// 内联函数：对 64 位值执行右循环移位（rotate right）
inline uint64_t ROR64(uint64_t value, unsigned int count) {
        return (value >> count) | (value << ((64 - count) & 63));
}
// 内联函数：对 64 位值执行左循环移位（rotate left）
inline uint64_t ROL64(uint64_t value, unsigned int count) {
        return (value << count) | (value >> ((64 - count) & 63));
}

// 强制内联：根据输入的 32 位 key 和长度为 7 的 state 数组生成解密用的 64 位值
__forceinline uint64_t decrypt_xor_keys(const uint32_t key, const uint64_t* state) {
        // 通过常数乘和位操作混淆 key，生成种子 v3
        uintptr_t v3 = 0x2545F4914F6CDD1D * (key ^ ((key ^ (key >> 15)) >> 12) ^ (key << 25));
        // v4 为 v3 对 7 取模的结果，用作 state 数组索引
        uint32_t v4 = (uint32_t)(v3 % 7);
        // 从 state 中取出对应索引的值 v5
        uintptr_t v5 = state[v4];
        // v6 为 v3 的高 32 位（使用 HIDWORD 宏）
        uintptr_t v6 = HIDWORD(v3);
        // v7 再次保存 v4 % 7（与 v4 相同，保留逆向原貌）
        uint32_t v7 = (uint32_t)(v4 % 7);
        // 若干临时变量，供后续分支计算使用
        uintptr_t v26 = 0;
        uintptr_t v27 = 0;
        uintptr_t v28 = 0;
        uintptr_t v29 = 0;
        // 以下为多个分支，根据 v4/v7 的不同对 v5 进行不同的位运算变换
        if (v4 == 7 * (v4 / 7)) // 判断 v4 是否为 7 的倍数（风格化表达）
        {
                // 一系列复杂的位运算与掩码操作，用于混淆/变换 v5
                uintptr_t v8 = ((((v6 - 1) + v5) >> 1) ^ ((((v6 - 1) + v5) >> 1) ^ (2 * ((v6 - 1) + v5))) & 0xAAAAAAAAAAAAAAAAui64) >> 2;
                uintptr_t v9 = v8 ^ (v8 ^ (4
                        * ((((v6 - 1) + v5) >> 1) ^ ((((v6 - 1) + v5) >> 1) ^ (2 * ((v6 - 1) + v5))) & 0xAAAAAAAAAAAAAAAAui64))) & 0xCCCCCCCCCCCCCCCCui64;
                uintptr_t v10 = (v9 >> 4) ^ ((v9 >> 4) ^ (16 * v9)) & 0xF0F0F0F0F0F0F0F0ui64;
                // 将 v10 的字节重新排列并右旋 32 位
                v5 = ROR64((v10 >> 8) ^ ((v10 >> 8) ^ (v10 << 8)) & 0xFF00FF00FF00FF00ui64, 32);
                goto LABEL_5; // 跳转到共享处理段
        }
        if (v7 != 1)
        {
LABEL_5:
                // 如果 v7 不等于 2，则跳转到 LABEL_16 进行其它处理
                if (v7 != 2)
                        goto LABEL_16;
                // 当 v7 == 2 时，执行另一套混淆算法
                uintptr_t v11 = ~(v6 + 2 * v4) ^ v5;
                uintptr_t v12 = ((v11 >> 1) ^ ((v11 >> 1) ^ (2 * v11)) & 0xAAAAAAAAAAAAAAAAui64) >> 2;
                uintptr_t v13 = v12 ^ (v12 ^ (4 * ((v11 >> 1) ^ ((v11 >> 1) ^ (2 * v11)) & 0xAAAAAAAAAAAAAAAAui64))) & 0xCCCCCCCCCCCCCCCCui64;
                uintptr_t v14 = (v13 >> 4) ^ ((v13 >> 4) ^ (16 * v13)) & 0xF0F0F0F0F0F0F0F0ui64;
                v5 = ROR64((v14 >> 8) ^ ((v14 >> 8) ^ (v14 << 8)) & 0xFF00FF00FF00FF00ui64, 32);
                goto LABEL_7;
        }
        // 当 v7 == 1 的情况，使用带有可变移位量的移位/轮换操作处理 v5
        v5 = ((v5 ^ ~(v6 + 2 * v4)) << (((v6 + v4) % 0x3Fu) + 1)) | ((v5 ^ ~(v6 + 2 * v4)) >> (63 * ((v6 + v4) / 0x3Fu)
                - (v6
                        + v4)
                + 63));
LABEL_16:
        // 如果 v4 % 7 不等于 3，就进入 LABEL_7 的处理路径
        if (v4 % 7 != 3)
        {
LABEL_7:
                // 如果 v4 % 7 不等于 4，则跳转到 LABEL_18
                if (v4 % 7 != 4)
                        goto LABEL_18;
                // 当 v4 % 7 == 4 时，使用另一套变换（混合移位/轮换）
                v5 = (((v6 + 2 * v4) + v5) << (63 * ((v6 + v4) / 0x3Fu) - (v6 + v4) + 63)) | (((v6 + 2 * v4) + v5) >> (((v6 + v4) % 0x3Fu) + 1));
                goto LABEL_9;
        }
        // 当 v4 % 7 == 3 时，使用序列化位块拆分与拼装的操作
        v26 = ((v5 >> 1) ^ ((v5 >> 1) ^ (2 * v5)) & 0xAAAAAAAAAAAAAAAAui64) >> 2;
        v27 = v26 ^ (v26 ^ (4 * ((v5 >> 1) ^ ((v5 >> 1) ^ (2 * v5)) & 0xAAAAAAAAAAAAAAAAui64))) & 0xCCCCCCCCCCCCCCCCui64;
        v28 = v27 >> 4;
        v29 = ((v28 ^ (v28 ^ (16 * v27)) & 0xF0F0F0F0F0F0F0F0ui64) >> 8) ^ (((v28 ^ (v28 ^ (16 * v27)) & 0xF0F0F0F0F0F0F0F0ui64) >> 8) ^ ((v28 ^ (v28 ^ (16 * v27)) & 0xF0F0F0F0F0F0F0F0ui64) << 8)) & 0xFF00FF00FF00FF00ui64;
        // 将构造的 v29 与其高 32 位拼接并按动态移位量轮换
        v5 = (((v29 << 32) | HIDWORD(v29)) >> (63 * ((v6 + v4) / 0x3Fu) - (v6 + v4) + 63)) | (((v29 << 32) | HIDWORD(v29)) << (((v6 + v4) % 0x3Fu) + 1));
LABEL_18:
        // 当 v4 % 7 == 5 的情形，使用带加法与轮换的处理
        if (v4 % 7 == 5)
        {
                v5 = (v6 + v4)
                        + ((v5 >> (((v6 + 2 * v4) % 0x3Fu) + 1)) | (v5 << (63 * ((v6 + 2 * v4) / 0x3Fu) - (v6 + 2 * v4) + 63)));
                goto LABEL_11;
        }
LABEL_9:
        // 当 v4 % 7 == 6 时，先取反再按动态移位量轮换
        if (v4 % 7 == 6)
        {
                uintptr_t v15 = ~(v6 + 2 * v4) ^ v5;
                v5 = (v15 >> (((v6 + v4) % 0x3Fu) + 1)) | (v15 << (63 * ((v6 + v4) / 0x3Fu) - (v6 + v4) + 63));
        }
LABEL_11:
        // 最终结果与原始 key 做 XOR 并返回
        uintptr_t v16 = v5 ^ key;
        return v16;
}

// 从内存中读取 state 数组并返回解密后的 FNameKey
uintptr_t GetFNameKey(uintptr_t base) {

        uintptr_t state[7]{}; // 声明 7 个元素的 state 数组并初始化为 0
        for (int i = 0; i < 7; i++) {
                // 从驱动或进程内存读取 state[i]，偏移基于 Val.Base + Offsets::FnameState
                state[i] = Driver:read<uintptr_t>(Val.Base + Offsets::FnameState + i * sizeof(uintptr_t));
        }
        // 读取位于 state 区之后的 key（偏移 0x38）
        uintptr_t key = Driver:read<uintptr_t>(Val.Base + Offsets::FnameState + 0x38);
        // 调用解密函数并返回解密结果
        return decrypt_xor_keys(key, state);
}


// 根据 FName 索引读取并解密名称字符串
std::string GetFName(int key)
{

        static uintptr_t cachedNameKey = 0; // 静态缓存，用于避免重复计算/读取密钥
        if (!cachedNameKey)
                cachedNameKey = getfnamekey(PasPas::Base); // 第一次调用时获取密钥（注意函数名/符号应一致）

        // 计算 chunk 索引（高 16 位）和在 chunk 内的偏移（低 16 位）
        uint32_t chunkOffset = (uint32_t)((int)(key) >> 16);
        uint16_t nameOffset = (uint16_t)key;
        // 读取名字池中对应 chunk 的基地址
        uint64_t namePoolChunk = Driver:read<uint64_t>((std::uintptr_t)(PasPas::Base + Offsets::FNamePool + ((chunkOffset + 2) * 8)));
        // 计算具体条目的偏移
        uint64_t entryOffset = namePoolChunk + (uint64_t)(4 * nameOffset);
        // 从内存读取 FNameEntry 结构
        FNameEntry nameEntry = Driver:read<FNameEntry>(entryOffset);
        // 如果长度异常（太长），返回占位符
        if (nameEntry.Header.Len > 55) return "None";


        // 构造 std::string，复制 AnsiName 字节
        std::string name(nameEntry.AnsiName, nameEntry.Header.Len);

        // 对每个字节执行异或解密：使用长度与从 decrypt_xor_keys 地址派生的字节作为密钥
        for (std::uint16_t i = 0; i < nameEntry.Header.Len; i++) {
                BYTE b = i & 3; // 取低 2 位作为索引
                name[i] ^= nameEntry.Header.Len ^ *((LPBYTE)&decrypt_xor_keys + b); // 异或解密
        }

        return name; // 返回解密后的名字
}

// 缓存层：通过 ID 查找名称，如果未缓存则从内存读取并缓存
std::string getNameFromID(std::uint32_t id) {

        auto it = std::find_if(fnamesids.begin(), fnamesids.end(), [id](const idnames& elem) {
                return elem.id == id; // 查找相同 id 的缓存项
                });

        if (it != fnamesids.end()) {

                return it->name; // 找到则直接返回缓存名
        }
        else {

                std::string finalname = GetFName(id); // 否则读取并解密名字

                idnames newIdName; // 构造新的缓存条目
                newIdName.id = id;
                newIdName.name = finalname;
                fnamesids.push_back(newIdName); // 将新条目加入缓存

                return finalname; // 返回新获取的名称
        }

}
另出
  瓦内部 DX11内绘 对接SDK文件 游戏更新只需要更新几个SDK文件即可
  功能：骨骼透视 内存自瞄 射线判断 漏打



联系我时，请说是在 挂海论坛 上看到的，谢谢！