检测点 15.1

奥普瓯江

（1）仔细分析一下上面的int 9 中断例程， 看看是否可以精简一下？
                其实在我们的int 9 中断例程中， 模拟int 指令调用原int 9 中断例程的程序段是可以精简的， 因为在进入中断例程后， IF 和 TF都已经置0，没有必要在进行设置了。
对于程序段：

1.                 pushf
   
2.                 pushf
   
3.                 pop ax
   
4.                 and  ah, 11111100b
   
5.                 push ax
   
6.                 popf
   
7.                 call dword ptr ds:[0]

复制代码

可以精简为：

1.                 pushf                                                ;因为下面的返回中call模拟int 9h 程序返回时需要 寄存器数据，所以这里需要向栈中输入一个cf寄存器数据供下面call中的iret返回使用
   
2.                 call dword ptr ds:[0]                ;这个是必须有的所以他不能动模拟int 9 程序
   
3.        

复制代码

原程序如下：

1. assume cs:code, ds:data_1, ss:stack
   
2. 
   
3. data_1 segment
   
4.                 dw 0,0
   
5. data_1 ends
   
6. 
   
7. stack segment
   
8.                 db 128 dup (0)
   
9. stack ends
   
10. 
    
11. 
    
12. code segment
    
13. start:
    
14.                 mov ax, data_1    ;数据段
    
15.                 mov ds, ax
    
16.                 mov si, 0
    
17.                
    
18.                 mov ax, stack                ;栈定义  ,这里定义不定义栈其实无所谓，因为编译器会自动定义栈位ffff
    
19.                 mov ss, ax
    
20.                 mov sp, 128
    
21.                
    
22.                 mov ax, 0
    
23.                 mov es, ax
    
24.                 ;把int 9h中断限量表中的地址传给数据段0、1和2、3， 这样中断限量表中的int 9h 中断就不会消失了，他的地址一致会储存在数据段中随时让我们可以调用
    
25.                 push es:[9 * 4]                ;低位为偏移地址
    
26.                 pop  ds:[0]                        ;ds低位为偏移地址储存
    
27.                
    
28.                 push es:[9 * 4 + 2] ;高位为段地址
    
29.                 pop         ds:[2]                        ;ds高位为短地址储存
    
30.                
    
31.                 mov word ptr es:[9 * 4], offset int9       ;偏移地址
    
32.                 mov word ptr es:[9 * 4 + 2], cs                          ;短地址每个地址占两个字节一共4个字节
    
33.                
    
34.                
    
35.                
    
36.                
    
37.                 mov ax, 0b800h
    
38.                 mov es, ax
    
39.                 mov ah, 'a'
    
40. s:
    
41.                 mov byte ptr es:[160 * 12 + 40 * 2], ah
    
42.                 inc ah
    
43.                 call jump_1
    
44.                 cmp ah, 'z'
    
45.                 jna s
    
46.                
    
47.                 ;把中断向量表中的地址恢复成初始地址
    
48.                 mov ax, 0
    
49.                 mov es, ax
    
50.                
    
51.                 push word ptr ds:[0]
    
52.                 pop word ptr es:[9 * 4]
    
53.                
    
54.                 push word ptr ds:[2]
    
55.                 pop word ptr es:[9 * 4 + 2]
    
56.                
    
57.                 mov ax, 4c00h
    
58.                 int 21h
    
59.                
    
60.                
    
61. jump_1:
    
62.                 push ax
    
63.                 push dx
    
64.                 mov ax, 0
    
65.                 mov dx, 1000h
    
66. jump_2:
    
67.                 sub ax, 1
    
68.                 sbb dx, 0
    
69.                
    
70.                 cmp ax, 0                ;内循环
    
71.                 jne jump_2
    
72.                
    
73.                 cmp dx, 0                ;外循环
    
74.                 jne jump_2
    
75.                
    
76.                 pop dx
    
77.                 pop ax
    
78.                 ret
    
79. int9:
    
80.                 push ax
    
81.                 push es
    
82.                 push ds
    
83.                
    
84.                 pushf
    
85.                 pushf
    
86.                
    
87.                 pop ax
    
88.                 and ax, 11111100b
    
89.                 push ax
    
90.                 popf
    
91.                 call dword ptr ds:[0]
    
92.                
    
93.                
    
94.                 in al, 60h
    
95. 
    
96.                 cmp al, 1
    
97.                 jne good
    
98.                
    
99.                 inc byte ptr es:[160 * 12 + 40 * 2 + 1]
    
100.                
     
101. good:
     
102.                 pop ds
     
103.                 pop es
     
104.                 pop ax
     
105.                 iret
     
106.                
     
107. code ends
     
108. end start

复制代码

int 9临时模拟图示这个是自己看的

Aslcwd

int9段我有疑问
push了ax、es、ds，再pushf两次，pop，push、popf，call dw
那么栈中内容，低到高，存着ip、cs、pushf、ds、es、ax
然后跳转到good，就能直接pop
ds、es、ax？
怎么看都是错的吧！
还有ip、cs、pushf内容隔着呢？

Aslcwd

看视频的时候我就觉得有问题
栈中内容，低到高，存着ip、cs、pushf、ds、es、ax
接下来由good，完成了6次pop，但是顺序不对
good:
                pop ds   ；看顺序应该是ip
                pop es    ；cs
                pop ax    ；pushf
                iret    ；完成了ds给ip，es给cs，ax给了标志寄存器

Aslcwd

assume cs:code, ds:data_1, ss:stack

data_1 segment
                dw 0,0
data_1 ends

stack segment
                db 128 dup (0)
stack ends


code segment
start:
                mov ax, data_1    ;数据段
                mov ds, ax
                mov si, 0
               
                mov ax, stack                ;栈定义  ,这里定义不定义栈其实无所谓，因为编译器会自动定义栈位ffff
                mov ss, ax
                mov sp, 128
               
                mov ax, 0
                mov es, ax
                ;把int 9h中断限量表中的地址传给数据段0、1和2、3， 这样中断限量表中的int 9h 中断就不会消失了，他的地址一致会储存在数据段中随时让我们可以调用
                push es:[9 * 4]                ;低位为偏移地址
                pop  ds:[0]                        ;ds低位为偏移地址储存
               
                push es:[9 * 4 + 2] ;高位为段地址
                pop  ds:[2]                        ;ds高位为短地址储存
               
                mov word ptr es:[9 * 4], offset int9       ;偏移地址
                mov word ptr es:[9 * 4 + 2], cs                          ;短地址每个地址占两个字节一共4个字节
               
               
               
               
                mov ax, 0b800h
                mov es, ax
                mov ah, 'a'
s:
                mov byte ptr es:[160 * 12 + 40 * 2], ah
                inc ah
                call jump_1
                cmp ah, 'z'
                jna s
               
                ;把中断向量表中的地址恢复成初始地址
                mov ax, 0
                mov es, ax
               
                push word ptr ds:[0]
                pop word ptr es:[9 * 4]
               
                push word ptr ds:[2]
                pop word ptr es:[9 * 4 + 2]
               
                mov ax, 4c00h
                int 21h
               
               
jump_1:
                push ax
                push dx
                mov ax, 0
                mov dx, 1000h
jump_2:
                sub ax, 1
                sbb dx, 0
               
                cmp ax, 0                ;内循环
                jne jump_2
               
                cmp dx, 0                ;外循环
                jne jump_2
               
                pop dx
                pop ax
                ret
int9:
                pushf
                               
                                push ax
                               
                                pushf
                                pop ax
                and ax, 11111100b
                push ax
                popf
                               
                                pop ax

                call dword ptr ds:[0]
                               
                push ax
                push es
                push ds
              
               
                in al, 60h

                cmp al, 1
                jne good
               
                inc byte ptr es:[160 * 12 + 40 * 2 + 1]
               
good:
                pop ds
                pop es
                pop ax
                iret
               
code ends
end start

Aslcwd

我只改动了int9的内容

int9:
                pushf         ；标志寄存器入栈，栈内数据低到高：flag
                                
                push ax        ；ax入栈保护，栈内数据低到高：ax，flag
                                
                pushf        ；标志寄存器再次入栈，栈内数据低到高：flag，ax，flag

                pop ax        ；标志寄存器，弹出给ax，栈内数据低到高：ax，flag

                and ah, 11111100b        ；这里是楼主的88行，代码写错，TF和IF清零，应该使用高位ah，栈内数据低到高：ax，flag
               
                push ax        ；TF、IF置零后的寄存器数据在ax中，入栈，栈内数据低到高：ax（flag），ax，flag
               
                popf                ；新的flag置零完毕，栈内数据低到高：ax，flag
                                
                pop ax        ；还原ax的值，栈内数据低到高：flag

                call dword ptr ds:[0]                ；双字call命令，CS入栈，IP入栈，栈内数据低到高：ip，cs，flag
                                                        ；此时栈内有flag标志寄存器，cs代码段地址，ip偏移地址，相当于完成了int 9的前3步，call命令完成了int 9的第四步
                                                        ；从此刻开始，模拟调用了int        9的中断命令，栈内数据低到高：ip，cs，flag
                                
                push ax                                ；入栈各个寄存器
                push es
                push ds                                ；入栈三个，栈内数据低到高：ds，es，ax，ip，cs，flag
              
               
                in al, 60h                                ；寄存器保存好，开始运行键盘的外部中断，此步为读取端口，栈内数据低到高：ds，es，ax，ip，cs，flag

                cmp al, 1                                ；比较esc的通码，栈内数据低到高：ds，es，ax，ip，cs，flag
         
                jne good                                ；不是则跳转good，是则向下执行变色
               
                inc byte ptr es:[160 * 12 + 40 * 2 + 1]        ；变色
               
good:
                pop ds                                ；弹出ds，栈内数据低到高：es，ax，ip，cs，flag
                pop es                                ；弹出es，栈内数据低到高：ax，ip，cs，flag
                pop ax                                ；弹出ax，栈内数据低到高：ip，cs，flag
                iret                                        ；恢复ip、恢复cs、恢复flag，此时栈内清空，模拟中断完成

Aslcwd

楼主88行的ax要改成ah，或者数据改成1111110011111111b

奥普瓯江

Aslcwd 发表于 2019-5-8 09:16
int9段我有疑问
push了ax、es、ds，再pushf两次，pop，push、popf，call dw
那么栈中内容，低到高，存着i ...

这里面这个call dword ptr ds:[0]是用来模拟int 9 命令的int 9 命令的运作原理是

所以在int 9 结束的时候已经把 你所说的 ip cs pushf都已经释放了所以不存在隔着的情况
在这里你指出的那个and ax,11111100b那个是我错了这个应该是ah我应该改正

Aslcwd

奥普瓯江 发表于 2019-5-8 20:02
这里面这个call dword ptr ds:[0]是用来模拟int 9 命令的int 9 命令的运作原理是

所以在int 9 结 ...

call的命令发出，其实是去执行真正的int 9去了，执行完毕还要iret，回到call下面那一行是吗？

奥普瓯江

Aslcwd 发表于 2019-5-10 16:54
call的命令发出，其实是去执行真正的int 9去了，执行完毕还要iret，回到call下面那一行是吗？

嗯嗯是的，执行call下面的 in al, 61h