[Assembleur x86] Opcode et calcul d'opcode + Création d'un outil.

[Kiwazaru]

Salut à tous

Bon, à l'arrivée de la rentrée, j'ai trouvé un petit projet sur les opcodes.
Vous le savez, une opcode c'est autrement dit une "autre forme" de voir un PUSH 5 par exemple, ainsi on aussi l'instruction 6A 05 qui signifie PUSH (6A) et son argument 5 (05), un opcode est donc foutu en Hexadecimal et est traduit en binaire pour être interprété par le processeur.
Alors pour un push c'est facile, il suffit d'avoir l'opcode de base de l'instruction et de traduire son argument en Hexadecimal. Mais pour un CALL ou un JMP ou d'autres calculs plus compliqués, je bloque un peu. Par exemple, je vois que CALL 00000000 vaut E8 7F0553FF. Cela, serait donc l'opcode de base pour une adresse 00000000. En augmentant de 1, donc 00000001 on voit que l'opcode change: 800553FF
On augmente encore un peu plus: pour 00000002 : 810553FF.
On voit donc une incrémentation, alors 7F0553FF est-il l'opcode de base sur lequel il faut se baser, ou alors cela est situationnel, en fonction d'un calcul ou autre?

Plus étrange encore:

CPU Disasm
Address Hex dump Command Comments
00ACFA49 |.-/75 06 JNE SHORT 00ACFA51

JNE (75) 00ACFA51 (06). Avec un seul octet il arrive à nous définir une adresse de 99999999 possibilités.

J'aimerais savoir si quelqu'un aurait plus d'information à ce sujet et en discuter sur ce post

Code PYTHON :


#!/usr/bin/python2.7

# OpCode

hexa = "0123456789ABCDEF"  # Pour afficher l'opcode
opcode =  [["ADD", "ADD", "ADD", "ADD", "ADD", "ADD", "ES PUSH SS", "ES POP SS", "OR", "OR", "OR", "OR", "OR", "OR", "CS PUSH DS", "TWO BYTE"],
          ["ADC", "ADC", "ADC", "ADC", "ADC", "ADC", "ES PUSH SS", "ES POP SS", "SBB", "SBB", "SBB", "SBB", "SBB", "SBB", "CS PUSH DS", "POP DS"],
          ["AND", "AND", "AND", "AND", "AND", "AND", "ES SEGMENT OVERRIDE SS", "DAA", "SUB", "SUB", "SUB", "SUB", "SUB", "SUB", "CS SEGMENT OVERRIDE DS", "DAS"],
          ["XOR", "XOR", "XOR", "XOR", "XOR", "XOR", "ES SEGMENT OVERRIDE SS", "AAA", "CMP", "CMP", "CMP", "CMP", "CMP", "CMP", "CS SEGMENT OVERRIDE DS", "AAS"],
          ["INC", "INC", "INC", "INC", "INC", "INC", "INC", "INC", "DEC", "DEC", "DEC", "DEC", "DEC", "DEC", "DEC", "DEC"],
          ["PUSH", "PUSH", "PUSH", "PUSH", "PUSH", "PUSH", "PUSH", "PUSH", "POP", "POP", "POP", "POP", "POP", "POP", "POP", "POP"],
          ["PUSHAD", "POPAD", "BOUND", "ARPL", "FS", "GS", "OPERAND SIZE", "ADDRESS SIZE", "PUSH", "IMUL", "PUSH", "IMUL", "INS", "INS", "OUTS", "OUTS"],
          ["JO", "JNO", "JB", "JNB", "JE", "JNE", "JBE", "JA", "JS", "JNS", "JPE", "JPO", "JL", "JGE", "JLE", "JG"],
          ["ADD/ADC/AND/XOR/OR/SBB/SUB/CMP", "ADD/ADC/AND/XOR/OR/SBB/SUB/CMP", "ADD/ADC/AND/XOR/OR/SBB/SUB/CMP", "ADD/ADC/AND/XOR/OR/SBB/SUB/CMP", "TEST", "TEST", "XCHG", "XCHG", "MOV REG", "MOV REG", "MOV REG", "MOV REG", "MOV SREG", "LEA", "MOV SREG", "POP"],
          ["NOP/XCHG EAX", "XCHG EAX", "XCHG EAX", "XCHG EAX", "XCHG EAX", "XCHG EAX", "XCHG EAX", "XCHG EAX", "CWD", "CDQ", "CALLF", "WAIT", "PUSHFD", "POPFD", "SAHF", "LAHF"],
          ["MOV EAX", "MOV EAX", "MOV EAX", "MOV EAX", "MOVS", "MOVS", "CMPS", "CMPS", "TEST", "TEST", "STOS", "STOS", "LODS", "LODS", "SCAS", "SCAS"],
          ["MOV", "MOV", "MOV", "MOV", "MOV", "MOV", "MOV", "MOV", "MOV", "MOV", "MOV", "MOV", "MOV", "MOV", "MOV", "MOV"],
          ["SHIFT IMM", "SHIFT IMM", "RETN", "RETN", "LES", "LDS", "MOV IMM", "MOV IMM", "ENTER", "LEAVE", "RETF", "RETF", "INT3", "INT IMM", "INTO", "IRETD"],
          ["SHIFT 1/ROL/ROR/RCL/RCR/SHL/SHR/SAL/SAR", "SHIFT 1/ROL/ROR/RCL/RCR/SHL/SHR/SAL/SAR", "SHIFT CL/ROL/ROR/RCL/RCR/SHL/SHR/SAL/SAR", "SHIFT CL/ROL/ROR/RCL/RCR/SHL/SHR/SAL/SAR", "AAM", "AAD", "SALC", "XLAT", "FPU", "FPU", "FPU", "FPU", "FPU", "FPU", "FPU", "FPU"],
          ["LOOPNZ", "LOOPZ", "LOOP", "JECXZ", "IN IMM", "IN IMM", "OUT IMM", "OUT IMM", "CALL", "JMP", "JMPF", "JMP SHORT", "IN DX", "IN DX", "OUT DX", "OUT DX"],
          ["LOCK", "ICE BP", "REPNE", "REPNE", "REPE", "REPE", "HLT", "CMC", "TEST/NOT/NEG/MUL/DIV", "TEST/NOT/NEG/MUL/DIV", "CLC", "STC", "CLI", "STI", "CLD", "STD", "INC DEC", "INC/DEC/CALL/JMP/PUSH"]]# Double dimension

op = raw_input("Opcode: ").upper()
if len(op) == 2:
    print "Opcode == " + opcode[hexa.find(op[0])][hexa.find(op[1])]
   
raw_input()
 

Il vous chie l'instruction correspondant à l'opcode rentré. Je me suit basé sur un tableau à double dimension en prenant exemple sur un document très bien foutu: http://net.cs.uni-bonn.de/fileadmin/user...erview.pdf

Mon but final étant de réussir à extraire du code Assembleur d'un exécutable avec mon script

[supersnail]

Bonjour,

Le calcul des sauts/calls sont relatifs à l'instruction du saut.

Par exemple l'instruction E8 00000000 va faire un saut à l'instruction à 0 octets de E8 00000000, autrement dit tu vas faire une fonction qui va se call indéfiniment :>

Bref globalement pour calculer l'adresse à foutre dans un jump à partir d'une adresse absolue, la formule c'est:

(adresse de destination - adresse du jump + taille de l'instruction)

Donc pour faire le calcul "inverse" avec ton JNE, ça te fait 00ACFA49 (adresse du jump) + 6 (décalage) + 2 (octets pris par l'opcode 0x75) soit 00ACFA51

[gruik]

Avec un seul octet il arrive à nous définir une adresse de 99999999 possibilités.

de fait t'as pas 99999999 possibilités, c'est un jump relatif donc tu peux sauter dans un intervalle [-127;128] par rapport à l'adresse courante comme l'a expliqué supersnail
c'est tout le propos des jmp short/near/far

[ark]

Have fun:
http://www.c-jump.com/CIS77/CPU/x86/lecture.html