lightweight encryption of text file

[Anthra Norell]

Daniel Fetchinson wrote:
 > I have a plain text file which I would like to protect in a very
 > simple minded, yet for my purposes sufficient, way. I'd like to
 > encrypt/convert it into a binary file in such a way that possession of
 > a password allows anyone to convert it back into the original text
 > file while not possessing the password one would only see the
 > following with the standard linux utility 'file':
 >
 > [fetchinson at fetch ~]$ file encrypted.data
 > encrypted.data: data
 >
 > and the effort required to convert the file back to the original text
 > file without the password would be equivalent to guessing the
 > password.
 >
 > I'm fully aware of the security implications of this loose
 > specification, but for my purposes this would be a good solution.
 >
 > What would be the simplest way to achieve this using preferably stock
 > python without 3rd party modules? If a not too complex 3rd part
 > module made it really simple that would be acceptable too.




Daniel,

Here's what looks like another thread veering off into package-ology, 
leaving a stumped OP behind.

"Don't use a random generator for encryption purposes!" warns the 
manual, of which fact I was reminded in no uncertain terms on this forum 
a few years ago when I proposed the following little routine in response 
to a post very similar to yours. One critic challenged me to encode my 
credit card data and post it. Which I did. Upon which another critic 
conjured up the horror vision of gigahertzes hacking my pathetic little 
effort to pieces as I was reading his message. Of the well-meaning kind, 
he urged me to put an immediate stop to this foolishness. I didn't.

No unplanned expenditures ensued.

Or to quote ... I forget who: Fools and innovators are people who don't 
care much about what one is not supposed to do.

So, take or leave what follows for what it is worth or not worth, I am 
confident it works and would serve your purpose, which, as I understand, 
is not to write a text book on cryptology.

Regards

Frederic


##############################


import random


def crypt_string (string, key, floor = 0, size_of_set = 255):

    # key is a number. The sign of that number controls which way the 
process
    # goes. If the number is positive, the result is an encryption. A 
negative
    # number orders a decryption.
     
   if key == 0: return string   # No processing

   import random

   MAX_CHUNK_SIZE  = 32
   MIN_CHUNK_SIZE  = 16

   def process_sequence (sequence):
      s = ''
      for c in sequence:
         r = random.randint (0, size_of_set - 1)
         s += chr (((ord (c) - floor + r * sign) % size_of_set) + floor)
      return s

   def shuffle_sequence (sequence):
      random.shuffle (sequence)
      return sequence

   sign = (key > 0) * 2 - 1
   random.seed (key * sign)

   s = ''

   if sign > 0:    # forward

      i = 0
      while i < len (string):
         random_size_of_chunk = random.randint (MIN_CHUNK_SIZE, 
MAX_CHUNK_SIZE)
         clear_chunk_shuffled = shuffle_sequence (list (string 
[i:i+random_size_of_chunk]))
         code_chunk_shuffled = process_sequence (clear_chunk_shuffled)
         s += code_chunk_shuffled
         i += len (code_chunk_shuffled)

   else:           # backward

      i = 0
      while i < len (string):
         random_size_of_chunk = random.randint (MIN_CHUNK_SIZE, 
MAX_CHUNK_SIZE)
         code_chunk_shuffled = list (string [i:i+random_size_of_chunk])
         real_size_of_chunk = len (code_chunk_shuffled)
         unshuffling_template = shuffle_sequence (range 
(real_size_of_chunk))  # 1. same ...
         clear_chunk_shuffled = process_sequence 
(code_chunk_shuffled)         # 2. ... order
         clear_chunk = real_size_of_chunk * [None]
         for ii in range (real_size_of_chunk):
            clear_chunk [unshuffling_template[ii]] = 
clear_chunk_shuffled [ii]
         s += ''.join (clear_chunk)
         i += real_size_of_chunk

   return s



def _crypt_file (in_file, out_file, key):

   BUFFER_SIZE = 1024
   while 1:
      s = in_file.read (BUFFER_SIZE)
      if s == '': break
      out_file.write (crypt_string (s, key))


def crypt_file (in_file_name, out_file_name, key):

    in_file = open (in_file_name, 'rb')
    out_file = open (out_file_name, 'wb')
    _crypt_file (in_file, out_file, key)
    out_file.close ()