Ŀ
۲ -=-=-= CyberRax Programming =-=-=- ۳


                                  presents:



  NN    NN                             NN         NN
  NNN   NN                             NN         NN
  NNNN  NN   NNNN   NN  NNNNN  NNNNNN  NN         NN NN NNNNN  NNNNNN NNNNN
  NNNNN NN  NN  NN     NN   NN NN      NN         NN    NN  NN NN     NN  NN
  NNNNNNNN NN    NN NN NN      NN      NN         NN NN NN  NN NN     NN  NN
  NN NNNNN NN    NN NN  NNNNN  NNNN    NN   NN    NN NN NNNNN  NNNN   NNNNN
  NN  NNNN NN    NN NN      NN NN       NN NNNN  NN  NN NN     NN     NNNN
  NN   NNN  NN  NN  NN NN   NN NN        NNNN NNNN   NN NN     NN     NN NN
  NN    NN   NNNN   NN  NNNNN  NNNNNN     NN   NN    NN NN     NNNNNN NN  NN



                       V  E  R  S  I  O  N     1 . 0 2


Ŀ
 Introduction 


 NoiseWiper is a program to securely erase sensitive materials so permanently
 that it would be *absolutely* impossible to recover them.


Ŀ
 A little closer 


 When you delete something in DOS it's not really gone: the operating  system
 simply marks  the  corresponding  disk area as not used.  And that's it (not
 even the filename is destroyed, only it's first character).  Until something
 else is saved in that area your information  will  be  present  and  can  be
 recovered  with  undeletion  utilities  (like  DOS's  own UnDelete) and disk
 editors (like Norton Disk Edit). This is good in case you deleted  something
 accidentally,  but  what if you *want* to get rid of something, and that for
 good?  Just for those cases exists a class  of  programs  known  as  wipers.
 They work  by  overwriting  the  contents  of  file before deleting it.  And
 that's exactly what NoiseWiper does.


Ŀ
 Fore-story 


 There are dozens and dozens of overwriters, why the hell did I write another
 one?  I've tried many different wiping programs  over  the  years  and  have
 currently  5  on  my  harddrive,  but  they all lack one or the other thing:
 Symantec  Corp's  Norton  WipeInfo  8.0  has  traditions  and  a  nice  user
 interface,  but  is big and slow; The Messiah's SWiper 1.0 is (almost) fast,
 but has no error handling and overwrites only with zeroes; EmilSoft's  WIPEM
 1.00  can  handle  only  drives,  same  goes  for  HUG-SL's DiscWash 1.1; V.
 Kolhinen's & J. Hood's WIPE 2.04 is a real skyscraper when compared  to  the
 others:  it's  got  quick-,  DoD  and flux reversal wiping, many options and
 supports extended wildcards, but is slow and has  no  indicator  (note:  the
 newest version, 2.06, can also wipe free space/file slack and *does* have an
 indicator).   The  last  mentioned  point  about  WIPE was the most powerful
 reason for me to write a wiping program.  My computer, namely, tends  to  go
 bonkers  on  me once in a while and I simply can't know whether WIPE's still
 doing it's job or if it's in heaven and my HD's light keeps working  because
 it went   insane.     And  there's  one  other  thing  -  Robert  Rothenburg
 Walking-Owl's NoiseSYS: I have it, I like it, I've got it  loaded,  but  I'm
 sick of the fact that after spending 4kB of my precious RAM the only one who
 actually  makes  use  of it's services is PGP. Atleast now it's also used to
 generate random garbage for my wiper.


Ŀ
 Highlights 


 + uses flux reversal wiping
 + optional synchronimous wiping
 + quick-wipes file before going to main destruction loop
 + uses R. Walking-Owl's NoiseSYS as garbage generator if present
 + commits file and resets disk to make sure that written data really ends up
   on disk and not in some cache
 + sets the starting cluster of file to a false one
 + wipes file slack on most systems where the cluster size is a  multiple  of
   512 bytes (most HDs nowadays(?))
 + indicator
 + doesn't bother with prompts
 + won't be stopped by read-only/hidden/system attributes
 + quite small
 + doesn't delete if aborted (you can additionally use your favorite wiper(s)
   on the file)
 + freeware
 + can be run on 286s


Ŀ
 Limitations 


 - not very fast
 - can't recurs through subdirectories
 - wipes only files
 - doesn't clean directory entries
 - can handle only 999 files
 - not the best when wiping on compressed drives
 - supports only standard DOS wildcards


Ŀ
 Working 


 NoiseWiper works in  three  phases.    Phase one: file is quick-wiped.  This
 means the first kB of file is overwritten with garbage, next  32kB  will  be
 skipped and then again 1kB will be overwritten.  This will be repeated until
 the end of  file.    The  last  kB is always wiped.  This is pretty unsecure
 because most of your data will still be around, but  it's  good  to  quickly
 render archives and compressed/encrypted volumes practically useless.  Phase
 two:  file  will  be overwritten 35(!) times using the following overwriting
 values (given in hex):

      1.  Random          11. 11h     21. BBh             31. DBh 6Dh B6h
      2.  Random          12. 22h     22. CCh             32. Random
      3.  Random          13. 33h     23. DDh             33. Random
      4.  Random          14. 44h     24. EEh             34. Random
      5.  55h             15. 55h     25. FFh             35. Random
      6.  AAh             16. 66h     26. 92h 49h 24h
      7.  92h 49h 24h     17. 77h     27. 49h 24h 92h
      8.  49h 24h 92h     18. 88h     28. 24h 92h 49h
      9.  24h 92h 49h     19. 99h     29. 6Dh B6h DBh
      10. 00h             20. AAh     30. B6h DBh 6Dh

 This sequence, which conforms to the one proposed by Peter  Gutmann  in  his
 "Secure  Deletion  of  Data from Magnetic and Solid-State Memory", is called
 flux reversal wiping and should erase  the  magnetic  pattern  on  disk,  so
 recovery  would  be  impossible  even with the newest and most sophisticated
 methods.  Phase three: file's size will be  set  to  0  bytes  and  starting
 sector  to  0  so  disk  editors would have no chance what so ever; original
 date/time are messed up by setting them to 01.01.1980 00:00:00 (this can  be
 disabled);  a  random  name is generated and the file renamed to it; finally
 the file is deleted.  After every write a file commit is performed  to  make
 sure  that  DOS  empties  it's internal buffers to disk and a drive reset is
 done to force disk caches to write to disk everything they  haven't  written
 yet.


Ŀ
 Usage 


 Simple (it's strange, but all my programs are easy to use :) :

                   NWIPER file [switch1] [switch2] [...]

    file - file or  files  to  be  wiped.    *Must*  be  the first parameter.
           NoiseWiper supports standard DOS wildcards.

 Switches are optional, must be preceeded by hypen (-) or slash (/) and  they
 can be:

       V - verbose output.    Additionally to main screen the name and number
           of file are shown, exactly like  the  total  amount  of  files  to
           wipe.
       Y - synchronimous wiping  of  files.   This means that the 1st file is
           overwritten once, then the same happens to the 2nd file,  then  to
           3rd and  so  on.  When all files have been wiped once the 1st file
           is overwritten a second time, the 2nd  file  too,  the  3rd  also,
           etc.    That's   slower   and   needs   more   disk   space   than
           non-synchronimous wiping, but is useful if you've  got  a  lot  of
           files and  have  to destroy them quickly.  By using "/Y" parameter
           you don't have after 72 wipes 2 files overwritten 36 times but  36
           files overwritten  twice.    This  is  (to  my knowledge) a unique
           feature.
       T - use timer for random garbage generation.   By  default  NoiseWiper
           will use  NoiseSYS  if  it's  present.    With this switch you can
           prohibit this.
       P - ask for conformation.  NoiseWiper  will  ask  once,  ONCE,  before
           wiping if  you are sure.  If you press "Y" or "ENTER" then all the
           specified  files  are  wiped,  by  "N"  or   "ESC"   the   program
           terminates.
       F - fully random  contents  for  writing buffer.  NoiseWiper fills the
           buffer by default in  the  following  way:  it  generates  2kB  of
           garbage  which  will be copied over and over into the buffer until
           it's full.  By "/F" switch the copying will  be  skipped  and  the
           randomness source  is  directly queried for 32kB of data.  This is
           mainly meant for compressed disks, but is slower  than  the  "fill
           buffer with that 2kB" scheme.
       Q - give no output what so ever, except error messages.
       K - keep original date/time of file.
       1 - for renaming  generate  a  file name with only one letter.  If you
           wipe files with NoiseWiper then, if checked with  some  undeletion
           utility,  the  directory  is full of deleted files named something
           like O9YNEHD7.Q2@ It does look suspicious and is a truly Bad Thing
           if you don't want the person looking to know that you're  using  a
           wiper.   A  filename  which  is  only  1  character long (and that
           character has been erased by DOS) doesn't look half as bad.   It's
           especially  useful  when  used  together  with  "/K". I do have to
           mention that the filesize will still be  zero  (exactly  like  the
           starting sector, if checked with a disk editor), so an experienced
           person might still figure out that a wiper has been working.
 NOERROR - no messages on errors.

 When no parameters are given then the help screen is shown. If only filename
 is  present  then  the main screen is presented which includes a bar and per
 cent indicator of wiping.

 By wiping you can press "N" to jump to next file or  "ESC"  for  cancelling.
 What  exactly  happens  by  "N"  depends  on whether or not you're wiping in
 synchronimous mode.  If not then your file is deleted without furder  wiping
 and the  program will step to next file.  If on the other hand synchronimous
 wiping is in action then "N" jumps to next file, but  the  cycle  is  simply
 pushed  forward and the wiping will occur later, in other words: the file is
 wiped 36 times, doesn't matter if you use "Next" or not.  But you can use it
 to wipe more than 36 times by big files.  Namely the "times  wiped"  counter
 is incremented  only when the whole file has been overwritten.  If you press
 "N" before that is true then the counter won't be incremented,  so  you  can
 wipe  the  bigger  part  of  file  even  thousand  times before the per cent
 indicator increases.  But as a single wipe's pretty fast then  you  probably
 won't manage to press the key before "flushing" on small files.
 If you're wiping in synchronimous mode then you have also the possibility of
 pressing "D",  by  which  all  files will be instantly deleted.  This is for
 cases when you're in a hurry and don't have the time to overwrite all  files
 36 times.  You can let NoiseWiper run for a couple of rounds and then delete
 files with a single keypress.

 BE VERY  CAREFUL  with  wiping.  There are exactly three situations when you
 can save something by an accidental wipe with NoiseWiper:
   a) you used "/P" switch and answer "N"
   b) you have a BIG file and quickly push "ESC"
   c) you have MANY files and push "ESC" as soon as you can
 In case 1 you have all your files  as  they  were  (because  no  wiping  was
 performed).  Case 2 ain't so happy: atleast part of your file is overwritten
 with garbage.  If this was a textfile then you might have something from the
 non-wiped parts.  By 3rd case some of your files have been damaged, but some
 might be orraid.  But only if you pressed "ESC". By "N", if in synchronimous
 mode,  the  next file will be wiped, else the file will be just deleted, but
 it's starting sector and name will be destroyed.  It is possible to retrieve
 the contents, but only if you're able to use a disk editor (or  an  advanced
 uneraser).  Never  less,  I still don't suggest it.  So, as already said: BE
 VERY CAREFUL!


Ŀ
 System requirements 


  MS-DOS 3.30 (or compatible)
  80286
  ca. 60kB memory
  keyboard (optional, only to conform wiping)
  MDA (textmode) videocard/monitor (optional)
  additionally up to  32kB  free  space  on  disk  (per  wiped  file  if  in
   synchronimous mode)


Ŀ
 Tested 


 NoiseWiper has been successfully tested with following...

 ...CPUs:

    * Cyrix 486DLC/40MHz
    * AMD 486DX/100MHz
    * Intel Pentium II/400MHz

 ...operating systems:

    * MS-DOS 3.30,  4.01,  5.0,  5.02,  6.0,  6.20,  6.22, 7.0 (Win95), 7.10
             (Win98), 8.0 (WinME)
    * PC-DOS 3.30, 4.0, 6.1, 6.3, 7.0
    * DR-DOS 5.0, 6.0, 7.01 (OpenDOS), 7.03
    * Novell DOS 7
    * FreeDOS beta 4, beta 5, beta 6, beta 7
    * ROM-DOS 6.22, 7.01
    * RxDOS 7.1.5

 ...disk caches:

    * MultiSoft's PC-Kwik 1.07, 3.19
    * Central Point Software's PC-Cache 5.1, 9.0
    * Microsoft's SMARTDrive 4.2, 5.0, 5.01, 5.02
    * HyperWare's HyperDisk 4.65, 4.70, 4.75
    * Symantec's Norton Cache 6.01, 8.0
    * P. R. Gassel & Associates' QUICKCACHE II 4.20
    * Qualitas' QCache 4.00
    * V. V. Vlasov's COMBI-Disk 1.13
    * Caldera's NWCache 1.02
    * M. Pawski's I_CACHE 1.20
    * PhysTechSoft's PTSCache 1.18h
    * C&D Programming Corp's CacheAll 1.0e
    * H. Shoichi's DOS Concurrent Disk Cache 1.10

 ...multitaskers:

    * Microsoft's Windows 3.1, 98 SE
    * Quarterdeck Office Systems' DESQview 2.60, 2.80
    * Caldera's Task Manager 2.02, 2.03
    * Quarterdeck Office Systems' DESQview/X 2.0
    * S&H Computer Systems' TSX-Lite 4.21

 and NoiseSYS 0.6.3 beta


Ŀ
 Notes 


 This time I *really* took the time and tested  this  program  with  all  the
 versions  I  have  of  MS-DOS  (and  it's clones) and with many disk caches.
 But... I  could  have  tested  even  more:  some  more  caches,  other  CPUs
 (especially 286s, because the fact that it's NoiseWiper's minimum is claimed
 by  the  C--  compiler  and  it's quite possible that actually a 386 or even
 better is needed), older versions of NoiseSYS (for my behalf I can say  that
 this program *is not* easy to find, but, as I just found out looking through
 the  file  listing, it seems that Garbo carries a copy of version 0.4.9 :( I
 can only hope you forgive me that I was too lazy  to  re-partition  my  main
 harddrive or open up the case of computer so I could get a 20MB disk into my
 PC  (all  caches  I left out supported only partitions smaller than 32MB) or
 exchange the motherboard against one that has a 286 or 386  processor.    Or
 that  I didn't try too many different CPU-OS-cache combinations (several OSs
 were simply started from a boot floppy without any other drivers at all).

 Drive compression systems (like DoubleSpace, Stacker, DriveSpace, etc.)  are
 a special  case.   The problem is, that they pack the data before physically
 writing it to drive, so 32kB data might end up on disk as,  let's  say,  1kB
 worth of  stuff,  thus not overwriting the whole file.  The best solution to
 the problem (besides not using  disk  compressors)  is  to  use  for  wiping
 completely random  data  which  can't  be packed.  But here're some problems
 too: it's impossible to know if the data is truly that random (you may  have
 an  excellent  garbage  generator in your program, but the environment might
 differ from the one you expected or other issues might rise which  make  the
 generator  less  effective) and it's also not possible to predict whether or
 not it's compressible by some particular algorithm  (altough  very  unlikely
 you  can't know for sure that nobody has a drive compressor which uses ACB's
 or RKIVE's notoriously slow but unbelievably effective pack method :)  Those
 are  a  problems  which  can't be solved, one just has to pray that the file
 will be completely wiped.   With  NoiseWiper  the  things  are  even  worse,
 because 75%  of used data is highly compressible.  The main idea behind "/F"
 switch was to make even a little bit up for the  lack  of  compressed  disks
 support.   With  "/F" you get 32kB of quite non-compressible garbage for the
 25% of wipes which use it.  For a figure: 32kB of garbage generated  without
 "/F" switch was compressed to 2002 bytes by RAR 2.50 (that goes for the data
 itself,  the archive was of course a little bigger), 64kB was packed to 2260
 bytes; in case of "/F" the 32kB couldn't be packed, 64kB was  compressed  to
 32kB. So, the "/F" seems to have some effect.  But in case you *really* have
 to  use  some  disk  doubling software I recommend that you make use of some
 other wiper which has been customized for this situation (like I. Davidson's
 Scorch) or wipe, instead of single files, the whole compressed volume.

 Multitaskers are another special case.  Namely, while NoiseWiper is  working
 in one  task or window the others become painfully slow.  That's because the
 wiper performs very intensive disk writing.  While  I  managed  to  set  the
 foreground/background  ratio  in  TSX-Lite  and  DESQview so that the wiping
 wouldn't disturb other tasks too much I failed to achieve this in DESQview/X
 (the wiping itself was OK, but everything stopped by the flushing, altough I
 have to mention that this might have been related to the fact  that  a  disk
 cache  was  loaded)  and Windows (3.1 wasn't too horrible, but 98 was simply
 unusable).  Dv/X can be perhaps tweaked until it works, but as Windoom lacks
 the simple low-level setup that DESQview has  and  because  there  are  such
 horrible things, from the security viewpoint, as a swap file by Win (ok, ok,
 DESQview  has it too, but it can be placed in EMS) then I didn't include any
 special code to handle the problem nor did any  other  attempts  to  promote
 wiping under WinCloset.

 The  limitation  of  999  files  exists  only  because I reserved room for 3
 numbers on screen at the "xxx of xxx" text.  The program could  handle  more
 files  (at  this moment up to 65535) and if someone asks I might enlarge the
 number over 999.

 NoiseWiper can by design handle files up to 2147450880 bytes (32kB less than
 2GB). I think that should be enough for everyone (DOS,  if  I'm  not  wrong,
 supports (theoretically (again this word :)) file sizes up to 4GB).

 This wiper hasn't been tested with other Windows versions than 3.1 and 98SE,
 but it should work without problems.  The only shortcomings:
   a) WindBlows  95+  tends  to cache on many levels so I'm not sure how many
      writes of those 36 actually end up on disk (even  with  disk  resetting
      and  in  a  DOS  box,  although  the drive's light was actively working
      during the flushing on the tested Windoza 98 machine)
   b) NoiseWiper doesn't support long file names
   c) There's the above mentioned problem with multitaskers

 The support for hiding the fact that something has been wiped is minimal.  I
 think that the best way to hide is to use  some  program  which  cleans  the
 directory entries.    As this would require some low-level code (about which
 I'm not sure that it's very compatible  with  WinCrash)  and  as  there  are
 already such cool wipers like WIPEM which do exactly this (and that fast and
 well)  then  I  don't  think  there's  much  reason  to  add  such  code  to
 NoiseWiper.


Ŀ
 Technical about NWIPER.COM 


 > Written in SPHINX/Sheker C-- and compiled with 0.237 beta 6
 > Norton Commander Editor (NCEdit, not Norton Editor), MS-DOS Editor 2.0.026
   and QEdit Advanced 3.00C SW were used for writing
 > Super Tracer 2.03 and Turbo Debug 5.0 were used for debugging
 > Hacker's View 6.16 was used for examining the code
 > Lot of material from Interrupt List R61, HelpPC 2.10 and Tech Help!   4.0a
   was used
 > Source's size is 41548 bytes (it's fully commented, that's why)
 > It has 1358 lines
 > Executable is packed with aPACK 0.99b
 > A  HUGE amount of coffee, electricity, cheese sandwiches and TV shows were
   spent during the coding


Ŀ
 History 


 Version 1.00 released on October 8th, 2001

   * initial release
   * CrCheck might report that NWIPER.COM has been changed.  This is my fault
     and if it does occur then know that it's related  only  to  the  missing
     read-only attribute and the error can be eliminated by setting it to the
     executable

 Version 1.01 released on October 17th, 2001

   * added /Q and /1 switches
   * optimized several parts of the code
   * dropped the protection scheme (it did cause some slight problems)

 Version 1.02 released on December 1st, 2001

   * added support for instant deletion of files in synchro mode with key "D"
   * optimized several parts of the code
   * added /K switch
   * fixed a bug which had the effect that NoiseWiper's display was messed up
     if cursor was originally in the upper part of screen
   * NoiseSYS  is  now  invoked  through  IOCTL  calls  rather than API. This
     ensures that older (which didn't support the API)  and  modified  (which
     use  for  example another interrupt for communication) versions of Noise
     should work
   * tested with all kind of different DOSs and disk caches
   * added support for NoiseSYS versions prior to  0.5.7  (which  use  device
     name URANDOM instead of URANDOM$)
   * the program should exit uynder DOS 1.0 without crashing (previously exit
     was performed in a way which wasn't available by DOS 1)
   * hypen can be used instead of slash by switches
   * now  additionally  to  backslash  also  slash  can  be used as directory
     separator
   * the wiper will besides reading  also  write  some  garbage  to  URANDOM$
     device to enhance the randomness


Ŀ
 Future 


 >>Phew<<, now  this program is *really* ready.  I've optimized it by several
 hundred bytes when compared to the very first version (I know, the COM ain't
 300 bytes smaller, but there have been several new features added) and  it's
 not possible to shorten the code much more if I want it to stay readable C--
 and not  pure  inside  assembly.  And there are no *very* desirable features
 which to add (I want this wiper to stay simple anyway).  So, it's not likely
 that I update NoiseWiper in near future, especially as I've  re-zipped  this
 package about 6(!) times during the time because of little changes I made in
 the  code  (although  the "now this program is *really* ready" statement has
 been present the whole time...I guess I don't hold much of my  own  plan  :)
 But if for some unknown reason (like me being sick or insane or something) I
 do happen to update then the following things might perhaps occur:

    + handling  of sub-directories (promised since the very first version and
      the most missed thing, but there are alternatives like using  SWEEP  or
      4DOS's internal GLOBAL to execute NoiseWiper in subdirectories)
    + generetic support for random number sources, which means that other RNG
      devices than NoiseSYS and even user defined files can be used


Ŀ
 Greets 


 Today's greets fly to:

 Robert Walking-Owl             -  after  all,  part  of this wiper's name is
                                   borrowed from your NoiseSYS
 Vesa Kolhinen & Jason Hood     -  authors of WIPE, one of the coolest wipers
                                   there is.  I got the idea  for  quick  and
                                   flux reversal wiping and the code for file
                                   commit  and wiping of date/time/size/start
                                   sector from your wiper.  So,  to  take  it
                                   together,   NoiseWiper   is   basically  a
                                   re-written and simplified version of  your
                                   WIPE.   Thus   you  guys  deserve  another
                                   greeting,  or  perhaps  a  hip-hip-hooray!
                                   even :)
 van Hauser / THC               -  I got some ideas for optimization from the
                                   source  of  your  Secure Delete 1.4 (which
                                   also implements flux reversal wiping)
 Nowhere Man/(original) [NuKE]  -  his WIPE from the Nowhere Utilities was my
                                   first wiping program
 Iolo Davidson                  -  the idea to use a 32kB buffer for  writing
                                   is from his Scorch
 Mishel Sheker                  -  for the on going development of C--
 Valmii tKD                     -  just like that :)
 Jibz                           -  gotta salute him because of the greet-ware
                                   license,  but  aPACK's certainly worth it.
                                   BTW, are any new version's on the  way  or
                                   have you ended the development?
 Liu TaoTao                     -  TR's a religion, man!
 Sen                            -  HIEW is FAR more than just a hexeditor
 Ralf Brown                     -  for IntList
 David Jurgens                  -  HelpPC f***in' rocks, dude!
 Dan Rollins                    -  Tech Help's old but still useful
 Ralph Roth / ROSE SWE          -  his  RoseGoat  2.12  was  used to generate
                                   test  files  for  wiping  (seems  I  found
                                   another purpose than viruses or scramblers
                                   for your program:)
 Douglas Boling                 -  I  got  some  of  the code for the initial
                                   bugfix from his CALC
 Symantec   Corp,   HUG-SL,
 EmilSoft and The Messiah       -  the  others  who's wiper I consider worthy
                                   enough to waste space on my HD :)
 Linkin Park                    -  for their AWESOME  album  "Hybrid  Theory"
                                   which  has  been  plying  a  lot  in my CD
                                   player lately


Ŀ
 Validating 


 To check if all files in this archive are OK store my public  PGP  key  into
 your  public-key-file  (PGPK -a CYBERRAX.SIG),  validate CRCHECK.CRC (PGP -v
 CRCHECK.CRC) and then execute ROSE SWE's CrCheck (I know, I know, MD5SUM  is
 free,  more  secure  and  comes  with  PGP  (atleast  it  came  with the 2.x
 versions), but CrCheck is faster and I happen to like it).


Ŀ
 End-story 


 Some thoughts why you should use NoiseWiper. The  main  advantages  of  this
 wiper over others are the high security and synchronimous wiping.  Like Iolo
 Davidson  explained  in  Scorch's  documentation,  in  practice  it's almost
 impossible to recover even data which has  been  overwritten  once,  so  the
 security  issue  is important only to cypherpunks like myself who are almost
 paranoiac about their privacy.  Synchronimous wiping mode might be useful if
 you have many files and want to wipe them as permanently as  possible  in  a
 short  period  of  time,  like  at the end of a work day during the time you
 clean up your desk.  On the day you were fired, that is :) You would have to
 use a wiper which can be instructed to not delete the files  and  you  would
 have  to  generate  batch  files  which  execute  the wiper for every wiping
 cycle.  Well, it doesn't have to be that difficult, you  just  have  to  use
 NoiseWiper in synchronimous mode, let it wipe, and press "D" if you leave to
 delete everything.


Ŀ
 Closing 


 So, we  have  come to the end.  If you have any suggestions, thoughts or bug
 reports, you want to point out some spelling error or just want to  say  how
 much you love this program (yeah, right) then feel free to mail me at

                              cyberrax@yahoo.com

 Oh yeah, forgive me my not so (but almost :) perfect English...


                                   CyberRax
                                the Hacking One
                                      of
                      -=-=-= CyberRax Programming =-=-=-

                                 "cypherpunk"

          December 1st, 2001; Tootsi, Parnu County, Estonia, Europe
