Chargement de fichier

[velus]

Bonjour a tous,

J'aimerai bien réaliser un petit programme en assembleur, son utilité serait de retourner entièrement un petit fichier hexadécimal de max 64Ko, il serait chouette si on pourrait l'utiliser de cette façon impec.exe progaretourner.bin -re
Je ne connais pas grand chose à l'assembleur sur PC. J'ai bien fait des recherches sur le net on parle des int 21h... Pas facile sans des exemples concrets.Si quelqu'un sait m'aider. Merci pour votre aide

[Forthman]

Ni une ni deux, je te refiles mon exercice d'info...

[velus]

Et bien voila, j'ai acheté un livre pas loin des 60 euros et dedans il y a une routine intéressante pour charger un fichier en memoire comme je veux le probleme c'est que ca va pas quelqu'un sait m'aider et trouver les bugs ?


alors il dit
size permet de retourner soit la taille totale du fichier si aucune lecture n'est faite, soit le nombre d'octets lus
path pointe vers une chaine de caracteres contenant le chemin du fichier
fptr pointe vers un descripteur de zone de memoire
off pointe vers le premier octet a charger a l'interieur du fichier

j'ai assemble le tout avec fasm et ça bloque sur OFF

Code asm :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
DOSread:
        push eax ebx ecx edx edi esi
        mov edi,[.fptr]
        mov edx,[.path]
        or edx,edx
        je .error
        mov ax,[edx+2]
        mov dx,[edx+0]
        push ds
        or ax,ax
        je @f
        mov ds,ax
@@:
        mov ax,3d00h
        int 21h
        pop dx
        jc .error
        or edi,edi
        je .close
        mov bx,ax
        mov ah,42h
        mov al,0
        mov cx,[.off+2]
        mov dx,[.off]
        int 21h
        jc .error
        mov ax,[edi+2]
        mov dx,[edi+0]
        mov ecx,[edi+4]
        push ds
        or ax,ax
        je @f
        mov ds,ax
@@:
        mov ah,3fh
        int 21h
        pop ds
        jc .error
        movzx eax,ax
        mov [edi+fptr.size],eax
 
@@:     
        mov ah,3eh
        int 21h
        jc .error
 
.end:
        pop esi edi edx ecx ebx eax
        ret
.close:
        call .id
        jmp @b
.error:
        mov dword[.size],0
        jmp .end
 
.id :   mov ah,42h
        mov al,2
        mov cx,0
        mov dx,0
        int 21h
        mov word[.size],ax
        mov word[.size+2],dx
        ret
.off dd 4000h
.size dd 4000h
.path dd c:\pouet.bin
.fptr dd 4000h

[golden boy]

Tu n'aurais pas oublié des deux-points ':' après ton .off, .path etc. ?

[velus]

Et bien j'ai enlevé les parentheses a path ligne 3 ainsi qu a off et off+2 et modifié la variable db pour le nom je ne sais pas si c'est la bonne solution en tout cas j'ai réussi a compiler le prog, j'aimerai bien voir s'il fonctionne comment je dois faire pour voir s'il a bien charger mon programme test.bin en 0030h:4000h ? j'ai essayé avec debug du dos option d 0030:4000 j'ai pas ce qui faut ou est l'erreur ?

Code asm :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
DOSread:
	push eax ebx ecx edx edi esi
	mov edi,[.fptr]
	mov edx,.path
	or edx,edx
	je .error
	mov ax,[edx+2]
	mov dx,[edx+0]
	push ds
	or ax,ax
	je @f
	mov ds,ax
@@:
	mov ax,3d00h
	int 21h
	pop dx
	jc .error
	or edi,edi
	je .close
	mov bx,ax
	mov ah,42h
	mov al,0
	mov cx,.off+2
	mov dx,.off
	int 21h
	jc .error
	mov ax,[edi+2]
	mov dx,[edi+0]
	mov ecx,[edi+4]
	push ds
	or ax,ax
	je @f
	mov ds,ax
@@:
	mov ah,3fh
	int 21h
	pop ds
	jc .error
	movzx eax,ax
	mov [edi+8000h],eax
 
@@:	
	mov ah,3eh
	int 21h
	jc .error
 
.end:
	pop esi edi edx ecx ebx eax
	ret
.close:
	call .id
	jmp @b
.error:
	mov dword[.size],0
	jmp .end
 
.id:	
	mov ah,42h
	mov al,2
	mov cx,0
	mov dx,0
	int 21h
	mov word[.size],ax
	mov word[.size+2],dx
	ret
 
.off dd 0030h:4000h
.size dd 0030h:4000h
.path db "c:\test.bin"
.fptr dd 0030h:4000h

[edfed]

Envoyé par velus

Code :

sont des pointeurs pour la plupart.

.off sert à indiquer l'adresse de debut de lecture dans le fichier, ici, tu lis à partir du 4000hième octet.

.path doit pointer vers un pointeur de chaine, car l'interruption 21h, avec ax=3d00h attend le pointeur ds:dx vers une chaine de caractère asciiz.

.fptr pointe vers une structure fptr indiquant la zone de mémoire à charger et sa taille.

.size n'est pas utilisé en entrée, il est utilisable en sortie donc, pas besoin de l'initialiser.

au final, il faut ecire ça

Code :

1
2
3
4
5
6
7
8
9
 
.off: dd 0;pour lire dès le premier octet
.size: dd ?;
.path: dd chemin; indique le pointeur de chaine
.fptr: dd ram;
 
ram: dd 30h:4000h,0ffffh;
chemin: dd 0:fichier
fichier: db "c:/pouet.bin",0

pour tester, tu peux essayer ceci:

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
 
 
        org 100h
        call DOSread
        push es 0b800h
        pop es
        mov si,buffer
        mov di,0
        mov ah,67h
@@:
        lodsb
        cmp al,0
        je @f
        stosw
        jmp @b
@@:
        pop es
        ret
fptr:
.off=0
.seg=2
.size=4
DOSread:
        push eax ebx ecx edx edi esi
        mov edi,[.fptr]
        mov edx,[.path]
        or edx,edx
        je .error
        mov ax,[edx+fptr.seg]
        mov dx,[edx+fptr.off]
        push ds
        or ax,ax
        je @f
        mov ds,ax
@@:
        mov ax,3d00h
        int 21h
        pop dx
        jc .error
        or edi,edi
        je .close
        mov bx,ax
        mov ah,42h
        mov al,0
        mov cx,[.off+2]
        mov dx,[.off]
        int 21h
        jc .error
        mov ax,[edi+fptr.seg]
        mov dx,[edi+fptr.off]
        mov ecx,[edi+fptr.size]
        push ds
        or ax,ax
        je @f
        mov ds,ax
@@:
        mov ah,3fh
        int 21h
        pop ds
        jc .error
        movzx eax,ax
        mov [edi+fptr.size],eax
 
@@:     
        mov ah,3eh
        int 21h
        jc .error
 
.end:
        pop esi edi edx ecx ebx eax
        ret
.close:
        call .id
        jmp @b
.error:
        mov dword[.size],0
        jmp .end
 
.id :   mov ah,42h
        mov al,2
        mov cx,0
        mov dx,0
        int 21h
        mov word[.size],ax
        mov word[.size+2],dx
        ret
.off:   dd 0
.size:  dd 0
.path:  dd chemin
.fptr:  dd zone
 
zone    dd 0:buffer,1000
chemin  dd 0:fichier
fichier db "c:/pouet.inc",0
buffer: rb 1000

et normalement, ça marche.

[velus]

Merci pour la solution

Je viens de tester ça, je ne retrouve pas mon fichier pouet.inc en memoire ou est-il exactement ? Est-ce qu'il a bien été chargé ? Désolé je suis vraiment novice sur l'assembleur

[edfed]

ici, le premier octet du fichier chargé en mémoire est à l'adresse buffer:, tout à la fin du code, dans le segment DS qui pointe au meme endroit que le segment CS ( ES et SS egalement) car c'est un executable DOS .com.


la routine d'affichage de l'exemple pointe sur buffer:, qui est aussi l'adresse de chargement du fichier.

le fait que le contenu du fichier s'affiche signifie qu'il est chargé en mémoire, sinon, il ne s'afficherait rien du tout ou n'importe quoi.

[velus]

Salut j'ai bien compris que ca devrait etre en 1000 mais moi je ne trouve aucun octet chargé, comment je fais pour être sur que c'est dedans. J'ai fait des tests avec debug du dos

je tape debug d pour desassembler

d 1000 rien pas les bons octets
d 0000:1000 rien pas les bons octets
d 1000:1000 rien pas les bons octets

ou est-il alors ?

[edfed]

Code :

1
2
 
buffer: rb 1000 ;reserver 1000 octets à l'adresse buffer.

ici, buffer, c'est un symbole (une etiquette) qui sera transformé par le compilo en une adresse et il vaut 01E5h (le buffer est à la fin du fichier, qui fait 0E5h octets de long, et est chargé à 100h dans le segment ds (org 100h) donc buffer est egal à 1E5h.


donc, le premier octet du fichier chargé sera à l'adresse [DS:1E5h], qui est en fait le buffer de 1000 octets, donc [ds:buffer]

[velus]

Pourquoi pas ! Je constate bien que le programme fait E5 de longueur ça ok mais pour le reste j'ai toujours le meme probleme ou sont les données je ne retrouve rien en memoire meme pas les octets du programme ? Ce n'est pas possible j'ai fait une recherche avec WINEXE de la ram et rien. Si je lance debug je tape quoi pour voir ma zone. Je comprends rien ça devrait pas etre si compliqué quand meme !

d 1000:1e5 ???

[edfed]

le seul bon moyen de voir ta ram, ici, ça serait d'utiliser une routine d'affichage, ce qui est déja le cas, ou un vrai debugger. parce que bon, debug de dos, ou winexe laissent à desirer.

quoi qu'il en soit, si tu arrives à voir le contenu de ton fichier sur l'ecran, en gris sur fond orange, alors c'est bien chargé en mémoire, là où on lui à dit de le mettre, à l'adresse buffer, dans le segment ds.

d 1000:E5 est erroné dans deux sens.

primo, le premier champ (1000) doit être la valeur du segment DS, qui n'est surement pas égal à 1000h, mais serait plutot defini à la volée par le système.

E5 aussi est erroné, car le fichier executable est chargé dans le segment à partir de 100h, donc, il faut ajouter 100h à 0E5h, soit 1E5h.

n'utilisant pas debug, je ne saurait te dire comment recuperer la valeur du segment DS du programme. mais ça ne doit pas etre bien dur.

peut etre d DS:1E5 ?

peut etre qu'en utilisant une routine de convertion binaire->hexadecimal, tu pourrais afficher la valeur du segment DS et l'adresse de buffer.
avec ce code, tu veras la valeur de ces deux words en haut de l'ecran. prêts à copier dans la commande debug.

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
 
        org 100h
        call DOSread
        call debug
        push es 0b800h
        pop es
        mov si,buffer
        mov di,0
        mov ah,67h
@@:
        lodsb
        cmp al,0
        je @f
        stosw
        jmp @b
@@:
        pop es
        ret
debug:
        push eax ebx ecx edx
        mov ax,ds
        call wordtohexa
        mov [buffer],eax
        mov byte[buffer+4],':'
        mov ax,buffer
        call wordtohexa
        mov [buffer+5],eax
        pop edx ecx ebx eax
        ret
wordtohexa:
        mov bx,ax
        shr ax,8
        call @f
        xchg bx,ax
        call @f
        shl eax,16
        mov ax,bx
        ret
 
@@:
        mov ah,al
        and al,0fh
        call @f
        xchg al,ah
        shr al,4
@@:
        cmp al,10
        cmc
        sbb dl,dl
        and dl,7
        add al,dl
        add al,'0'
        ret    
 
fptr:
.off=0
.seg=2
.size=4
DOSread:
        push eax ebx ecx edx edi esi
        mov edi,[.fptr]
        mov edx,[.path]
        or edx,edx
        je .error
        mov ax,[edx+2]
        mov dx,[edx+0]
        push ds
        or ax,ax
        je @f
        mov ds,ax
@@:
        mov ax,3d00h
        int 21h
        pop dx
        jc .error
        or edi,edi
        je .close
        mov bx,ax
        mov ah,42h
        mov al,0
        mov cx,[.off+2]
        mov dx,[.off]
        int 21h
        jc .error
        mov ax,[edi+2]
        mov dx,[edi+0]
        mov ecx,[edi+4]
        push ds
        or ax,ax
        je @f
        mov ds,ax
@@:
        mov ah,3fh
        int 21h
        pop ds
        jc .error
        movzx eax,ax
        mov [edi+fptr.size],eax
 
@@:     
        mov ah,3eh
        int 21h
        jc .error
 
.end:
        pop esi edi edx ecx ebx eax
        ret
.close:
        call .id
        jmp @b
.error:
        mov dword[.size],0
        jmp .end
 
.id :   mov ah,42h
        mov al,2
        mov cx,0
        mov dx,0
        int 21h
        mov word[.size],ax
        mov word[.size+2],dx
        ret
.off:   dd 0
.size:  dd 0
.path:  dd chemin
.fptr:  dd zone
zone    dd 0:buffer,1000
chemin  dd 0:fichier
fichier db "c:\fool\shell.asm",0
buffer:

mais si je continue à te donner les solutions, tu ne vas pas progresser.

[velus]

Je vais essayer ce soir d'utiliser le segment DS pour mettre une valeur dedans comme ça je serai ou le programme est.

[velus]

Bon ça n'avance guère mes recherches

j'ai rajouté ces qq octets afin de charger mon programme dans une zone déterminée mais comment on fait pour le mettre en 0000:7000

mov ax,7000h
mov ds,ax

avec mon instruction ça doit se mettre en ????:7000

[edfed]

Envoyé par velus

Bon ça n'avance guère mes recherches

j'ai rajouté ces qq octets afin de charger mon programme dans une zone déterminée mais comment on fait pour le mettre en 0000:7000

mov ax,7000h
mov ds,ax

avec mon instruction ça doit se mettre en ???? :7000

si ds=7000h, l'adresse s'écrit 7000h???.

lorsque tu changes la valeur d'un registre de segment, tu ne change que la valeur d'un registre de segment, en aucun cas le contenu de la mémoire n'est déplacé ou copié.

le dos charge ton programme à un endroit ou l'allocateur de mémoire estime qu'il y a de la place et tu ne peux pas le changer ou le forcer, tu pourrais, à la limite, demander au dos de te donner une autre zone de ram ou lancer une autre copie du programme... mais là encore, tu ne peux pas forcer l'adresse de chargement, le dos l'interdit.
le seul interet de forcer le chargement est lors de la programmation d'os ou tu prend la main sur le dos pour faire tourner ton systeme en mode test, car un os, une fois booté, ne vois pas le dos, sauf s'il est un dos lui même.

donc, tu ne peux pas forcer ton programme à être à une adresse particulière juste en changeant la valeur de DS.


je pense que tu ne devrais pas bruler les étapes, et commencer par une longue série d'essais des divers mode d'adressages et instructions, il ne te reste plus qu'à commencer par le commencement, en affichant des caractère un par un, puis en copiant des caractères d'une zone de ram à une autre avant de l'afficher, puis en convertissant des chaines en nombres, des nombres en chaines, faire des boucles, et essayer de coder les fonction les plus elementaires.

parce que là, tu utilise du code assez complexe pour un debutant, sans même comprendre ce qu'il fait, tu n'es pas à l'abri d'une erreur fatale, du genre qui effacerait tout tes fichiers en ne changeant que quelques lignes de code au hazard par ci par là.

donc, je te reconseille une fois de plus de faire simple pour commencer, et petit à petit, lorsque tu auras assimilé le modèle mémoire et le fonctionnement du cpu, tu pourras passer à l'utilisation (et l'ecriture) de fonctions compliquées.

fais surtout des belles sauvegardes de ton code lorsqu'il marche bien, et dès que tu n'arrives plus à le faire fonctionner à cause des modifs, tu supprime tout, et tu restaures la dernière sauvegarde à la place.

[velus]

OK mais moi mon but c'est
1. Charger un ficher Ok
2. Le retourner comment je saurais le retourner si je ne connais pas l'adresse ou il est implanté ?
3. Le sauver

[edfed]

il est là:

Code :

1
2
3
4
 
.fptr:  dd zone
 
zone    dd 0:buffer,1000

ici, le segment à 0 signifie segment DS car dans le code:

Code :

1
2
3
4
5
6
7
8
 
        mov ax,[edx+fptr.seg] ;charger la partie segment du fptr
        mov dx,[edx+fptr.off]
        push ds ;sauver DS
        or ax,ax ;egal à 0?
        je @f    ;ouais, on saute par dessus
        mov ds,ax ;non, on charge ds avec la partie segment du fptr
@@:;mais si on à sauté par dessus, ds ne change pas

peut importe l'emplacement du fichier chargé, il faut comprendre l'adressage par pointeurs. au lieu de manipuler des adresses, tu manipules des pointeurs, ce qui est bien plus facile car un pointeur peut pointer où on veut, et etre modifié à chaud.