[linux] lire clavier et ecrire console

Soyez le premier à donner votre avis sur cette source.

Vue 9 605 fois - Téléchargée 408 fois

Description

je vais certainement me faire lynché de poster un code aussi basic mais je prend le risque pour ceux qui comme moi
on decidé d'essayer de comprendre l'asm
ce code lit ce que vous entrez et l'affiche ensuite

Source / Exemple :


; Instruction de compilation : 
; NASM -f elf hello_world.asm
; ld -o hello_world hello_world.o

segment .data				; variables initialisées constantes
	buflen: db 1024                 ; taille du buffer
segment .bss
	buf:		resb	1024    ; buffer
segment .text				; équivalent de main() mais c'est pas une fonction
	global _start

_start:					; programme en lui même
	
	mov eax,3			;syscall 3 => read
	mov ebx,0			; 0 => lit le clavier
	mov ecx,buf			;dans quoi on stock
	mov edx,buflen			;taille du buffer
	int 80h				;on execute en appelant la syscall
	mov eax,4			;syscall 4 => write
	mov ebx,1			;1 => STDOUT
	mov ecx,buf			; ecrire quoi ? buf
	mov edx,buflen			;taille
	int 80h				;appel de syscall
	mov eax,1			; 1 => exit
	mov ebx,0			; 0 code de sortie
	int 80h				;fin ^^

Conclusion :


petite note :
voila pour certain cela paraitra logique mais bon ....
eax => syscall appelé
ebx => argument 1
ecx => argument 2
edx => argument 3

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

_dune2_
Messages postés
141
Date d'inscription
mercredi 19 juillet 2006
Statut
Membre
Dernière intervention
20 avril 2011
-
salut,
merci pour cette précision.
En fait j'ai oublié de mettre les indicateurs de segment, c'est pourquoi les data se trouve en début du segment de code (et c'est pas beau du tout !! :) surtout si on gère le bit de protection d'écriture et execution des zones mémoires !!!).

Mais je garde l'astuce de mettre les variables en fin de code, pour des embryons de test.

dune2.
cs_patatalo
Messages postés
1466
Date d'inscription
vendredi 2 janvier 2004
Statut
Modérateur
Dernière intervention
14 février 2014
1 -
salut,



le probleme est que tu dois specifier l'offset de debut de desassemblage avec ndisasm car sinon, il commence a 0x00000080 au lieu de 0x00000084.

etant donné que tu a un dword data a 0x00000080, ndisasm le prends comme faisant partie du code si non spécifié et tu te retrouve avec:
00000080 000000 add truc,bidule
00000083 00BA80800408 add [edx+0x8048080],bh
00000089 8B1580800408 mov edx,[0x8048080]

ce code serait correctement désassemblé par ndisasm:
_start:
mov edx,monadresse
mov edx,[monadresse]

mov edx,monadresse
mov edx,[edx]

mov eax,1
mov ebx,0
int 80h

monadresse: dd 0

je me rappelle plus l'option pour specifier l'offset ou commencer le desassemblage, "ndisasm" tout court dans une console doit te l'afficher.

@++
_dune2_
Messages postés
141
Date d'inscription
mercredi 19 juillet 2006
Statut
Membre
Dernière intervention
20 avril 2011
-
re :)

Aprés plusieurs essais, ... je reste perplexe :)
Je ne sais plus vraiement où se cache la vérité ....
Je m'explique :
- Code d'exemple :

monadresse: dd 0
_start:
mov edx,monadresse
mov edx,[monadresse]

mov edx,monadresse
mov edx,[edx]

mov eax,1
mov ebx,0
int 80h

Et voilà le désassemblage de nasm (ndisasm -b32) :

00000083 00BA80800408 add [edx+0x8048080],bh <- décalage de 1 byte ....
démarrage @00000084 = "mov edx,0x8048080"
00000089 8B1580800408 mov edx,[0x8048080]
0000008F BA80800408 mov edx,0x8048080
00000094 8B12 mov edx,[edx]
00000096 B801000000 mov eax,0x1
0000009B BB00000000 mov ebx,0x0
000000A0 CD80 int 0x80

Ce qui semble tout à fait exact.
Maintenant avec objdump :

8048084: ba 80 80 04 08 mov $0x8048080,%edx <- @ de départ correct
8048089: 8b 15 80 80 04 08 mov 0x8048080,%edx
804808f: ba 80 80 04 08 mov $0x8048080,%edx
8048094: 8b 12 mov (%edx),%edx
8048096: b8 01 00 00 00 mov $0x1,%eax
804809b: bb 00 00 00 00 mov $0x0,%ebx
80480a0: cd 80 int $0x80

Mais à priori une subtilité dans la notation porte à confusion, l'absence de '$' devant une adresse semble indiquer la présence d'un pointeur vers la valeur ....

Ceci explique ma confusion ... et donc confirme que l'utilisation de "mov edx,[buflen] est tout à fait correct, et j'en prend note ;)

Merci pour cette mise au point ;)
cs_patatalo
Messages postés
1466
Date d'inscription
vendredi 2 janvier 2004
Statut
Modérateur
Dernière intervention
14 février 2014
1 -
re,



c'est bien de nasm que l'on parle ?

mov edx,buflen -> edx = adresse de la variable buflen
mov edx,[buflen] -> edx = valeur dword a l'adresse buflen

si tu obtient la meme chose au desassemblage, verifie que tu n'ai pas compilé deux fois la meme chose.

tiré de la doc de nasm (Writing 32bits code):

At the other end of the process, to call a C function from your assembly code, you would do something like this:


extern _printf

; and then, further down...

push dword [myint] ; one of my integer variables
push dword mystring ; pointer into my data segment
call _printf
add esp,byte 8 ; `byte' saves space

; then those data items...

segment _DATA

myint dd 1234
mystring db 'This number -> %d <- should be 1234',10,0

@++
sheorogath
Messages postés
2465
Date d'inscription
samedi 21 février 2004
Statut
Modérateur
Dernière intervention
29 janvier 2010
11 -
woaw merci a tous !!!
je vais tout reprendre alors :s

merci encore
bonne soiree

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.