home *** CD-ROM | disk | FTP | other *** search
/ Hackers Toolkit v2.0 / Hackers_Toolkit_v2.0.iso / HTML / archive / Texts / cracking / razzia-vbtutor.txt < prev    next >
Text File  |  1999-11-04  |  23KB  |  496 lines
  1. razzia's tutorial for vb cracking
  2.  
  3. Introduction
  4.  
  5.      Lately more and more programs come out that are programmed in VB.
  6.      Since VB programs are still unknown material for most crackers they
  7.      ignore them and label it as 'uncrackable'. In this document i will
  8.      show you that that is not true for text based protections
  9.      (serials/reg#'s).
  10.  
  11.      For tools we will need only soft-ice and in one case hiew.
  12.      Further-more i assume that the reader is somewhat familiar with
  13.      cracking. For absolutely beginners i recommend the great tutorials
  14.      made by +orc and ed!son's good windows tutorial. But i will try my
  15.      best to make the text understandable for everyone who has a litle
  16.      knownledge about cracking.
  17.  
  18. Getting ourselves prepared
  19.  
  20.      Before i start bombing you with asm listings lets take a moment to
  21.      think about what we are dealing with.
  22.      We are dealing with exe's that dont have code themselves but instead
  23.      they make calls to a library with standard functions.
  24.      What does this mean? It means that this is a big disadventage to
  25.      protect programs written in VB. Why? Do you think that the writers of
  26.      the VB dll made 10 different functions that you can use to compare 2
  27.      strings? No, ofcourse not. They made the dll to be as efficient as
  28.      possible, as small as possible.
  29.  
  30.      So therefore a good guess is that there will be only 1 or 2 places in
  31.      the dll where it can compare two strings. And that turns out to be the
  32.      case as you will see if you finish reading this document.
  33.  
  34.      Does the litle lamp already begin to glow in your head ? ;--)
  35.      Wouldnt it be great if we knew where in the dll 2 strings get
  36.      compared? Yes, it would be great. It would reduce VB cracking to a
  37.      boring job of setting a single breakpoint at the right place. Continue
  38.      reading for the details.
  39.  
  40. Strategy
  41.  
  42.      Before we continue it would be wise to set out a strategy (like its
  43.      the case with every other case of cracking).
  44.  
  45.      Lets think about the protection ...
  46.      You enter a string of text , you hit enter or press 'OK' or whatever.
  47.      Then windows gives the data you entered to the VB dll. The VB dll then
  48.      does whatever it needs to know if that data is right or wrong. And you
  49.      get a msg saying you entered a good/wrong code.
  50.      So what would be the weak link in the chain? The answer is where
  51.      windows gives the data you entered to the VB dll. Thats our entry
  52.      point. We can make softice break there. And then we are at the source
  53.      of the protection-chain. With the aid of breakpoints we can then
  54.      monitor what happens with our text.
  55.  
  56.      I think that we now have enough background information to crack a
  57.      first example.
  58.  
  59. Case 1 : The Collector v2.1
  60.  
  61.      The collector is an utility for creating and maintaining your
  62.      image/photo collection. Not bad for a VB program.
  63.  
  64.      More info about this program :
  65.  
  66.         Name       : The Collector v2.1
  67.         Where      : http://intranet.ca/~logic/collectr.html
  68.         Size       : collectr.exe = 246.047 bytes
  69.         Protection : serial
  70.         DLL        : uses VB3 dll
  71.  
  72.      I find it easier to explain things in steps. So therefor i will split
  73.      the cracking process in smaller chunks :
  74.  
  75.      Step 1 : Run The Collector - right at startup it will ask you for a
  76.      serial #
  77.  
  78.      Step 2 : Enter a dummy serial like '9876543210'. Now press control-d
  79.      to enter softice. In softice enter 'bpx hmemcpy' to place a breakpoint
  80.      on the hmemcpy function of the kernel.
  81.  
  82.      Intermezzo : What is hmemcpy ?
  83.      Windows uses hmemcpy alot in operations concerning strings. In this
  84.      case it will be used to copy the buffer with the text we entered to
  85.      the memory space of the VB dll. Remember when i said that we were
  86.      gonna break when windows gave the string we entered to the VB dll?)
  87.  
  88.      Step 3 : Leave softice with control-d. And press 'OK". This will make
  89.      softice break right at the beginning of hmemcpy.
  90.  
  91.      Step 4 : Now we will continue with tracing further into the hmemcpy
  92.      function to find out where the string we entered will be stored. Keep
  93.      pressing F10 untill you see this :
  94.  
  95.      JMP   9E9F
  96.      PUSH  ECX           ;these lines copy the
  97.      SHR   ECX,02        ;string at ds:si to es:di
  98.      REPZ  MOVSD
  99.      POP   ECX
  100.      AND   ECX,03
  101.      REPZ  MOVSB
  102.      XOR   DX,DX
  103.  
  104.      Step 5: Right before REPZ MOVSD do a 'ed si'. You will the text you
  105.      entered, in my case its shows '0987654321'. Do a 'ed es:di' and you
  106.      will see nothing (yet). But if you press F10 and get passed the REPZ
  107.      MOVSB you will see the text getting copied to this new location where
  108.      the VB dll can access it.
  109.  
  110.      Step 6: Now we know where the text is located. Lets review our
  111.      strategy here. Our plan was to find out where the VB dll kept our
  112.      serial, then put a breakpoint on that memory location and find out
  113.      with what it got compared. So, lets set a bpr (breakpoint on range) at
  114.      the location with our string. Since the REPZ MOVS(D/B) instructions
  115.      increased the pointer in di (it now points to the end of our string)
  116.      we do 'bpr es:di-8 es:di-1 rw'. Dont hit enter yet - read step 7
  117.      first.
  118.  
  119.      Step 7: Before you hit enter i will tell you what to expect. Softice
  120.      will break everywhere where that block of memory with the string is
  121.      read or written to.
  122.  
  123.      For example you will break inside the function strlen where the lenght
  124.      of the string is calculated.
  125.      And you will break where the string is copied to another place in
  126.      memory (for example with REPZ MOVSW). When this happens place a new
  127.      bpr at the new location with the string.
  128.      It will also break when the string or part of it gets deleted. If not
  129.      the whole string gets deleted do not remove the corresponding bpr.
  130.      Only remove it when the complete string gets written over by something
  131.      else.
  132.      Also you will break again in hmemcpy. Hmemcpy will read another echo
  133.      of the string in the dll's memory. Place a bpr there too.
  134.      And finally you will break at the part of the code that does the
  135.      comparing (the instruction you will see is REPZ CMPSB).
  136.  
  137.      When i reached that part of code i had 4 breakpoints set. One
  138.      breakpoint for hmemcpy and 3 bpr's on 3 echos of the string (or parts
  139.      of it).
  140.  
  141.      Step 8: Now we found the code where the VB3 dll does comparing we can
  142.      place a breakpoint there and disable the other breakpoints. We wont
  143.      need them anymore. We found the place where things get compared in
  144.      VB3. What you see is this :
  145.  
  146.      : 8BCA         mov cx, dx
  147.      : F3A6         repz cmpsb  ;<- here the strings in ds:si and es:di
  148.      : 7401         je 8CB6     ;   are being compared
  149.      : 9F           lahf
  150.      : 92           xchg ax,dx
  151.      : 8D5E08       lea bx, [bp+08]
  152.      : E80E06       call 92CB
  153.  
  154.      Just before the REPZ CMPSB if you do a 'ed si' and a 'ed es:di', you
  155.      will see what is compared with what. In this case the second and third
  156.      character of the string we entered gets comared with 'V8'. So if you
  157.      restart the program and enter 0V87654321 it will register.
  158.  
  159.      Step 9: We are not finished yet. The contrary is true, the important
  160.      part is what we do now. Next time we meet a VB3 program we want to
  161.      place a breakpoint at the location with the code above and read out
  162.      the right serial.
  163.  
  164.      How do we do that ? Lets try it real quick with The Collector.
  165.    * Start The Collector and enter a dummy serial.
  166.    * Enter softice and place a breakpoint on hmemcpy.
  167.    * Leave softice and press 'OK', this will put you back in softice.
  168.    * Now, get out of the kernel and and get in the code of VBRUN300 (press
  169.      F11 and F10 untill you get there)
  170.    * Now do a search for the pattern :
  171.      8B,CA,F3,A6,74,01,9f,92,8D,5E,08,E8,0E,06
  172.      :s 0 l ffffffffff 8B,CA,F3,A6,74,01,9f,92,8D,5E,08,E8,0E,06
  173.    * Place a breakpoint at the adress that gets returned
  174.      :bpx <seg:offset>
  175.    * press F5 and you will land in the middle of the above comparing code.
  176.    * Only thing left to do is check out the pointers in es:di and ds:si
  177.  
  178. Case 2 : Minimize Magic 1.2.4
  179.  
  180.      Minimize Magic is an utility that you can use to minimize your
  181.      programs to the traybar.
  182.  
  183.      More info about this program:
  184.  
  185.         Name       : Minimize Magic 1.2.4
  186.         Where      : http://www.genesoft.demon.co.uk/
  187.         Size       : minimagic.exe =  159.744 bytes
  188.         Protection : password based on key
  189.         DLL        : uses VB4 dll
  190.  
  191.      To crack this program you can do the same as we did with The
  192.      Collector. Starting with hmemcpy working your way to the code that
  193.      compares the string you entered. Important thing to know is that the
  194.      VB4 dll always converts strings to the WideChar format before it does
  195.      anything with them. So instead of using hmemcpy you can set a
  196.      breakpoint on MultiByteToWideChar to break. Check your windows API
  197.      reference to learn more about this function.
  198.  
  199.      I have done all the hard work for you and found the VB4 dll code that
  200.      compares two strings (in WideChar format !).
  201.  
  202.      Heres the listing :
  203.  
  204.      : 56            push esi
  205.      : 57            push edi
  206.      : 8B7C2410      mov edi, [esp + 10]
  207.      : 8B74240C      mov esi, [esp + 0C]
  208.      : 8B4C2414      mov ecx, [esp + 14]
  209.      : 33C0          xor eax, eax
  210.      : F366A7        repz cmpsw  ;<-- here the (WideChar) strings at ds:esi
  211.      : 7405          je 0F79B362 ;    and es:edi get compared
  212.      : 1BC0          sbb eax, eax
  213.      : 83D8FF        sbb eax, FFFFFFFF
  214.      : 5F            pop edi
  215.      : 5E            pop esi
  216.      : C20C00        ret 000C
  217.  
  218.      Now we know enough of the VB4 dll to crack Minimize Magic:
  219.  
  220.      Step 1: Start Minimize Magic and chose Register from the menus. You
  221.      will be asked for a Name and a Password. Enter a name and a dummy
  222.      password. Dont press 'OK' yet, continue with next step.
  223.  
  224.      Step 2: Enter softice and place a breakpoint on hmemcpy. Leave softice
  225.      and press 'OK'. You will land in softice.
  226.  
  227.      Step 3: Press F11 and F10 untill you are out of the kernel and in the
  228.      code of the VB40032.dll. Now we will search for the pattern of the
  229.      code above. Do 's 0 l fffffffff
  230.      56,57,8b,7c,24,10,8b,74,24,0c,8b,4c,24,14' and place a breakpoint at
  231.      the adress that gets returned.
  232.  
  233.      Step 4: Press F5 to leave softice, but you will immediately break
  234.      again, right at the beginning of the above code. Here the password you
  235.      entered will be compared to the correct password. Trace untill right
  236.      before the REPZ CMPSW and do 'ed es:edi', this will show the password
  237.      you entered. If you do 'ed esi' you will see the correct password.
  238.      (the strings will be in WideChar format - for example you could see A
  239.      T G H D E H D. That means your password is ATGHDEHD)
  240.  
  241.      Ok, now you found a working password that will work only for the
  242.      version on your computer. If you give that password to somebody else,
  243.      the program wont accept it. The password is calculated from a Key that
  244.      is different on each computer. This key could be randomly generated at
  245.      setup or based on the info on your hd. Whichever one it is, it will be
  246.      hard to find out how its generated or where it is stored.
  247.  
  248.      So how can we make a general crack ?
  249.  
  250.      We could use the 'Magic Window' trick here. We will 'reprogram' the
  251.      VB40032.dll to show the correct password.
  252.  
  253.      The original code in the VB40032.dll looks like this :
  254.  
  255.      :0F79B348 56         push esi
  256.      :0F79B349 57         push edi
  257.      :0F79B34A 8B7C2410   mov edi, [esp + 10] ; es:edi -> pw you entered
  258.      :0F79B34E 8B74240C   mov esi, [esp + 0C] ; esi -> correct pw
  259.      :0F79B352 8B4C2414   mov ecx, [esp + 14]
  260.      :0F79B356 33C0       xor eax, eax
  261.      :0F79B358 F366A7     repz cmpsw          ; compare them
  262.      :0F79B35B 7405       je 0F79B362
  263.      :0F79B35D 1BC0       sbb eax, eax
  264.      :0F79B35F 83D8FF     sbb eax, FFFFFFFF
  265.      :0F79B362 5F         pop edi
  266.      :0F79B363 5E         pop esi
  267.      :0F79B364 C20C00     ret 000C            ; end of this function
  268.      :0F79B367 57         push edi            ; the code below this adress
  269.      :0F79B368 8B7C2408   mov edi, [esp + 08] ; is not important, but we
  270.      :0F79B36C 8B4C2410   mov ecx, [esp + 10] ; will need its space
  271.      :0F79B370 8B44240C   mov eax, [esp + 0C]
  272.      :0F79B374 0BE4       or esp, esp
  273.      :0F79B376 F266AF     repnz scasw
  274.      :0F79B379 B800000000 mov eax, 00000000
  275.      :0F79B37E 7503       jne 0F79B383
  276.      :0F79B380 8D47FE     lea eax, [edi-02]
  277.      :0F79B383 5F         pop edi
  278.      :0F79B384 C20C00     ret 000C
  279.  
  280.      The code is located at offset 7a748 in the vb40032.dll file. So, to
  281.      make a general crack make a patch that turns the above code into:
  282.  
  283.      :0F79B348 56           push esi
  284.      :0F79B349 57           push edi
  285.      :0F79B34a 8B7C2410     mov edi, [esp + 10] ;es:edi --> text you enter
  286.      :0F79B34E 8B74240C     mov esi, [esp + 0C] ;esi --> correct pw
  287.      :0F79B352 813F70006300 cmp dword ptr [edi], 00630070 ;edi -> 'PC" ?
  288.      :0F79B358 7527         jne 0F79B381                  ;if not - leave
  289.      :0F79B35A 803E00       cmp byte ptr [esi], 00   |<- these lines
  290.      :0F79B35D 7410         je 0F79B36F              |   put spaces
  291.      :0F79B35F 83C601       add esi, 00000001        |   between the chars
  292.      :0F79B362 C60620       mov byte ptr [esi], 20   |
  293.      :0F79B365 EB03         jmp 0F79B36A             |<--skip the ret
  294.      :0F79B367 C20C00       ret 000C            ;<-- this to prevent crash
  295.      :0F79B36A 83C601       add esi, 00000001        |
  296.      :0F79B36D EBEB         jmp 0F79B35A             |<- back to the start
  297.      :0F79B36F 8B3DDCC47B0F mov edi, [0F7BC4DC]      *<-- these lines
  298.      :0F79B375 8B74240C     mov esi, [esp + 0C]      *    call the
  299.      :0F79B379 6A00         push 00000000            *    MessageBoxA
  300.      :0F79B37B 56           push esi                 *    function to show
  301.      :0F79B37C 56           push esi                 *    the correct
  302.      :0F79B37D 6A00         push 00000000            *    password
  303.      :0F79B37F FFD7         call edi                 *
  304.      :0F79B381 5F           pop edi
  305.      :0F79B382 5E           pop esi
  306.      :0F79B383 90           nop
  307.      :0F79B384 C20C00       ret 000C
  308.  
  309.      Comments:
  310.  
  311.      We used the space of two routines, so to prevent a crash we have to
  312.      put a RET function at the beginning of the (original) second function
  313.      (see line 0F79B367).
  314.  
  315.      This part of the VB4 dll code is not only used to check the passwords.
  316.      It is used by other parts of the program as well. Therefor we need to
  317.      do something so that only something will be shown when we are dealing
  318.      with a password comparison. That is what the code at line 0F79B352 is
  319.      about. It checks to see if EDI points to the text "PC". So we can use
  320.      that to trigger the crack. To trigger the crack, "PC" has to be
  321.      entered for password when registering.
  322.  
  323.      The lines marked with | are there to put spaces between chars of the
  324.      string. Originally there would be a string of WideChar format. That
  325.      means that in memory there will be zero's between the chars. And the
  326.      function we will use to show the text (MessageBoxA) translates a 0 to
  327.      end of string. So only 1 letter would be shown if we dont replace the
  328.      zeros with spaces.
  329.  
  330.      The lines marked with * are there to call the function MessageBoxA to
  331.      show the correct password. I ripped those commands from the VB4 dll.
  332.      Placed a breakpoint on MessageBoxA to see how VB4 called it.
  333.  
  334.      Well thats it for Minimize Magic. To make a general crack, a patch
  335.      could be written that patches the VB4 dll at offset 7a748 with the
  336.      above code. To use such a crack minimagic.exe and the vb40032.dll
  337.      should be placed in a temp dir and the patch run there. Then start
  338.      minimize.exe from that temp dir, and use 'PC' for password. And voila,
  339.      a window will pop up with the correct password. Once the correct pw is
  340.      known, the temp files should be deleted and the password can be used
  341.      in the original Minimize Magic.
  342.  
  343. Case 3 : Sub Station Alpha 2.02
  344.  
  345.      Most of the VB4 programs can be cracked with the method described in
  346.      case 2, but i have encountered 2 programs which used a different
  347.      method of comparing. One of those programs is Sub Station Alpha 2.02.
  348.      It uses a protection that first converts a number you enter to its hex
  349.      value and then compares it with the correct number. Lets start to
  350.      crack Sub Station Alpha and things will get clearer.
  351.  
  352.      Info about this program:
  353.  
  354.      Name       : Sub Station Alpha 2.02
  355.      Where      : http://www.genesoft.demon.co.uk/
  356.      Size       : SUBSTN32.EXE = 629.248 bytes
  357.      Protection : password based on user name
  358.      DLL        : uses VB4 dll
  359.  
  360.      Earlier i mentioned that VB4 converts strings to the widechar format
  361.      before it does aything with them. Therefor we will use this function
  362.      as an entry point. Again we will do it step by step ;--)
  363.  
  364.      Step 1: Start Sub Station Alpha and chose register from the menus.
  365.      Enter a name and a dummy registration key.
  366.  
  367.      Step 2: Enter softice and place a breakpoint on MultiByteToWideChar
  368.      (with 'bpx MultiByteToWideChar')
  369.  
  370.      Step 3: Now, leave softice and press "Register".
  371.  
  372.      Step 4: Softice will break at the beginning of MultiByteToWideChar,
  373.      press F11 to get out of it. You will see :
  374.  
  375.      :FF1500C27B0F call [KERNEL32!MultiByteToWideChar]
  376.      :8BD8         mov ebx, eax
  377.      :83FEFF       cmp esi, FFFFFFFF
  378.      :7501         jne 0F738BCF
  379.      :4B           dec ebx
  380.      :53           push ebx
  381.      :6A00         push 00
  382.      :FF1518C97B0F call dword ptr [0F7BC918]
  383.      :8BE8         mov ebp, eax
  384.      :85ED         test ebp, ebp
  385.      :0F845B260100 jz 0F74B23D
  386.      :43           inc ebx
  387.      :53           push ebx
  388.      :55           push ebp
  389.      :56           push esi
  390.      :57           push edi
  391.      :6A00         push 00
  392.      :6A00         push 00
  393.      :FF1500C27B0F call [KERNEL32!MultiByteToWideChar]
  394.      :8BC5         mov eax, ebp       ;<-- do 'ed ebp' here
  395.      :5D           pop ebp
  396.      :5F           pop edi
  397.      :5E           pop esi
  398.  
  399.      The important place is right after the second call to
  400.      MultiByte-ToWideChar. Disable the first bp on MultiByteToWideChar and
  401.      place a new bp right after the second call to that function (on the
  402.      line with MOV EAX,EBP). On that line EBP will contain a pointer to a
  403.      string in WideChar format that was processed. It doesnt have to be the
  404.      string of the registration key. Therefor we will edit that breakpoint
  405.      so that it will only break when it is processing the registration key.
  406.  
  407.      How can we do that? Well, the MultiByteToWideChar function returns the
  408.      lenght of the string it processed plus 1 in EAX. So we will add a
  409.      conditional statement on the breakpoint. Do 'bl' to find out what the
  410.      number is of that breakpoint. Then do 'bpe #' and add 'if al==' to the
  411.      breakpoint. For example, if you entered '212121', lenghtOfKeyString
  412.      would be 6 :--).
  413.  
  414.      Step 5: Now we will let the program run with F5. When softice breaks
  415.      do a 'ed edp' and see the WideChar form of the key you entered. We
  416.      place a bpr on the block of memory containing the string and we
  417.      continue (F5). What will happen is this. Softice will break on several
  418.      places. Whats important is that it will break in the code of OLEAUT32.
  419.      When that happens trace a litle further to see whats going on. The
  420.      first few times you will get out of the OLEAUT32 very quickly. But
  421.      eventually you will see this code :
  422.  
  423.      ( listing from OLEAUT32.DLL)
  424.      :6534B6B3 395C240C cmp [esp + 0C], ebx     ;  this is a loop that
  425.      :6534B6B7 7E14     jle 6534B6CD            ;  goes trough all
  426.      :6534B6B9 33C9     xor ecx, ecx            ;  the chars of a
  427.      :6534B6BB 8D0492   lea eax, [edx + 4*edx]  ;  string, in the end
  428.      :6534B6BE 8A0E     mov cl , [esi]          ;  edx will have the
  429.      :6534B6C0 46       inc esi                 ;  hex value of the string
  430.      :6534B6C1 4F       dec edi
  431.      :6534B6C2 FF4C240C dec [esp + 0C]
  432.      :6534B6C6 8D1441   lea edx, [ecx + 2*eax]
  433.      :6534B6C9 85FF     test edi, edi
  434.      :6534B6CB 7FE6     jg 6534B6B3
  435.      :6534B6CD 85FF     test edi, edi
  436.      :6534B6CF 7F4A     jg 6534B71B
  437.        .............
  438.        .............
  439.      :6534B6F2 8910     mov [eax], edx          ;  edx is saved
  440.      :6534B6F4 33C0     xor eax, eax
  441.      :6534B6F6 83C424   add esp, 00000024
  442.      :6534B6F9 C21000   ret 0010
  443.  
  444.      Step 6: We saw that the key is transformed into its hex value, and
  445.      saved to a place in memory. If you monitor this memory location, you
  446.      will end up here in the VB4 dll that compares it with another value:
  447.  
  448.      :0F7A2CE1 5A             pop edx             ; load edx
  449.      :0F7A2CE2 58             pop eax             ; load eax
  450.      :0F7A2CE3 2BC2           sub eax, edx        ; subtract them
  451.      :0F7A2CE5 83F801         cmp eax, 00000001
  452.      :0F7A2CE8 1BC0           sbb eax, eax
  453.      :0F7A2CEA 50             push eax
  454.      :0F7A2CEB 0FB706         movzx word ptr eax, [esi]
  455.      :0F7A2CEE 83C602         add esi, 00000002
  456.      :0F7A2CF1 FF2445F4997B0F jmp dword ptr [2*eax + 0F7B99F4]
  457.      :0F7A2CF8 E8BB000000     call 0F7A2DB8
  458.  
  459.      We see that EDX and EAX get loaded from the stack, and then
  460.      substracted. This is just an indirect way of comparing those two
  461.      values. If you check out the contents of EAX and EDX, you will see
  462.      that one has the number you entered and the other one will have the
  463.      correct registration number.
  464.  
  465.      Step 7: Now we found this location its wise to note the hex values of
  466.      the code, so you can find it back quickly when you suspect that
  467.      another VB4 program uses this protection.
  468.  
  469. Final notes
  470.  
  471.      Well, with the above 3 techniques i have been able to crack quite some
  472.      VB3/4 programs that used a text based protection. Sometimes when you
  473.      set a breakpoint at the comparing routine, softice will not break. Try
  474.      then to enter strings with a different length. Because the program
  475.      could be checking the length of the string you enter before it
  476.      compares the string itself. And other programs first isolate chars
  477.      from the string you enter and then compare those isolated chars, but
  478.      again they get compared at the locations stated in the examples above.
  479.  
  480.      With VB5 programs i havent much experience, i only cracked one of
  481.      them. It was called Hitlist Pro v3.0. By patching the VB5 dll, I could
  482.      remove its 30 day timelimit just like it was a regular program. Of
  483.      course, the VB5 dll had to be placed in the Hitlist Pro main dir, this
  484.      to prevent other VB5 programs using the patched DLL.
  485.  
  486.      Thats it folks, you may contact me (if you know how ;--) on irc with
  487.      feedback and questions.
  488.  
  489.      Big greets to : tHATDUDE, madmax!, cH, Teraphy, KillerBee,j0b,
  490.      StarDogg Champion,aCP,rANDOM and all the others i forgot.
  491.  
  492.      Special greets and thanks to +ORC, fravia and gthorne and rest of +HCU
  493.  
  494.                                                              razzia [pc97]
  495.                                                             date: 05-08-97
  496.