Database Data Security: both from within (using MIMEbase64 encoding) and from without (using encryption).

Question

In my MDB file databases (Jet 4.x format) I turn on both compression and encryption.  This gives me data security from without, meaning, I can't open a MDB file in a Word Processing software (or otherwise) and read the data in a humanly recognized
format.   But I am also using MIMEbase64 encoding of my stored data so that the data is humanly unreadable from within - meaning that anyone performing an SQL query will not be able to humanly read the data in my database.  I do the decoding
(from MIMEbase64) within my end-user software interfaces to the databases. 
I found out just recently (last few months) that I can do this from Win32 Perl, so I encorporated this feature into my Perl database applications.   Only thing is that MIMEbase64 increases the size of the data stored.
Is there a better encoding strategy available today which might actually compress the data a little?    

Answer 1

 INSTRUCTIONS FOR SECURE/CUSTOM (non-formula based) TEXTFILE ENCODING (should be undecipherable w/o mappings file):
by Eric C. Hansen. You may freely use these encoding instructions, and the code I have provided, but please
acknowledge me as the author where credit is due - such as in a publication. And do not try to sell it.
However, any code I have provided you may freely use in any programs you write to be sold for your own profit,
except you may not attempt to sell this encoding scheme (or my code provided), as a generic encoding tool, for
general use, to be marketed as a turn-key custom encoding solution. 
(1) Create a unique code list 
      Using the characters:  A-Z a-z 0-9 only. That's 62 characters only.  
       62 (1 char codes) + 3844 (2 char codes) + 238,328 (3 char codes) = 242,234 total codes
                 62x1         +      62x62         +       62x62x62    
       REMINDS ME of my college Genetics course i.e. dominant/recessive trait inheritance tables  
       EXAMPLE CODES:  a, k, 3c, A4, xy1, H8j
(2) Create a unique word(+punc) list from your textfile which is to be encoded. You know how to do this.
       Example of 9 words(+punc) found between whitespace within a textfile input line:
            "Hello", this is Mr. Bell-va-deer. My number is 999-342-8998.   
                1       2    3   4       5              6      7       8       9
 PERL code for STEPS 3-7 is provided below. Code for STEP 1 above was previously provided. 
         You should have little trouble writing the textfile encode/decode logic yourself.  
(3) Read your list of unique codes into an array.
(4) Read your list of unique words(+punc) into another array.
     LOOP   #-- 0 to number of elements in words array
            (5)     select a random code and a random word(+punc) from the 2 arrays.
            (6)     now remove that code and that word(+punc) from each array using "splice".
            (7)     then save them as key/val pairs to persistent Perl SDBM database files ("mappings").  
     END LOOP
 (8) Once you have your persistent, random code/word mappings, you can convert your textfile
      to an encoded textfile. Read in one line at a time from your textfile (chomp), parse the words(+punc.)
     between whitespace within that line, then for each word(+punc) parsed, perform
     the word-to-code mapping conversions by doing a lookup within the Perl SDBM database
     file of key/val pairs, where KEY=word and VAL=code. You will then need to 
     concatenate these codes (space delimited) to your outputline, in the same order as found in your
     inputline, finally writing the outputline (newline "\n" terminated) to your new encoded textfile.    
(9) Keep your persistent Perl SDBM database file ("mappings") in SAFE KEEPING, with a naming
     convention of your choice that perhaps hides any relationship to the name of
     your encoded text document - which it specifically pertains to. But keep a record of that joint
    relationship somewhere.  Keep a copy of both the original textfile and the encoded textfile,
    or perhaps you'd like to keep just the encoded textfile?, and not the original?  You can always decode it. 
(10) Send your encoded text document via email as an attachment, to the recipient of your choice.
(11) Upload your persistent Perl SDBM database "mappings" file to your secure login FTP download site. 
     NOTE:  If your encoded text document is very large, you may want to reverse 10 & 11, putting the encoded file
         on the FTP site, and sending the Perl SDBM database file ("mappings") as the email attachment.
(12) Call your recipient to see if they have received the encoded textfile, email attachment.
     Let them know that the "mappings" file is uploaded for them to download from the FTP site.
    You can have a LINGO you both use/know on the phone, to secretly convey this message, if you like,
      to avoid possible interception of this sensitive information.
     Recipient will then take the encoded textfile email attachment, the FTP downloaded "mappings" file,
    and place them both in a directory on their PC where the Perl decoding program is located which you
     had previously sent them to handle all the decoding anytime you send them an encoded textfile + "mappings".
     Recipient will run the Perl decoding utility program to create the original textfile.
use Win32;         #-- as you can see, I use a Windows O/S Perl distribution. 
use IO::Handle;
use SDBM_File;     #-- my understanding is this module comes standard with every Perl distribution
use Fcntl;
    $PWD=Win32::GetCwd();  #-- get current working directory on Windows O/S platform.            
    srand;        #-- random seeding initiated, do this just once at top.
    @codesARR=();    @wordsARR=();          #-- initialize the arrays
    print "working.  please wait...\n\n";
    unlink( "$PWD\\Project_0836_Mappings_CtoW.pag" )
                if (-e "$PWD\\Project_0836_Mappings_CtoW.pag" );
   unlink( "$PWD\\Project_0836_Mappings_CtoW.dir" )
              if (-e "$PWD\\Project_0836_Mappings_CtoW.dir" );
    unlink( "$PWD\\Project_0836_Mappings_WtoC.pag" )
              if (-e "$PWD\\Project_0836_Mappings_WtoC.pag" );
   unlink( "$PWD\\Project_0836_Mappings_WtoC.dir" )
             if (-e "$PWD\\Project_0836_Mappings_WtoC.dir" );
     unlink( "$PWD\\Project_0836_Mappings.txt" )
             if (-e "$PWD\\Project_0836_Mappings.txt" );
   $cnt1=0;    $ret="Y";
    open(CODES,"$PWD\\codes.txt") || do {$ret="N";};
    if ($ret eq "N") {  
           print "Codes input file not opened \n";  
           sleep 5;   die;  
    while (<CODES>) {
           chomp $_;
          $codesARR[$cnt1]=$_;
          $cnt1++;
    print $cnt1 . " codes loaded\n\n";
   close(CODES);
   $cnt2=0;    $ret="Y";
   open(WORDS,"$PWD\\words.txt") || do {$ret="N";};
    if ($ret eq "N") {  
            print "Words input file not opened \n";  
           sleep 5;   die;  
   while (<WORDS>) {
           chomp $_;
          $wordsARR[$cnt2]=$_;
            $cnt2++;
    print $cnt2 . " words loaded\n\n";
    close(WORDS);
    sleep 3;       #-- a little time to check on record counts loaded to both arrays
  tie( %Project_0836_Mappings_WtoC, "SDBM_File", '.\Project_0836_Mappings_WtoC', O_RDWR|O_CREAT, 0666 );
   if (tied %Project_0836_Mappings_WtoC) {
           print "WtoC Hash/SDBM File are now tied\n\n";    
   } else {
          print "Could not tie WtoC Hash/SDBM File\n\n";  sleep 5;  die;
   tie( %Project_0836_Mappings_CtoW, "SDBM_File", '.\Project_0836_Mappings_CtoW', O_RDWR|O_CREAT, 0666 );
    if (tied %Project_0836_Mappings_CtoW) {
             print "CtoW Hash/SDBM File are now tied\n\n";    
    } else {
           untie(%Project_0836_Mappings_WtoC);  #-- close the successful tie made directly above 
          print "Could not tie CtoW Hash/SDBM File\n\n";  sleep 5;  die;
  open (OUT,"> $PWD\\Project_0836_Mappings.txt");
   OUT->autoflush(1);
   $cnt2=$#wordsARR;   #-- we do this because we will be removing elements from wordsARR
   for ($i=0; $i<=$cnt2; $i++) {
         $index   = rand @codesARR;    # get a random index from the codes array
        $code    = $codesARR[$index]; # get the value of that array element
        splice(@codesARR,$index,1);   # removes only this element from the codes array.
        $index   = rand @wordsARR;    # get a random index from the words array
        $word    = $wordsARR[$index]; # get the value of that array element
        splice(@wordsARR,$index,1);   # removes only this element from the words array.
        $Project_0836_Mappings_WtoC{$word}=$code;   # key/value pair where: word is key, code is value
        $Project_0836_Mappings_CtoW{$code}=$word;   # key/value pair where: code is key, word is value
    print "Your Mappings have been created and saved to (.dir and .pag extension files)\n\n";
    print OUT "Here are your Mappings you just created:\n\n";
    foreach $key (keys %Project_0836_Mappings_WtoC) {
          print OUT "word=" . $key . "     code=" . $Project_0836_Mappings_WtoC{$key} . "\n";
  print OUT "##################################################\n";
   foreach $key (keys %Project_0836_Mappings_CtoW) {
           print OUT "code=" . $key . "     word=" . $Project_0836_Mappings_CtoW{$key} . "\n";
    untie(%Project_0836_Mappings_WtoC);  #-- now you have saved a persistent word/code mappings file
    untie(%Project_0836_Mappings_CtoW);  #-- now you have saved a persistent code/word mappings file
    close(OUT);   
    print "Done.  Goodbye!\n";
    sleep 5;
    exit;