[TASM] Détournement d'interruption

**adrien_najaque** · 10/05/2008, 23h17

Bonsoir à tous, je suis enseignant en math à la fac de toulouse, et j'ai repris mes études d'informatique en début d'année, j'ai déjà assez bien progréssé dans les langages de programmation (pascal, c) et là je suis bloqué devant un problème en Assembleur. La question me semblait très simple au début, mais bon... écrire une séquence assembleur qui déroute une interruption (le num d'it doit être saisi au clavier, j'ai déjà fait cette procédure), pour le déroutement je suis bloqué, si vous avez un moment, je vous prie de bien vouloir m'aider à régler le problème, merci d'avance.
PS: si vous avez des problèmes en algèbre ou en analyse n'hésitez pas à me contacter je me ferais une joie de vous aider !

**- Robby -** · 11/05/2008, 00h35

hé hé ...
détourner une interruption ? (hi)
Premier point capital ...
Sous quel OS devez-vous faire cela ?
Sous Windows ?
plusieurs processeurs ?

**dapounet** · 11/05/2008, 12h53

Il y a une fonction DOS pour ça, je ne connais pas bien la programmation 16 bits mais ce code a l'air de marcher :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
org 100h
use16
 
        push ds
 
        mov ah, 25h
        mov al, 34h  ; numéro de l'interruption à modifier
        push cs        ;
        pop ds         ; ds = segment de la nouvelle interruption
        mov dx, f    ; offset de la nouvelle interruption
        int 21h
 
        pop ds  ; restauration de DS
 
        int 34h  ; test de la nouvelle interruption
 
        mov ax, 4C00h
        int 21h
 
f:
        mov ah, 02h
        mov dl, 'A'
        int 21h
 
        iret

On peut aussi écrire directement dans la table des interruptions :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
org 100h
use16
 
        push ds
 
        xor ax, ax  ; DS est mis temporairement à zéro pour écrire dans le 
        mov ds, ax  ; premier segment
        mov ax, cs
 
        mov word[34h*4], f
        mov [34h*4 + 2], ax
 
        pop ds
 
        int 34h
 
        mov ax, 4C00h
        int 21h
 
f:
        mov ah, 02h
        mov dl, 'A'
        int 21h
 
        iret

**- Robby -** · 11/05/2008, 13h29

mais comment faites vous pour parler de DOS ?

Sous quel OS vous trouvez-vous pour parler d'interruption DOS ?

Votre PC ne se trouve-t-il pas sous un OS multi-tâches en mode protégé ?

Windows par exemple ?

Merci pour ta réponse Dapounet.

**dapounet** · 11/05/2008, 13h58

Ben l'assembleur n'est pas le langage le plus fashion donc beaucoup de profs utilisent encore l'ASM 16 bits sous DOS. Windows 32 bits émule encore très bien les programmes DOS avec NTVDM mais c'est pas vraiment le mieux pour s'y mettre (c'est dommage de devoir encore s'embarrasser avec l'adressage du 286 en 2008). Le gros problème que j'ai vu dans ma classe c'est que la grosse majorité des élèves n'aiment pas l'assembleur, donc ils n'ont pas fait l'effort de faire de l'ASM 32 bits chez eux, donc ils ne sauront sans doute jamais utiliser ce langage-là si un jour ils en ont besoin.

**- Robby -** · 11/05/2008, 17h52

Oui, compris.
Mais bon ... sous une émulation DOS, c'est juste pour le plaisir de "faire" un peu d'assembleur ... le résultat obtenu est inutilisable dans la réalité des PCs actuels. Dommage d'avoir si peu d'intérêt pour l'assembleur 32bits et sous OS multi-tâches. C'est un peu plus compliqué, mais quel plaisir ! Mais bon ... il faut "aimer", voir être passionné, je comprends.

**adrien_najaque** · 11/05/2008, 23h41

Merci pour votre aide, tout d'abord je travaille sous DOS, j'utilise tasm pour compiler, j'ai une autre solution à vous soumettre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
mov ax,0
mov ds,ax
mov ax,180 ;derouter l'it numero 180 par ex
mov opr,4
mul opr
mov bx,ax
mov [bx],new_ip   ;on peut la definir
mov [bx+2],new_cs ;  meme chose

voilÀ, pouvez-vous me dire si ma solution est correcte ou pas, j'ai essayé de la compiler, j'ai executé ensuitE je suis rentré sur le debug pour voir l'@ ip que j'avais défini mais j'ai pas su le faire

**- Robby -** · 12/05/2008, 00h22

Sous DOS avec TASM ? ... le Turbo Assembleur de Borlan ?
Ahhh ... ça c'était le bon vieux temps, j'en ai pris du plaisir avec tasm ! :-)
Bon, sous dos, dérouter une INT, c'est encore assez relax.
Sous Windows XP avec 2 processeurs derrière ... c'est une autre chanson, hi !
J'ai regardé ton code, l'idée est bonne. Tu peux remplacer ton "mul 4" par un shift left de 2. Pour le reste, je laisse la place au pro du dos et de l'assembleur 16bits ... j'ai oublié comment la gestion des INTs se passe sous dos, c'est trop loin. Le code machine disponible en asm 16 bits, je sais plus trop non plus. Mais à voir ton code, c'est dans ce sens là.

PS:

N'oublie pas de sauvegarder le vecteur d'interruption de départ ...
Le truc bien serait de tout replacer comme d'origine avant de quitter
ton programme. Tu déroutes ... et en final tu replaces.

**adrien_najaque** · 17/05/2008, 20h44

Voila j'ai términé mon pgme assembleur, pour résumer, il se compose de 3 proc, une qui lit puis converti un num d'interruption (de l'ascii vers le décimal), une autre qui fait le déroutement de cette IT vers des @ ip et cs (déclarées en tant que constantes), et puis la dernière qui se charge de la vérification du déroutement, voila le source:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
;TP architecture des microprocesseurs X86 16bits
;Par Adrien Najaque
;Objectif: déroutement d'une interruption 
 
DATA SEGMENT  ;Déclaration des variables
 
mes1 db '                   TP architecture des microprocesseurs X86 16bits',13,10,'$'
mes2 db '                                 par Adrien Najaque',13,10,'$'
mes3 db 'Veuillez inserer un numero d interruption :',13,10,'$'
mes4 db 'Deroutement effectue',13,10,'$'
mes5 db 'Appuyez sur ENTER pour proceder a la verification : ',13,10,'$'
mes6 db 'Verification termine avec succes',13,10,'$'
mes7 db 'Merci d avoir utilise mon programme a bientot'
mes8 db 'Echec de la vérification',13,10,'$'
sautln db 10,13,'$'
 
ch1 db 8 dup("$")
oldcs dw ?
oldip dw ?
newcs dw 2609h
newip dw 1988h
x dw ?                                               
 
DATA ENDS   ;Fin du data segment
 
 
 
CODE SEGMENT
 
assume cs:CODE, ds:DATA
 
 
;Procédure de saisie et de convertion de la chaine de caractères correspondant au numero d'intéruption 
 
 
convertion proc near
 
push ax bx cx dx
 
mov ah,09h  
lea dx,sautln
int 21h   ;Affichage
 
mov ah,09h  
lea dx,mes3
int 21h   ;Affichage d'un message 
 
mov ah,0ah
lea dx,ch1
int 21h   ;L'utilisateur doit saisir un numero d'IT     
 
xor cx,cx
xor si,si
mov si,1                                           
mov cl,[ch1+si]
inc si                                  
cmp cl,3
jz centaines                                                                 
 
cmp cl,2                                                          
jz disaines                                                                    
 
CMP cl,1
jz unites
 
unites:  ;Dans ce cas le nombre saisi ne contient qu'un seul chiffre     
 
xor ax,ax 
xor bx,bx                                                             
mov si,2                                                               
mov al,[ch1+si]                                                     
sub al,30h                                                                     
mov bl,1H
mul bl
mov bx,ax                                                                                                                                                                         
jmp ending   ;Sauter jusqu'à la fin de la procédure                                                                                          
 
disaines:   ;Dans ce cas le nombre saisi contient 2 chiffres
xor ax,ax 
xor bx,bx
xor cx,cx
mov si,2
mov al,[ch1+si]
sub al,30h
mov bl,10
mul bl
inc si
sub [ch1+si],30h
mov bx,ax
mov al,[ch1+si]
mov cl,1
mul cl
add bx,ax
jmp ending   ;Sauter jusqu'à la fin de la procédure
 
 
centaines:    ;Dans ce cas le nombre saisi contient 3 chiffres
xor ax,ax 
xor bx,bx
xor cx,cx
xor dx,dx
mov si,2
mov al,[ch1+si]
sub al,30h
mov bl,100
mul bl
mov bx,ax
inc si
XOR ax,ax
mov al,[ch1+si]
sub al,30h
mov cl,10
mul cl
add bx,ax
inc si
xor ax,ax
mov al,[ch1+si]
sub aL,30H
mov dl,1
mul dl
add bx,ax
jmp ending    ;Sauter jusqu'à la fin de la procédure
 
 
ending:    
mov x,bx      ;Copie du résultat de la convertion dans une variable                                                                                               
 
pop dx cx bx ax                                                                                                      
ret
convertion endp   ;Fin de la procédure     
 
 
;Procédure de déroutement de l'IT
 
deroutement proc NEAR
 
push ax bx cx dx
 
mov ax,4
mul x
xor cx,cx
mov cx,ax
mov ax,0
mov ds,ax
mov bx,cx
mov ax,[bx]
mov oldip,ax
mov ax,[bx+2]
mov oldcs,ax
xor cx,cx
mov ax,data
mov ds,ax
mov cx,newip
mov [bx],cx
xor cx,cx
mov cx,newcs
mov [bx+2],cx
 
mov ah,09h           
lea dx,mes4
int 21h  ;affichage 
 
pop dx cx bx ax
ret
deroutement endp
 
 
 
verif proc NEAR
 
push ax bx cx dx
mov ax,data
mov ds,ax
 
 mov ah,09h           
           mov dx,offset mes5
           int 21h  ;affichage erreur 
 
 
mov ax,4
mul x
MOV CX,AX
mov ax,0
mov ds,ax
mov bx,Cx
mov ax,[bx]
mov ax,data
mov ds,ax
cmp ax,oldip
jz vrip
 
jmp erreur
 
vrip: 
      mov cx,[bx+2]
      cmp cx,oldcs
      jz vrcs
jmp erreur
 
vrcs:
  mov ah,09h
 
           mov dx,offset mes6
           int 21h ;affichage 
 
jmp fin
 
erreur: 
 
  mov ah,09h           
           mov dx,offset mes8
           int 21h  ;affichage erreur
 
fin:
 
pop dx cx bx ax
 
ret
verif endp
 
 
 
 
;Programme principal
 
debut:
 
mov ax,data
mov ds,ax
 
mov cx,5
saut:
mov ah,09h  
lea dx,sautln
int 21h   ;Affichage
loop saut
 
mov ah,09h  
lea dx,mes1
int 21h   ;Affichage
 
mov ah,09h  
lea dx,sautln
int 21h   ;Affichage
 
mov ah,09h  
lea dx,mes2
int 21h   ;Affichage
 
call convertion     
 
call deroutement
 
call verif
 
mov ax,data
mov ds,ax
 
mov ah,09h
lea dx,mes7
int 21h  ;Affichage
 
mov ax,4c00h
int 21h  
 
CODE ends
 
end debut                  
 
;Fin du programme

voila le problème se pose dans la proc de vérification (enfain il me semble...) si vous pouvez jetter un coup d'oeuil dessus ça m'évitera de passer une nouvelle nuit blanche, merci d'avance!!!

**bpmfoukamoko** · 19/05/2008, 15h40

Bonjour,
J'ai décompilé un jar du java 1.3 puis j'ai une partie des fichiers tels que :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
ByteArrayOutputStream bStrm;
        bStrm = new ByteArrayOutputStream();
        responseString = "data :";
        responseString;
        JVM INSTR new #179 <Class StringBuffer>;
        JVM INSTR dup_x1 ;
        JVM INSTR swap ;
        String.valueOf();
        StringBuffer();
        "[";
        append();
        input.available();
        append();
        "]";

Qui a une idée sur ce que ça donne en Java, la partie affichée sous Assembleur ?
merci!

**Pascal_** · 19/05/2008, 17h22

Bonjour , juste une petite remarque , pourquoi dite vous deroutement ? ne dit on pas detournement d'interruption?
Je reviens sur la procedure de detournement d'interruption , j'ai ça à proposer :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
mov	ah,35h
mov	al,21h                              ; Detourne l'int 21h (dos)
int	21h			; DOS Services  ah=function 35h
				;  get intrpt vector al in es:bx

Donc ici on a dans es:bx le segment et l'offset de l'int 21h (dans votre programme on parametrera AL)
puis ...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
mov	cs:old_int,bx		; 
mov	word ptr cs:old_int+2,es	; sauvegarde dans old_int le segment et l'offset de l'int 21h qu'on va detourner
mov	ah,25h			
mov	al,21h			
lea	dx,new_int_21h_entry	; Load effective addr
int	21h			; DOS Services  ah=function 25h
				;  set intrpt vector al to ds:dx

Perso , je ne comprends pas trop ton programme ;-( pourquoi n'utilises-tu pas les interruptions DOS prévues à cet effet ? (je n'ai rien contre la modification de la table des vecteurs d'interruption directement mais bon ...)

Pourrais-tu m'envoyer par MP une version compilée, que je comprenne un peu mieux ?

Pour répondre à "bpmfoukamoko" , c'est une fonction Assembleur 128 bits qui permet d'afficher tous les mots de passe Windows ainsi que la taille des clusters de ta partion reiserfs pour finir par cette lign "input.available" qui t'indique si tes paquets udp sont bufférisés ou pas ;-) (attention le resultat ne sera pas en decimal mais en optodecimal).

**bouazza92** · 23/05/2008, 21h37

http://www.osdev.org/wiki/IVT

Après tu n'as qu'à modifier l'entrée dont t'as besoin, c'est plus simple ( à mon avis ) et t'évitera d'être dépendant de DOS

**dapounet** · 24/05/2008, 13h23

Envoyé par adrien_najaque

Voila j'ai términé mon pgme assembleur, pour résumer, il se compose de 3 proc, une qui lit puis converti un num d'interruption (de l'ascii vers le décimal), une autre qui fait le déroutement de cette IT vers des @ ip et cs (déclarées en tant que constantes), et puis la dernière qui se charge de la vérification du déroutement, voila le source:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
;TP architecture des microprocesseurs X86 16bits
;Par Adrien Najaque
;Objectif: déroutement d'une interruption 
 
DATA SEGMENT  ;Déclaration des variables
 
mes1 db '                   TP architecture des microprocesseurs X86 16bits',13,10,'$'
mes2 db '                                 par Adrien Najaque',13,10,'$'
mes3 db 'Veuillez inserer un numero d interruption :',13,10,'$'
mes4 db 'Deroutement effectue',13,10,'$'
mes5 db 'Appuyez sur ENTER pour proceder a la verification : ',13,10,'$'
mes6 db 'Verification termine avec succes',13,10,'$'
mes7 db 'Merci d avoir utilise mon programme a bientot'
mes8 db 'Echec de la vérification',13,10,'$'
sautln db 10,13,'$'
 
ch1 db 8 dup("$")
oldcs dw ?
oldip dw ?
newcs dw 2609h
newip dw 1988h
x dw ?                                               
 
DATA ENDS   ;Fin du data segment
 
 
 
CODE SEGMENT
 
assume cs:CODE, ds:DATA
 
 
;Procédure de saisie et de convertion de la chaine de caractères correspondant au numero d'intéruption 
 
 
convertion proc near
 
push ax bx cx dx
 
mov ah,09h  
lea dx,sautln
int 21h   ;Affichage
 
mov ah,09h  
lea dx,mes3
int 21h   ;Affichage d'un message 
 
mov ah,0ah
lea dx,ch1
int 21h   ;L'utilisateur doit saisir un numero d'IT     
 
xor cx,cx
xor si,si
mov si,1                                           
mov cl,[ch1+si]
inc si                                  
cmp cl,3
jz centaines                                                                 
 
cmp cl,2                                                          
jz disaines                                                                    
 
CMP cl,1
jz unites
 
unites:  ;Dans ce cas le nombre saisi ne contient qu'un seul chiffre     
 
xor ax,ax 
xor bx,bx                                                             
mov si,2                                                               
mov al,[ch1+si]                                                     
sub al,30h                                                                     
mov bl,1H
mul bl
mov bx,ax                                                                                                                                                                         
jmp ending   ;Sauter jusqu'à la fin de la procédure                                                                                          
 
disaines:   ;Dans ce cas le nombre saisi contient 2 chiffres
xor ax,ax 
xor bx,bx
xor cx,cx
mov si,2
mov al,[ch1+si]
sub al,30h
mov bl,10
mul bl
inc si
sub [ch1+si],30h
mov bx,ax
mov al,[ch1+si]
mov cl,1
mul cl
add bx,ax
jmp ending   ;Sauter jusqu'à la fin de la procédure
 
 
centaines:    ;Dans ce cas le nombre saisi contient 3 chiffres
xor ax,ax 
xor bx,bx
xor cx,cx
xor dx,dx
mov si,2
mov al,[ch1+si]
sub al,30h
mov bl,100
mul bl
mov bx,ax
inc si
XOR ax,ax
mov al,[ch1+si]
sub al,30h
mov cl,10
mul cl
add bx,ax
inc si
xor ax,ax
mov al,[ch1+si]
sub aL,30H
mov dl,1
mul dl
add bx,ax
jmp ending    ;Sauter jusqu'à la fin de la procédure
 
 
ending:    
mov x,bx      ;Copie du résultat de la convertion dans une variable                                                                                               
 
pop dx cx bx ax                                                                                                      
ret
convertion endp   ;Fin de la procédure     
 
 
;Procédure de déroutement de l'IT
 
deroutement proc NEAR
 
push ax bx cx dx
 
mov ax,4
mul x
xor cx,cx
mov cx,ax
mov ax,0
mov ds,ax
mov bx,cx
mov ax,[bx]
mov oldip,ax
mov ax,[bx+2]
mov oldcs,ax
xor cx,cx
mov ax,data
mov ds,ax
mov cx,newip
mov [bx],cx
xor cx,cx
mov cx,newcs
mov [bx+2],cx
 
mov ah,09h           
lea dx,mes4
int 21h  ;affichage 
 
pop dx cx bx ax
ret
deroutement endp
 
 
 
verif proc NEAR
 
push ax bx cx dx
mov ax,data
mov ds,ax
 
 mov ah,09h           
           mov dx,offset mes5
           int 21h  ;affichage erreur 
 
 
mov ax,4
mul x
MOV CX,AX
mov ax,0
mov ds,ax
mov bx,Cx
mov ax,[bx]
mov ax,data
mov ds,ax
cmp ax,oldip
jz vrip
 
jmp erreur
 
vrip: 
      mov cx,[bx+2]
      cmp cx,oldcs
      jz vrcs
jmp erreur
 
vrcs:
  mov ah,09h
 
           mov dx,offset mes6
           int 21h ;affichage 
 
jmp fin
 
erreur: 
 
  mov ah,09h           
           mov dx,offset mes8
           int 21h  ;affichage erreur
 
fin:
 
pop dx cx bx ax
 
ret
verif endp
 
 
 
 
;Programme principal
 
debut:
 
mov ax,data
mov ds,ax
 
mov cx,5
saut:
mov ah,09h  
lea dx,sautln
int 21h   ;Affichage
loop saut
 
mov ah,09h  
lea dx,mes1
int 21h   ;Affichage
 
mov ah,09h  
lea dx,sautln
int 21h   ;Affichage
 
mov ah,09h  
lea dx,mes2
int 21h   ;Affichage
 
call convertion     
 
call deroutement
 
call verif
 
mov ax,data
mov ds,ax
 
mov ah,09h
lea dx,mes7
int 21h  ;Affichage
 
mov ax,4c00h
int 21h  
 
CODE ends
 
end debut                  
 
;Fin du programme

voila le problème se pose dans la proc de vérification (enfain il me semble...) si vous pouvez jetter un coup d'oeuil dessus ça m'évitera de passer une nouvelle nuit blanche, merci d'avance!!!

Tu as mis directement les fonctions au début du segment de code donc a priori la première (convertion) va être exécutée et tomber sur le RET à la fin alors qu'il n'y a pas eu d'appel, donc ça va retourner à l'adresse qui se trouve sur la pile à ce moment-là. Essaie de mettre le programme principal au début ou au moins un "jmp debut".

[TASM] Détournement d'interruption

x86 16-bits Assembleur

Discussions similaires

Partager

Partager