C++ Исходник Простой x86 Length Disassembler

[wlux.net]

namespace ts::util::native
{
    struct opcode
    {
        u8 code;
        u8 prefix;
        ptr_n length;
    };

    class length_disassembler
    {
    public:
        ptr_n disassemble(const u8* data)
        {
            return lookup(data).length;
        }

    private:
        const opcode& lookup(const u8* data) const
        {
            // at least tell me some info
            if (win::is_bad_read_ptr(data, 1))
            {
                DBG_THROW("Failed to read upstream code at %p", data);
            }

            const auto prefix = *(data++);
            const auto code = *data;

            for (const auto& op : opcodes)
            {
                if (op.prefix == prefix)
                {
                    if (op.code == code)
                        return op;
                }
            }

            const auto op = std::find_if(opcodes.begin(), opcodes.end(), [prefix](const opcode& op) {
                return op.code == prefix;
            });

            // useful for development process
            if (op == opcodes.end())
            {
                DBG_THROW("Opcode was not found: %X %X ...", prefix, code);
            }

            return *op;
        }

        std::vector<opcode> opcodes = {
                // single byte
                { 0xD9, 0x00, 6 },
                { 0xE8, 0x00, 5 },
                { 0xE9, 0x00, 5 },
                { 0xA1, 0x00, 5 },
                { 0x85, 0x00, 2 },
                { 0x55, 0x00, 1 },
                { 0x53, 0x00, 1 },
                { 0x64, 0x00, 1 },
                { 0x57, 0x00, 1 },
                { 0x6A, 0x00, 2 },
                { 0x51, 0x00, 1 },
                { 0x56, 0x00, 1 },

                // 80
                { 0x3D, 0x80, 7 },

                // 83
                { 0xE4, 0x83, 3 },
                { 0xEC, 0x83, 3 },
                { 0xB9, 0x83, 7 },

                // 8B
                { 0xEC, 0x8B, 2 },
                { 0x0D, 0x8B, 6 },
                { 0xDC, 0x8B, 2 },
                { 0x55, 0x8B, 3 },
                { 0xF9, 0x8B, 2 },
                { 0x07, 0x8B, 2 },
                { 0x80, 0x8B, 6 },
                { 0x45, 0x8B, 3 },

                // 0F
                { 0xB7, 0x0F, 7 }
        };
    };

    inline length_disassembler dis_asm{};
}

Кратко про кодстайл:
u8 - unsigned char
ptr_n - uintptr_t / unsigned int

Подходит для детур хуков, использую в одном своем CS:GO чите. Добавлять опкоды достаточно легко:
{ опкод, префикс, длина }

опкод - основной байт опкода
префикс - префикс, для mov/jmp это 8B или 0F. 00 озночает, что префикса нет
длина - полная длина инструкции

Проще всего посмотреть длину инструкции можно в IDA или любом другом дизассемблере

 

[Type 00000]

Выглядит очень интересно, но мне не хватает компетенции для понимания всего кода...

 

[mj12]

Ого, крутая штука, впервые вижу такое и только здесь нашёл