Securely Erase the Content of A Drive... The Easy Way!

Do you sometimes have somewhat sensitive data that has been deleted on a drive but you would feel better if it were unrecoverable? And you don't want to wipe-out the whole drive (keep the data that is already in). Such a situation occurs a lot when changing PC at work. You know the next guy will likely be a computer expert; if that person has a penchant for evil, you definitely do not what that person to have access to the data that used to be on that computer.


Leave this script running overnight and you can be (kind of) confident nothing will be recoverable.

#python 3

import random
import os

def _getRandStr(rand_str_len):
  lib = "abcdefghjiklmnopqrstuvwxyz123456789"
  
  randomStr = []
  
  while len(randomStr) < rand_str_len:
    randomStr += lib[ random.randint(0,len(lib)-1) ]
  
  assert len(randomStr) == rand_str_len
  return "".join(randomStr)

def writeToHDUntilException():
  randomfolder = None
  nfilesInFolder = 0
  while True:
    if randomfolder is None or nfilesInFolder > 9:
      randomfolder = _getRandStr(16)
      if not os.path.isdir(randomfolder):
        os.mkdir(randomfolder)
      nfilesInFolder = 0
    fh = open( randomfolder + '/' + _getRandStr(32) + '.jpg', 'wb' )
    fh.write( _getRandStr(128).encode()*1024*8 )
    fh.close()
    nfilesInFolder += 1

if __name__ == '__main__':
  writeToHDUntilException()

If you leave that script running for long enough then you will eventually have overwritten all the free nodes of the HD. Delete the files created and the content that was there beforehand will be unrecoverable. Quite handy for USB keys.

da_crypt.py: The smallest encryption library you will ever find!

Here is a small library that I wrote just for fun. If you provide a key that is the same length as the file/bytes to be encrypted, this algorithm is unbreakable (see XOR_cipher and One Time Pad).

#!/usr/bin/python3.0

class Key:

 def __init__(self, bytesKey):
   self.__key = bytesKey

 def getAt(self, x):
   x = x % len(self.__key)
   return self.__key[x]

class Crypt_Xor:

 def __init__(self, key):
   self.__key = key

 def encrypt(self, bytesToCrypt):
   bytesCrypt = bytearray(len(bytesToCrypt))
   x = 0
   for byte in bytesToCrypt:
     key_node = self.__key.getAt(x)
     bytesCrypt[x] = byte ^ key_node
     x += 1   
   return bytesCrypt
  
 def decrypt(self, bytesToDecrypt):
   bytesDeCrypt = bytearray(len(bytesToDecrypt))
   x = 0
   lstDecrypted = []
   for char in bytesToDecrypt:
     key_node = self.__key.getAt(x)
     bytesDeCrypt[x] = bytesToDecrypt[x] ^ key_node
     x += 1
  
   return bytesDeCrypt

The amazing thing is that it can be fully implemented with very little code (31 lines in this case).
I got the idea reading the excellent book 'Computer Networks by Andrew S.Tanenbaum -- 8.1.4'.

Here is a small test function:

def _test_crypt_object( crypt ):
 data_orig = b'I am a simple string to be encrypted.'
 print( 'data_orig: %s' % data_orig )

 testKey = b'My secret key... \x123\x456\x798' 

 crypt = crypt( Key(testKey) )
 data_encoded = crypt.encrypt(data_orig)
 print( 'data_encoded: %s' % data_encoded )
 data_decoded = crypt.decrypt(data_encoded)
 print( 'data_decoded: %s' % data_decoded )

 assert data_decoded == data_orig

def test_module():
 print( 'da_crypt test start' )
 _test_crypt_object(Crypt_Xor)
 print( 'da_crypt test end' )

if __name__ == '__main__':
 test_module()

You can check the updated code at:
http://code.google.com/p/miscdev/source/browse/da_crypt/
It also contains a small extension that allows file encryption.

Be careful though: the implementation uses a circular key (for simplicity's sake). If you use a key that is not random or a key that is less than the size of the data to be encrypted then it becomes relatively easy to crack.

Enjoy!