🚀 go-pugleaf

I have, for personal use only (so don't ask for source :-) invented a
small encryption utility.  I have no (zero, zippo, none) experience
assessing the security of a cryptosystem, so I'm wondering if someone
knowledgable in this area might give me some inkling of the degree of
security of this system.  Mostly this is acedemic curiosity only - I'm
just wondering whether what I made is any good.  (Aside from the fact
that it isn't a public key system - ignore those issues, if you might -
I'm just interested in security).

Here's how it works:

  1) An arbitrary length key is transformed into a 128 bit key.  The
     initial arbitrary length key is purely for the convenience of the
     user.

  2) This 128 bit key is used for two things:
     A) it is used as the "seed" for pseudo-random number generator.
     B) it is used to modify the algorithm used by the above random
        number generator by changing key parameters used when generating
        the pseudo-random sequence.

  3) Step 2) is run multiple times using different parameters to produce
     multiple pseudo-random sequences (all from the same key, but all
     different).

  4) The sequences from 3) are used to encrypt the plaintext.  Some of
     the sequences perform character translation in-place.  Others
     perform character relocation within blocks of a length defined
     pseudo-randomly by the initial key (but within given bounds).  The
     multiple sequences from 3) perform the above two operations
     multiple times, interleaved.  (Ie, 1st a character translation
     pass, then a relocation pass, etc.)  The number of passes is,
     again, determined pseudo-randomly from the initial key subject to
     given bounds.

How secure is this?  Since I know nothing about the relative security of
various algorithms, I just tried to come up with something that would
hopelessly scramble the plaintext, in the hopes that this would somehow
be secure.  How did I do?  (probably worse than I suspected, right? :-)

Side notes:

  1. Each of the pseudo-random sequences generated from the initial key
     has been shown to be non-repeating for at least 10^7 digits.  The
     actual length is probably much greater.  In any case, this is far
     larger than the expected message length.

  2. Since the initial key is 128 bits, I doubt that a brute-force
     attack is very practical for your typical PC user.  The algorithm,
     when coded in C, can encrypt 45 Kb per second on an Amiga 4000
     (appoximately a 22 MIP machine).  It is not all that fast,
     obviously, so I'm assuming its safe from brute-force methods on
     anything short of a Connection Machine 5, and maybe even there :-)

  3. I have verified that 1 bit changes in the key produce entirely
     different crypted data.

  4. I have verified that the crypted data appears random from the
     viewpoint of character frequences.  Ie, sending all "a"'s as
     plaintext yields binary data using all 256 character codes roughly
     equally. 

John

--
   The opinions expressed are not necessarily those of the University of
     North Carolina at Chapel Hill, the Campus Office for Information
        Technology, or the Experimental Bulletin Board Service.
           internet:  laUNChpad.unc.edu or 152.2.22.80