PageRenderTime 64ms CodeModel.GetById 20ms RepoModel.GetById 1ms app.codeStats 0ms

/trunk/scrambled_egg.py

http://scrambled-egg.googlecode.com/
Python | 1594 lines | 1407 code | 53 blank | 134 comment | 119 complexity | 299b740a6d5cd97d5e602f606e907489 MD5 | raw file
    

  1. #!/usr/bin/env python
    2. 

  2. 

  3. # ---
    4. 

  4. # An application by Cristi Constantin,
    5. 

  5. # E-mail : cristi.constantin@live.com,
    6. 

  6. # Blog : http://cristi-constantin.com.
    7. 

  7. # ---
    8. 

  8. 

  9. import os, sys
    10. 

  10. import platform
    11. 

  11. import subprocess
    12. 

  12. import re, math
    13. 

  13. import string
    14. 

  14. import struct
    15. 

  15. import urllib
    16. 

  16. import base64
    17. 

  17. import json
    18. 

  18. import bz2, zlib
    19. 

  19. import tarfile
    20. 

  20. 

  21. import binascii as ba
    22. 

  22. from collections import OrderedDict
    23. 

  23. from cStringIO import StringIO
    24. 

  24. from Padding import appendPadding, removePadding
    25. 

  25. from pbkdf2 import PBKDF2
    26. 

  26. 

  27. from Crypto.Cipher import AES
    28. 

  28. from Crypto.Cipher import ARC2
    29. 

  29. from Crypto.Cipher import CAST
    30. 

  30. from Crypto.Cipher import Blowfish
    31. 

  31. from Crypto.Cipher import DES3
    32. 

  32. from Crypto.PublicKey import RSA
    33. 

  33. 

  34. import sip
    35. 

  35. sip.setapi('QString', 2)
    36. 

  36. sip.setapi('QVariant', 2)
    37. 

  37. 

  38. from PyQt4 import QtCore
    39. 

  39. from PyQt4 import QtGui
    40. 

  40. 

  41. try: import Image
    42. 

  42. except: Image = None
    43. 

  43. 

  44. #
    45. 

  45. ROT = string.maketrans('nopqrstuvwxyzabcdefghijklmNOPQRSTUVWXYZABCDEFGHIJKLM', 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ')
    46. 

  46. #
    47. 

  47. SCRAMBLE = ['None', 'ROT13', 'ZLIB', 'BZ2']
    48. 

  48. SCRAMBLE_D = {'None':'N', 'ROT13':'R', 'ZLIB':'ZL', 'BZ2':'BZ'}
    49. 

  49. ENC = OrderedDict([('AES', 'AES'), ('Blowfish', 'B'), ('ARC2', 'ARC'), ('CAST', 'CA'), ('DES3', 'D'), ('RSA', 'RSA'), ('None', 'N')])
    50. 

  50. ENCODE = ['Base64 Codec', 'Base32 Codec', 'HEX Codec', 'Quopri Codec', 'Json', 'XML']
    51. 

  51. ENCODE_D = {'Base64 Codec':'64', 'Base32 Codec':'32', 'HEX Codec':'H', 'Quopri Codec':'Q', 'Json':'JS', 'XML':'XML'}
    52. 

  52. #
    53. 

  53. NO_TAGS = re.compile(
    54. 

  54.     '<#>(?P<ts>[0-9a-zA-Z ]{1,3}:[0-9a-zA-Z ]{1,3}:[0-9a-zA-Z ]{1,3})</?#>|' \
    55. 

  55.     '\[#\](?P<tq>[0-9a-zA-Z ]{1,3}:[0-9a-zA-Z ]{1,3}:[0-9a-zA-Z ]{1,3})\[#\]|' \
    56. 

  56.     '\{#\}(?P<ta>[0-9a-zA-Z ]{1,3}:[0-9a-zA-Z ]{1,3}:[0-9a-zA-Z ]{1,3})\{#\}|' \
    57. 

  57.     '\(#\)(?P<tp>[0-9a-zA-Z ]{1,3}:[0-9a-zA-Z ]{1,3}:[0-9a-zA-Z ]{1,3})\(#\)|' \
    58. 

  58.     '(?P<tx><pre>[0-9a-zA-Z ]{1,3}</pre>\s*?<enc>[0-9a-zA-Z ]{1,3}</enc>\s*?<post>[0-9a-zA-Z ]{1,3}</post>)|' \
    59. 

  59.     '(?P<tj>"pre": "[0-9a-zA-Z ]{1,3}",\s*?"enc": "[0-9a-zA-Z ]{1,3}",\s*?"post": "[0-9a-zA-Z ]{1,3}")')
    60. 

  60. #
    61. 

  61. # These numbers are used when (re)creating PNG images.
    62. 

  62. SCRAMBLE_NR = {'None':'1', 'ROT13':'2', 'ZLIB':'3', 'BZ2':'4'}
    63. 

  63. ENCRYPT_NR = {'AES':'1', 'ARC2':'2', 'CAST':'3', 'Blowfish':'5', 'DES3':'4', 'RSA':'6', 'None':'9'}
    64. 

  64. ENCODE_NR = {'Base64 Codec':'4', 'Base32 Codec':'2', 'HEX Codec':'1', 'Quopri Codec':'9', 'XML':'7'}
    65. 

  65. #
    66. 

  66. C = {} # Config.
    67. 

  67. D = {} # Themes.
    68. 

  68. #
    69. 

  69. __version__ = 'ver 0.5'
    70. 

  70. #
    71. 

  71. 

  72. def findg(g):
    73. 

  73.     for i in g:
    74. 

  74.         if i: return ''.join(i.split())
    75. 

  75. 

  76. # ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- -----
    77. 

  77. #       Scrambled-Egg  Encryption  Engine
    78. 

  78. # ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- -----
    79. 

  79. 

  80. class ScrambledEgg():
    81. 

  81. 

  82.     def __init__(self):
    83. 

  83.         self.error = '' # Error string.
    84. 

  84.         self.pre = ''   # Current operations, in order.
    85. 

  85.         self.enc = ''
    86. 

  86.         self.post = ''
    87. 

  87.         self.rsa_path = ''
    88. 

  88. 

  89.     def __error(self, step, pre, enc, post, field='R'):
    90. 

  90.         #
    91. 

  91.         if step==1:
    92. 

  92.             if field=='R':
    93. 

  93.                 pre += ' (ERROR!)'
    94. 

  94.             else:
    95. 

  95.                 pre += ' (IGNORED!)'
    96. 

  96.         elif step==2:
    97. 

  97.             enc += ' (ERROR!)'
    98. 

  98.         elif step==3:
    99. 

  99.             post += ' (ERROR!)'
    100. 

  100. 

  101.         if field=='R':
    102. 

  102.             self.error = '  Decryption mode   step 1: %s ,   step 2: %s ,   step 3: %s' % (pre, enc, post)
    103. 

  103.         else:
    104. 

  104.             self.error = '  Encryption mode   step 1: %s ,   step 2: %s ,   step 3: %s' % (pre, enc, post)
    105. 

  105.         #
    106. 

  106. 

  107.     def _fix_password(self, pwd, enc):
    108. 

  108.         '''
    109. 

  109.         Scramble and adapt the password for each encryption. \n\
    110. 

  110.         AES accepts maxim 32 characters. \n\
    111. 

  111.         ARC2 accepts maxim 128 characters. \n\
    112. 

  112.         CAST accepts maxim 8 characters. \n\
    113. 

  113.         Blowfish accepts maxim 56 characters. \n\
    114. 

  114.         DES3 accepts maxim 24 characters.
    115. 

  115.         '''
    116. 

  116.         #
    117. 

  117.         # Accepting ANY type of password.
    118. 

  118.         pwd = ba.b2a_base64(pwd)
    119. 

  119. 

  120.         if type(enc) == type(''):
    121. 

  121.             enc = enc.decode()
    122. 

  122. 

  123.         if enc == 'AES' or enc == ENC['AES']:
    124. 

  124.             key_size = 32
    125. 

  125. 

  126.         elif enc == 'Blowfish' or enc == ENC['Blowfish']:
    127. 

  127.             key_size = 56
    128. 

  128. 

  129.         elif enc == 'ARC2' or enc == ENC['ARC2']:
    130. 

  130.             key_size = 128
    131. 

  131. 

  132.         elif enc == 'CAST' or enc == ENC['CAST']:
    133. 

  133.             key_size = 8
    134. 

  134. 

  135.         elif enc == 'DES3' or enc == ENC['DES3']:
    136. 

  136.             key_size = 24
    137. 

  137. 

  138.         elif enc == 'RSA' and self.rsa_path:
    139. 

  139.             key_size = 56
    140. 

  140.             # Read the public/ private key from file, encrypt password and return.
    141. 

  141.             rsa_key = open(self.rsa_path, 'rb').read()
    142. 

  142.             o = RSA.importKey(rsa_key)
    143. 

  143.             # RSA text is max 128 characters.
    144. 

  144.             rsa_pwd = pwd[:128]
    145. 

  145.             pwd = o.encrypt(rsa_pwd, 0)[0]
    146. 

  146.             del o, rsa_key, rsa_pwd
    147. 

  147. 

  148.         elif not enc or enc == 'None':
    149. 

  149.             return pwd
    150. 

  150. 

  151.         else:
    152. 

  152.             raise Exception('Fix password: Invalid encryption mode "%s" !' % enc)
    153. 

  153. 

  154.         if not pwd:
    155. 

  155.             # Only for NULL passwords.
    156. 

  156.             return key_size * 'X'
    157. 

  157. 

  158.         # Scramble the password many times.
    159. 

  159.         # Can't use random salt, 'cose the same pass must be recreated for decryption.
    160. 

  160.         hash_key = PBKDF2(passphrase=pwd, salt='scregg', iterations=1024)
    161. 

  161. 

  162.         # The password for encryption/ decryption.
    163. 

  163.         # This is very strong, binary data!
    164. 

  164.         return hash_key.read(key_size)
    165. 

  165.         #
    166. 

  166. 

  167.     def encrypt(self, txt, pre, enc, post, pwd, tags=True):
    168. 

  168.         #
    169. 

  169.         if type(txt) != type('') and type(txt) != type(u''):
    170. 

  170.             raise TypeError('Invalid data type for encryption: "%s" !' % str(type(txt)))
    171. 

  171.         #
    172. 

  172.         # Scramble operation.
    173. 

  173.         if pre in ['None', 'None']:
    174. 

  174.             pass
    175. 

  175.         elif pre in ['ZLIB', 'ZLIB']:
    176. 

  176.             txt = zlib.compress(txt)
    177. 

  177.         elif pre in ['BZ2', 'BZ2']:
    178. 

  178.             txt = bz2.compress(txt)
    179. 

  179.         elif pre in ['ROT13', 'ROT13']:
    180. 

  180.             txt = string.translate(txt, ROT)
    181. 

  181.         else:
    182. 

  182.             raise Exception('Invalid scramble "%s" !' % pre)
    183. 

  183.         #
    184. 

  184.         # Check RSA key path.
    185. 

  185.         if enc in ['RSA', 'RSA'] and not os.path.exists(self.rsa_path):
    186. 

  186.             print('RSA encryption must specify a valid path !')
    187. 

  187.             self.__error(2, pre, enc, post, field='L')
    188. 

  188.             return
    189. 

  189.         #
    190. 

  190.         pwd = self._fix_password(pwd, enc)
    191. 

  191.         #
    192. 

  192.         if enc in ['AES', 'AES']:
    193. 

  193.             o = AES.new(pwd, mode=2)
    194. 

  194.         elif enc in ['ARC2', 'ARC2']:
    195. 

  195.             o = ARC2.new(pwd, mode=2)
    196. 

  196.         elif enc in ['CAST', 'CAST']:
    197. 

  197.             o = CAST.new(pwd, mode=2)
    198. 

  198.         elif enc in ['Blowfish', 'Blowfish']:
    199. 

  199.             o = Blowfish.new(pwd, mode=2)
    200. 

  200.         elif enc in ['DES3', 'DES3']:
    201. 

  201.             o = DES3.new(pwd, mode=2)
    202. 

  202.         elif enc in ['RSA', 'RSA']:
    203. 

  203.             # Using Blowfish encryption for RSA.
    204. 

  204.             o = Blowfish.new(pwd, mode=3)
    205. 

  205.         elif not enc or enc in ['None', 'None']:
    206. 

  206.             o = None
    207. 

  207.         else:
    208. 

  208.             raise Exception('Invalid encryption mode "%s" !' % enc)
    209. 

  209.         #
    210. 

  210.         # Encryption operation.
    211. 

  211.         if o:
    212. 

  212.             temp = appendPadding(txt, blocksize=16)
    213. 

  213.             txt = o.encrypt(temp)
    214. 

  214.             del temp
    215. 

  215.         #
    216. 

  216.         # Codec operation.
    217. 

  217.         if post in ['Base64 Codec', 'Base64 Codec']:
    218. 

  218.             if tags:
    219. 

  219.                 txt = '<#>%s:%s:%s<#>%s' % \
    220. 

  220.                     (SCRAMBLE_D[pre], ENC[enc], ENCODE_D[post].replace(' Codec',''), ba.b2a_base64(txt).decode())
    221. 

  221.             else:
    222. 

  222.                 txt = ba.b2a_base64(txt).decode()
    223. 

  223.         elif post in ['Base32 Codec', 'Base32 Codec']:
    224. 

  224.             if tags:
    225. 

  225.                 txt = '<#>%s:%s:%s<#>%s' % \
    226. 

  226.                     (SCRAMBLE_D[pre], ENC[enc], ENCODE_D[post].replace(' Codec',''), base64.b32encode(txt).decode())
    227. 

  227.             else:
    228. 

  228.                 txt = base64.b32encode(txt).decode()
    229. 

  229.         elif post in ['HEX Codec', 'HEX Codec']:
    230. 

  230.             if tags:
    231. 

  231.                 txt = '<#>%s:%s:%s<#>%s' % \
    232. 

  232.                     (SCRAMBLE_D[pre], ENC[enc], ENCODE_D[post].replace(' Codec',''), ba.b2a_hex(txt).decode())
    233. 

  233.             else:
    234. 

  234.                 txt = ba.b2a_hex(txt).decode()
    235. 

  235.         elif post in ['Quopri Codec', 'Quopri Codec']:
    236. 

  236.             if tags:
    237. 

  237.                 txt = '<#>%s:%s:%s<#>%s' % (SCRAMBLE_D[pre], ENC[enc], ENCODE_D[post].replace(' Codec',''), \
    238. 

  238.                     ba.b2a_qp(txt, quotetabs=True, header=True).decode())
    239. 

  239.             else:
    240. 

  240.                 txt = ba.b2a_qp(txt, quotetabs=True, header=True).decode()
    241. 

  241.         elif post in ['Json', 'Json']:
    242. 

  242.             if tags:
    243. 

  243.                 # Format : {"pre": "AAA", "enc": "BBB", "post": "CCC", "data": "Blah blah blah"}
    244. 

  244.                 txt = '{"pre": "%s", "enc": "%s", "post": "%s", "data": "%s"}' % \
    245. 

  245.                     (SCRAMBLE_D[pre], ENC[enc], ENCODE_D[post], ba.b2a_base64(txt).rstrip().decode())
    246. 

  246.             else:
    247. 

  247.                 txt = json.dumps({'data':ba.b2a_base64(txt).rstrip().decode()})
    248. 

  248.         elif post in ['XML', 'XML']:
    249. 

  249.             if tags:
    250. 

  250.                 # Format : <root><pre>AAA</pre> <enc>BBB</enc> <post>CCC</post> <data>Blah blah blah</data></root>
    251. 

  251.                 txt = '<root>\n<pre>%s</pre><enc>%s</enc><post>%s</post>\n<data>%s</data>\n</root>' % \
    252. 

  252.                     (SCRAMBLE_D[pre], ENC[enc], ENCODE_D[post], ba.b2a_base64(txt).rstrip().decode())
    253. 

  253.             else:
    254. 

  254.                 txt = '<root>\n<data>%s</data>\n</root>' % ba.b2a_base64(txt).rstrip().decode()
    255. 

  255.         else:
    256. 

  256.             raise Exception('Invalid codec "%s" !' % post)
    257. 

  257.         #
    258. 

  258.         # The final text must be String, to be used in GUI
    259. 

  259.         return txt
    260. 

  260.         #
    261. 

  261. 

  262.     def decrypt(self, txt, pre, enc, post, pwd):
    263. 

  263.         #
    264. 

  264.         if type(txt) != type('') and type(txt) != type(u''):
    265. 

  265.             raise TypeError('Invalid data type for decryption: "%s" !' % str(type(txt)))
    266. 

  266.         #
    267. 

  267.         if not (pre and enc and post):
    268. 

  268.             # Trying to identify and/or delete pre/enc/post tags.
    269. 

  269.             #try:
    270. 

  270.             re_groups = re.search(NO_TAGS, txt).groups()
    271. 

  271.             tags = findg(re_groups)
    272. 

  272. 

  273.             # If Json.
    274. 

  274.             if '{' in txt and '}' in txt and '"data":' in txt:
    275. 

  275.                 pre = 'Json'
    276. 

  276.                 temp = json.loads(txt.decode())
    277. 

  277.                 enc = temp.get('enc').encode()
    278. 

  278.                 post = temp.get('pre').encode()
    279. 

  279.                 txt = temp['data'].encode()
    280. 

  280. 

  281.             # If XML.
    282. 

  282.             elif '<data>' in txt and '</data>' in txt:
    283. 

  283.                 pre = 'XML'
    284. 

  284.                 enc = re.search('<enc>([0-9a-zA-Z ]{1,3})</enc>', tags).group(1)
    285. 

  285.                 post = re.search('<pre>([0-9a-zA-Z ]{1,3})</pre>', tags).group(1)
    286. 

  286.                 txt = re.search('<data>(.+)</data>', txt, re.S).group(1)
    287. 

  287. 

  288.             else:
    289. 

  289.                 pre = tags.split(':')[2]
    290. 

  290.                 enc = tags.split(':')[1]
    291. 

  291.                 post = tags.split(':')[0]
    292. 

  292.                 txt = re.sub(NO_TAGS, '', txt)
    293. 

  293. 

  294.             pre = self.pre = pre.decode()
    295. 

  295.             enc = self.enc = enc.decode()
    296. 

  296.             post = self.post = post.decode()
    297. 

  297. 

  298.             #except:
    299. 

  299.             #    print('Cannot decrypt, caught error with', pre, enc, post, '!')
    300. 

  300. 

  301.         else:
    302. 

  302.             # If Json.
    303. 

  303.             if '{' in txt and '}' in txt and '"data":' in txt:
    304. 

  304.                 pre = 'Json'
    305. 

  305.                 temp = json.loads(txt.decode())
    306. 

  306.                 txt = temp['data'].encode()
    307. 

  307. 

  308.             # If XML.
    309. 

  309.             elif '<data>' in txt and '</data>' in txt:
    310. 

  310.                 pre = 'XML'
    311. 

  311.                 txt = re.search('<data>(.+)</data>', txt, re.S).group(1)
    312. 

  312. 

  313.             else:
    314. 

  314.                 txt = re.sub(NO_TAGS, '', txt)
    315. 

  315.         #
    316. 

  316.         # Check RSA key path.
    317. 

  317.         if enc == 'RSA' and not os.path.exists(self.rsa_path):
    318. 

  318.             print('RSA decryption must specify a valid path !')
    319. 

  319.             self.__error(2, pre, enc, post)
    320. 

  320.             return
    321. 

  321.         #
    322. 

  322.         # Adapting password for encryption.
    323. 

  323.         pwd = self._fix_password(pwd, enc)
    324. 

  324.         #
    325. 

  325.         # Codec operation.
    326. 

  326.         if not pre:
    327. 

  327.             self.__error(1, 'None', enc, post) ; return
    328. 

  328.         elif pre == 'Base64 Codec' or pre == ENCODE_D['Base64 Codec']:
    329. 

  329.             try: txt = ba.a2b_base64(txt)
    330. 

  330.             except: self.__error(1, pre, enc, post) ; return
    331. 

  331.         elif pre == 'Base32 Codec' or pre == ENCODE_D['Base32 Codec']:
    332. 

  332.             try: txt = base64.b32decode(txt)
    333. 

  333.             except: self.__error(1, pre, enc, post) ; return
    334. 

  334.         elif pre == 'HEX Codec' or pre == ENCODE_D['HEX Codec']:
    335. 

  335.             try: txt = ba.a2b_hex(txt)
    336. 

  336.             except: self.__error(1, pre, enc, post) ; return
    337. 

  337.         elif pre == 'Quopri Codec' or pre == ENCODE_D['Quopri Codec']:
    338. 

  338.             try: txt = ba.a2b_qp(txt, header=True)
    339. 

  339.             except: self.__error(1, pre, enc, post) ; return
    340. 

  340.         elif pre == 'Json' or pre == ENCODE_D['Json']:
    341. 

  341.             try: txt = ba.a2b_base64(txt)
    342. 

  342.             except: self.__error(1, pre, enc, post) ; return
    343. 

  343.         elif pre == 'XML':
    344. 

  344.             try: txt = ba.a2b_base64(txt)
    345. 

  345.             except: self.__error(1, pre, enc, post) ; return
    346. 

  346.         else:
    347. 

  347.             raise Exception('Invalid codec "%s" !' % pre)
    348. 

  348.         #
    349. 

  349.         if enc == 'AES' or enc == ENC['AES']:
    350. 

  350.             o = AES.new(pwd, mode=2)
    351. 

  351.         elif enc == 'ARC2' or enc == ENC['ARC2']:
    352. 

  352.             o = ARC2.new(pwd, mode=2)
    353. 

  353.         elif enc == 'CAST' or enc == ENC['CAST']:
    354. 

  354.             o = CAST.new(pwd, mode=2)
    355. 

  355.         elif enc == 'Blowfish' or enc == ENC['Blowfish']:
    356. 

  356.             o = Blowfish.new(pwd, mode=2)
    357. 

  357.         elif enc == 'DES3' or enc == ENC['DES3']:
    358. 

  358.             o = DES3.new(pwd, mode=2)
    359. 

  359.         elif enc == 'RSA':
    360. 

  360.             # Using Blowfish decryption for RSA.
    361. 

  361.             o = Blowfish.new(pwd, mode=3)
    362. 

  362.         elif not enc or enc == 'None':
    363. 

  363.             o = None
    364. 

  364.         else:
    365. 

  365.             raise Exception('Invalid decrypt "%s" !' % enc)
    366. 

  366.         #
    367. 

  367.         # Decryption operation.
    368. 

  368.         if o:
    369. 

  369.             try:
    370. 

  370.                 temp = o.decrypt(txt)
    371. 

  371.                 txt = removePadding(temp, 16)
    372. 

  372.                 del temp
    373. 

  373.             except: self.__error(2, pre, enc, post) ; return
    374. 

  374.         #
    375. 

  375.         # Un-scramble operation.
    376. 

  376.         if not post or post == 'N' or post == 'None':
    377. 

  377.             pass
    378. 

  378.         elif post == 'ZLIB' or post == SCRAMBLE_D['ZLIB']:
    379. 

  379.             try: txt = zlib.decompress(txt)
    380. 

  380.             except: self.__error(3, pre, enc, post) ; return
    381. 

  381.         elif post == 'BZ2' or post == SCRAMBLE_D['BZ2']:
    382. 

  382.             try: txt = bz2.decompress(txt)
    383. 

  383.             except: self.__error(3, pre, enc, post) ; return
    384. 

  384.         elif post == 'ROT13' or post == SCRAMBLE_D['ROT13']:
    385. 

  385.             txt = string.translate(txt, ROT)
    386. 

  386.         else:
    387. 

  387.             raise Exception('Invalid scramble "%s" !' % post)
    388. 

  388.         #
    389. 

  389.         return txt
    390. 

  390.         #
    391. 

  391. 

  392.     def toImage(self, txt, pre, enc, post, pwd, path, encrypt=True):
    393. 

  393.         '''
    394. 

  394.         Any information, text and/or files, can be encoded inside a little PNG image. \n\
    395. 

  395.         Depending on how you encode the crypted data, images come in 3 flavors: HEX, Base32 and Base64. \n\
    396. 

  396.         Normally each letter can be encoded inside a color value from 1 to 255,
    397. 

  397.         and 4 colors become one RGBA pixel. \n\
    398. 

  398.         HEX encoding is `high density`. Two letters are transformed into a color from 1 to 255,
    399. 

  399.         so one pixel consists of 8 letters, instead of 4 letters.
    400. 

  400.         '''
    401. 

    402. 

  402.         if not pre: pre = 'None'
    403. 

  403.         if not enc: enc = 'None'
    404. 

  404.         if post not in ('HEX Codec', 'Base32 Codec', 'Base64 Codec'):
    405. 

  405.             print('Encoding must be HEX, Base32, or Base64! Exiting!')
    406. 

  406.             return
    407. 

  407. 

  408.         # Input can be string, or file. If's file, read it.
    409. 

  409.         if str(type(txt)) == "<type 'file'>":
    410. 

  410.             txt.seek(0)
    411. 

  411.             txt = txt.read()
    412. 

  412. 

  413.         # All text must be reversed, to pop from the end of the characters list.
    414. 

  414.         if encrypt: # If text MUST be encrypted first, encrypt without pre/enc/post tags.
    415. 

  415.             val = self.encrypt(txt, pre, enc, post, pwd, False)[::-1]
    416. 

  416.             if not val:
    417. 

  417.                 return
    418. 

  418.         else: # Else, the text is already encrypted.
    419. 

  419.             # Strip pre/enc/post tags.
    420. 

  420.             txt = re.sub(NO_TAGS, '', txt)
    421. 

  421.             # All information is reversed, because it's faster to just Pop from the end of a list,
    422. 

  422.             # Rather then using Pop(0), from the beggining of a list.
    423. 

  423.             # So the "first pixel" will be added at the end, but will be fetched first,
    424. 

  424.             # When creating the final image.
    425. 

  425.             val = txt[::-1]
    426. 

  426.             del txt
    427. 

  427. 

  428.         # Calculate the edge of the square and blank square.
    429. 

  429.         if post == 'HEX Codec':
    430. 

  430.             # Length.
    431. 

  431.             edge = math.ceil(math.sqrt( float(len(val) + 1)/8.0 ))
    432. 

  432.             blank = math.ceil(edge * edge - float(len(val)) / 8.0)
    433. 

  433.             if blank:
    434. 

  434.                 blank -= 1
    435. 

  435.         else:
    436. 

  436.             # Length + 5, just to make sure there are enough blank pixels.
    437. 

  437.             edge = math.ceil(math.sqrt( float(len(val) + 5)/4.0 ))
    438. 

  438.             blank = math.ceil((edge * edge - float(len(val))/4.0) / 2.0)
    439. 

  439. 

  440.         # `Second pixel` : a number representing the length of valid characters.
    441. 

  441.         # This is only used for HEX, because when decrypting, this number of letters is trimmed from the end of the string.
    442. 

  442.         if post == 'HEX Codec':
    443. 

  443.             second_pixel = struct.pack('BB', int(blank/255), (blank%256)).encode('hex')
    444. 

  444.             val += second_pixel[::-1]
    445. 

  445.             #print '! Second pixel', second_pixel
    446. 

  446.             del second_pixel
    447. 

  447. 

  448.         # `First pixel` : a string with 4 numbers representing Pre/ Enc/ Post information.
    449. 

  449.         # For Base64/ Base32, this variabile is encoded in one pixel (4 characters).
    450. 

  450.         # For HEX, First Pixel + Second Pixel are both encoded in one pixel (8 characters).
    451. 

  451.         if post == 'HEX Codec':
    452. 

  452.             first_pixel = '0'
    453. 

  453.         else:
    454. 

  454.             first_pixel = '1'
    455. 

  455. 

  456.         # Add first pixel at the end of the reversed string.
    457. 

  457.         first_pixel += SCRAMBLE_NR[pre] + ENCRYPT_NR[enc] + ENCODE_NR[post]
    458. 

  458.         val += first_pixel[::-1]
    459. 

  459.         #print '! First pixel', first_pixel
    460. 

  460.         del first_pixel
    461. 

  461. 

  462.         # Explode the encrypted string.
    463. 

  463.         list_val = list(val)
    464. 

  464.         # Creating new square image.
    465. 

  465.         print('Creating img, %ix%i, blank : %i, string to encode : %i chars.' % (edge, edge, blank, len(val)))
    466. 

  466. 

  467.         edge = int(edge)
    468. 

  468.         if not Image:
    469. 

  469.             im = QtGui.QImage(edge, edge, QtGui.QImage.Format_ARGB32)
    470. 

  470.             _pix = im.setPixel
    471. 

  471.             _rgba = QtGui.qRgba
    472. 

  472.         else:
    473. 

  473.             im = Image.new('RGBA', (edge, edge))
    474. 

  474.             _pix = im.load()
    475. 

  475.         _int = int
    476. 

  476.         _ord = ord
    477. 

  477. 

  478.         # HEX codec.
    479. 

  479.         if post == 'HEX Codec':
    480. 

  480.             for i in range(edge):
    481. 

  481.                 for j in range(edge):
    482. 

  482.                     #
    483. 

  483.                     _r = _g = _b = _a = 255
    484. 

  484. 

  485.                     # Red
    486. 

  486.                     if len(list_val) >= 2:
    487. 

  487.                         _r = _int(list_val.pop()+list_val.pop(), 16)
    488. 

  488.                     elif len(list_val) == 1:
    489. 

  489.                         _r = _int(list_val.pop(), 16)
    490. 

  490. 

  491.                     # Green
    492. 

  492.                     if len(list_val) >= 2:
    493. 

  493.                         _g = _int(list_val.pop()+list_val.pop(), 16)
    494. 

  494.                     elif len(list_val) == 1:
    495. 

  495.                         _g = _int(list_val.pop(), 16)
    496. 

  496. 

  497.                     # Blue
    498. 

  498.                     if len(list_val) >= 2:
    499. 

  499.                         _b = _int(list_val.pop()+list_val.pop(), 16)
    500. 

  500.                     elif len(list_val) == 1:
    501. 

  501.                         _b = _int(list_val.pop(), 16)
    502. 

  502. 

  503.                     # Alpha
    504. 

  504.                     if len(list_val) >= 2:
    505. 

  505.                         _a = _int(list_val.pop()+list_val.pop(), 16)
    506. 

  506.                     elif len(list_val) == 1:
    507. 

  507.                         _a = _int(list_val.pop(), 16)
    508. 

  508.                     #
    509. 

  509.                     if not Image:
    510. 

  510.                         _pix(j, i, _rgba(_r, _g, _b, _a))
    511. 

  511.                     else:
    512. 

  512.                         _pix[j, i] = (_r, _g, _b, _a)
    513. 

  513.                     #
    514. 

  514. 

  515.         # Base 64 and Base 32.
    516. 

  516.         else:
    517. 

  517.             for i in range(edge):
    518. 

  518.                 for j in range(edge):
    519. 

  519.                     #
    520. 

  520.                     if blank:
    521. 

  521.                         blank -= 1
    522. 

  522.                         # Put one #FFFFFFFF, completely white pixel.
    523. 

  523.                         if not Image:
    524. 

  524.                             _pix(j, i, 4294967295)
    525. 

  525.                         else:
    526. 

  526.                             _pix[j, i] = (255,255,255,255)
    527. 

  527. 

  528.                         continue
    529. 

  529.                     #
    530. 

  530.                     _r = _g = _b = _a = 255
    531. 

  531. 

  532.                     if len(list_val) >= 1:
    533. 

  533.                         _r = _ord(list_val.pop())
    534. 

  534.                     if len(list_val) >= 1:
    535. 

  535.                         _g = _ord(list_val.pop())
    536. 

  536.                     if len(list_val) >= 1:
    537. 

  537.                         _b = _ord(list_val.pop())
    538. 

  538.                     if len(list_val) >= 1:
    539. 

  539.                         _a = _ord(list_val.pop())
    540. 

  540. 

  541.                     if not Image:
    542. 

  542.                         _pix(j, i, _rgba(_r, _g, _b, _a))
    543. 

  543.                     else:
    544. 

  544.                         _pix[j, i] = (_r, _g, _b, _a)
    545. 

  545.                     #
    546. 

  546. 

  547.         #
    548. 

  548.         try:
    549. 

  549.             im.save(path, 'PNG') #, -1)
    550. 

  550.         except:
    551. 

  551.             print('Cannot save PNG file "%s" !' % path)
    552. 

  552.         #
    553. 

  553. 

  554.     def fromImage(self, pwd, path, decrypt=True):
    555. 

  555.         #
    556. 

  556.         if not os.path.isfile(path):
    557. 

  557.             print('Cannot find file "%s" !' % path)
    558. 

  558.             return
    559. 

  559. 

  560.         try:
    561. 

  561.             if not Image:
    562. 

  562.                 im = QtGui.QImage()
    563. 

  563.                 im.load(path, 'PNG')
    564. 

  564.                 W = im.width()
    565. 

  565.                 H = im.height()
    566. 

  566.                 _r = QtGui.qRed
    567. 

  567.                 _g = QtGui.qGreen
    568. 

  568.                 _b = QtGui.qBlue
    569. 

  569.                 _a = QtGui.qAlpha
    570. 

  570.                 _pix = im.pixel
    571. 

  571. 

  572.             else:
    573. 

  573.                 im = Image.open(path, 'r')
    574. 

  574.                 W = im.size[0] # Width
    575. 

  575.                 H = im.size[1] # Height
    576. 

  576.                 _pix = im.load()
    577. 

  577. 

  578.         except:
    579. 

  579.             print('Image "%s" is not a valid RGBA PNG !' % path)
    580. 

  580.             return
    581. 

  581. 

  582.         fp_val = 0
    583. 

  583.         list_val = []
    584. 

  584. 

  585.         # Calculate First Pixel.
    586. 

  586.         for i in range(W):
    587. 

  587.             for j in range(H):
    588. 

  588.                 #
    589. 

  589.                 if fp_val:
    590. 

  590.                     break
    591. 

  591. 

  592.                 if not Image:
    593. 

  593.                     #
    594. 

  594.                     pix1 = _pix(j, i)
    595. 

  595.                     # For QtColor
    596. 

  596.                     if pix1 != 4294967295: # Color #FFFFFFFF, completely white pixel.
    597. 

  597.                         fp_val = [_r(pix1), _g(pix1), _b(pix1), _a(pix1)]
    598. 

  598.                         break
    599. 

  599.                     #
    600. 

  600.                 else:
    601. 

  601.                     #
    602. 

  602.                     pix1 = _pix[j, i]
    603. 

  603.                     # For PIL Image
    604. 

  604.                     if pix1 != (255,255,255,255):
    605. 

  605.                         fp_val = pix1
    606. 

  606.                         break
    607. 

  607.                     #
    608. 

  608. 

  609.         # Calculate the colors of first pixel.
    610. 

  610.         # For HEX: Red+Green represents pre/enc/post information and Blue+Alpha value represents nr of valid characters.
    611. 

  611.         # For Base64/ Base32, first pixel represents only the Pre/ Enc/ Post information.
    612. 

  612.         first_pixel_hex = struct.pack('BB', fp_val[0], fp_val[1]).encode('hex')
    613. 

  613.         blank = int(struct.pack('BB', fp_val[2], fp_val[3]).encode('hex'), 16)
    614. 

  614.         first_pixel_base = [unichr(fp_val[0]), unichr(fp_val[1]), unichr(fp_val[2]), unichr(fp_val[3])]
    615. 

  615. 

  616.         # Reverse number dictionaries.
    617. 

  617.         reverse_s = dict(zip(SCRAMBLE_NR.values(), SCRAMBLE_NR.keys()))
    618. 

  618.         reverse_ey = dict(zip(ENCRYPT_NR.values(), ENCRYPT_NR.keys()))
    619. 

  619.         reverse_ed = dict(zip(ENCODE_NR.values(), ENCODE_NR.keys()))
    620. 

  620. 

  621.         if first_pixel_hex[0] == '0' and first_pixel_base[0] != '0':
    622. 

  622.             post = reverse_s[first_pixel_hex[1]]
    623. 

  623.             enc = reverse_ey[first_pixel_hex[2]]
    624. 

  624.             pre = reverse_ed[first_pixel_hex[3]]
    625. 

  625.         else:
    626. 

  626.             post = reverse_s[first_pixel_base[1]]
    627. 

  627.             enc = reverse_ey[first_pixel_base[2]]
    628. 

  628.             pre = reverse_ed[first_pixel_base[3]]
    629. 

  629. 

  630.         # Save Pre/ Enc/ Post information for GUI.
    631. 

  631.         self.pre = pre
    632. 

  632.         self.enc = enc
    633. 

  633.         self.post = post
    634. 

  634. 

  635.         # For HEX and PyQt.
    636. 

  636.         if pre == 'HEX Codec' and not Image:
    637. 

  637.             for i in range(W):
    638. 

  638.                 for j in range(H):
    639. 

  639.                     #
    640. 

  640.                     rgba = _pix(j, i)
    641. 

  641.                     #
    642. 

  642.                     # For each channel in current pixel.
    643. 

  643.                     for v in [_r(rgba), _g(rgba), _b(rgba), _a(rgba)]:
    644. 

  644.                         # This is much faster than struct.pack('B',v).encode('hex')
    645. 

  645.                         # I need 2 characters; in HEX 16=>10; less than 16 must have 0 in front of it.
    646. 

  646.                         if v < 16:
    647. 

  647.                             list_val.append('0'+hex(v)[-1])
    648. 

  648.                         else:
    649. 

  649.                             list_val.append(hex(v)[-2:])
    650. 

  650.                     #
    651. 

  651. 

  652.         # For HEX and PIL Image.
    653. 

  653.         elif pre == 'HEX Codec':
    654. 

  654.             for i in range(W):
    655. 

  655.                 for j in range(H):
    656. 

  656.                     #
    657. 

  657.                     rgba = _pix[j, i]
    658. 

  658.                     #
    659. 

  659.                     # For each channel in current pixel.
    660. 

  660.                     for v in rgba:
    661. 

  661.                         # I need 2 characters; in HEX 16=>10; less than 16 must have 0 in front of it.
    662. 

  662.                         if v < 16:
    663. 

  663.                             list_val.append('0'+hex(v)[-1])
    664. 

  664.                         else:
    665. 

  665.                             list_val.append(hex(v)[-2:])
    666. 

  666.                     #
    667. 

  667. 

  668.         # For the rest, with PyQt.
    669. 

  669.         elif not Image:
    670. 

  670.             for i in range(W):
    671. 

  671.                 for j in range(H):
    672. 

  672.                     #
    673. 

  673.                     rgba = _pix(j, i)
    674. 

  674.                     #
    675. 

  675.                     # For each channel in current pixel.
    676. 

  676.                     for v in [_r(rgba), _g(rgba), _b(rgba), _a(rgba)]:
    677. 

  677.                         if v and v != 255:
    678. 

  678.                             list_val.append(unichr(v))
    679. 

  679.                         # If this color is 0 or 255, the rest of the pixel is blank.
    680. 

  680.                         else:
    681. 

  681.                             break
    682. 

  682.                     #
    683. 

  683. 

  684.         # For the rest, with PIL Image.
    685. 

  685.         else:
    686. 

  686.             for i in range(W):
    687. 

  687.                 for j in range(H):
    688. 

  688.                     #
    689. 

  689.                     rgba = _pix[j, i]
    690. 

  690.                     #
    691. 

  691.                     # For each channel in current pixel.
    692. 

  692.                     for v in rgba:
    693. 

  693.                         if v and v != 255:
    694. 

  694.                             list_val.append(unichr(v))
    695. 

  695.                         # If this color is 0 or 255, the rest of the pixel is blank.
    696. 

  696.                         else:
    697. 

  697.                             break
    698. 

  698.                     #
    699. 

  699. 

  700.         # Fix `blank` value.
    701. 

  701.         if blank:
    702. 

  702.             blank = - blank * 8
    703. 

  703.         else:
    704. 

  704.             blank = len(list_val) * 8
    705. 

  705. 

  706.         # Used for DEBUG.
    707. 

  707.         #ff = open('dump.txt', 'wb')
    708. 

  708.         #ff.write('\nColor: %s ; FP Val: %s ; FP Hex: %s ; FP B64/32: %s ; Blank: %i' % (cc.name(),str(fp_val),first_pixel_hex,''.join(first_pixel_b),blank))
    709. 

  709.         #ff.write('\n'+''.join(list_val)+'\n')
    710. 

  710.         #ff.write(''.join(list_val)[8:blank])
    711. 

  711.         #ff.close() ; del ff, fp_val
    712. 

  712. 

  713.         # If the text MUST be decrypted.
    714. 

  714.         if decrypt:
    715. 

  715.             if pre == 'HEX Codec':
    716. 

  716.                 val = self.decrypt(''.join(list_val)[8:blank], pre, enc, post, pwd)
    717. 

  717.             else:
    718. 

  718.                 val = self.decrypt(''.join(list_val[4:]), pre, enc, post, pwd)
    719. 

  719. 

  720.             if not val:
    721. 

  721.                 print('Error from image (decrypt)! ' + self.error.strip())
    722. 

  722.             else:
    723. 

  723.                 return val
    724. 

  724. 

  725.         # Else, don't decrypt.
    726. 

  726.         else:
    727. 

  727.             if pre == 'HEX Codec':
    728. 

  728.                 val = ''.join(list_val)[8:blank]
    729. 

  729.             else:
    730. 

  730.                 val = ''.join(list_val[4:])
    731. 

  731. 

  732.             if not val:
    733. 

  733.                 print('Error from image (no decrypt)!')
    734. 

  734.             else:
    735. 

  735.                 return val
    736. 

  736.         #
    737. 

  737. 

  738.     def _import(self, pre, enc, post, pwd, fpath, decrypt=True):
    739. 

  739.         #
    740. 

  740.         if not os.path.isfile(fpath):
    741. 

  741.             print('Cannot find file "%s" !' % fpath)
    742. 

  742.             return
    743. 

  743.         #
    744. 

  744.         ext = os.path.splitext(fpath)[1].lower()
    745. 

  745. 

  746.         # For PNG files.
    747. 

  747.         if ext=='.png':
    748. 

  748.             return self.fromImage(pwd, fpath, decrypt)
    749. 

  749. 

  750.         # For the rest of the files.
    751. 

  751.         if decrypt:
    752. 

  752.             val = self.decrypt(open(fpath, 'rb').read(), pre, enc, post, pwd)
    753. 

  753.             if not val:
    754. 

  754.                 print(self.error)
    755. 

  755.             else:
    756. 

  756.                 return val
    757. 

  757. 

  758.         # Else, don't decrypt.
    759. 

  759.         else:
    760. 

  760.             val = open(fpath, 'rb').read()
    761. 

  761.             return val
    762. 

  762.         #
    763. 

  763. 

  764. 

  765. # ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- -----
    766. 

  766. #       GUI  Container  Widget
    767. 

  767. # ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- -----
    768. 

  768. 

  769. class ContainerWidget(QtGui.QWidget):
    770. 

  770. 

  771.     def __init__(self, parent):
    772. 

  772.         '''
    773. 

  773.         Main container. It's not transparent. \n\
    774. 

  774.         I must use this, to accept file drops.
    775. 

  775.         '''
    776. 

  776.         super(ContainerWidget, self).__init__(parent)
    777. 

  777.         self.mMoving = False
    778. 

  778.         self.setMouseTracking(False)
    779. 

  779.         self.setSizePolicy(QtGui.QSizePolicy(QtGui.QSizePolicy.Maximum, QtGui.QSizePolicy.Maximum))
    780. 

  780. 

  781.     def mousePressEvent(self, event):
    782. 

  782.         if(event.button() == QtCore.Qt.LeftButton):
    783. 

  783.             self.mMoving = True
    784. 

  784.             self.mOffset = event.pos()
    785. 

  785. 

  786.     def mouseMoveEvent(self, event):
    787. 

  787.         if(self.mMoving):
    788. 

  788.             self.parentWidget().move(event.globalPos() - self.mOffset)
    789. 

  789. 

  790.     def mouseReleaseEvent(self, event):
    791. 

  791.         if(event.button() == QtCore.Qt.LeftButton):
    792. 

  792.             self.mMoving = False
    793. 

  793. 

  794. 

  795. # ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- -----
    796. 

  796. #       MAIN  Scrambled-Egg  Window
    797. 

  797. # ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- ----- -----
    798. 

  798. 

  799. class Window(QtGui.QMainWindow):
    800. 

  800. 

  801.     def __init__(self):
    802. 

  802.         '''
    803. 

  803.         Main window class.
    804. 

  804.         It's frameless and transparent.
    805. 

  805.         '''
    806. 

  806.         super(Window, self).__init__(None, QtCore.Qt.FramelessWindowHint)
    807. 

  807.         QtGui.QApplication.setStyle(QtGui.QStyleFactory.create('CleanLooks'))
    808. 

  808.         QtGui.QApplication.setPalette(QtGui.QApplication.style().standardPalette())
    809. 

  809. 

  810.         icon_path = os.path.split(os.path.abspath(__file__))[0] + '/config/icon.ico'
    811. 

  811.         self.setWindowIcon(QtGui.QIcon(icon_path))
    812. 

  812.         self.resize(C['W_WIDTH'], C['W_HEIGHT'])
    813. 

  813.         self.setMaximumHeight(C['W_MAX_HEIGHT'])
    814. 

  814.         self.setStyleSheet(D['STYLE_MAIN'])
    815. 

  815.         self.setWindowTitle('Scrambled Egg %s :: Live Crypt' % __version__)
    816. 

  816.         self.setAttribute(QtCore.Qt.WA_TranslucentBackground)
    817. 

  817.         self.setWindowOpacity(0.9)
    818. 

  818.         self.setAcceptDrops(True)
    819. 

  819. 

  820.         self.SE = ScrambledEgg()
    821. 

  821. 

  822.         self.centralWidget = ContainerWidget(self) # Central Widget.
    823. 

  823.         self.setCentralWidget(self.centralWidget)
    824. 

  824.         self.container = QtGui.QWidget(self.centralWidget) # Container Widget.
    825. 

  825.         self.container.setObjectName('Container')
    826. 

  826.         self.container.setStyleSheet(D['STYLE_CONTAINER'])
    827. 

  827. 

  828.         self.textBar = QtGui.QLabel(self) # Top text bar.
    829. 

  829.         self.layout = QtGui.QGridLayout(self.centralWidget) # Main Layout.
    830. 

  830.         self.centralWidget.setLayout(self.layout)
    831. 

  831. 

  832.         self.leftText = QtGui.QTextEdit('', self.centralWidget)        # To write clean text.
    833. 

  833.         self.rightText = QtGui.QPlainTextEdit('' , self.centralWidget) # To view encrypted text.
    834. 

  834. 

  835.         self.buttonCryptMode = QtGui.QPushButton(self.centralWidget)
    836. 

  836.         self.buttonDecryptMode = QtGui.QPushButton(self.centralWidget)
    837. 

  837.         self.buttonBrowseRSAL = QtGui.QPushButton('Browse', self.centralWidget)
    838. 

  838.         self.buttonBrowseRSAR = QtGui.QPushButton('Browse', self.centralWidget)
    839. 

  839. 

  840.         self.preProcess = QtGui.QComboBox(self.centralWidget)    # Left side.
    841. 

  841.         self.comboCrypt = QtGui.QComboBox(self.centralWidget)    # Left side.
    842. 

  842.         self.postProcess = QtGui.QComboBox(self.centralWidget)   # Left side.
    843. 

  843.         self.linePasswordL = QtGui.QLineEdit(self.centralWidget) # Left password line.
    844. 

  844.         self.lineRSAPathL = QtGui.QLineEdit(self.centralWidget)  # Left RSA Path line.
    845. 

  845.         self.checkPwdL = QtGui.QCheckBox('<- Pwd', self.centralWidget) # Left side.
    846. 

  846.         self.nrLettersL = QtGui.QLabel('', self.centralWidget)   # Left side.
    847. 

  847.         self.setFormatting = QtGui.QCheckBox('Formatted text', self.centralWidget) # Left side.
    848. 

  848.         self.showHTML = QtGui.QCheckBox('Show HTML', self.centralWidget) # Left side.
    849. 

  849.         self.setTags = QtGui.QCheckBox('No tags', self.centralWidget)    # Left side.
    850. 

  850. 

  851.         self.preDecrypt = QtGui.QComboBox(self.centralWidget)    # Right side.
    852. 

  852.         self.comboDecrypt = QtGui.QComboBox(self.centralWidget)  # Right side.
    853. 

  853.         self.postDecrypt = QtGui.QComboBox(self.centralWidget)   # Right side.
    854. 

  854.         self.linePasswordR = QtGui.QLineEdit(self.centralWidget) # Right password line.
    855. 

  855.         self.lineRSAPathR = QtGui.QLineEdit(self.centralWidget)  # Right RSA Path line.
    856. 

  856.         self.checkPwdR = QtGui.QCheckBox('<- Pwd', self.centralWidget) # Right side.
    857. 

  857.         self.nrLettersR = QtGui.QLabel('', self.centralWidget)   # Right side.
    858. 

  858.         self.loadFile = QtGui.QPushButton('Import', self.centralWidget)   # Right side.
    859. 

  859.         self.saveFile = QtGui.QPushButton('Export', self.centralWidget)   # Right side.
    860. 

  860.         self.helpButton = QtGui.QPushButton('Help !', self.centralWidget) # Right side.
    861. 

  861. 

  862.         self.minButton = QtGui.QPushButton(D['MIN_BTN_TXT'], self.centralWidget)
    863. 

  863.         self.closeButton = QtGui.QPushButton(D['CLOSE_BTN_TXT'], self.centralWidget)
    864. 

  864.         self.micLayout = QtGui.QHBoxLayout()
    865. 

  865.         self.micLayout.addWidget(self.minButton)
    866. 

  866.         self.micLayout.addWidget(self.closeButton)
    867. 

  867. 

  868.         # Row, Col, rowSpan, colSpan
    869. 

  869.         self.layout.addWidget(self.container,           0, 1, 43, 12)
    870. 

  870.         self.layout.addWidget(self.textBar,             1, 1, 3, 8)
    871. 

  871.         self.layout.addLayout(self.micLayout,           1, 10+C['MIC_BTNS_POS'], 1, C['MIC_BTNS_SPAN'])
    872. 

  872.         self.layout.addItem(QtGui.QSpacerItem(1, 8),    3, 1, 1, 1)
    873. 

  873. 

  874.         self.layout.addWidget(self.buttonCryptMode,     4, 2, 1, 5)
    875. 

  875.         self.layout.addWidget(self.buttonDecryptMode,   4, 7, 1, 5)
    876. 

  876. 

  877.         self.layout.addWidget(self.preProcess,          5, 2, 1, 1)
    878. 

  878.         self.layout.addWidget(self.comboCrypt,          5, 3, 1, 1)
    879. 

  879.         self.layout.addWidget(self.postProcess,         5, 4, 1, 1)
    880. 

  880.         self.layout.addWidget(self.preDecrypt,          5, 7, 1, 1)
    881. 

  881.         self.layout.addWidget(self.comboDecrypt,        5, 8, 1, 1)
    882. 

  882.         self.layout.addWidget(self.postDecrypt,         5, 9, 1, 1)
    883. 

  883. 

  884.         self.layout.addWidget(self.linePasswordL,       6, 2, 1, 4)
    885. 

  885.         self.layout.addWidget(self.linePasswordR,       6, 7, 1, 4)
    886. 

  886.         self.layout.addWidget(self.checkPwdL,           6, 6, 1, 1)
    887. 

  887.         self.layout.addWidget(self.checkPwdR,           6, 11, 1, 1)
    888. 

  888. 

  889.         self.layout.addWidget(self.lineRSAPathL,        7, 2, 1, 4)
    890. 

  890.         self.layout.addWidget(self.lineRSAPathR,        7, 7, 1, 4)
    891. 

  891.         self.layout.addWidget(self.buttonBrowseRSAL,    7, 6, 1, 1)
    892. 

  892.         self.layout.addWidget(self.buttonBrowseRSAR,    7, 11, 1, 1)
    893. 

  893. 

  894.         self.layout.addWidget(self.leftText,            8, 2, 32, 5)
    895. 

  895.         self.layout.addWidget(self.rightText,           8, 7, 32, 5)
    896. 

  896. 

  897.         self.layout.addWidget(self.setFormatting,       40, 2, 1, 1)
    898. 

  898.         self.layout.addWidget(self.setTags,             40, 3, 1, 1)
    899. 

  899.         self.layout.addWidget(self.showHTML,            40, 4, 1, 1)
    900. 

  900.         self.layout.addWidget(self.loadFile,            40, 7, 1, 1)
    901. 

  901.         self.layout.addWidget(self.saveFile,            40, 8, 1, 1)
    902. 

  902.         self.layout.addWidget(self.helpButton,          40, 9, 1, 1)
    903. 

  903. 

  904.         self.layout.addWidget(self.nrLettersL,          40, 6, 1, 1)
    905. 

  905.         self.layout.addWidget(self.nrLettersR,          40, 11, 1, 1)
    906. 

  906. 

  907.         self.__setup() # Prepair all components!
    908. 

  908.         self.__connect() # Connect all components!
    909. 

  909. 

  910.     def __setup(self):
    911. 

  911.         '''
    912. 

  912.         Setup all components.
    913. 

  913.         '''
    914. 

  914.         #
    915. 

  915.         # Toogle buttons.
    916. 

  916.         self.buttonCryptMode.setCheckable(True)
    917. 

  917.         self.buttonCryptMode.setChecked(True)
    918. 

  918.         self.buttonCryptMode.setToolTip('Switch to Encryption mode')
    919. 

  919.         self.buttonCryptMode.setStyleSheet(D['STYLE_BUTTON'])
    920. 

  920.         self.buttonDecryptMode.setCheckable(True)
    921. 

  921.         self.buttonDecryptMode.setToolTip('Switch to Decryption mode')
    922. 

  922.         self.buttonDecryptMode.setStyleSheet(D['STYLE_BUTTON'])
    923. 

  923. 

  924.         self.helpButton.setStyleSheet(D['STYLE_HELP_BUTTON'])
    925. 

  925.         self.minButton.setMaximumWidth(25)
    926. 

  926.         self.minButton.setMaximumHeight(25)
    927. 

  927.         self.minButton.setStyleSheet(D['STYLE_MIN_BUTTON'])
    928. 

  928.         self.closeButton.setMaximumWidth(25)
    929. 

  929.         self.closeButton.setMaximumHeight(25)
    930. 

  930.         self.closeButton.setStyleSheet(D['STYLE_CLOSE_BUTTON'])
    931. 

  931. 

  932.         # Some styles.
    933. 

  933.         self.loadFile.setStyleSheet(D['STYLE_BUTTON'])
    934. 

  934.         self.saveFile.setStyleSheet(D['STYLE_BUTTON'])
    935. 

  935.         self.leftText.setStyleSheet(D['STYLE_L_TEXTEDIT'])
    936. 

  936.         self.rightText.setStyleSheet(D['STYLE_R_TEXTEDIT'])
    937. 

  937. 

  938.         # Password fields.
    939. 

  939.         self.linePasswordL.setEchoMode(QtGui.QLineEdit.Password)
    940. 

  940.         self.linePasswordL.setToolTip('Password used for encrypting the text')
    941. 

  941.         self.linePasswordL.setMaxLength(99)
    942. 

  942.         self.linePasswordL.setStyleSheet(D['STYLE_LINEEDIT'])
    943. 

  943.         self.checkPwdL.setTristate(False)
    944. 

  944.         self.checkPwdL.setStyleSheet(D['STYLE_CHECKBOX'])
    945. 

  945.         self.linePasswordR.setEchoMode(QtGui.QLineEdit.Password)
    946. 

  946.         self.linePasswordR.setToolTip('Password used for decrypting the text')
    947. 

  947.         self.linePasswordR.setMaxLength(99)
    948. 

  948.         self.linePasswordR.setDisabled(True)
    949. 

  949.         self.linePasswordR.setStyleSheet(D['STYLE_LINEEDIT'])
    950. 

  950.         self.checkPwdR.setTristate(False)
    951. 

  951.         self.checkPwdR.setStyleSheet(D['STYLE_CHECKBOX'])
    952. 

  952. 

  953.         # RSA Path.
    954. 

  954.         self.lineRSAPathL.setStyleSheet(D['STYLE_LINEEDIT'])
    955. 

  955.         self.lineRSAPathL.setToolTip('RSA Encryption requires both a password and the path to a public/ private RSA key')
    956. 

  956.         self.lineRSAPathL.hide()
    957. 

  957.         self.lineRSAPathR.setStyleSheet(D['STYLE_LINEEDIT'])
    958. 

  958.         self.lineRSAPathR.setToolTip('RSA Decryption requires both a password and the path to a public/ private RSA key')
    959. 

  959.         self.lineRSAPathR.hide()
    960. 

  960.         self.lineRSAPathR.setDisabled(True)
    961. 

  961. 

  962.         self.buttonBrowseRSAL.setStyleSheet(D['STYLE_BUTTON'])
    963. 

  963.         self.buttonBrowseRSAL.hide()
    964. 

  964.         self.buttonBrowseRSAL.setMaximumWidth(60)
    965. 

  965.         self.buttonBrowseRSAR.setStyleSheet(D['STYLE_BUTTON'])
    966. 

  966.         self.buttonBrowseRSAR.hide()
    967. 

  967.         self.buttonBrowseRSAR.setMaximumWidth(60)
    968. 

  968.         self.buttonBrowseRSAR.setDisabled(True)
    969. 

  969. 

  970.         # Formatted text.
    971. 

  971.         self.setFormatting.setTristate(False)
    972. 

  972.         self.setFormatting.setToolTip('Encrypt this text as HTML')
    973. 

  973.         self.setFormatting.setStyleSheet(D['STYLE_CHECKBOX'])
    974. 

  974.         self.setTags.setTristate(False)
    975. 

  975.         self.setTags.setToolTip('Strip pre/enc/post tags')
    976. 

  976.         self.setTags.setStyleSheet(D['STYLE_CHECKBOX'])
    977. 

  977.         self.showHTML.setTristate(False)
    978. 

  978.         self.showHTML.setToolTip('Toogle view HTML source behind the formatted text')
    979. 

  979.         self.showHTML.setStyleSheet(D['STYLE_CHECKBOX'])
    980. 

  980. 

  981.         # All combo boxes.
    982. 

  982.         MIN = 120
    983. 

  983.         self.preProcess.setMinimumWidth(MIN)
    984. 

  984.         self.preProcess.setStyleSheet(D['STYLE_COMBOBOX'])
    985. 

  985.         self.comboCrypt.setMinimumWidth(MIN)
    986. 

  986.         self.comboCrypt.setStyleSheet(D['STYLE_COMBOBOX'])
    987. 

  987.         self.postProcess.setMinimumWidth(MIN)
    988. 

  988.         self.postProcess.setStyleSheet(D['STYLE_COMBOBOX'])
    989. 

  989.         self.preDecrypt.setMinimumWidth(MIN)
    990. 

  990.         self.preDecrypt.setStyleSheet(D['STYLE_COMBOBOX'])
    991. 

  991.         self.comboDecrypt.setMinimumWidth(MIN)
    992. 

  992.         self.comboDecrypt.setStyleSheet(D['STYLE_COMBOBOX'])
    993. 

  993.         self.postDecrypt.setMinimumWidth(MIN)
    994. 

  994.         self.postDecrypt.setStyleSheet(D['STYLE_COMBOBOX'])
    995. 

  995. 

  996.         # Pre combo-boxes.
    997. 

  997.         self.preProcess.setToolTip('Select pre-process')
    998. 

  998.         self.postDecrypt.setToolTip('Select post-decrypt')
    999. 

  999.         for scramble in SCRAMBLE:
    1000. 

  1000.             self.preProcess.addItem(scramble, scramble)
    1001. 

  1001.             self.postDecrypt.addItem(scramble, scramble)
    1002. 

  1002. 

  1003.         # Encryption/ decryption combo-boxes.
    1004. 

  1004.         self.comboCrypt.setToolTip('Select encryption algorithm; it will use the provided password')
    1005. 

  1005.         self.comboDecrypt.setToolTip('Select encryption algorithm; it will use the provided password')
    1006. 

  1006.         for enc in ENC.keys():
    1007. 

  1007.             self.comboCrypt.addItem(enc, enc)
    1008. 

  1008.             self.comboDecrypt.addItem(enc, enc)
    1009. 

  1009. 

  1010.         # Post combo-boxes.
    1011. 

  1011.         self.postProcess.setToolTip('Select post-process')
    1012. 

  1012.         self.preDecrypt.setToolTip('Select pre-decrypt')
    1013. 

  1013.         for encode in ENCODE:
    1014. 

  1014.             self.postProcess.addItem(encode, encode)
    1015. 

  1015.             self.preDecrypt.addItem(encode, encode)
    1016. 

  1016.         #
    1017. 

  1017. 

  1018.     def __connect(self):
    1019. 

  1019.         '''
    1020. 

  1020.         Connect all components.
    1021. 

  1021.         '''
    1022. 

  1022.         #
    1023. 

  1023.         self.linePasswordL.textChanged.connect(self.onLeftTextChanged)
    1024. 

  1024.         self.leftText.textChanged.connect(self.onLeftTextChanged)
    1025. 

  1025.         self.checkPwdL.stateChanged.connect(lambda x: \
    1026. 

  1026.             self.linePasswordL.setEchoMode(QtGui.QLineEdit.Normal) if self.checkPwdL.isChecked() \
    1027. 

  1027.             else self.linePasswordL.setEchoMode(QtGui.QLineEdit.Password))
    1028. 

  1028.         self.buttonCryptMode.clicked.connect(self.onCryptMode)
    1029. 

  1029.         #
    1030. 

  1030.         self.linePasswordR.textChanged.connect(self.onRightTextChanged)
    1031. 

  1031.         self.rightText.textChanged.connect(self.onRightTextChanged)
    1032. 

  1032.         self.checkPwdR.stateChanged.connect(lambda x: \
    1033. 

  1033.             self.linePasswordR.setEchoMode(QtGui.QLineEdit.Normal) if self.checkPwdR.isChecked() \
    1034. 

  1034.             else self.linePasswordR.setEchoMode(QtGui.QLineEdit.Password))
    1035. 

  1035.         self.buttonDecryptMode.clicked.connect(self.onDecryptMode)
    1036. 

  1036.         #
    1037. 

  1037.         self.buttonBrowseRSAL.clicked.connect(self.browseRSAkey)
    1038. 

  1038.         self.buttonBrowseRSAR.clicked.connect(self.browseRSAkey)
    1039. 

  1039.         #
    1040. 

  1040.         self.preProcess.currentIndexChanged.connect(self.onLeftTextChanged)
    1041. 

  1041.         self.comboCrypt.currentIndexChanged.connect(self.onLeftTextChanged)
    1042. 

  1042.         self.postProcess.currentIndexChanged.connect(self.onLeftTextChanged)
    1043. 

  1043.         #
    1044. 

  1044.         self.preDecrypt.currentIndexChanged.connect(self.onRightTextChanged)
    1045. 

  1045.         self.comboDecrypt.currentIndexChanged.connect(self.onRightTextChanged)
    1046. 

  1046.         self.postDecrypt.currentIndexChanged.connect(self.onRightTextChanged)
    1047. 

  1047.         #
    1048. 

  1048.         self.saveFile.clicked.connect(self.onSave)
    1049. 

  1049.         self.loadFile.clicked.connect(self.onLoad)
    1050. 

  1050.         self.helpButton.clicked.connect(self.onHelp)
    1051. 

  1051.         self.setFormatting.toggled.connect(self.onLeftTextChanged)
    1052. 

  1052.         self.setTags.toggled.connect(self.onLeftTextChanged)
    1053. 

  1053.         self.showHTML.toggled.connect(self.toggleHtml)
    1054. 

  1054.         #
    1055. 

  1055.         self.minButton.clicked.connect(lambda: self.setWindowState(QtCore.Qt.WindowMinimized))
    1056. 

  1056.         self.closeButton.clicked.connect(lambda: self.close())
    1057. 

  1057.         #
    1058. 

  1058.         # ACTION !
    1059. 

  1059.         self.onCryptMode()
    1060. 

  1060.         #
    1061. 

  1061. 

  1062.     def dragEnterEvent(self, e):
    1063. 

  1063.         #
    1064. 

  1064.         mime_data = e.mimeData()
    1065. 

  1065. 

  1066.         # Accept plain text, HTML text and file paths.
    1067. 

  1067.         if mime_data.hasHtml() or mime_data.hasText() or mime_data.hasFormat('text/uri-list'):
    1068. 

  1068.             e.accept()
    1069. 

  1069.         else:
    1070. 

  1070.             e.ignore()
    1071. 

  1071.         #
    1072. 

  1072. 

  1073.     def dropEvent(self, e):
    1074. 

  1074.         #
    1075. 

  1075.         mime_data = e.mimeData()
    1076. 

  1076. 

  1077.         if mime_data.hasFormat('text/html'):
    1078. 

  1078.             dataf = mime_data.html()
    1079. 

  1079.             self.leftText.setHtml(dataf)
    1080. 

  1080. 

  1081.         elif mime_data.hasFormat('text/plain'):
    1082. 

  1082.             dataf = mime_data.text()
    1083. 

  1083.             self.leftText.setPlainText(dataf)
    1084. 

  1084. 

  1085.         elif mime_data.hasFormat('text/uri-list'):
    1086. 

  1086.             uri = mime_data.data('text/uri-list')
    1087. 

  1087.             uris = str(uri).split('\r\n')[:-1]
    1088. 

  1088.             # List of dragged files.
    1089. 

  1089.             for url in uris:
    1090. 

  1090.                 #
    1091. 

  1091.                 f_name = urllib.unquote(url)
    1092. 

  1092.                 # Ignore windows shortcuts. They are ugly :)
    1093. 

  1093.                 if os.path.splitext(f_name)[1].lower() == '.lnk':
    1094. 

  1094.                     continue
    1095. 

  1095.                 o = urllib.urlopen(url)
    1096. 

  1096.                 sz = os.fstat(o.fileno())[6]
    1097. 

  1097.                 t = tarfile.TarInfo(os.path.split(f_name)[1])
    1098. 

  1098.                 t.size = sz
    1099. 

  1099.                 #self.attach.addFile(t, o) #?
    1100. 

  1100.                 #
    1101. 

  1101. 

  1102.         print('I should encrypt on DROP!')
    1103. 

  1103.         #
    1104. 

  1104. 

  1105.     def browseRSAkey(self):
    1106. 

  1106.         #
    1107. 

  1107.         f = QtGui.QFileDialog()
    1108. 

  1108.         path = f.getOpenFileName(self, 'Path to RSA public or private key', os.getcwd(), 'All files (*.*)')
    1109. 

  1109.         if not path:
    1110. 

  1110.             return
    1111. 

  1111.         #
    1112. 

  1112.         self.SE.rsa_path = path
    1113. 

  1113.         self.lineRSAPathL.setText(path)
    1114. 

  1114.         self.lineRSAPathR.setText(path)
    1115. 

  1115.         #
    1116. 

  1116. 

  1117.     def onCryptMode(self):
    1118. 

  1118.         #
    1119. 

  1119.         self.buttonCryptMode.setChecked(True)
    1120. 

  1120.         self.buttonCryptMode.setText('Encrypt Mode is Enabled')
    1121. 

  1121.         self.buttonDecryptMode.setChecked(False)
    1122. 

  1122.         self.buttonDecryptMode.setText('Decrypt Mode')
    1123. 

  1123.         #
    1124. 

  1124.         self.linePasswordL.setDisabled(False)
    1125. 

  1125.         self.lineRSAPathL.setDisabled(False)
    1126. 

  1126.         self.buttonBrowseRSAL.setDisabled(False)
    1127. 

  1127.         self.leftText.setDisabled(False)
    1128. 

  1128.         #
    1129. 

  1129.         self.linePasswordR.setDisabled(True)
    1130. 

  1130.         self.lineRSAPathR.setDisabled(True)
    1131. 

  1131.         self.buttonBrowseRSAR.setDisabled(True)
    1132. 

  1132.         self.rightText.setDisabled(True)
    1133. 

  1133.         #
    1134. 

  1134.         self.checkPwdL.setDisabled(False)
    1135. 

  1135.         self.checkPwdR.setDisabled(True)
    1136. 

  1136.         #
    1137. 

  1137.         self.preProcess.setCurrentIndex(self.postDecrypt.currentIndex())
    1138. 

  1138.         self.comboCrypt.setCurrentIndex(self.comboDecrypt.currentIndex())
    1139. 

  1139.         self.postProcess.setCurrentIndex(self.preDecrypt.currentIndex())
    1140. 

  1140.         #
    1141. 

  1141. 

  1142.     def onDecryptMode(self):
    1143. 

  1143.         #
    1144. 

  1144.         self.buttonCryptMode.setChecked(False)
    1145. 

  1145.         self.buttonCryptMode.setText('Encrypt Mode')
    1146. 

  1146.         self.buttonDecryptMode.setChecked(True)
    1147. 

  1147.         self.buttonDecryptMode.setText('Decrypt Mode is Enabled')
    1148. 

  1148.         #
    1149. 

  1149.         self.linePasswordL.setDisabled(True)
    1150. 

  1150.         self.lineRSAPathL.setDisabled(True)
    1151. 

  1151.         self.buttonBrowseRSAL.setDisabled(True)
    1152. 

  1152.         self.leftText.setDisabled(True)
    1153. 

  1153.         #
    1154. 

  1154.         self.linePasswordR.setDisabled(False)
    1155. 

  1155.         self.lineRSAPathR.setDisabled(False)
    1156. 

  1156.         self.buttonBrowseRSAR.setDisabled(False)
    1157. 

  1157.         self.rightText.setDisabled(False)
    1158. 

  1158.         #
    1159. 

  1159.         self.checkPwdL.setDisabled(True)
    1160. 

  1160.         self.checkPwdR.setDisabled(False)
    1161. 

  1161.         #
    1162. 

  1162.         self.postDecrypt.setCurrentIndex(self.preProcess.currentIndex())
    1163. 

  1163.         self.comboDecrypt.setCurrentIndex(self.comboCrypt.currentIndex())
    1164. 

  1164.         self.preDecrypt.setCurrentIndex(self.postProcess.currentIndex())
    1165. 

  1165.         #
    1166. 

  1166. 

  1167.     def cleanupHtml(self, txt):
    1168. 

  1168.         #
    1169. 

  1169.         def spacerepl(matchobj):
    1170. 

  1170.             return matchobj.group(0).replace(b' ', b'&nbsp;')
    1171. 

  1171. 

  1172.         # Replacing all spaces with &nbsp;
    1173. 

  1173.         txt = re.sub(b'>([^<>]+)<(?!/style>)', spacerepl, txt)
    1174. 

  1174.         # Write the new file
    1175. 

  1175.         open('doc.htm', 'w').write(txt)
    1176. 

  1176. 

  1177.         # Process the file with Tidy
    1178. 

  1178.         if platform.uname()[0].lower() == 'windows':
    1179. 

  1179.             p = subprocess.Popen(['tidy.exe', '-config', 'tidy.txt', 'doc.htm']).wait()
    1180. 

  1180.         elif platform.uname()[0].lower() == 'linux':
    1181. 

  1181.             p = subprocess.Popen(['./tidy', '-config', 'tidy.txt', 'doc.htm']).wait()
    1182. 

  1182.         else:
    1183. 

  1183.             print('Platform `%s` is not supported yet!\n' % platform.uname()[0])
    1184. 

  1184.             return ''
    1185. 

  1185. 

  1186.         txt = open('doc.htm', 'r').read()
    1187. 

  1187.         # Delete the wrong/ obsolete tags
    1188. 

  1188.         txt = txt.replace(b'<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"\n"http://www.w3.org/TR/html4/loose.dtd">\n', '')
    1189. 

  1189.         txt = txt.replace(b'<meta name="generator" content="HTML Tidy for Windows (vers 25 March 2009), see www.w3.org">\n', '')
    1190. 

  1190.         txt = txt.replace(b'<meta name="generator" content="HTML Tidy for Linux (vers 25 March 2009), see www.w3.org">\n', '')
    1191. 

  1191.         txt = txt.replace(b'<meta name="qrichtext" content="1">\n', '')
    1192. 

  1192.         txt = txt.replace(b'<title></title>\n', '')
    1193. 

  1193.         txt = txt.replace(b'</style>\n\n<style type="text/css">\n', '')
    1194. 

  1194.         txt = txt.replace(b'<br>\n', '\n')
    1195. 

  1195.         # The clean file, for debug...
    1196. 

  1196.         open('doc.htm', 'w').write(txt)
    1197. 

  1197. 

  1198.         return txt
    1199. 

  1199.         #
    1200. 

  1200. 

  1201.     def toggleHtml(self):
    1202. 

  1202.         #
    1203. 

  1203.         if self.showHTML.isChecked():
    1204. 

  1204.             txt = self.leftText.toHtml()
    1205. 

  1205.             self.leftText.clear()
    1206. 

  1206.             self.leftText.setFontFamily("Verdana")
    1207. 

  1207.             self.leftText.setFontItalic(False)
    1208. 

  1208.             self.leftText.setFontUnderline(False)
    1209. 

  1209.             self.leftText.setFontWeight(10)
    1210. 

  1210.             self.leftText.setFontPointSize(10)
    1211. 

  1211.             self.leftText.setTextColor(QtGui.QColor())
    1212. 

  1212.             self.leftText.setPlainText(self.cleanupHtml(txt))
    1213. 

  1213.         else:
    1214. 

  1214.             txt = self.leftText.toPlainText()
    1215. 

  1215.             self.leftText.clear()
    1216. 

  1216.             self.leftText.setHtml(self.cleanupHtml(txt))
    1217. 

  1217.         #
    1218. 

  1218. 

  1219.     def onLeftTextChanged(self):
    1220. 

  1220.         #
    1221. 

  1221.         if not self.buttonCryptMode.isChecked():
    1222. 

  1222.             return
    1223. 

  1223.         #
    1224. 

  1224.         # Save all pre/enc/post operations.
    1225. 

  1225.         pre = self.preProcess.currentText()
    1226. 

  1226.         enc = self.comboCrypt.currentText()
    1227. 

  1227.         post = self.postProcess.currentText()
    1228. 

  1228.         #
    1229. 

  1229.         # If encryption mode is RSA, reveal key path.
    1230. 

  1230.         if enc=='RSA':
    1231. 

  1231.             self.lineRSAPathL.show()
    1232. 

  1232.             self.lineRSAPathR.show()
    1233. 

  1233.             self.buttonBrowseRSAL.show()
    1234. 

  1234.             self.buttonBrowseRSAR.show()
    1235. 

  1235.         else:
    1236. 

  1236.             self.lineRSAPathL.hide()
    1237. 

  1237.             self.lineRSAPathR.hide()
    1238. 

  1238.             self.buttonBrowseRSAL.hide()
    1239. 

  1239.             self.buttonBrowseRSAR.hide()
    1240. 

  1240.         #
    1241. 

  1241.         if not self.leftText.toPlainText():
    1242. 

  1242.             self.rightText.clear()
    1243. 

  1243.             return
    1244. 

  1244.         #
    1245. 

  1245.         pwd = self.linePasswordL.text().encode()
    1246. 

  1246.         tags = not self.setTags.isChecked()
    1247. 

  1247.         #
    1248. 

  1248.         if self.setFormatting.isChecked() and not self.showHTML.isChecked():
    1249. 

  1249.             # HTML string.
    1250. 

  1250.             txt = self.leftText.toHtml().encode()
    1251. 

  1251.             # Cleanup HTML string.
    1252. 

  1252.             txt = self.cleanupHtml(txt)
    1253. 

  1253.         else:
    1254. 

  1254.             txt = self.leftText.toPlainText().encode()
    1255. 

  1255.         #
    1256. 

  1256.         # Setup default (no error) status.
    1257. 

  1257.         if self.buttonCryptMode.isChecked():
    1258. 

  1258.             self.textBar.setStyleSheet(D['TXT_BAR_OK'])
    1259. 

  1259.             self.textBar.setText('  Encryption mode   step 1: %s ,   step 2: %s ,   step 3: %s' % (pre, enc, post))
    1260. 

  1260.         #
    1261. 

  1261.         self.postDecrypt.setCurrentIndex(self.preProcess.currentIndex())
    1262. 

  1262.         self.comboDecrypt.setCurrentIndex(self.comboCrypt.currentIndex())
    1263. 

  1263.         self.preDecrypt.setCurrentIndex(self.postProcess.currentIndex())
    1264. 

  1264.         #
    1265. 

  1265.         # Encrypt the text.
    1266. 

  1266.         final = self.SE.encrypt(txt, pre, enc, post, pwd, tags)
    1267. 

  1267.         #
    1268. 

  1268.         if final:
    1269. 

  1269.             self.rightText.setPlainText(final)
    1270. 

  1270.             if self.setFormatting.isChecked():
    1271. 

  1271.                 self.nrLettersL.setText('Html: %i' % len(txt))
    1272. 

  1272.             else:
    1273. 

  1273.                 self.nrLettersL.setText('Text: %i' % len(txt))
    1274. 

  1274.             self.nrLettersR.setText('Enc: %i' % len(final))
    1275. 

  1275.         else:
    1276. 

  1276.             self.rightText.clear()
    1277. 

  1277.             self.textBar.setStyleSheet(D['TXT_BAR_BAD'])
    1278. 

  1278.             self.textBar.setText(self.SE.error)
    1279. 

  1279.         #
    1280. 

  1280. 

  1281.     def onRightTextChanged(self):
    1282. 

  1282.         #
    1283. 

  1283.         if not self.buttonDecryptMode.isChecked():
    1284. 

  1284.             return
    1285. 

  1285.         #
    1286. 

  1286.         txt = self.rightText.toPlainText().encode()
    1287. 

  1287.         #
    1288. 

  1288.         try:
    1289. 

  1289.             re_groups = re.search(NO_TAGS, txt).groups()
    1290. 

  1290.             tags = findg(re_groups)
    1291. 

  1291. 

  1292.             # If Json.
    1293. 

  1293.             if tags.startswith('"pre"'):
    1294. 

  1294.                 pre = 'Json'
    1295. 

  1295.                 enc = re.search('"enc":"([0-9a-zA-Z ]{1,3})"', tags).group(1)
    1296. 

  1296.                 post = re.search('"pre":"([0-9a-zA-Z ]{1,3})"', tags).group(1)
    1297. 

  1297.             # If XML.
    1298. 

  1298.             elif tags.startswith('<pre>'):
    1299. 

  1299.                 pre = 'XML'
    1300. 

  1300.                 enc = re.search('<enc>([0-9a-zA-Z ]{1,3})</enc>', tags).group(1)
    1301. 

  1301.                 post = re.search('<pre>([0-9a-zA-Z ]{1,3})</pre>', tags).group(1)
    1302. 

  1302.             else:
    1303. 

  1303.                 pre=None ; enc=None ; post=None
    1304. 

  1304. 

  1305.             # Identify the rest.
    1306. 

  1306.             if not pre:
    1307. 

  1307.                 pre = tags.split(':')[2]
    1308. 

  1308.             if not enc:
    1309. 

  1309.                 enc = tags.split(':')[1]
    1310. 

  1310.             if not post:
    1311. 

  1311.                 post = tags.split(':')[0]
    1312. 

  1312. 

  1313.             pre = pre.decode()
    1314. 

  1314.             enc = enc.decode()
    1315. 

  1315.             post = post.decode()
    1316. 

  1316. 

  1317.             self.postDecrypt.setCurrentIndex( self.postDecrypt.findText(post, QtCore.Qt.MatchFlag(QtCore.Qt.MatchContains)) )
    1318. 

  1318.             self.comboDecrypt.setCurrentIndex( self.comboDecrypt.findText(enc, QtCore.Qt.MatchFlag(QtCore.Qt.MatchContains)) )
    1319. 

  1319.             self.preDecrypt.setCurrentIndex( self.preDecrypt.findText(pre, QtCore.Qt.MatchFlag(QtCore.Qt.MatchContains)) )
    1320. 

  1320.         except:
    1321. 

  1321.             pass
    1322. 

  1322.         #
    1323. 

  1323.         # This must be right here.
    1324. 

  1324.         pre = self.preDecrypt.currentText()
    1325. 

  1325.         enc = self.comboDecrypt.currentText()
    1326. 

  1326.         post = self.postDecrypt.currentText()
    1327. 

  1327.         pwd = self.linePasswordR.text().encode()
    1328. 

  1328.         #
    1329. 

  1329.         # If encryption mode is RSA, reveal key path.
    1330. 

  1330.         if enc=='RSA':
    1331. 

  1331.             self.lineRSAPathL.show()
    1332. 

  1332.             self.lineRSAPathR.show()
    1333. 

  1333.             self.buttonBrowseRSAL.show()
    1334. 

  1334.             self.buttonBrowseRSAR.show()
    1335. 

  1335.         else:
    1336. 

  1336.             self.lineRSAPathL.hide()
    1337. 

  1337.             self.lineRSAPathR.hide()
    1338. 

  1338.             self.buttonBrowseRSAL.hide()
    1339. 

  1339.             self.buttonBrowseRSAR.hide()
    1340. 

  1340.         #
    1341. 

  1341.         if not txt:
    1342. 

  1342.             self.leftText.clear()
    1343. 

  1343.             return
    1344. 

  1344.         #
    1345. 

  1345.         if self.buttonDecryptMode.isChecked():
    1346. 

  1346.             self.textBar.setStyleSheet(D['TXT_BAR_OK'])
    1347. 

  1347.             self.textBar.setText('  Decryption mode   step 1: %s ,   step 2: %s ,   step 3: %s' % (pre, enc, post))
    1348. 

  1348.         #
    1349. 

  1349.         self.preProcess.setCurrentIndex(self.postDecrypt.currentIndex())
    1350. 

  1350.         self.comboCrypt.setCurrentIndex(self.comboDecrypt.currentIndex())
    1351. 

  1351.         self.postProcess.setCurrentIndex(self.preDecrypt.currentIndex())
    1352. 

  1352.         #
    1353. 

  1353.         # Decrypt the text.
    1354. 

  1354.         final = self.SE.decrypt(txt, pre, enc, post, pwd)
    1355. 

  1355.         #
    1356. 

  1356.         if final:
    1357. 

  1357.             # Cleanup HTML string.
    1358. 

  1358.             final = self.cleanupHtml(final)
    1359. 

  1359.             # Setup string as HTML.
    1360. 

  1360.             self.leftText.setHtml(final.decode())
    1361. 

  1361.             self.nrLettersL.setText('Dec: %i' % len(final))
    1362. 

  1362.             self.nrLettersR.setText('Enc: %i' % len(txt))
    1363. 

  1363.         else:
    1364. 

  1364.             self.leftText.clear()
    1365. 

  1365.             self.textBar.setStyleSheet(D['TXT_BAR_BAD'])
    1366. 

  1366.             self.textBar.setText(self.SE.error)
    1367. 

  1367.         #
    1368. 

  1368. 

  1369.     def onSave(self):
    1370. 

  1370.         #
    1371. 

  1371.         # Save all pre/enc/post operations.
    1372. 

  1372.         pre = self.preProcess.currentText()
    1373. 

  1373.         enc = self.comboCrypt.currentText()
    1374. 

  1374.         post = self.postProcess.currentText()
    1375. 

  1375.         #
    1376. 

  1376.         f = QtGui.QFileDialog()
    1377. 

  1377.         if post in ['Base64 Codec', 'Base32 Codec', 'HEX Codec']:
    1378. 

  1378.             path = f.getSaveFileName(self, 'Save crypted text', os.getcwd(), 'PNG Images (*.png)')
    1379. 

  1379.             ext = '.png'
    1380. 

  1380.         elif post=='XML':
    1381. 

  1381.             path = f.getSaveFileName(self, 'Save crypted text', os.getcwd(), 'XML Files (*.xml)')
    1382. 

  1382.             ext = '.xml'
    1383. 

  1383.         elif post=='Json':
    1384. 

  1384.             path = f.getSaveFileName(self, 'Save crypted text', os.getcwd(), 'Json Files (*.json)')
    1385. 

  1385.             ext = '.json'
    1386. 

  1386.         else:
    1387. 

  1387.             path = f.getSaveFileName(self, 'Save crypted text', os.getcwd(), 'All files (*.*)')
    1388. 

  1388.             ext = ''
    1389. 

  1389.         if not path:
    1390. 

  1390.             return
    1391. 

  1391.         #
    1392. 

  1392.         # Save password.
    1393. 

  1393.         pwd = self.linePasswordL.text()
    1394. 

  1394.         # Text from rigth side.
    1395. 

  1395.         txt = self.rightText.toPlainText()
    1396. 

  1396.         # File extension.
    1397. 

  1397.         if not os.path.splitext(path)[1]:
    1398. 

  1398.             path += ext
    1399. 

  1399.         #
    1400. 

  1400.         # For PNG files.
    1401. 

  1401.         if ext=='.png':
    1402. 

  1402.             self.SE.toImage(txt, pre, enc, post, pwd, path, encrypt=False)
    1403. 

  1403.         else:
    1404. 

  1404.             open(path, 'w').write(txt)
    1405. 

  1405.         #
    1406. 

  1406. 

  1407.     def onLoad(self):
    1408. 

  1408.         #
    1409. 

  1409.         f = QtGui.QFileDialog()
    1410. 

  1410.         path = f.getOpenFileName(self, 'Load crypted text', os.getcwd(), 'All files (*.*)')
    1411. 

  1411.         if not path:
    1412. 

  1412.             return
    1413. 

  1413. 

  1414.         # Import the text from file, without decryption.
    1415. 

  1415.         val = self.SE._import(pre=None, enc=None, post=None, pwd=None, fpath=path, decrypt=False)
    1416. 

  1416. 

  1417.         if val:
    1418. 

  1418.             # For step 1.
    1419. 

  1419.             self.preProcess.setCurrentIndex( self.preProcess.findText(self.SE.post, QtCore.Qt.MatchFlag(QtCore.Qt.MatchFixedString)) )
    1420. 

  1420.             self.postDecrypt.setCurrentIndex( self.postDecrypt.findText(self.SE.post, QtCore.Qt.MatchFlag(QtCore.Qt.MatchFixedString)) )
    1421. 

  1421.             # For step 2.
    1422. 

  1422.             self.comboCrypt.setCurrentIndex( self.comboCrypt.findText(self.SE.enc, QtCore.Qt.MatchFlag(QtCore.Qt.MatchFixedString)) )
    1423. 

  1423.             self.comboDecrypt.setCurrentIndex( self.comboDecrypt.findText(self.SE.enc, QtCore.Qt.MatchFlag(QtCore.Qt.MatchFixedString)) )
    1424. 

  1424.             # For step 3.
    1425. 

  1425.             self.postProcess.setCurrentIndex( self.postProcess.findText(self.SE.pre, QtCore.Qt.MatchFlag(QtCore.Qt.MatchFixedString)) )
    1426. 

  1426.             self.preDecrypt.setCurrentIndex( self.preDecrypt.findText(self.SE.pre, QtCore.Qt.MatchFlag(QtCore.Qt.MatchFixedString)) )
    1427. 

  1427. 

  1428.             self.rightText.setPlainText(val)
    1429. 

  1429.             self.onDecryptMode()
    1430. 

  1430.             self.onRightTextChanged()
    1431. 

  1431.             self.rightText.setFocus()
    1432. 

  1432.         #
    1433. 

  1433. 

  1434.     def onHelp(self):
    1435. 

  1435.         #
    1436. 

  1436.         QtGui.QMessageBox.about(self.centralWidget, 'Scrambled Egg %s Help' % __version__,
    1437. 

  1437.             '<br><b>Copyright (C) 2010-2012</b> : Cristi Constantin. All rights reserved.<br>'
    1438. 

  1438.             '<b>Website</b> : http://scrambled-egg.googlecode.com/<br><br>'
    1439. 

  1439.             'Scrambled-Egg is a software designed for encrypting your sensitive data.<br>'
    1440. 

  1440.             'This is done in <font color="blue"><b>3 steps</b></font> : <i>pre encryption</i>, <i>encryption</i>, and <i>post encryption</i>.<br>'
    1441. 

  1441.             'The input data can be : plain text, or formatted text (Microsoft Office or HTML).<br><br>'
    1442. 

  1442.             '<font color="blue"><b>Step 1</b></font> can compress your data using <b>ZLIB</b>, or <b>BZ2</b>. This step is optional.<br>'
    1443. 

  1443.             '<font color="blue"><b>Step 2</b></font> is the real encryption, for example with <b>AES</b>, or <b>Blowfish</b>. '
    1444. 

  1444.             'The password is used only in this step. '
    1445. 

  1445.             'For <b>RSA</b> encryption, along with the password, you have to type the path to the public or private RSA key.<br>'
    1446. 

  1446.             '<font color="blue"><b>Step 3</b></font> will encode your data. This step is required, the rest are optional. '
    1447. 

  1447.             'There are a lot of encodings available, for example <b>Base64</b>, or <b>HEX</b>.<br><br>'
    1448. 

  1448.             'This FREE program is distributed in the hope that it will be useful, but without any warranty.<br><br>'
    1449. 

  1449.             'Enjoy!')
    1450. 

  1450.         #
    1451. 

  1451. 

  1452. #
    1453. 

  1453. 

  1454. def loadConfig():
    1455. 

  1455. 

  1456.     script_path = os.path.abspath(__file__)
    1457. 

  1457.     base_path = os.path.split(script_path)[0] + '/config/'
    1458. 

  1458.     C = {}
    1459. 

  1459. 

  1460.     if os.path.exists(base_path):
    1461. 

  1461.         try:
    1462. 

  1462.             c = open(base_path + 'config.json', 'r').read()
    1463. 

  1463.             C = json.loads(c)
    1464. 

  1464.         except:
    1465. 

  1465.             print('Cannot load config: `{0}` ! Using builtin config !'.format(base_path + 'config.json'))
    1466. 

  1466. 

  1467.     C['W_WIDTH'] = C.get('W_WIDTH', 800)
    1468. 

  1468.     C['W_HEIGHT'] = C.get('W_HEIGHT', 420)
    1469. 

  1469.     C['W_MAX_HEIGHT'] = C.get('W_MAX_HEIGHT', 660)
    1470. 

  1470.     C['THEME'] = C.get('THEME', 'default/theme.json')
    1471. 

  1471.     C['MIC_BTNS_POS'] = C.get('MIC_BTNS_POS', 1)
    1472. 

  1472.     C['MIC_BTNS_SPAN'] = C.get('MIC_BTNS_SPAN', 1)
    1473. 

  1473.     return C
    1474. 

  1474. 

  1475. #
    1476. 

  1476. 

  1477. def loadThemes():
    1478. 

  1478. 

  1479.     script_path = os.path.abspath(__file__)
    1480. 

  1480.     theme_file = os.path.split(script_path)[0] + '/config/themes/' + C['THEME']
    1481. 

  1481.     theme_path = os.path.split(theme_file)[0]
    1482. 

  1482.     D = {}
    1483. 

  1483. 

  1484.     try:
    1485. 

  1485.         c = open(theme_file, 'r').read()
    1486. 

  1486.         theme_path = theme_path.replace('\\', '/')
    1487. 

  1487.         c = c.replace('%HOME%', theme_path)
    1488. 

  1488.         D = json.loads(c)
    1489. 

  1489.     except:
    1490. 

  1490.         print('Cannot load theme: `{0}` ! Using builtin theme !'.format(theme_path))
    1491. 

  1491. 

  1492.     D['STYLE_MAIN']         = D.get('STYLE_MAIN', "QMainWindow {background:transparent;}")
    1493. 

  1493.     D['STYLE_CONTAINER']    = D.get('STYLE_CONTAINER',   "#ContainerWidget {background:white; border:3px solid grey; border-radius:11px;}")
    1494. 

  1494.     D['STYLE_BUTTON']       = D.get('STYLE_BUTTON',      "QPushButton {color:#2E2633; background-color:#E1EDB9;} QPushButton:checked {color:#555152; background-color:#F3EFEE;} QPushButton:disabled {background-color:#EFEBE7;} QPushButton::hover {color:#99173C;}")
    1495. 

  1495.     D['TXT_BAR_OK']         = D.get('TXT_BAR_OK',  "color:blue")
    1496. 

  1496.     D['TXT_BAR_BAD']        = D.get('TXT_BAR_BAD', "color:red")
    1497. 

  1497.     D['STYLE_HELP_BUTTON']  = D.get('STYLE_HELP_BUTTON',  D['STYLE_BUTTON'])
    1498. 

  1498.     D['STYLE_MIN_BUTTON']   = D.get('STYLE_MIN_BUTTON',   D['STYLE_BUTTON'])
    1499. 

  1499.     D['STYLE_CLOSE_BUTTON'] = D.get('STYLE_CLOSE_BUTTON', D['STYLE_BUTTON'])
    1500. 

  1500.     D['STYLE_LINEEDIT']     = D.get('STYLE_LINEEDIT',   "QLineEdit      {background-color:#E1EDB9; border:1px solid #A59D95; border-radius:4px;} QLineEdit:disabled      {background-color:#EFEBE7;}                QLineEdit:focus      {border:1px solid #99173C;}")
    1501. 

  1501.     D['STYLE_L_TEXTEDIT']   = D.get('STYLE_L_TEXTEDIT', "QTextEdit      {background-color:#E1EDB9; border:1px solid #A59D95; border-radius:4px;} QTextEdit:disabled      {color:#555152; background-color:#EFEBE7;} QTextEdit:focus      {border:1px solid #99173C;}")
    1502. 

  1502.     D['STYLE_R_TEXTEDIT']   = D.get('STYLE_R_TEXTEDIT', "QPlainTextEdit {background-color:#E1EDB9; border:1px solid #A59D95; border-radius:4px;} QPlainTextEdit:disabled {color:#555152; background-color:#EFEBE7;} QPlainTextEdit:focus {border:1px solid #99173C;}")
    1503. 

  1503.     D['STYLE_CHECKBOX']     = D.get('STYLE_CHECKBOX',   "QCheckBox {color:#2E2633; margin:0px;} QCheckBox::hover {color:#99173C; background:transparent; margin:0px;}")
    1504. 

  1504.     D['STYLE_COMBOBOX']     = D.get('STYLE_COMBOBOX',   "QComboBox {color:#2E2633;} QComboBox QAbstractItemView {selection-background-color:#E1EDB9;}")
    1505. 

  1505.     D['MIN_BTN_TXT']        = D.get('MIN_BTN_TXT', '_')
    1506. 

  1506.     D['CLOSE_BTN_TXT']      = D.get('CLOSE_BTN_TXT', 'X')
    1507. 

  1507.     return D
    1508. 

  1508. 

  1509. #
    1510. 

  1510. 

  1511. def commandLine():
    1512. 

  1512. 

  1513.     import optparse
    1514. 

  1514.     usage = """
    1515. 

  1515. Encryption: %prog --input in_file [--output out_file] -p password --pre PRE --enc ENC --post POST
    1516. 

  1516. or
    1517. 

  1517. Decryption: %prog --input in_file [--output out_file] -p password --decrypt true"""
    1518. 

  1518.     version="%prog v1.0"
    1519. 

  1519.     description = '''Scrambled-Egg v1.0 command line.
    1520. 

  1520. Compress, encrypt and encode your file in command line.
    1521. 

  1521. * pre  - can be one of the values: ROT13, ZLIB, BZ2, None ;
    1522. 

  1522. * enc  - can be one of : AES, Blowfish, ARC2, CAST, DES3, RSA ;
    1523. 

  1523. * post - can be one of : Base64, Base32, HEX, Json, XML.
    1524. 

  1524. '''
    1525. 

    1526. 

  1526.     parser = optparse.OptionParser(usage=usage, version=version, description=description)
    1527. 

  1527.     parser.add_option("-i", "--input",  action="store", help="input file path")
    1528. 

  1528.     parser.add_option("-o", "--output", action="store", help="output file path")
    1529. 

  1529.     parser.add_option("-p", "--pwd",    action="store", help="password used for encryption")
    1530. 

  1530.     parser.add_option("--decrypt",      action="store", help="decrypt operation (default=False)")
    1531. 

  1531.     parser.add_option("--pre",          action="store", help="pre operation     (compress, default=None)")
    1532. 

  1532.     parser.add_option("-e", "--enc",    action="store", help="encryption operation (default=AES)")
    1533. 

  1533.     parser.add_option("--post",         action="store", help="post operation    (encode, default=Base64)")
    1534. 

  1534.     (options, args) = parser.parse_args()
    1535. 

  1535. 

  1536.     if not options.output:
    1537. 

  1537.         options.output = 'output.dat'
    1538. 

  1538. 

  1539.     if not options.enc and not options.decrypt:
    1540. 

  1540.         options.enc = 'AES'
    1541. 

  1541.     elif options.decrypt:
    1542. 

  1542.         options.enc = 'X'
    1543. 

  1543. 

  1544.     if not options.pre and not options.decrypt:
    1545. 

  1545.         options.pre = 'None'
    1546. 

  1546.     elif options.decrypt:
    1547. 

  1547.         options.pre = 'X'
    1548. 

  1548. 

  1549.     if not options.post and not options.decrypt:
    1550. 

  1550.         options.post = 'Base64'
    1551. 

  1551.     elif options.decrypt:
    1552. 

  1552.         options.post = 'X'
    1553. 

  1553. 

  1554.     if not options.input:
    1555. 

  1555.         print('Must specify an input file ! Exiting !')
    1556. 

  1556.         return 1
    1557. 

  1557. 

  1558.     if not os.path.exists(options.input):
    1559. 

  1559.         print('The file `%s` doesn\'t exist ! Exiting !' % options.input)
    1560. 

  1560.         return 1
    1561. 

  1561. 

  1562.     if not options.pwd:
    1563. 

  1563.         print('Must specify a password ! Exiting !')
    1564. 

  1564.         return 1
    1565. 

  1565. 

  1566.     pre =  {'NONE':'None', 'ROT13':'ROT13', 'ZLIB':'ZLIB', 'BZ2':'BZ2', 'X':None}
    1567. 

  1567.     enc =  {'AES':'AES', 'BLOWFISH':'Blowfish', 'ARC2':'ARC2', 'CAST':'CAST', 'DES3':'DES3', 'RSA':'RSA', 'X':None}
    1568. 

  1568.     post = {'BASE64':'Base64 Codec', 'BASE32':'Base32 Codec', 'HEX':'HEX Codec', 'JSON':'Json', 'XML':'XML', 'X':None}
    1569. 

  1569. 

  1570.     if options.enc.upper() not in enc:
    1571. 

  1571.         print('Value `%s` is an invalid encryption operation ! Exiting !' % options.enc)
    1572. 

  1572.         return 1
    1573. 

  1573. 

  1574.     if options.pre.upper() not in pre:
    1575. 

  1575.         print('Value `%s` is an invalid pre operation ! Exiting !' % options.pre)
    1576. 

  1576.         return 1
    1577. 

  1577. 

  1578.     if options.post.upper() not in post:
    1579. 

  1579.         print('Value `%s` is an invalid post operation ! Exiting !' % options.post)
    1580. 

  1580.         return 1
    1581. 

  1581. 

  1582.     if options.decrypt:
    1583. 

  1583.         SE = ScrambledEgg()
    1584. 

  1584.         print('Decrypting from `%s` to `%s`...' % (options.input, options.output))
    1585. 

  1585.         val = SE.decrypt(open(options.input, 'rb').read(),
    1586. 

  1586.             pre[options.pre.upper()], enc[options.enc.upper()], post[options.post.upper()],
    1587. 

  1587.             pwd=options.pwd)
    1588. 

  1588.         open(options.output, 'wb').write(val)
    1589. 

  1589. 

  1590.     else:
    1591. 

  1591.         SE = ScrambledEgg()
    1592. 

  1592.         print('Encrypting from `%s` to `%s`...' % (options.input, options.output))
    1593. 

  1593.         val = SE.encrypt(open(options.input, 'rb').read(),
    1594. 

  1594.             pre[options.pre.upper()], enc[options.enc.upper()
    1595.