changes to be compatible Python 2.7 and 3.6

src/keas/kmi/README.txt

@@ -65,10 +65,7 @@ HIPAA and NIST key strength requirement.
 
 You can now use this key encrypting key to extract the encryption keys:
 
-  >>> try:
-  ...    from hashlib import md5
-  ... except ImportError:
-  ...    from md5 import md5
+  >>> from hashlib import md5
   >>> hash_key = md5(key).hexdigest()
 
   >>> len(keys.get(hash_key))

src/keas/kmi/facility.py

@@ -20,27 +20,30 @@
 import Crypto.PublicKey.RSA
 from Crypto.Random import random
 import binascii
-import httplib
+try:
+    # Python 3
+    from http.client import HTTPSConnection
+    from urllib import parse as urlparse
+except ImportError:
+    # Python 2
+    from httplib import HTTPSConnection
+    from urlparse import urlparse
 import logging
 import os
 import struct
 import time
-import urlparse
-import zope.interface
+from zope.interface import implementer
 from keas.kmi import interfaces
 
-try:
-    from hashlib import md5
-except ImportError:
-    from md5 import md5
+from hashlib import md5
 
 __docformat__ = "reStructuredText"
 
 logger = logging.getLogger('kmi')
 
 
+@implementer(interfaces.IEncryptionService)
 class EncryptionService(object):
-    zope.interface.implements(interfaces.IEncryptionService)
 
     CipherFactory = Crypto.Cipher.AES
     CipherMode = Crypto.Cipher.AES.MODE_CBC
@@ -185,16 +188,16 @@ def decrypt_file(self, key, fsrc, fdst, chunksize=24*1024):
         fdst.truncate(origsize)
 
 
+@implementer(interfaces.IExtendedKeyManagementFacility)
 class KeyManagementFacility(EncryptionService):
-    zope.interface.implements(interfaces.IExtendedKeyManagementFacility)
 
     timeout = 3600
 
     rsaKeyLength = 2048 # The length of the key encrypting key
     rsaKeyExponent = 65537 # Should be sufficiently high and non-symmetric
     rsaPassphrase = 'key management facility'
 
-    keyLength = rsaKeyLength/16
+    keyLength = rsaKeyLength // 16
 
     def __init__(self, storage_dir):
         self.storage_dir = storage_dir
@@ -241,7 +244,7 @@ def __contains__(self, name):
 
     def __setitem__(self, name, key):
         fn = os.path.join(self.storage_dir, name+'.dek')
-        with open(fn, 'w') as file:
+        with open(fn, 'wb') as file:
             file.write(key)
         logger.info('New key added (hash): %s', name)
 
@@ -300,20 +303,20 @@ def __repr__(self):
         return '<%s (%i)>' %(self.__class__.__name__, len(self))
 
 
+@implementer(interfaces.IKeyManagementFacility)
 class LocalKeyManagementFacility(EncryptionService):
     """A local facility that requests keys from the master facility."""
-    zope.interface.implements(interfaces.IKeyManagementFacility)
 
     timeout = 3600
-    httpConnFactory = httplib.HTTPSConnection
+    httpConnFactory = HTTPSConnection
 
     def __init__(self, url):
         self.url = url
         self.__cache = {}
 
     def generate(self):
         """See interfaces.IKeyGenerationService"""
-        pieces = urlparse.urlparse(self.url)
+        pieces = urlparse(self.url)
         conn = self.httpConnFactory(pieces.netloc)
         conn.request('POST', '/new', '', {})
         response = conn.getresponse()
@@ -326,7 +329,7 @@ def getEncryptionKey(self, key):
         if (key in self.__cache and
             self.__cache[key][0] + self.timeout > time.time()):
             return self.__cache[key][1]
-        pieces = urlparse.urlparse(self.url)
+        pieces = urlparse(self.url)
         conn = self.httpConnFactory(pieces.netloc)
         conn.request('POST', '/key', key, {'content-type': 'text/plain'})
         response = conn.getresponse()

src/keas/kmi/keyholder.py

@@ -14,15 +14,14 @@
 """Simple Key Holder
 """
 __docformat__ = "reStructuredText"
-from zope.interface import implements
+from zope.interface import implementer
 from keas.kmi.interfaces import IKeyHolder
 
 
+@implementer(IKeyHolder)
 class KeyHolder(object):
     """A key holder utility that loads the key from a file and keeps it in RAM."""
 
-    implements(IKeyHolder)
-
     def __init__(self, filename):
         self.key = file(filename, 'rb').read()
 

src/keas/kmi/persistent.py

@@ -14,8 +14,7 @@
 """Encrypted persistent objects
 """
 from __future__ import absolute_import
-import cPickle
-import cStringIO
+from ZODB._compat import BytesIO, Pickler, Unpickler
 import persistent
 import persistent.wref
 from zope.component import getUtility
@@ -52,7 +51,7 @@ def decrypt_state(state):
 
 
 def pickle_nonpersistent(state):
-    buf = cStringIO.StringIO()
+    buf = BytesIO()
     persistent_refs = []
     cache = {}
     def persistent_id(obj):
@@ -68,17 +67,17 @@ def persistent_id(obj):
             idx = cache[id(obj)] = len(persistent_refs)
             persistent_refs.append(obj)
         return idx
-    pickler = cPickle.Pickler(buf, 2)
+    pickler = Pickler(buf, 2)
     pickler.persistent_id = persistent_id
     pickler.dump(state)
     return buf.getvalue(), persistent_refs
 
 
 def unpickle_nonpersistent(data, persistent_refs):
-    buf = cStringIO.StringIO(data)
+    buf = BytesIO(data)
     def persistent_load(ref):
         return persistent_refs[ref]
-    unpickler = cPickle.Unpickler(buf)
+    unpickler = Unpickler(buf)
     unpickler.persistent_load = persistent_load
     return unpickler.load()
 

src/keas/kmi/testing.py

@@ -13,16 +13,12 @@
 ##############################################################################
 """Testing Support
 """
-import StringIO
+from io import BytesIO
 import webob
-from zope.publisher import browser
-from zope.interface import implements
+from zope.interface import implementer
 from keas.kmi import facility, rest, interfaces
 
-try:
-    from hashlib import md5
-except ImportError:
-    from md5 import md5
+from hashlib import md5
 
 KeyEncyptingKey = '''-----BEGIN RSA PRIVATE KEY-----
 MIIBOAIBAAJBAL+VS9lDsS9XOaeJppfK9lhxKMRFdcg50MR3aJEQK9rvDEqNwBS9
@@ -53,12 +49,13 @@ class FakeHTTPResponse(object):
     reason = 'Ok'
 
     def __init__(self, data):
-        self.fp = StringIO.StringIO(data)
+        self.fp = BytesIO(data)
+        self.fp_len = len(data)
         self.msg = FakeHTTPMessage(self)
 
     def read(self, amt=10*2**10):
         data = self.fp.read(amt)
-        if self.fp.len == self.fp.tell():
+        if self.fp_len == self.fp.tell():
             self.fp = None
         return data
 
@@ -83,7 +80,7 @@ def getresponse(self, buffering=False):
         elif url == '/key':
             view = rest.get_key
 
-        io = StringIO.StringIO(self.request_data[2])
+        io = BytesIO(self.request_data[2])
         req = webob.Request({'wsgi.input': io})
         res = view(self.context, req)
         return FakeHTTPResponse(res.body)
@@ -106,7 +103,7 @@ def generate(self):
         return KeyEncyptingKey
 
 
+@implementer(interfaces.IKeyHolder)
 class TestingKeyHolder(object):
-    implements(interfaces.IKeyHolder)
     key = KeyEncyptingKey