crypto.py 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483
  1. #============================================================================
  2. # This file is part of Pwman3.
  3. #
  4. # Pwman3 is free software; you can redistribute it and/or modify
  5. # it under the terms of the GNU General Public License, version 2
  6. # as published by the Free Software Foundation;
  7. #
  8. # Pwman3 is distributed in the hope that it will be useful,
  9. # but WITHOUT ANY WARRANTY; without even the implied warranty of
  10. # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  11. # GNU General Public License for more details.
  12. #
  13. # You should have received a copy of the GNU General Public License
  14. # along with Pwman3; if not, write to the Free Software
  15. # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  16. #============================================================================
  17. # Copyright (C) 2012 Oz Nahum <nahumoz@gmail.com>
  18. #============================================================================
  19. # Copyright (C) 2006 Ivan Kelly <ivan@ivankelly.net>
  20. #============================================================================
  21. """
  22. Encryption Module used by PwmanDatabase
  23. Supports AES, ARC2, Blowfish, CAST, DES, DES3, IDEA, RC5.
  24. Usage:
  25. import pwman.util.crypto.CryptoEngine as CryptoEngine
  26. from pwman.util.crypto import CryptoEngine
  27. class myCallback(CryptoEngine.Callback):
  28. def execute(self):
  29. return "mykey"
  30. params = {'encryptionAlgorithm': 'AES',
  31. 'encryptionCallback': callbackFunction}
  32. CryptoEngine.init(params)
  33. crypto = CryptoEngine.get()
  34. ciphertext = crypto.encrypt("plaintext")
  35. plaintext = cyypto.decrypt(ciphertext)
  36. """
  37. from Crypto.Cipher import Blowfish as cBlowfish
  38. from Crypto.Cipher import AES as cAES
  39. from Crypto.Cipher import ARC2 as cARC2
  40. from Crypto.Cipher import CAST as cCAST
  41. from Crypto.Cipher import DES as cDES
  42. from Crypto.Cipher import DES3 as cDES3
  43. from Crypto.Random import OSRNG
  44. from pwman.util.callback import Callback
  45. import pwman.util.config as config
  46. import cPickle
  47. import time
  48. import sys
  49. import ctypes
  50. import hashlib
  51. def zerome(string):
  52. """
  53. securely erase strings ...
  54. for windows: ctypes.cdll.msvcrt.memset
  55. """
  56. bufsize = len(string) + 1
  57. offset = sys.getsizeof(string) - bufsize
  58. ctypes.memset(id(string) + offset, 0, bufsize)
  59. # Use this to tell if crypto is successful or not
  60. _TAG = "PWMANCRYPTO"
  61. _INSTANCE = None
  62. class CryptoException(Exception):
  63. """Generic Crypto Exception."""
  64. def __init__(self, message):
  65. self.message = message
  66. def __str__(self):
  67. return "CryptoException: " + self.message
  68. class CryptoUnsupportedException(CryptoException):
  69. """Unsupported feature requested."""
  70. def __str__(self):
  71. return "CryptoUnsupportedException: " + self.message
  72. class CryptoBadKeyException(CryptoException):
  73. """Encryption key is incorrect."""
  74. def __str__(self):
  75. return "CryptoBadKeyException: " + self.message
  76. class CryptoNoKeyException(CryptoException):
  77. """No key has been initalised."""
  78. def __str__(self):
  79. return "CryptoNoKeyException: " + self.message
  80. class CryptoNoCallbackException(CryptoException):
  81. """No Callback has been set."""
  82. def __str__(self):
  83. return "CryptoNoCallbackException: " + self.message
  84. class CryptoEngine(object):
  85. """
  86. Cryptographic Engine, overrides CryptoEngineOld.
  87. The main change is that _getcipher_real is now hashing the key
  88. before encrypting it.
  89. This method can eventually remove the call to _retrievedata,
  90. which used to strip the _TAG from the plain text string or return
  91. the cPickle object as string.
  92. Since we don't use cPickle to serialize object anymore, we can
  93. safely aim towards removing this method. Thus, removing also
  94. the _TAG in the beginning of each string as per recommendation of
  95. Ralf Herzog.
  96. """
  97. _timeoutcount = 0
  98. _instance = None
  99. _instance_new = None
  100. _callback = None
  101. @classmethod
  102. def get(cls, dbver=None):
  103. """
  104. CryptoEngine.get() -> CryptoEngine
  105. Return an instance of CryptoEngine.
  106. If no instance is found, a CryptoException is raised.
  107. """
  108. if dbver < 0.5:
  109. if not CryptoEngine._instance:
  110. CryptoEngine._instance = CryptoEngineOld()
  111. return CryptoEngine._instance
  112. elif dbver == 0.5:
  113. if not CryptoEngine._instance_new:
  114. CryptoEngine._instance_new = CryptoEngine()
  115. return CryptoEngine._instance_new
  116. def __init__(self):
  117. """Initialise the Cryptographic Engine
  118. params is a dictionary. Valid keys are:
  119. algorithm: Which cipher to use
  120. callback: Callback class.
  121. keycrypted: This should be set by the database layer.
  122. timeout: Time after which key will be forgotten.
  123. Default is -1 (disabled).
  124. """
  125. algo = config.get_value("Encryption", "algorithm")
  126. if algo:
  127. self._algo = algo
  128. else:
  129. raise CryptoException("Parameters missing, no algorithm given")
  130. callback = config.get_value("Encryption", "callback")
  131. if isinstance(callback, Callback):
  132. self._callback = callback
  133. else:
  134. self._callback = None
  135. keycrypted = config.get_value("Encryption", "keycrypted")
  136. if len(keycrypted) > 0:
  137. self._keycrypted = keycrypted
  138. else:
  139. self._keycrypted = None
  140. timeout = config.get_value("Encryption", "timeout")
  141. if timeout.isdigit():
  142. self._timeout = timeout
  143. else:
  144. self._timeout = -1
  145. self._cipher = None
  146. def auth(self, key):
  147. """
  148. authenticate using a given key
  149. """
  150. tmpcipher = self._getcipher_real(key, self._algo)
  151. plainkey = tmpcipher.decrypt(str(self._keycrypted).decode('base64'))
  152. key = self._retrievedata(plainkey)
  153. key = str(key).decode('base64')
  154. self._cipher = self._getcipher_real(key, self._algo)
  155. def encrypt(self, obj):
  156. """
  157. encrypt(obj) -> ciphertext
  158. Encrypt obj and return its ciphertext. obj must be a picklable class.
  159. Can raise a CryptoException and CryptoUnsupportedException"""
  160. cipher = self._getcipher()
  161. plaintext = self._preparedata(obj, cipher.block_size)
  162. ciphertext = cipher.encrypt(plaintext)
  163. return str(ciphertext).encode('base64')
  164. def decrypt(self, ciphertext):
  165. """
  166. decrypt(ciphertext) -> obj
  167. Decrypt ciphertext and returns the obj that was encrypted.
  168. If key is bad, a CryptoBadKeyException is raised
  169. Can also raise a CryptoException and CryptoUnsupportedException"""
  170. cipher = self._getcipher()
  171. ciphertext = str(ciphertext).decode('base64')
  172. plaintext = cipher.decrypt(ciphertext)
  173. return self._retrievedata(plaintext)
  174. def set_cryptedkey(self, key):
  175. """
  176. hold _keycrypted
  177. """
  178. self._keycrypted = key
  179. def get_cryptedkey(self):
  180. """
  181. return _keycrypted
  182. """
  183. return self._keycrypted
  184. def set_callback(self, callback):
  185. """
  186. set the callback function
  187. """
  188. self._callback = callback
  189. @property
  190. def callback(self):
  191. """
  192. return call back function
  193. """
  194. return self._callback
  195. def changepassword(self):
  196. """
  197. Creates a new key. The key itself is actually stored in
  198. the database in crypted form. This key is encrypted using the
  199. password that the user provides. This makes it easy to change the
  200. password for the database.
  201. If oldKeyCrypted is none, then a new password is generated."""
  202. if self._callback is None:
  203. raise CryptoNoCallbackException("No call back class has been "
  204. "specified")
  205. if self._keycrypted is None:
  206. # Generate a new key, 32 byts in length, if that's
  207. # too long for the Cipher, _getCipherReal will sort it out
  208. random = OSRNG.new()
  209. key = str(random.read(32)).encode('base64')
  210. else:
  211. password = self._callback.getsecret(("Please enter your current "
  212. "password"))
  213. cipher = self._getcipher_real(password, self._algo)
  214. plainkey = cipher.decrypt(str(self._keycrypted).decode('base64'))
  215. key = self._retrievedata(plainkey)
  216. newpassword1 = self._callback.getnewsecret("Please enter your new \
  217. password")
  218. newpassword2 = self._callback.getnewsecret("Please enter your new \
  219. password again")
  220. while newpassword1 != newpassword2:
  221. print "Passwords do not match!"
  222. newpassword1 = self._callback.getnewsecret("Please enter your new \
  223. password")
  224. newpassword2 = self._callback.getnewsecret("Please enter your new \
  225. password again")
  226. newcipher = self._getcipher_real(newpassword1, self._algo)
  227. self._keycrypted = str(newcipher.encrypt(
  228. self._preparedata(key,
  229. newcipher.block_size)
  230. )).encode('base64')
  231. # newpassword1, newpassword2 are not needed any more so we erase
  232. # them
  233. zerome(newpassword1)
  234. zerome(newpassword2)
  235. del(newpassword1)
  236. del(newpassword2)
  237. # we also want to create the cipher if there isn't one already
  238. # so this CryptoEngine can be used from now on
  239. if self._cipher is None:
  240. self._cipher = self._getcipher_real(str(key).decode('base64'),
  241. self._algo)
  242. CryptoEngine._timeoutcount = time.time()
  243. return self._keycrypted
  244. def alive(self):
  245. """
  246. check if we have cipher
  247. """
  248. if self._cipher is not None:
  249. return True
  250. else:
  251. return False
  252. def forget(self):
  253. """
  254. discard cipher
  255. """
  256. self._cipher = None
  257. def _getcipher(self):
  258. """
  259. get cypher from user, to decrypt DB
  260. """
  261. if (self._cipher is not None
  262. and (self._timeout == -1
  263. or (time.time() -
  264. CryptoEngine._timeoutcount) < self._timeout)):
  265. return self._cipher
  266. if self._callback is None:
  267. raise CryptoNoCallbackException("No Callback exception")
  268. if self._keycrypted is None:
  269. raise CryptoNoKeyException("Encryption key has not been generated")
  270. max_tries = 5
  271. tries = 0
  272. key = None
  273. while tries < max_tries:
  274. try:
  275. password = self._callback.getsecret("Please enter your "
  276. "password")
  277. tmpcipher = self._getcipher_real(password, self._algo)
  278. plainkey = tmpcipher.decrypt(str(self._keycrypted).decode(
  279. 'base64'))
  280. key = self._retrievedata(plainkey)
  281. break
  282. except CryptoBadKeyException:
  283. print "Wrong password."
  284. tries += 1
  285. if not key:
  286. raise CryptoBadKeyException("Wrong password entered {x} times; "
  287. "giving up ".format(x=max_tries))
  288. try:
  289. key = str(key).decode('base64')
  290. except Exception:
  291. key = cPickle.loads(key)
  292. key = str(key).decode('base64')
  293. self._cipher = self._getcipher_real(key,
  294. self._algo)
  295. CryptoEngine._timeoutcount = time.time()
  296. return self._cipher
  297. def _getcipher_real(self, key, algo):
  298. """
  299. do the real job of decrypting using functions
  300. form PyCrypto
  301. """
  302. if (algo == "AES"):
  303. key = hashlib.sha256(key)
  304. cipher = cAES.new(key.digest(), cAES.MODE_ECB)
  305. elif (algo == 'ARC2'):
  306. cipher = cARC2.new(key, cARC2.MODE_ECB)
  307. elif (algo == 'ARC4'):
  308. raise CryptoUnsupportedException("ARC4 is currently unsupported")
  309. elif (algo == 'Blowfish'):
  310. cipher = cBlowfish.new(key, cBlowfish.MODE_ECB)
  311. elif (algo == 'CAST'):
  312. cipher = cCAST.new(key, cCAST.MODE_ECB)
  313. elif (algo == 'DES'):
  314. if len(key) != 8:
  315. raise Exception("DES Encrypted keys must be 8 characters "
  316. "long!")
  317. cipher = cDES.new(key, cDES.MODE_ECB)
  318. elif (algo == 'DES3'):
  319. key = hashlib.sha224(key)
  320. cipher = cDES3.new(key.digest()[:24], cDES3.MODE_ECB)
  321. elif (algo == 'XOR'):
  322. raise CryptoUnsupportedException("XOR is currently unsupported")
  323. else:
  324. raise CryptoException("Invalid algorithm specified")
  325. return cipher
  326. def _preparedata(self, obj, blocksize):
  327. """
  328. prepare data before encrypting
  329. """
  330. plaintext = obj
  331. numblocks = (len(plaintext)/blocksize) + 1
  332. newdatasize = blocksize*numblocks
  333. return plaintext.ljust(newdatasize)
  334. def _retrievedata(self, plaintext):
  335. """
  336. retrieve encrypted data
  337. """
  338. if (plaintext.startswith(_TAG)):
  339. plaintext = plaintext[len(_TAG):]
  340. return plaintext
  341. class CryptoEngineOld(CryptoEngine):
  342. def _getcipher_real(self, key, algo):
  343. """
  344. do the real job of decrypting using functions
  345. form PyCrypto
  346. """
  347. if (algo == "AES"):
  348. key = self._padkey(key, [16, 24, 32])
  349. cipher = cAES.new(key, cAES.MODE_ECB)
  350. elif (algo == 'ARC2'):
  351. cipher = cARC2.new(key, cARC2.MODE_ECB)
  352. elif (algo == 'ARC4'):
  353. raise CryptoUnsupportedException("ARC4 is currently unsupported")
  354. elif (algo == 'Blowfish'):
  355. cipher = cBlowfish.new(key, cBlowfish.MODE_ECB)
  356. elif (algo == 'CAST'):
  357. cipher = cCAST.new(key, cCAST.MODE_ECB)
  358. elif (algo == 'DES'):
  359. self._padkey(key, [8])
  360. cipher = cDES.new(key, cDES.MODE_ECB)
  361. elif (algo == 'DES3'):
  362. key = self._padkey(key, [16, 24])
  363. cipher = cDES3.new(key, cDES3.MODE_ECB)
  364. elif (algo == 'XOR'):
  365. raise CryptoUnsupportedException("XOR is currently unsupported")
  366. else:
  367. raise CryptoException("Invalid algorithm specified")
  368. return cipher
  369. def _padkey(self, key, acceptable_lengths):
  370. """
  371. pad key with extra string
  372. """
  373. maxlen = max(acceptable_lengths)
  374. keylen = len(key)
  375. if (keylen > maxlen):
  376. return key[0:maxlen]
  377. acceptable_lengths.sort()
  378. acceptable_lengths.reverse()
  379. newkeylen = None
  380. for i in acceptable_lengths:
  381. if (i < keylen):
  382. break
  383. newkeylen = i
  384. return key.ljust(newkeylen)
  385. def _preparedata(self, obj, blocksize):
  386. """
  387. prepare data before encrypting
  388. """
  389. plaintext = _TAG + obj
  390. numblocks = (len(plaintext)/blocksize) + 1
  391. newdatasize = blocksize*numblocks
  392. return plaintext.ljust(newdatasize)
  393. def _retrievedata(self, plaintext):
  394. """
  395. retrieve encrypted data
  396. """
  397. # startswith(_TAG) is to make sure the decryption
  398. # is correct! However this method is SHIT! It is dangerous,
  399. # and exposes the datebase.
  400. # Instead we sould make sure that the string is composed of legal
  401. # printable stuff and not garbage
  402. # string.printable is one such set
  403. try:
  404. plaintext.decode('utf-8')
  405. except UnicodeDecodeError:
  406. raise CryptoBadKeyException("Error decrypting, bad key")
  407. if (plaintext.startswith(_TAG)):
  408. plaintext = plaintext[len(_TAG):]
  409. try:
  410. # old db version used to write stuff to db with
  411. # plaintext = cPickle.dumps(obj)
  412. # DONE: completely remove this block, and convert
  413. # the DB to a completely plain text ...
  414. # See the above CryptoEngine
  415. # This implies that the coversion from OLD DATABASE FORMAT has
  416. # plain strings too ...
  417. return cPickle.loads(plaintext)
  418. except (TypeError, ValueError, cPickle.UnpicklingError, EOFError):
  419. return plaintext