首页
社区
课程
招聘
问答 CTF 排行榜 知识库 工具下载 峰会 看雪商城 证书查询
  1. 社区
  2. 科锐培训
    3. 发新帖
7
[原创]调试器中不通过TF标记位实现单步操作的实现思路
发表于: 2010-8-21 17:27 14401

[原创]调试器中不通过TF标记位实现单步操作的实现思路

besterChen 活跃值
4
2010-8-21 17:27
14401

调试器中不通过TF标记位实现单步操作的实现思路


----besterChen       

               


        最近刚讲完Debug API，马上就要开始第三阶段写调试器的作业了。如果没有意外的话，这应该是我在科锐学习的最后一个编程类作业了吧，%>_<%。



        说实话，这个调试器写出来以后， 我用它的可能性不大。但作为作业，就索性往难处做，虽然可能不实用，甚至根本就没必要……， 就权当作是锻炼下自己吧。



       


我们都知道，如果程序不借助标志寄存器的TF位来实现单步步过和步入功能的话，我们只需要知道下一条指令的地址，然后在这个地址上随便下个int3或者硬件之类的断点，然后放开程序跑就可以实现单步步过或者步入了。至于难点应该就是怎么确定下一条要执行的代码的地址，由于需要考虑的情况比较多，故写此文档一来算是备忘，二来就算作抛砖引玉，看看各位师兄有没有更好的解决方法。


       


        进入主题。


一、类别统计


        一般程序都是顺序执行的，其下一条指令地址就是EIP+当前指令的长度作为下一条指令的位置，但是如果遇到转移类指令就需要做特殊的计算，这里列出已知的情况，供参考：


1、CALL 类指令


        CALL类指令，如果是步过的话，不需要特别计算，只要按照EIP+当前指令的长度的算法即可解决，下面讨论的是步入时的问题。


CALL  ADDR


        像这样的立即数寻址比较简单，可以通过取到机器指令中的相对地址部分，计算出目标地址；也可以通过反汇编引擎反汇编的代码来直接拿到目标地址。


CALL  [ADDR]


对于地址取内容的也比较简单，取到地址，自己ReadMemory就可以了。


CALL  [Reg]


        对于地址取内容的也比较简单，比较麻烦的就是取出相应寄存器的内容，但是有CONTEXT，也不麻烦的。取到内容以后自己ReadMemory也可以搞定。


CALL  [Reg+offset]


        这一类的指令多见于调用虚函数，也是CALL类指令中最复杂的，应为它需要我们自己计算出指针的值，通过指针ReadMemory才可以。


call    dword ptr [reg+reg*NUM+0xOFFSET]


这是我见过的最复杂的寻址方式….


RET


        对于RET指令，需要结合CONTEXT中ESP的内容来获取下一条指令的地址，这个应该是这些所有的情况中最简单的。


JCC类指令


        JCC类指令中JMP指令的情况与CALL相同，其它的条件指令先根据符号标记寄存器来判断跳转是否已经实现，如果跳转没有实现，其下一条指令地址就是EIP+当前指令的长度。下面讨论的是跳转已经实现的情况下。


JCC  ADDR


同CALL  ADDR的思路


JCC  [ADDR]


同 CALL [ADDR]的思路


JCC  [Reg] / JCC  [REG+OFFSET]


同CALL 的思路


JCC  [REG+REG*OFFSET]


        这是所有需要分析的指令中最复杂的情况，通过比例因子的寻址方式。我们不仅需要分离出各个元素及其内容，最难麻烦的是它的四则运算还需要考虑优先级。



二、整体的计算流程


        通过以上的统计，我们知道，有些情况下CALL类指令和JCC类指令的处理流程是一样的，所以，我整理的处理流程如下：



  • 检测当前指令是否是CALL或JCC类指令，如果不是，下一条指令就是 EIP + 当前指令长度
  • 检测指令是否为CALL类指令，如果指令是CALL类的指令就看下当前是步入还是不过，如果是步过，下条指令就是 EIP + 当前指令长度，如果是步入就继续步骤4。
  • 如果检测指令是JCC类指令，就如果是检测跳转是否实现，如果没实现下一条指令就是EIP + 当前指令长度；如果跳转实现，就继续步骤4。
  • 取出当前指令的操作数中中的所有的寄存器、立即数操作数以及操作符号。
  • 根据取出的内容，判断当前的转移指令是属于上面的哪个部分。
  • 对分离出的指令按照当前操作数中的规定进行运算得到目标地址



大致的说明性代码如下:


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
//************************************************************************
// 函数名: GetNextAddr
// 权  限: public
// 返回值: DWORD 返回下一条指令的地址
// 参  数: BOOL isStepOver  TRUE为步过，FALSE为步入
// 说  明: 用于计算下一条指令所在地址的函数
// 合  格:
//************************************************************************
DWORD CDebugLib::GetNextAddr(BOOL isStepOver)
{
    DWORD    dwNextAddr = 0;
    TCHAR    szCommand[CODE_SIZE] = {0};    // 用来接收指令
    TCHAR    szCmdLine[CODE_SIZE] = {0};    // 用来接收反汇编出来的汇编指令
 
    t_disasm da                = {0};
 
    if (m_pBreakPoint == NULL)
    {
        return FALSE;
    }
 
    PCONTEXT tagpContext = GetContextValue();
 
    if (!tagpContext || tagpContext->Eip == NULL)
    {
        return FALSE;
    }
 
    int nLen = GetAsmCode((LPVOID)tagpContext->Eip, &da);
    _tcscpy(szCmdLine, da.result);
    _stscanf(szCmdLine, _T("%[^ ]"), szCommand); // 分离出指令来作判断
    _tcsupr(szCommand);
 
    if (_tcsicmp(szCommand, _T("CALL")) == 0)
    {
        if (isStepOver != TRUE)
        {
            // 对于单步步入的情况，需要计算步入的地址
            #pragma chMSG(CALL 指令的单步步入情况还没处理....)
            return dwNextAddr;
        }
        // 对于CALL的步过情况，与普通指令相同，这里就不处理了。
    }
    else if (_tcsstr(szCommand, _T("J")) != 0)
    {
        // 需要判断跳转实现没有
        if(IsJmpSuccess(tagpContext, szCommand))
        {
            // 如果跳转实现了，需要自己计算目标地址。
            _tprintf(_T("跳转已经实现....\r\n"));
            #pragma chMSG(JCC 指令中跳转实现的情况还没处理....)
 
            return dwNextAddr;
        }
 
        // 如果没有实现，与普通指令相同，这里就不处理了。
        _tprintf(_T("跳转没有实现....\r\n"));
    }
    else if (_tcsstr(szCommand, _T("RET")) != 0)
    {
        // 需要手工计算步入的地址
        assert(m_pBreakPoint->ReadMemory((LPVOID)tagpContext->Esp, \
               &dwNextAddr, sizeof(DWORD)));
 
        return dwNextAddr;
    }
 
    // 剩下的指令都是 EIP + 当前指令长度了。
    return (DWORD)((BYTE*)tagpContext->Eip+nLen);
}




[培训]内核驱动高级班，冲击BAT一流互联网大厂工作，每周日13:00-18:00直播授课

上传的附件：
收藏
点赞 ・7
支持
分享
赞赏记录
参与人
雪币
留言
时间
Youlor
为你点赞~
2024-5-31 03:20
伟叔叔
为你点赞~
2024-2-14 00:01
QinBeast
为你点赞~
2024-1-16 03:23
shinratensei
为你点赞~
2024-1-9 05:18
心游尘世外
为你点赞~
2023-12-27 00:07
飘零丶
为你点赞~
2023-12-15 00:51
PLEBFE
为你点赞~
2023-3-18 03:40
最新回复 (11)
besterChen
雪    币： 168
活跃值： (152)
能力值： ( LV11，RANK：180 )
在线值：
发帖
回帖
粉丝
私信
2 楼
难得今天上网，发现没有人讨论~
反而钱老师给了一个精华~
为了对得起这个精华，我就顺便贴下我的实现代码和效果图吧~（代码太挫……）
关于代码的分离部分：
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
//************************************************************************
// 函数名: Lex_Split
// 权  限: public
// 返回值: list<TCHAR*>*        返回一个字符串链表
// 参  数: IN TCHAR * pszRegular
// 参  数: IN TCHAR * pszSource
// 说  明: 从指定的字符串中分离出各种子串
// 合  格:
//************************************************************************
list<TCHAR*>* Lex_Split(IN const TCHAR* pszRegular, IN const TCHAR* pszSource)
{
    int ntmpLen = 0;
    int nCount = 0; // 用来统计匹配的数量作为返回值
    match_results result; // 匹配结果
    list<TCHAR*> *pszResultList = new list<TCHAR*>;
    REGEX_FLAGS emRegEx*** = GLOBAL | ALLBACKREFS | NOCASE | SINGLELINE;
    rpattern pat((LPCTSTR)pszRegular, emRegEx***);  //正则模式及设置
    int iGroups = pat.cgroups();
    match_results::backref_type br = pat.match(pszSource, result );
 
    if (pszRegular == NULL || pszSource == NULL || br.matched == FALSE)
    {
        return NULL;
    }
 
 
    for( int i=0; i < result.cbackrefs(); i++ )
    {
        ntmpLen = _tcslen(result.backref(i).str().c_str());
        if( i%iGroups == 0 && ntmpLen > 0)
        {
            nCount++;
             
            TCHAR *pszResult = new TCHAR[ntmpLen+1];
            ZeroMemory(pszResult, ntmpLen+1);
            _tcscpy(pszResult, result.backref(i).str().c_str());
            pszResultList->push_back(pszResult);
        }
    }
 
    return pszResultList;
}


关于根据token获取值的部分：
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
//************************************************************************
// 函数名: GetRegTokenValue
// 权  限: public
// 返回值: DWORD
// 参  数: IN CONTEXT * tagpContext
// 参  数: TCHAR * pszRegToken
// 说  明: 获取 分离出的各种token代表的值
// 合  格:
//************************************************************************
DWORD GetRegTokenValue(IN CONTEXT *tagpContext, TCHAR *pszRegToken)
{
    for (int i = 0; i < 8; i++)
    {
        if (_tcsicmp(st_RegInfo[i].pszString, pszRegToken) != 0)
        {
            continue;
        }
 
        switch(st_RegInfo[i].tagType.e)
        {
        case REG_TYPE::REG_TYPE_EAX:
             return tagpContext->Eax;
 
        case REG_TYPE::REG_TYPE_EBX:
             return tagpContext->Ebx;
 
        case REG_TYPE::REG_TYPE_ECX:
             return tagpContext->Ecx;
        case REG_TYPE::REG_TYPE_EDX:
             return tagpContext->Edx;
        case REG_TYPE::REG_TYPE_ESP:
             return tagpContext->Esp;
        case REG_TYPE::REG_TYPE_EBP:
             return tagpContext->Ebp;
        case REG_TYPE::REG_TYPE_ESI:
             return tagpContext->Esi;
        case REG_TYPE::REG_TYPE_EDI:
             return tagpContext->Edi;
        default:
            ;
        }
    }
 
    return -1;
}
 
 
 
//************************************************************************
// 函数名: GetRegTokenValue
// 权  限: public
// 返回值: DWORD
// 参  数: TCHAR * pszCstToken
// 说  明: 获取 分离出的 常量 的值
// 合  格:
//************************************************************************
DWORD GetCstTokenValue(TCHAR *pszCstToken)
{
    DWORD dwResult = 0;
    if (pszCstToken == NULL)
    {
        return 0;
    }
 
    _stscanf(pszCstToken, _T("%x"), &dwResult);
 
    return dwResult;
}


整体上的模拟运算的流程如下：
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
//************************************************************************
// 函数名: CalcSimulator
// 权  限: public
// 返回值: DWORD
// 参  数: IN CONTEXT * tagpContext
// 参  数: IN list<TCHAR * > * pTokenList
// 说  明: 表达式计算
// 合  格:
//************************************************************************
DWORD CalcSimulator(IN CONTEXT *tagpContext, IN list<TCHAR*>* pTokenList)
{
    int nCount = 0;
    DWORD dwResult = 0; // 前一个操作数
    DWORD dwCurNum = 0;
    if (tagpContext == NULL || pTokenList == NULL)
    {
        return -1;
    }
 
    if (pTokenList->size() <= 1)
    {
        return -1;
    }
 
    OPERATE_STATE em_OperReg;
    OPERATE_STATE em_OperCst;
    OPERATE_STATE em_OperSign;
    OPERATE_STATE em_OperStart;
    OPERATE_STATE em_OperEnd;
 
    em_OperReg.e = OPERATE_STATE::STATE_OPER_REG;
    em_OperCst.e = OPERATE_STATE::STATE_CONST_NUM;
    em_OperSign.e = OPERATE_STATE::STATE_SIGN_TOKEN;
    em_OperStart.e= OPERATE_STATE::STATE_SIGN_START;
    em_OperEnd.e = OPERATE_STATE::STATE_SIGN_END;
 
    pTokenList = CalcMulti(tagpContext, pTokenList); // 先处理乘法
 
    if (pTokenList == (list<TCHAR*>*)-1)
    {
        return -1;
    }
 
    nCount = pTokenList->size();
 
    list<TCHAR*>::iterator it = pTokenList->begin();
    for ( int i = 0 ; i < nCount ; i++ )
    {
        TCHAR *pResultBuf = NULL;
        pResultBuf = *it;
 
        if (pResultBuf == NULL)
        {
            continue;
        }
         
        if (Is(em_OperStart, pResultBuf))
        {
            // 清空栈内容
            while (!g_WaitForCalcStack.empty())
            {
                g_WaitForCalcStack.pop();
            }
        }
 
        if (Is(em_OperEnd, pResultBuf))
        {
            // 处理完成，开始计算栈中的数据
            int nSize = g_WaitForCalcStack.size();
            for (int i = 0; i < nSize; i ++)
            {
                dwResult += g_WaitForCalcStack.top();
                g_WaitForCalcStack.pop();
            }
 
            break;
        }
 
 
        if (Is(em_OperReg, pResultBuf))
        {
            // 如果是寄存器，就保存寄存器中的内容
            g_WaitForCalcStack.push(GetRegTokenValue(tagpContext, pResultBuf));
        }
 
        if (Is(em_OperCst, pResultBuf))
        {
            // 如果是立即数，就保存其值
            g_WaitForCalcStack.push(GetCstTokenValue(pResultBuf));
        }
 
        if (Is(em_OperSign, pResultBuf))
        {
            if (_tcsicmp(pResultBuf, _T("-")) == 0)
            {
                it++;
                //如果是减法，则需要将后面的数据取补保存
                pResultBuf = *it;
 
                if (Is(em_OperReg, pResultBuf))
                {
                    // 如果是寄存器，就保存寄存器中的内容
                    dwCurNum = GetRegTokenValue(tagpContext, pResultBuf);
                    g_WaitForCalcStack.push(dwCurNum);
                }
 
                if (Is(em_OperCst, pResultBuf))
                {
                    // 如果是立即数，就保存其值
                    dwCurNum = GetCstTokenValue(pResultBuf);
                    dwCurNum = (~dwCurNum)+1; // 求补码
                    g_WaitForCalcStack.push(dwCurNum);
                }
            }
        }
 
        it++;
    }
 
    return dwResult;

    由于乘法在我们当前的环境下优先级最高，所以我将乘法的计算过程分离出去了：
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
// 先计算乘法
static list<TCHAR*>* CalcMulti(IN CONTEXT *tagpContext, IN list<TCHAR*>* pTokenList)
{
    if (tagpContext == NULL || pTokenList == NULL)
    {
        return NULL;
    }
    TCHAR *pPreToken = NULL;
    TCHAR *pResultBuf = NULL;
    DWORD dwPreNum = 0; // 前一个操作数
    DWORD dwNextNum = 0; // 后一个操作数
 
    int   nCount = 0;
    OPERATE_STATE em_OperReg;
    OPERATE_STATE em_OperCst;
    OPERATE_STATE em_OperSign;
    OPERATE_STATE em_OperStart;
    OPERATE_STATE em_OperEnd;
 
    em_OperReg.e = OPERATE_STATE::STATE_OPER_REG;
    em_OperCst.e = OPERATE_STATE::STATE_CONST_NUM;
    em_OperSign.e = OPERATE_STATE::STATE_SIGN_TOKEN;
    em_OperStart.e= OPERATE_STATE::STATE_SIGN_START;
    em_OperEnd.e = OPERATE_STATE::STATE_SIGN_END;
 
    list<TCHAR*>* pResultList = new list<TCHAR*>;
    list<TCHAR*>::iterator it = pTokenList->begin();
    nCount = pTokenList->size();
    for ( int i = 0 ; i < nCount; i++ ) // 多循环了一次，需要看看
    {
        pResultBuf = *it;
 
        if (pResultBuf == NULL)
        {
            continue;
        }
 
        if (_tcsicmp(pResultBuf, _T("*")) != 0)
        {
            pResultList->push_back(pResultBuf);
        }
 
        if (i > 0)
        {
            it--;
            pPreToken = *it;
            it++;
        }
 
        if (pPreToken != NULL && _tcsicmp(pPreToken, _T("*")) == 0)
        {
            // 如果前一个是*也不保存当前的
            pResultList->pop_back();
        }
 
 
        if (Is(em_OperSign, pResultBuf) && _tcsicmp(pResultBuf, _T("*")) == 0)
        {
            pResultList->pop_back();
            // 先取出前一个操作数
            it--;
            pResultBuf = *it;
            if (Is(em_OperReg, pResultBuf))
            {
                // 如果是寄存器，就保存寄存器中的内容
                dwPreNum = GetRegTokenValue(tagpContext, pResultBuf);
            }
 
            if (Is(em_OperCst, pResultBuf))
            {
                // 如果是立即数，就保存其值
                dwPreNum = GetCstTokenValue(pResultBuf);
            }
 
            // 取出后一个操作数
            it++;
            it++;
            pResultBuf = *it;
            if (Is(em_OperReg, pResultBuf))
            {
                // 如果是寄存器，就保存寄存器中的内容
                dwNextNum = GetRegTokenValue(tagpContext, pResultBuf);
            }
 
            if (Is(em_OperCst, pResultBuf))
            {
                // 如果是立即数，就保存其值
                dwNextNum = GetCstTokenValue(pResultBuf);
            }
             
            TCHAR* pNewNum = new TCHAR[4];
            ZeroMemory(pNewNum, sizeof(TCHAR)*4);
            _stprintf(pNewNum, _T("%d"), dwPreNum*dwNextNum);
            pResultList->push_back(pNewNum);
             
            it--;
        }
 
        it++;
    }
 
    pTokenList->clear();
    if (pTokenList)
    {
        delete pTokenList;
        pTokenList = NULL;
    }
 
    pTokenList = pResultList;
    return pResultList;
}


主要的代码就这些了，也用不着我多说废话了，下面贴一下效果图：
先贴个简单的立即数寻址的：


CALL  reg形式的：


再看下 call [addr]这种形式的:


再看下return的效果:


最后来个超级复杂的那种（我自己修改代码构造的测试程序）:


就到这里吧，希望各位师兄能多提点意见，也希望本文能对其它朋友有所帮助。
上传的附件：
2010-8-26 22:34
0
creakerzgz
雪    币： 62
活跃值： (82)
能力值： ( LV5，RANK：70 )
在线值：
发帖
回帖
粉丝
私信
3 楼
要活得下一条指令的地址。。。。。。。。

1.在本条指令处暂停，保存Context
2.单步一下
3.保持Context
4.活得eip
5.恢复Context
2010-8-27 10:59
0
MeowCat
雪    币： 45
活跃值： (10)
能力值： ( LV2，RANK：10 )
在线值：
发帖
回帖
粉丝
私信
4 楼
LZ的意思好像是要实现你说的第二步，怎么单步一下……
2010-8-27 12:42
0
疯子
雪    币： 2248
活跃值： (498)
能力值： ( LV9，RANK：200 )
在线值：
发帖
回帖
粉丝
私信
5 楼
楼主需要一个稍微好点的反汇编引擎.
或者自己解析opcode都比二次解析方便得多
2010-8-27 21:32
0
kingcomer
雪    币： 73
活跃值： (10)
能力值： ( LV2，RANK：10 )
在线值：
发帖
回帖
粉丝
私信
6 楼
楼主强大...吾等小弟...膜拜
2010-8-28 18:17
0
likunkun
雪    币： 334
活跃值： (22)
能力值： ( LV4，RANK：50 )
在线值：
发帖
回帖
粉丝
私信
7 楼
很强大！！

不过有点绕弯了：把OPCODE反汇编成字符串，又把字符串分成了Token处理。
为什么不直接处理OPCODE呢？这样代码会少很多效率也会有所提高

像得到instuction [reg*4n + xxx]写一个GetModeRMValue函数即可了。

还有一点就是在用OD的时候当用F7单步sysenter的效果，这个思路是做不到的。

总体来说很强大了！100个支持
2010-8-29 23:31
0
besterChen
雪    币： 168
活跃值： (152)
能力值： ( LV11，RANK：180 )
在线值：
发帖
回帖
粉丝
私信
8 楼
[QUOTE=likunkun;852500]很强大！！

不过有点绕弯了：把OPCODE反汇编成字符串，又把字符串分成了Token处理。
为什么不直接处理OPCODE呢？这样代码会少很多效率也会有所提高

像得到instuction [reg*4n + xxx]写一个GetModeRMValue函数即可了。

还有一点就是在用OD的时候...[/QUOTE]

恩，不过，说实话，OpCode是啥我现在都没搞明白……

当时只是第一感觉是这样，我就这样做了。自己也感觉这样的做法不是很妥当，但是没有别的什么方法，所以发上来抛砖引玉，(*^__^*) 嘻嘻……

至于效率问题，我没考虑过，我觉得，单步的话，不用太考虑效率，毕竟人按键盘也不会太效率……

那个sysenter这个指令我还真没想到，我只想到了JCC, RETN, CALL……
2010-8-30 05:38
0
超然
雪    币： 422
活跃值： (130)
能力值： ( LV8，RANK：130 )
在线值：
发帖
回帖
粉丝
私信
9 楼
壮壮写的很强大啊。
你用的是啥反汇编引擎啊？
如果是OD的，他里面有指令类型，会告诉你当前指令是CALL，跳转之类的。还有寻址方式，好像有些也有说明。
2010-9-15 08:53
0
A1Pass
雪    币： 883
活跃值： (314)
能力值： ( LV9，RANK：280 )
在线值：
发帖
回帖
粉丝
私信
10 楼
哎，前浪死在沙滩上，壮壮果然很强、很大！
2010-9-23 09:11
0
caojianrui
雪    币： 206
活跃值： (15)
能力值： ( LV2，RANK：10 )
在线值：
发帖
回帖
粉丝
私信
11 楼
我们也要写调试器了，学习先
2010-11-4 23:20
0
dwboy
雪    币： 45
活跃值： (25)
能力值： ( LV3，RANK：20 )
在线值：
发帖
回帖
粉丝
私信
12 楼
mov [eax], 2;   eax = 0;
div eax;
....
....

且如果程序的异常处理中故意修改了eip..

这样的话是让异常进调试器的异常处理，然后在调试器中遍历异常链表?

如果异常链有100个handle,那就是先执行handle1,然后重新运行指令,如果该指令没修复,再执行handle2..?

郁闷中....
2010-11-25 15:36
0
游客
登录 | 注册 方可回帖
回帖 表情 雪币赚取及消费
高级回复
返回

账号登录
验证码登录

忘记密码？
没有账号？立即免费注册
我已同意 《看雪服务条款》 《看雪课程免责声明》 《看雪隐私政策》