Discussion :

[b4u]

Bonsoir,
est-ce que quelqu'un pourrait me donner la ou les instructions qui permettent d'appeler une fonction, ainsi que celles pour retourner d'une fonction, en assembleur i386?
Je bosse sur un programme en C qui doit me permettre de reconnaitre des appels de fonctions, a partir d'une suite d'octets en entrée. Si vous avez des infos sur la structure des opcodes correspondants (et la convention pour la récupération des arguments) je suis preneur
Merci d'avance

[Scarmatil]

Appeler une fonction ? Tu veux dire CALL/RET ?
Si c'est bien ça ce que tu cherches, voilà ce que la doc NASM donne:
(Et la convention de récupération des arguments varie selon le langage utilisé, voilà un récapitulatif : http://www.codeproject.com/cpp/calli...emystified.asp )

CALL
Usage: CALL dest Modifies flags: None
Pushes Instruction Pointer onto stack and loads Instruction Pointer with the address of proc-name.
Code continues with execution at EIP upon RET.
Call Subroutine

CALL imm ; E8 rw/rd [8086]
CALL imm:imm16 ; o16 9A iw iw [8086]
CALL imm:imm32 ; o32 9A id iw [386]
CALL FAR mem16 ; o16 FF /3 [8086]
CALL FAR mem32 ; o32 FF /3 [386]
CALL r/m16 ; o16 FF /2 [8086]
CALL r/m32 ; o32 FF /2 [386]

CALL calls a subroutine, by means of pushing the current instruction pointer (IP) and optionally CS as well on the stack, and then jumping to a given address.

CS is pushed as well as IP if and only if the call is a far call, i.e. a destination segment address is specified in the instruction. The forms involving two colon-separated arguments are far calls; so are the CALL FAR mem forms.

The immediate call takes one of two forms (call imm16/imm32, determined by the current segment size limit. For 16-bit operands, you would use CALL 0x1234, and for 32-bit operands you would use CALL 0x12345678. The value passed as an operand is a relative offset.

You can choose between the two immediate call forms (CALL imm:imm) by the use of the WORD and DWORD keywords:
CALL WORD 0x1234:0x5678) or CALL DWORD 0x1234:0x56789abc.

The CALL FAR mem forms execute a far call by loading the destination address out of memory. The address loaded consists of 16 or 32 bits of offset (depending on the operand size), and 16 bits of segment. The operand size may be overridden using:
CALL WORD FAR mem or CALL DWORD FAR mem.

The CALL r/m forms execute a call (within the same segment), loading the destination address out of memory or out of a register. The keyword NEAR may be specified, for clarity, in these forms, but is not necessary. Again, operand size can be overridden using CALL WORD mem or CALL DWORD mem.

RET
Usage: RET nBytes Modifies flags: None
RETF nBytes
RETN nBytes
Transfers control from a procedure back to the instruction address saved on the stack. 'n bytes' is an optional number of bytes to release. Far returns pop the EIP followed by the CS, while near returns pop only the IP register.
Return from Procedure Call

RET ; C3 [8086]
RET imm16 ; C2 iw [8086]

RETF ; CB [8086]
RETF imm16 ; CA iw [8086]

RETN ; C3 [8086]
RETN imm16 ; C2 iw [8086]

RET, and its exact synonym RETN, pop EIP from the stack and transfer control to the new address. Optionally, if a numeric second operand is provided, they increment the stack pointer by a further imm16 bytes after popping the return address.

RETF executes a far return: after popping EIP, it then pops CS, and increments the stack pointer by the optional argument if present.

[b4u]

Appeler une fonction ? Tu veux dire CALL/RET

je n'appelle pas la fonction moi-meme, il faut juste que je sois capable de reconnaitre puis désassembler un appel de fonction, à partir d'un flux d'octets que je reçois en entrée (idem pour les retours d'appels). Tu me confirmes que CALL/RET est la seule possibilité?
Pour ça, j'ai besoin de connaitre le codage et la structure de l'instrution:

CALL imm:imm32 ; o32 9A id iw [386]
CALL FAR mem32 ; o32 FF /3 [386]
CALL r/m32 ; o32 FF /2 [386]

J'ai gardé que les lignes qui évoquent l'archi i386, mais si je comprends bien,
les opcodes sont les octets 0x9A et 0xFF c'est bien cela?
Que représentent o32, id, iw, FF /3 et FF /2 dans l'explication des modes d'adressages?
Merci encore =)

[Scarmatil]

Il n'y a en asm que CALL/RET pour appeler une fonction, ceci-dit cela reste des sauts donc un JMP suffirait pour faire la même chose, donc ça dépends si ce qui sort de ton flux d'octet vient d'un compilateur ou d'un petit rigolo s'amuse à écrire des programme tordus

Sinon, en gros o32, id, iw indiquent les tailles des opérandes et d'encodage,
Pour les détails et pour éviter de dire n'importe quoi je te renvoit au manuel de nasm : http://nasm.sourceforge.net/doc/html/nasmdocb.html

[Blustuff]

On ne peut pas trouver dans un flot d'octet si une suite d'octet est un saut ou non, simplement parce que l'opcode que vous aurez trouvé peut très bien être un morceau d'immediate ou d'adresse.

iw signifie "immediate word"
id "immediate double-word"
o16 j'imagine que c'est pour dire "quand la taille d'adressage est 16bits" ce qui est étrange puisque a priori j'aurais dit o pour opérand pas pour adresse...
/3 signifie que dans l'octet suivant, le champs reg contiiendra 3 (extension d'opcode)
idem pour /2

[b4u]

Scarmatil> Oui bonne remarque, en effet Je vais donc supposer que les sources du binaire à désassembler on été écrites en langage de haut niveau, donc il ne devrait pas contenir de hacks du style de ceux que tu décris

Blustuff> Tout à fait, désolé, j'ai oublié de préciser que j'aurais systématiquement en entrée des opcodes valides (le processus à désassembler est configuré pour se lancer en pas-à-pas, et ne me rend la main qu'avant d'exécuter une instruction, que je traite; puis je repasse le jeton au processus tracé, et ainsi de suite).
Pour le reste, c'est toujours pas très clair mais je devrais m'en sortir avec la doc de NASM et à coups de débuggeur...

Merci à vous deux!