Referencia de Opcode Intel x86?

Si bien el Manual del Desarrollador de Software de Intel en sí no es muy conveniente para buscar, las tablas de opcode en este manual podrían ayudar. Eche un vistazo al Apéndice A "Opcode Map" en el volumen 2B del manual, podría ser útil.

Aquí hay una imagen bastante bonita. No entra en muchos detalles, pero si solo necesita buscar un valor hexadecimal muy rápido, esto debería hacerlo-

Fuente: http://pnx.tf/files/x86_opcode_structure_and_instruction_overview.png

Una referencia rápida para buscar opcodes es sandpile. Necesito dos clics para averiguar qué hace 0xc8 (es enter, por cierto).

También existe el proyecto asmjit/asmdb, que proporciona una base de datos de dominio público X86/X64 en un formato similar a JSON (en realidad es un módulo de nodo, solo require() desde el nodo o inclúyalo en el navegador). Está diseñado para un procesamiento adicional (por ejemplo, para escribir validadores, ensambladores, desensambladores), pero también es muy fácil abrir el archivo de base de datos y explorarlo.

AsmDB viene con una herramienta llamada x86util.js, que puede indexar la base de datos x86 en mucho más amigable representación que puede usarse para hacer algo con ella. Vamos a escribir una herramienta simple en el nodo.js que imprime todas las instrucciones que tienen el mismo byte de opcode que usted proporciona:

const asmdb = require("asmdb");
const x86isa = new asmdb.x86.ISA();

function printByOpCode(opcode) {
  x86isa.instructions.forEach(function(inst) {
    if (inst.opcodeHex === opcode) {
      const ops = inst.operands.map(function(op) { return op.data; });
      console.log(`INSTRUCTION '${inst.name} ${ops.join(", ")}' -> '${inst.opcodeString}'`);
    }
  });
}

if (process.argv.length < 3)
  console.log("USAGE: node x86search.js XX (opcode)")
else
  printByOpCode(process.argv[2]);

Pruébalo:

$ node x86search.js A9
INSTRUCTION 'pop gs' -> '0F A9'
INSTRUCTION 'test ax, iw' -> '66 A9 iw'
INSTRUCTION 'test eax, id' -> 'A9 id'
INSTRUCTION 'test rax, id' -> 'REX.W A9 id'
INSTRUCTION 'vfmadd213sd xmm, xmm, xmm/m64' -> 'VEX.DDS.LIG.66.0F38.W1 A9 /r'
INSTRUCTION 'vfmadd213sd xmm, xmm, xmm/m64' -> 'EVEX.DDS.LIG.66.0F38.W1 A9 /r'
INSTRUCTION 'vfmadd213ss xmm, xmm, xmm/m32' -> 'VEX.DDS.LIG.66.0F38.W0 A9 /r'
INSTRUCTION 'vfmadd213ss xmm, xmm, xmm/m32' -> 'EVEX.DDS.LIG.66.0F38.W0 A9 /r'

$ node x86search.js FF
INSTRUCTION 'call r32/m32' -> 'FF /2'
INSTRUCTION 'call r64/m64' -> 'FF /2'
INSTRUCTION 'dec r16/m16' -> '66 FF /1'
INSTRUCTION 'dec r32/m32' -> 'FF /1'
INSTRUCTION 'dec r64/m64' -> 'REX.W FF /1'
INSTRUCTION 'fcos ' -> 'D9 FF'
INSTRUCTION 'inc r16/m16' -> '66 FF /0'
INSTRUCTION 'inc r32/m32' -> 'FF /0'
INSTRUCTION 'inc r64/m64' -> 'REX.W FF /0'
INSTRUCTION 'jmp r32/m32' -> 'FF /4'
INSTRUCTION 'jmp r64/m64' -> 'FF /4'
INSTRUCTION 'push r16/m16' -> '66 FF /6'
INSTRUCTION 'push r32/m32' -> 'FF /6'
INSTRUCTION 'push r64/m64' -> 'FF /6'

Además, hay herramientas de línea de comandos que se pueden usar para un desmontaje rápido y sucio, pero requieren toda la instrucción (en contraste con tener solo el byte de opcode), aquí hay algunos consejos:

Usando llvm-mc de LLVM proyecto:

$ echo "0x0f 0x28 0x44 0xd8 0x10" | llvm-mc -disassemble -triple=x86_64 -output-asm-variant=1
.text
movaps xmm0, xmmword ptr [rax + 8*rbx + 16]

Usando ndisasm de nasm proyecto:

$ echo -n -e '\x0f\x28\x44\xd8\x10' | ndisasm -b64 -
00000000 0F2844D810 movaps xmm0,oword [rax+rbx*8+0x10]

También hay un proyecto AsmGrid del mismo autor que AsmDB. Es un explorador AsmDB en línea de trabajo en curso que utiliza colores para visualizar varias propiedades de cada instrucción.

Otra manera, usando un depurador (gdb, windbg, ollydbg,...) o desensamblador (IDA), y luego, establecer secuencias de bytes en la región de memoria de escritura. Finalmente, desmontaje en la dirección inicial de las secuencias de bytes.
Es costura complicada, pero útil en algunas situaciones cuando se agrieta/marcha atrás.

Sandpile es probablemente lo que estás buscando. Aún así, la mejor manera de ver la codificación x86 no es en hexadecimal, sino en octal. De repente x86 no se ve tan feo y tiene algún sentido. La explicación clásica de esto es de Usenet alt.lang.asm circa 1992:

Http://reocities.com/SiliconValley/heights/7052/opcode.txt