加解密杂烩程序开发（四）

上一章是加密程序，这章是解密程序。

#!/usr/bin/python
# -*- coding: utf-8 -*-
 
import os,base64,binascii,re
from urllib import unquote

QWE_dicts = {'A':'k','B':'x','C':'v','D':'m','E':'c','F':'n','G':'o','H':'p',
             'I':'h','J':'q','K':'r','L':'s','M':'z','N':'y','O':'i','P':'j',
             'Q':'a','R':'d','S':'l','T':'e','U':'g','V':'w','W':'b','X':'u',
             'Y':'f','Z':'t'};
#--------------------------------------------------------
Atbash_dicts = {'A':'z','B':'y','C':'x','D':'w','E':'v','F':'u','G':'t','H':'s',
             'I':'r','J':'q','K':'p','L':'o','M':'n','N':'m','O':'l','P':'k',
             'Q':'j','R':'i','S':'h','T':'g','U':'f','V':'e','W':'d','X':'c',
             'Y':'b','Z':'a'};
#--------------------------------------------------------
Morse_encoding = {'A': '.-','B': '-...','C': '-.-.','D': '-..','E': '.','F': '..-.','G': '--.',
                  'H': '....','I': '..','J': '.---','K': '-.-','L': '.-..','M': '--','N': '-.',
                  'O': '---','P': '.--.','Q': '--.-','R': '.-.','S': '...','T': '-',
                  'U': '..-','V': '...-','W': '.--','X': '-..-','Y': '-.--','Z': '--..',
                  '0': '-----',  '1': '.----',  '2': '..---','3': '...--',  '4': '....-',  
                  '5': '.....','6': '-....',  '7': '--...',  '8': '---..', '9': '----.',
                  # Seen in use on the uncyclopedia:
                  "'": '.----.' }
Morse_decoding = {}
for key, val in Morse_encoding.items(): 
    Morse_decoding[val] = key;
#--------------------------------------------------------
Bacon_dicts1 = {'aaaaa':'a','aaaab':'b','aaaba':'c','aaabb':'d','aabaa':'e',
                'aabab':'f','aabba':'g','aabbb':'h','abaaa':'i','abaab':'j',
                'ababa':'k','ababb':'l','abbaa':'m','abbab':'n','abbba':'o',
                'abbbb':'p','baaaa':'q','baaab':'r','baaba':'s','baabb':'t',
                'babaa':'u','babab':'v','babba':'w','babbb':'x','bbaaa':'y','bbaab':'z'};
Bacon_dicts2 = {'AAAAA':'a','AAAAB':'b','AAABA':'c','AAABB':'d','AABAA':'e',
                'AABAB':'f','AABBA':'g','AABBB':'h','ABAAA':'i/j',
                'ABAAB':'k','ABABA':'l','ABABB':'m','ABBAA':'n','ABBAB':'o',
                'ABBBA':'p','ABBBB':'q','BAAAA':'r','BAAAB':'s','BAABA':'t',
                'BAABB':'u/v','BABAA':'w','BABAB':'x','BABBA':'y','BABBB':'z'};
#--------------------------------------------------------
ADFGX_dicts = {'AA':'b','AD':'t','AF':'a','AG':'l','AX':'p',
               'DA':'d','DD':'h','DF':'o','DG':'z','DX':'k',
               'FA':'q','FD':'f','FF':'v','FG':'s','FX':'n',
               'GA':'g','GD':'i/j','GF':'c','GG':'u','GX':'x',
               'XA':'m','XD':'r','XF':'e','XG':'w','XX':'y'};
ADFGX_dicts2 = {'11':'a','12':'b','13':'c','14':'d','15':'e',
               '21':'f','22':'g','23':'h','24':'i/j','25':'k',
               '31':'l','32':'m','33':'n','34':'o','35':'p',
               '41':'q','42':'r','43':'s','44':'t','45':'u',
               '51':'v','52':'w','53':'x','54':'y','55':'z'};
#--------------------------------------------------------

def urldecode(m_str):
	return unquote(m_str)

def Myswapcase(m_str):
	return m_str.swapcase()

def AsciiToHex(m_str):
	return binascii.b2a_hex(m_str)

def HexToAscii(m_str):
	return binascii.a2b_hex(m_str)	
	
def S_rot13(s, OffSet=13):
    def encodeCh(ch):
        f=lambda x: chr((ord(ch)-x+OffSet) % 26 + x)
        return f(97) if ch.islower() else (f(65) if ch.isupper() else ch)
    return ''.join(encodeCh(c) for c in s)

def MyBase64(m_str):
	str1 = base64.b64decode(m_str) + '\r\n'
	str1 += "\r\nHex Mode: "+binascii.b2a_hex(base64.b64decode(m_str))
	return str1

def S_QWE(S_str):
    result ='';
    S_str = S_str.upper();
    for i in range(len(S_str)):
        if S_str[i].isupper():
            result += ''.join(QWE_dicts[S_str[i]]);
        else:
            result += ''.join(S_str[i]) ;
    return result;	

def S_Atbash(S_str):
    result ='';
    S_str = S_str.upper();
    for i in range(len(S_str)):
        if S_str[i].isupper():
            result += ''.join(Atbash_dicts[S_str[i]]);
        else:
            result += ''.join(S_str[i]) ;
    return result;
	
def S_Morse(S_str):
    ans = ''.join(map(lambda x, g=Morse_decoding.get: g(x, ' '), S_str.split(' ')))
    return ' '.join(ans.split()) # tidy up spacing	

def S_ADFGX(S_str):
    result ='';
    S_str = S_str.upper();
    S_str = re.sub(r'[^ADFGX]+', '', S_str);
    for i in xrange(0, len(S_str) / 2):
        result += ADFGX_dicts.get(S_str[i * 2:i * 2 + 2], ' ')
    return result  

def S_ADFGX2(S_str):
    result ='';
    S_str = re.sub(r'[^12345]+', '', S_str);
    for i in xrange(0, len(S_str) / 2):
        result += ADFGX_dicts2.get(S_str[i * 2:i * 2 + 2], ' ')
    return result 	

def S_Bacon(S_str):
    result ='';
    S_str = S_str.lower();
    S_str = re.sub(r'[^ab]+', '', S_str);
    for i in xrange(0, len(S_str) / 5):
        result += Bacon_dicts1.get(S_str[i * 5:i * 5 + 5], ' ')
    S_return = "Mode 1: "+result + "\r\n";
    result ='';
    S_str = S_str.upper();
    S_str = re.sub(r'[^AB]+', '', S_str);
    for i in xrange(0, len(S_str) / 5):
        result += Bacon_dicts2.get(S_str[i * 5:i * 5 + 5], ' ')
    S_return += "Mode 2: "+result;
    return S_return

def S_Caesar(S_str):
	S_return = ''
	for i in xrange(0,26):
		S_return +=  S_rot13(S_str,i) + '\r\n'
	return S_return

def S_Vigenere(all_the_text):

	fp1 = open("encrypted.txt","wb");
	try:
		fp1.write(all_the_text);
	finally:
		fp1.close();

	os.system("python decrypt.py")	
	fp2 = open("decrypted.txt","r");
	try:
		S_return = fp2.read()
	finally:
		fp2.close()
	
	return S_return

#print S_Vigenere("abcdefg")