Хукинг экспортируемых функций

Тема в разделе "WASM.X64", создана пользователем katrus, 30 окт 2007.

  1. TermoSINteZ

    TermoSINteZ Синоби даоса Команда форума

    Публикаций:
    2
    Регистрация:
    11 июн 2004
    Сообщения:
    3.549
    Адрес:
    Russia
    katrus
    http://wasmforum.com/forum/YaBB.pl?num=1170142245
    Тут дизасмы я как то давно искал....
    А так я взял какой то опенсорс, и вырезал из него дизасм длин инструкций.. Получился довольно небольшой бинарник, его и подключал.
    Если интересно - гляну что юзал
     
  2. z0mailbox

    z0mailbox z0

    Публикаций:
    0
    Регистрация:
    3 фев 2005
    Сообщения:
    635
    Адрес:
    Russia СПБ
    katrus
    если это дизассемблер длин - то все сами пишут. в прологе сравнительно небольшой набор инструкций. у меня такой огрызок например прекрасно справляется
    Код (Text):
    1. #define JMP_SIZE 2
    2.  
    3. #define PREFIX_OPERAND 1
    4. #define PREFIX_ADDRESS 2
    5.  
    6. void postbyte (BYTE* &pointer)
    7. {
    8.     BYTE byte;
    9.  
    10.     pointer++;
    11.  
    12.     byte = *pointer;
    13.  
    14.     pointer++;
    15.  
    16.     switch (byte >> 6)
    17.     {
    18.         case 0:
    19.         {
    20.             if (4 == (byte & 7))
    21.             {
    22.                 byte = *pointer;
    23.                 pointer++;
    24.  
    25.                 if (5 == (byte &7))
    26.                 {
    27.                     pointer +=4;
    28.                 }
    29.                 return;
    30.             }
    31.  
    32.             if (5 == (byte & 7))
    33.             {
    34.                 pointer += 4;
    35.                 return;
    36.             }
    37.  
    38.             return;
    39.         }
    40.  
    41.         case 1:
    42.         {
    43.             if (4 == (byte & 7))
    44.             {
    45.                 pointer +=2;
    46.                 return;
    47.             }
    48.  
    49.             pointer++;
    50.             return;
    51.         }
    52.  
    53.         case 2:
    54.         {
    55.             if (4 == (byte & 7))
    56.             {
    57.                 pointer +=5;
    58.                 return;
    59.             }
    60.  
    61.             pointer +=4;
    62.             return;
    63.         }
    64.     }
    65. }
    66.  
    67. DWORD get_size (PVOID address)
    68. {
    69.     BYTE byte;
    70.     BYTE* pointer;
    71.     DWORD prefix;
    72.  
    73.     pointer = (BYTE*) address;
    74.     for ( ;(pointer - address) < JMP_SIZE; )
    75.     {
    76.         prefix = 0;
    77.         for (;;)
    78.         {
    79.             byte = *pointer;
    80.  
    81.             if ((byte >= 0x40) && (byte <= 0x4f))
    82.             {
    83.                 pointer++;
    84.             #ifdef _WIN64
    85.                 continue;   // prefix REX
    86.             #else
    87.                 break;      // inc/dec reg32
    88.             #endif
    89.             }
    90.  
    91.             if ((byte >= 0x50) && (byte <= 0x5f))   // push/pop reg32
    92.             {
    93.                 pointer++;
    94.                 break;
    95.             }
    96.  
    97.             if (0x2e == byte) // prefix CS (ignored in 64-bit mode)
    98.             {
    99.                 pointer++;
    100.                 continue;
    101.             }
    102.  
    103.             if (0x3e == byte) // prefix DS (ignored in 64-bit mode)
    104.             {
    105.                 pointer++;
    106.                 continue;
    107.             }
    108.  
    109.             if (0x26 == byte) // prefix ES (ignored in 64-bit mode)
    110.             {
    111.                 pointer++;
    112.                 continue;
    113.             }
    114.  
    115.             if (0x36 == byte) // prefix SS (ignored in 64-bit mode)
    116.             {
    117.                 pointer++;
    118.                 continue;
    119.             }
    120.  
    121.             if (0x64 == byte) // prefix FS
    122.             {
    123.                 pointer++;
    124.                 continue;
    125.             }
    126.  
    127.             if (0x65 == byte) // prefix GS
    128.             {
    129.                 pointer++;
    130.                 continue;
    131.             }
    132.  
    133.             if (0x66 == byte) // prefix operand-size override
    134.             {
    135.                 prefix |= PREFIX_OPERAND;
    136.  
    137.                 pointer++;
    138.                 continue;
    139.             }
    140.  
    141.             if (0x67 == byte) // prefix address-size override
    142.             {
    143.                 prefix |= PREFIX_ADDRESS;
    144.  
    145.                 pointer++;
    146.                 continue;
    147.             }
    148.  
    149.             if (0xf0 == byte) // prefix LOCK
    150.             {
    151.                 pointer++;
    152.                 continue;
    153.             }
    154.  
    155.             if (0xf2 == byte) // prefix REPNE
    156.             {
    157.                 pointer++;
    158.                 continue;
    159.             }
    160.  
    161.             if (0xf3 == byte) // prefix REPE
    162.             {
    163.                 pointer++;
    164.                 continue;
    165.             }
    166.  
    167.             if (0x68 == byte) // push imm32
    168.             {
    169.                 pointer +=5;
    170.                 break;
    171.             }
    172.  
    173.             if (0x6a == byte) // push imm32
    174.             {
    175.                 pointer +=2;
    176.                 break;
    177.             }
    178.  
    179.             if ((byte >= 0xa0) && (byte <= 0xa3))   // mov rax,imm64
    180.             {
    181.                 if (prefix & PREFIX_OPERAND)
    182.                 {
    183.                 #ifdef _WIN64
    184.                     pointer +=5;
    185.                 #else
    186.                     pointer +=3;
    187.                 #endif
    188.                 }
    189.                 else
    190.                 {
    191.                 #ifdef _WIN64
    192.                     pointer +=9;
    193.                 #else
    194.                     pointer +=5;
    195.                 #endif
    196.                 }
    197.                 break;
    198.             }
    199.  
    200.             if ((byte >= 0xb0) && (byte <= 0xb7))   // mov al,imm8
    201.             {
    202.                 pointer +=2;
    203.                 break;
    204.             }
    205.  
    206.             if ((byte >= 0xb8) && (byte <= 0xbf))   // mov al,imm8
    207.             {
    208.                 if (prefix & PREFIX_OPERAND)
    209.                 {
    210.                 #ifdef _WIN64
    211.                     pointer +=5;
    212.                 #else
    213.                     pointer +=3;
    214.                 #endif
    215.                 }
    216.                 else
    217.                 {
    218.                 #ifdef _WIN64
    219.                     pointer +=9;
    220.                 #else
    221.                     pointer +=5;
    222.                 #endif
    223.                 }
    224.                 break;
    225.             }
    226.  
    227.             if ((0x89 == byte) || (0x8b == byte) || (0x8d == byte) || (0xff == byte))
    228.             {
    229.                 postbyte (pointer);
    230.                 break;
    231.             }
    232.  
    233.             if (0x81 == byte)
    234.             {
    235.                 postbyte (pointer);
    236.                 pointer += 4;
    237.                 break;
    238.             }
    239.  
    240.             if (0x83 == byte)
    241.             {
    242.                 postbyte (pointer);
    243.                 pointer++;
    244.                 break;
    245.             }
    246.  
    247.             return 0;
    248.         }
    249.     }
    250.     return pointer - address;
    251. }
    ваще это можно и на один экран запихнуть но тогда дебажить будет неудобно