Partilhar via


Desmontagem x86 anotada

A seção a seguir orientará você por um exemplo de desmontagem.

Código-fonte

Veja a seguir o código da função que será analisada.

HRESULT CUserView::CloseView(void)
{
    if (m_fDestroyed) return S_OK;

    BOOL fViewObjectChanged = FALSE;
    ReleaseAndNull(&m_pdtgt);

    if (m_psv) {
        m_psb->EnableModelessSB(FALSE);
        if(m_pws) m_pws->ViewReleased();

        IShellView* psv;

        HWND hwndCapture = GetCapture();
        if (hwndCapture && hwndCapture == m_hwnd) {
            SendMessage(m_hwnd, WM_CANCELMODE, 0, 0);
        }

        m_fHandsOff = TRUE;
        m_fRecursing = TRUE;
        NotifyClients(m_psv, NOTIFY_CLOSING);
        m_fRecursing = FALSE;

        m_psv->UIActivate(SVUIA_DEACTIVATE);

        psv = m_psv;
        m_psv = NULL;

        ReleaseAndNull(&_pctView);

        if (m_pvo) {
            IAdviseSink *pSink;
            if (SUCCEEDED(m_pvo->GetAdvise(NULL, NULL, &pSink)) && pSink) {
                if (pSink == (IAdviseSink *)this)
                    m_pvo->SetAdvise(0, 0, NULL);
                pSink->Release();
            }

            fViewObjectChanged = TRUE;
            ReleaseAndNull(&m_pvo);
        }

        if (psv) {
            psv->SaveViewState();
            psv->DestroyViewWindow();
            psv->Release();
        }

        m_hwndView = NULL;
        m_fHandsOff = FALSE;

        if (m_pcache) {
            GlobalFree(m_pcache);
            m_pcache = NULL;
        }

        m_psb->EnableModelessSB(TRUE);

        CancelPendingActions();
    }

    ReleaseAndNull(&_psf);

    if (fViewObjectChanged)
        NotifyViewClients(DVASPECT_CONTENT, -1);

    if (m_pszTitle) {
        LocalFree(m_pszTitle);
        m_pszTitle = NULL;
    }

    SetRect(&m_rcBounds, 0, 0, 0, 0);
    return S_OK;
}

Código do assembly

Esta seção contém o exemplo de desmontagem anotada.

As funções que usam o registro de ebp como um ponteiro de quadro começam da seguinte maneira:

HRESULT CUserView::CloseView(void)
SAMPLE!CUserView__CloseView:
71517134 55               push    ebp
71517135 8bec             mov     ebp,esp

Isso configura o quadro para que a função possa acessar seus parâmetros como deslocamentos positivos de ebp e variáveis locais como deslocamentos negativos.

Esse é um método em uma interface COM privada, portanto, a convenção de chamada é __stdcall. Isso significa que os parâmetros são enviados por push da direita para a esquerda (nesse caso, não há nenhum), o ponteiro "this" é enviado por push e, em seguida, a função é chamada. Assim, ao entrar na função, a pilha terá esta aparência:

[esp+0] = return address
[esp+4] = this

Após as duas instruções anteriores, os parâmetros são acessíveis como:

[ebp+0] = previous ebp pushed on stack
[ebp+4] = return address
[ebp+8] = this

Para uma função que usa ebp como um ponteiro de quadro, o primeiro parâmetro enviado por push é acessível em [ebp+8]; os parâmetros subsequentes são acessíveis em endereços DWORD posteriores consecutivos.

71517137 51               push    ecx
71517138 51               push    ecx

Essa função requer apenas duas variáveis de pilha locais, portanto, uma instrução sub esp, 8. Os valores enviados por push ficam disponíveis como [ebp-4] e [ebp-8].

Para uma função que usa ebp como um ponteiro de quadro, as variáveis locais de pilha são acessíveis em deslocamentos negativos do registro de ebp .

71517139 56               push    esi

Agora, o compilador salva os registros que precisam ser preservados entre chamadas de função. Na verdade, ele os salva em bits e partes, intercalados com a primeira linha de código real.

7151713a 8b7508           mov     esi,[ebp+0x8]     ; esi = this
7151713d 57               push    edi               ; save another registers

Acontece que CloseView é um método em ViewState, que está no deslocamento 12 no objeto subjacente. Consequentemente, esse é um ponteiro para uma classe ViewState, embora quando houver uma possível confusão com outra classe base, ela será especificada com mais cuidado como (ViewState*)this.

    if (m_fDestroyed)
7151713e 33ff             xor     edi,edi           ; edi = 0

XORing um registro consigo mesmo é uma maneira padrão de zero-lo.

71517140 39beac000000     cmp     [esi+0xac],edi    ; this->m_fDestroyed == 0?
71517146 7407             jz      NotDestroyed (7151714f)  ; jump if equal

A instrução cmp compara dois valores (subtraindo-os). A instrução jz verifica se o resultado é zero, indicando que os dois valores comparados são iguais.

A instrução cmp compara dois valores; uma instrução j subsequente salta com base no resultado da comparação.

    return S_OK;
71517148 33c0             xor     eax,eax           ; eax = 0 = S_OK
7151714a e972010000       jmp     ReturnNoEBX (715172c1) ; return, do not pop EBX

O compilador atrasou o salvamento do registro EBX até mais tarde na função, portanto, se o programa for "antecipado" neste teste, o caminho de saída precisará ser aquele que não restaura o EBX.

    BOOL fViewObjectChanged = FALSE;
    ReleaseAndNull(&m_pdtgt);

A execução dessas duas linhas de código é intercalada, portanto, preste atenção.

NotDestroyed:
7151714f 8d86c0000000     lea     eax,[esi+0xc0]    ; eax = &m_pdtgt

A instrução lea calcula o endereço de efeito de um acesso à memória e o armazena no destino. O endereço de memória real não é desreferenciado.

A instrução lea usa o endereço de uma variável.

71517155 53               push    ebx

Você deve salvar esse registro EBX antes que ele seja danificado.

71517156 8b1d10195071     mov ebx,[_imp__ReleaseAndNull]

Como você chamará ReleaseAndNull com frequência, é uma boa ideia armazenar seu endereço em cache no EBX.

7151715c 50               push    eax               ; parameter to ReleaseAndNull
7151715d 897dfc           mov     [ebp-0x4],edi     ; fViewObjectChanged = FALSE
71517160 ffd3             call    ebx               ; call ReleaseAndNull
    if (m_psv) {
71517162 397e74           cmp     [esi+0x74],edi    ; this->m_psv == 0?
71517165 0f8411010000     je      No_Psv (7151727c) ; jump if zero

Lembre-se de que você zerou o registro EDI um tempo atrás e que EDI é um registro preservado entre chamadas de função (portanto, a chamada para ReleaseAndNull não o alterou). Portanto, ele ainda mantém o valor zero e você pode usá-lo para testar rapidamente para zero.

        m_psb->EnableModelessSB(FALSE);
7151716b 8b4638           mov     eax,[esi+0x38]    ; eax = this->m_psb
7151716e 57               push    edi               ; FALSE
7151716f 50               push    eax               ; "this" for callee
71517170 8b08             mov     ecx,[eax]         ; ecx = m_psb->lpVtbl
71517172 ff5124           call    [ecx+0x24]        ; __stdcall EnableModelessSB

O padrão acima é um sinal revelador de uma chamada de método COM.

As chamadas de método COM são muito populares, portanto, é uma boa ideia aprender a reconhecê-las. Em particular, você deve ser capaz de reconhecer os três métodos IUnknown diretamente de seus deslocamentos Vtable: QueryInterface=0, AddRef=4 e Release=8.

        if(m_pws) m_pws->ViewReleased();
71517175 8b8614010000     mov     eax,[esi+0x114]   ; eax = this->m_pws
7151717b 3bc7             cmp     eax,edi           ; eax == 0?
7151717d 7406             jz      NoWS (71517185) ; if so, then jump
7151717f 8b08             mov     ecx,[eax]         ; ecx = m_pws->lpVtbl
71517181 50               push    eax               ; "this" for callee
71517182 ff510c           call    [ecx+0xc]         ; __stdcall ViewReleased
NoWS:
        HWND hwndCapture = GetCapture();
71517185 ff15e01a5071    call [_imp__GetCapture]    ; call GetCapture

Chamadas indiretas por meio de globais é como as importações de função são implementadas no Microsoft Win32. O carregador corrige os globais para apontar para o endereço real do destino. Essa é uma maneira útil de obter seus rumos quando você está investigando um computador com falha. Procure as chamadas para funções importadas e no destino. Normalmente, você terá o nome de alguma função importada, que pode ser usada para determinar onde você está no código-fonte.

        if (hwndCapture && hwndCapture == m_hwnd) {
            SendMessage(m_hwnd, WM_CANCELMODE, 0, 0);
        }
7151718b 3bc7             cmp     eax,edi           ; hwndCapture == 0?
7151718d 7412             jz      No_Capture (715171a1) ; jump if zero

O valor retornado da função é colocado no registro EAX.

7151718f 8b4e44           mov     ecx,[esi+0x44]    ; ecx = this->m_hwnd
71517192 3bc1             cmp     eax,ecx           ; hwndCapture = ecx?
71517194 750b             jnz     No_Capture (715171a1) ; jump if not

71517196 57               push    edi               ; 0
71517197 57               push    edi               ; 0
71517198 6a1f             push    0x1f              ; WM_CANCELMODE
7151719a 51               push    ecx               ; hwndCapture
7151719b ff1518195071     call    [_imp__SendMessageW] ; SendMessage
No_Capture:
        m_fHandsOff = TRUE;
        m_fRecursing = TRUE;
715171a1 66818e0c0100000180 or    word ptr [esi+0x10c],0x8001 ; set both flags at once

        NotifyClients(m_psv, NOTIFY_CLOSING);
715171aa 8b4e20           mov     ecx,[esi+0x20]    ; ecx = (CNotifySource*)this.vtbl
715171ad 6a04             push    0x4               ; NOTIFY_CLOSING
715171af 8d4620           lea     eax,[esi+0x20]    ; eax = (CNotifySource*)this
715171b2 ff7674           push    [esi+0x74]        ; m_psv
715171b5 50               push    eax               ; "this" for callee
715171b6 ff510c           call    [ecx+0xc]         ; __stdcall NotifyClients

Observe como você teve que alterar o ponteiro "this" ao chamar um método em uma classe base diferente da sua.

        m_fRecursing = FALSE;
715171b9 80a60d0100007f   and     byte ptr [esi+0x10d],0x7f
        m_psv->UIActivate(SVUIA_DEACTIVATE);
715171c0 8b4674           mov     eax,[esi+0x74]    ; eax = m_psv
715171c3 57               push    edi               ; SVUIA_DEACTIVATE = 0
715171c4 50               push    eax               ; "this" for callee
715171c5 8b08             mov     ecx,[eax]         ; ecx = vtbl
715171c7 ff511c           call    [ecx+0x1c]        ; __stdcall UIActivate
        psv = m_psv;
        m_psv = NULL;
715171ca 8b4674           mov     eax,[esi+0x74]    ; eax = m_psv
715171cd 897e74           mov     [esi+0x74],edi    ; m_psv = NULL
715171d0 8945f8           mov     [ebp-0x8],eax     ; psv = eax

A primeira variável local é psv.

        ReleaseAndNull(&_pctView);
715171d3 8d466c           lea     eax,[esi+0x6c]    ; eax = &_pctView
715171d6 50               push    eax               ; parameter
715171d7 ffd3             call    ebx               ; call ReleaseAndNull
        if (m_pvo) {
715171d9 8b86a8000000     mov     eax,[esi+0xa8]    ; eax = m_pvo
715171df 8dbea8000000     lea     edi,[esi+0xa8]    ; edi = &m_pvo
715171e5 85c0             test    eax,eax           ; eax == 0?
715171e7 7448             jz      No_Pvo (71517231) ; jump if zero

Observe que o compilador preparou especulativamente o endereço do membro m_pvo , pois você o usará com frequência por um tempo. Assim, ter o endereço à mão resultará em um código menor.

            if (SUCCEEDED(m_pvo->GetAdvise(NULL, NULL, &pSink)) && pSink) {
715171e9 8b08             mov     ecx,[eax]         ; ecx = m_pvo->lpVtbl
715171eb 8d5508           lea     edx,[ebp+0x8]     ; edx = &pSink
715171ee 52               push    edx               ; parameter
715171ef 6a00             push    0x0               ; NULL
715171f1 6a00             push    0x0               ; NULL
715171f3 50               push    eax               ; "this" for callee
715171f4 ff5120           call    [ecx+0x20]        ; __stdcall GetAdvise
715171f7 85c0             test    eax,eax           ; test bits of eax
715171f9 7c2c             jl      No_Advise (71517227) ; jump if less than zero
715171fb 33c9             xor     ecx,ecx           ; ecx = 0
715171fd 394d08           cmp     [ebp+0x8],ecx     ; _pSink == ecx?
71517200 7425             jz      No_Advise (71517227)

Observe que o compilador concluiu que o parâmetro "this" de entrada não era necessário (porque há muito tempo o escondia no registro ESI). Assim, ele reutilizava a memória como a variável local pSink.

Se a função usa um quadro EBP, os parâmetros de entrada chegam a deslocamentos positivos do EBP e as variáveis locais são colocadas em deslocamentos negativos. Mas, como nesse caso, o compilador é livre para reutilizar essa memória para qualquer finalidade.

Se você estiver prestando muita atenção, verá que o compilador poderia ter otimizado esse código um pouco melhor. Ele poderia ter atrasado a instrução lea edi, [esi+0xa8] até depois que os dois 0x0 instruções de push, substituindo-os por push edi. Isso teria salvo 2 bytes.

                if (pSink == (IAdviseSink *)this)

Essas próximas várias linhas são para compensar o fato de que, em C++, (IAdviseSink *)NULL ainda deve ser NULL. Portanto, se o "this" for realmente "(ViewState*)NULL", o resultado da conversão deverá ser NULL e não a distância entre IAdviseSink e IBrowserService.

71517202 8d46ec           lea     eax,[esi-0x14]    ; eax = -(IAdviseSink*)this
71517205 8d5614           lea     edx,[esi+0x14]    ; edx = (IAdviseSink*)this
71517208 f7d8             neg     eax               ; eax = -eax (sets carry if != 0)
7151720a 1bc0             sbb     eax,eax           ; eax = eax - eax - carry
7151720c 23c2             and     eax,edx           ; eax = NULL or edx

Embora o Pentium tenha uma instrução de movimentação condicional, a arquitetura base i386 não tem, portanto, o compilador usa técnicas específicas para simular uma instrução de movimentação condicional sem dar nenhum salto.

O padrão geral para uma avaliação condicional é o seguinte:

        neg     r
        sbb     r, r
        and     r, (val1 - val2)
        add     r, val2

O neg r define o sinalizador de transporte se r não for zero, pois neg nega o valor subtraindo de zero. E a subtração de zero gerará um empréstimo (defina o transporte) se você subtrair um valor diferente de zero. Ele também danifica o valor no registro r , mas isso é aceitável porque você está prestes a substituí-lo de qualquer maneira.

Em seguida, a instrução sbb r, r subtrai um valor de si mesmo, o que sempre resulta em zero. No entanto, ele também subtrai o bit carry (borrow), portanto, o resultado líquido é definir r como zero ou -1, dependendo se o transporte estava limpo ou definido, respectivamente.

Portanto, sbb r, r define r como zero se o valor original de r era zero ou para -1 se o valor original não fosse zero.

A terceira instrução executa uma máscara. Como o registro r é zero ou -1, "this" serve para deixar r zero ou para alterar r de -1 para (val1 - val1), nesse ANDing qualquer valor com -1 deixa o valor original.

Portanto, o resultado de "e r, (val1 - val1)" será definir r como zero se o valor original de r for zero ou como "(val1 - val2)" se o valor original de r não era zero.

Por fim, você adiciona val2 a r, resultando em val2 ou (val1 - val2) + val2 = val1.

Portanto, o resultado final desta série de instruções é definir r como val2 se era originalmente zero ou para val1 se não fosse zero. Esse é o assembly equivalente a r = r ? val1 : val2.

Nesta instância específica, você pode ver que val2 = 0 e val1 = (IAdviseSink*)isso. (Observe que o compilador elided a instrução final add eax, 0 porque não tem efeito.)

7151720e 394508           cmp     [ebp+0x8],eax ; pSink == (IAdviseSink*)this?
71517211 750b             jnz     No_SetAdvise (7151721e) ; jump if not equal

Anteriormente nesta seção, você definiu EDI como o endereço do membro m_pvo . Você vai usá-lo agora. Você também zerou o registro ECX anteriormente.

                    m_pvo->SetAdvise(0, 0, NULL);
71517213 8b07             mov     eax,[edi]         ; eax = m_pvo
71517215 51               push    ecx               ; NULL
71517216 51               push    ecx               ; 0
71517217 51               push    ecx               ; 0
71517218 8b10             mov     edx,[eax]         ; edx = m_pvo->lpVtbl
7151721a 50               push    eax               ; "this" for callee
7151721b ff521c           call    [edx+0x1c]        ; __stdcall SetAdvise
No_SetAdvise:
                pSink->Release();
7151721e 8b4508           mov     eax,[ebp+0x8]     ; eax = pSink
71517221 50               push    eax               ; "this" for callee
71517222 8b08             mov     ecx,[eax]         ; ecx = pSink->lpVtbl
71517224 ff5108           call    [ecx+0x8]         ; __stdcall Release
No_Advise:

Todas essas chamadas de método COM devem parecer muito familiares.

A avaliação das duas próximas instruções é intercalada. Não se esqueça de que o EBX contém o endereço de ReleaseAndNull.

            fViewObjectChanged = TRUE;
            ReleaseAndNull(&m_pvo);
71517227 57               push    edi               ; &m_pvo
71517228 c745fc01000000   mov     dword ptr [ebp-0x4],0x1 ; fViewObjectChanged = TRUE
7151722f ffd3             call    ebx               ; call ReleaseAndNull
No_Pvo:
        if (psv) {
71517231 8b7df8           mov     edi,[ebp-0x8]     ; edi = psv
71517234 85ff             test    edi,edi           ; edi == 0?
71517236 7412             jz      No_Psv2 (7151724a) ; jump if zero
            psv->SaveViewState();
71517238 8b07             mov     eax,[edi]         ; eax = psv->lpVtbl
7151723a 57               push    edi               ; "this" for callee
7151723b ff5034           call    [eax+0x34]        ; __stdcall SaveViewState

Aqui estão mais chamadas de método COM.

            psv->DestroyViewWindow();
7151723e 8b07             mov     eax,[edi]         ; eax = psv->lpVtbl
71517240 57               push    edi               ; "this" for callee
71517241 ff5028           call    [eax+0x28]        ; __stdcall DestroyViewWindow
            psv->Release();
71517244 8b07             mov     eax,[edi]         ; eax = psv->lpVtbl
71517246 57               push    edi               ; "this" for callee
71517247 ff5008           call    [eax+0x8]         ; __stdcall Release
No_Psv2:
        m_hwndView = NULL;
7151724a 83667c00         and     dword ptr [esi+0x7c],0x0 ; m_hwndView = 0

Anding a memory location with zero is the same as setting it to zero, because anything AND zero is zero. O compilador usa esse formulário porque, embora seja mais lento, ele é muito menor do que a instrução mov equivalente. (Esse código foi otimizado para tamanho, não velocidade.)

        m_fHandsOff = FALSE;
7151724e 83a60c010000fe   and     dword ptr [esi+0x10c],0xfe
        if (m_pcache) {
71517255 8b4670           mov     eax,[esi+0x70]    ; eax = m_pcache
71517258 85c0             test    eax,eax           ; eax == 0?
7151725a 740b             jz      No_Cache (71517267) ; jump if zero
            GlobalFree(m_pcache);
7151725c 50               push    eax               ; m_pcache
7151725d ff15b4135071     call    [_imp__GlobalFree]    ; call GlobalFree
            m_pcache = NULL;
71517263 83667000         and     dword ptr [esi+0x70],0x0 ; m_pcache = 0
No_Cache:
        m_psb->EnableModelessSB(TRUE);
71517267 8b4638           mov     eax,[esi+0x38]    ; eax = this->m_psb
7151726a 6a01             push    0x1               ; TRUE
7151726c 50               push    eax               ; "this" for callee
7151726d 8b08             mov     ecx,[eax]         ; ecx = m_psb->lpVtbl
7151726f ff5124           call    [ecx+0x24]        ; __stdcall EnableModelessSB
        CancelPendingActions();

Para chamar CancelPendingActions, você precisa passar de (ViewState*)para (CUserView*)isso. Observe também que CancelPendingActions usa a convenção de chamada __thiscall em vez de __stdcall. De acordo com __thiscall, o ponteiro "this" é passado no registro ECX em vez de ser passado na pilha.

71517272 8d4eec           lea     ecx,[esi-0x14]    ; ecx = (CUserView*)this
71517275 e832fbffff       call CUserView::CancelPendingActions (71516dac) ; __thiscall
    ReleaseAndNull(&_psf);
7151727a 33ff             xor     edi,edi           ; edi = 0 (for later)
No_Psv:
7151727c 8d4678           lea     eax,[esi+0x78]    ; eax = &_psf
7151727f 50               push    eax               ; parameter
71517280 ffd3             call    ebx               ; call ReleaseAndNull
    if (fViewObjectChanged)
71517282 397dfc           cmp     [ebp-0x4],edi     ; fViewObjectChanged == 0?
71517285 740d             jz      NoNotifyViewClients (71517294) ; jump if zero
       NotifyViewClients(DVASPECT_CONTENT, -1);
71517287 8b46ec           mov     eax,[esi-0x14]    ; eax = ((CUserView*)this)->lpVtbl
7151728a 8d4eec           lea     ecx,[esi-0x14]    ; ecx = (CUserView*)this
7151728d 6aff             push    0xff              ; -1
7151728f 6a01             push    0x1               ; DVASPECT_CONTENT = 1
71517291 ff5024           call    [eax+0x24]        ; __thiscall NotifyViewClients
NoNotifyViewClients:
    if (m_pszTitle)
71517294 8b8680000000     mov     eax,[esi+0x80]    ; eax = m_pszTitle
7151729a 8d9e80000000     lea     ebx,[esi+0x80]    ; ebx = &m_pszTitle (for later)
715172a0 3bc7             cmp     eax,edi           ; eax == 0?
715172a2 7409             jz      No_Title (715172ad) ; jump if zero
        LocalFree(m_pszTitle);
715172a4 50               push    eax               ; m_pszTitle
715172a5 ff1538125071     call   [_imp__LocalFree]
        m_pszTitle = NULL;

Lembre-se de que EDI ainda é zero e o EBX ainda está &m_pszTitle, pois esses registros são preservados por chamadas de função.

715172ab 893b             mov     [ebx],edi         ; m_pszTitle = 0
No_Title:
    SetRect(&m_rcBounds, 0, 0, 0, 0);
715172ad 57               push    edi               ; 0
715172ae 57               push    edi               ; 0
715172af 57               push    edi               ; 0
715172b0 81c6fc000000     add     esi,0xfc          ; esi = &this->m_rcBounds
715172b6 57               push    edi               ; 0
715172b7 56               push    esi               ; &m_rcBounds
715172b8 ff15e41a5071     call   [_imp__SetRect]

Observe que você não precisa mais do valor de "isso", portanto, o compilador usa a instrução add para modificá-lo em vez de usar outro registro para manter o endereço. Na verdade, isso é uma vitória de desempenho devido à pipeagem pentium u/v, porque o pipe v pode fazer aritmética, mas não lidar com cálculos.

    return S_OK;
715172be 33c0             xor     eax,eax           ; eax = S_OK

Por fim, você restaura os registros necessários para preservar, limpo a pilha e retorna ao chamador, removendo os parâmetros de entrada.

715172c0 5b               pop     ebx               ; restore
ReturnNoEBX:
715172c1 5f               pop     edi               ; restore
715172c2 5e               pop     esi               ; restore
715172c3 c9               leave                     ; restores EBP and ESP simultaneously
715172c4 c20400           ret     0x4               ; return and clear parameters