Référence de l'Opcode Intel x86?

Bien que le manuel du développeur de logiciels Intel lui-même ne soit certainement pas très pratique à rechercher, les tables d'opcodes de ce manuel pourraient aider. Jetez un oeil à L'Annexe A "Opcode Map" dans le volume 2B du manuel, cela pourrait être utile.

Voici un joli visuel. Ne va pas dans beaucoup de détails, mais si vous avez juste besoin de rechercher une valeur hexadécimale très rapidement, cela devrait le faire -

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

Une référence rapide pour rechercher des opcodes est sandpile . J'ai besoin de deux clics pour savoir ce que fait 0xc8 (c'est enter, btw).

Il y a aussiasmjit/asmdb projet, qui fournit le domaine public base de données X86/X64 dans un format de type JSON (c'est un module de nœud en fait, il suffit de le require() du nœud ou de l'inclure dans le navigateur). Il est conçu pour un traitement supplémentaire (par exemple pour écrire des validateurs, des assembleurs, des désassembleurs), mais il est également très facile d'ouvrir le fichier de base de données et de l'explorer.

AsmDB est livré avec un outil appelé x86util.js, qui peut indexer la base de données x86 en beaucoup plus convivial représentation qui peut être utilisée pour faire quelque chose avec. Écrivons un outil simple dans node.js qui imprime toutes les instructions qui ont le même octet d'opcode que vous fournissez:

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]);

Essayez-le:

$ 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'

De plus, il existe des outils de ligne de commande qui peuvent être utilisés pour un démontage rapide et sale, mais ceux-ci nécessitent toute l'instruction (contrairement à l'octet d'opcode), voici quelques conseils:

En utilisant llvm-mc à partir de LLVM projet:

$ 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]

Utiliser ndisasm à partir denasm projet:

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

Il y a aussi un projet AsmGrid du même auteur que AsmDB. C'est un explorateur asmdb en ligne en cours qui utilise des couleurs pour visualiser diverses propriétés de chaque instruction.

Une autre façon, en utilisant un débogueur (gdb, windbg, ollydbg,...) ou désassembleur (IDA), puis, définir des séquences d'octets dans la région de mémoire inscriptible. Enfin, le démontage à l'adresse de départ de ces séquences d'octets.
C'est une couture compliquée, mais utile dans certaines situations lorsque vous craquez/renversez.

Sandpile est probablement ce que vous cherchez. Pourtant, la meilleure façon de regarder l'encodage x86 n'est pas en hexadécimal mais plutôt en octal. Soudain, x86 n'a pas l'air si laid et cela a du sens. L'explication classique de ceci est de Usenet alt.lang.asm vers 1992:

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