Merge pull request #520 from c00kiemon5ter/fix-warnings

Fix warnings and minor cleanup

Author: c00kiemon5ter

src/saml2/__init__.py

@@ -586,7 +586,8 @@ def get_ns_map(self, elements, uri_set):
 
         for elem in elements:
             uri_set = self.get_ns_map_attribute(elem.attrib, uri_set)
-            uri_set = self.get_ns_map(elem.getchildren(), uri_set)
+            children = list(elem)
+            uri_set = self.get_ns_map(children, uri_set)
             uri = self.tag_get_uri(elem)
             if uri is not None:
                 uri_set.add(uri)
@@ -651,7 +652,7 @@ def set_prefixes(self, elem, prefix_map):
 
         # fixup all elements in the tree
         memo = {}
-        for elem in elem.getiterator():
+        for elem in elem.iter():
             self.fixup_element_prefixes(elem, uri_map, memo)
 
     def fixup_element_prefixes(self, elem, uri_map, memo):

src/saml2/cert.py

@@ -150,7 +150,6 @@ def create_certificate(self, cert_info, request=False, valid_from=0,
         cert.set_pubkey(k)
         cert.sign(k, hash_alg)
 
-        filesCreated = False
         try:
             if request:
                 tmp_cert = crypto.dump_certificate_request(crypto.FILETYPE_PEM,
@@ -169,33 +168,18 @@ def create_certificate(self, cert_info, request=False, valid_from=0,
             else:
                 tmp_key = crypto.dump_privatekey(crypto.FILETYPE_PEM, k)
             if write_to_file:
-                fc = open(c_f, "wt")
-                fk = open(k_f, "wt")
-
-                if request:
-                    fc.write(tmp_cert.decode('utf-8'))
-                else:
+                with open(c_f, 'wt') as fc:
                     fc.write(tmp_cert.decode('utf-8'))
-                fk.write(tmp_key.decode('utf-8'))
-                filesCreated = True
-                try:
-                    fc.close()
-                except:
-                    pass
-
-                try:
-                    fk.close()
-                except:
-                    pass
+                with open(k_f, 'wt') as fk:
+                    fk.write(tmp_key.decode('utf-8'))
                 return c_f, k_f
             return tmp_cert, tmp_key
         except Exception as ex:
             raise CertificateError("Certificate cannot be generated.", ex)
 
     def write_str_to_file(self, file, str_data):
-        f = open(file, "wt")
-        f.write(str_data)
-        f.close()
+        with open(file, 'wt') as f:
+            f.write(str_data)
 
     def read_str_from_file(self, file, type="pem"):
         with open(file, 'rb') as f:

src/saml2/config.py

@@ -373,7 +373,6 @@ def load_file(self, config_file, metadata_construction=False):
             config_file = config_file[:-3]
 
         mod = self._load(config_file)
-        # return self.load(eval(open(config_file).read()))
         return self.load(copy.deepcopy(mod.CONFIG), metadata_construction)
 
     def load_metadata(self, metadata_conf):

src/saml2/eptid.py

@@ -56,6 +56,9 @@ def get(self, idp, sp, *args):
             self[key] = val
             return val
 
+    def close(self):
+        pass
+
 
 class EptidShelve(Eptid):
     def __init__(self, secret, filename):
@@ -64,3 +67,6 @@ def __init__(self, secret, filename):
             if filename.endswith('.db'):
                 filename = filename.rsplit('.db', 1)[0]
         self._db = shelve.open(filename, writeback=True, protocol=2)
+
+    def close(self):
+        self._db.close()

src/saml2/mdbcache.py

@@ -31,7 +31,7 @@ def __init__(self, server=None, debug=0, db=None):
         self.debug = debug
 
     def delete(self, subject_id):
-        self._cache.remove({"subject_id": subject_id})
+        self._cache.delete_many({'subject_id': subject_id})
 
     def get_identity(self, subject_id, entities=None,
                      check_not_on_or_after=True):
@@ -196,4 +196,4 @@ def valid_to(self, subject_id, entity_id, newtime):
                            {"$set": {"timestamp": newtime}})
 
     def clear(self):
-        self._cache.remove()
+        self._cache.delete_many({})

src/saml2/mongo_store.py

@@ -178,11 +178,7 @@ def handle_name_id_mapping_request(self, name_id, name_id_policy):
         # else create and return a new one
         return self.construct_nameid(_id, name_id_policy=name_id_policy)
 
-    def close(self):
-        pass
-
 
-#------------------------------------------------------------------------------
 class MDB(object):
     primary_key = "mdb"
 

src/saml2/s2repoze/plugins/formswithhidden.py

@@ -116,7 +116,8 @@ def make_plugin(login_form_qs='__do_login', rememberer_name=None, form=None):
         raise ValueError(
             'must include rememberer key (name of another IIdentifier plugin)')
     if form is not None:
-        form = open(form).read()
+        with open(form, 'r') as f:
+            form = f.read()
     plugin = FormHiddenPlugin(login_form_qs, rememberer_name, form)
     return plugin
 

src/saml2/saml.py

@@ -3,6 +3,8 @@
 #
 # Generated Mon May  2 14:23:33 2011 by parse_xsd.py version 0.4.
 #
+import base64
+
 from saml2.validate import valid_ipv4, MustValueError
 from saml2.validate import valid_ipv6
 from saml2.validate import ShouldValueError
@@ -81,11 +83,12 @@
 SCM_SENDER_VOUCHES = "urn:oasis:names:tc:SAML:2.0:cm:sender-vouches"
 SCM_BEARER = "urn:oasis:names:tc:SAML:2.0:cm:bearer"
 
-# -----------------------------------------------------------------------------
 XSD = "xs:"
 NS_SOAP_ENC = "http://schemas.xmlsoap.org/soap/encoding/"
 
-# -----------------------------------------------------------------------------
+
+_b64_decode_fn = getattr(base64, 'decodebytes', base64.decodestring)
+_b64_encode_fn = getattr(base64, 'encodebytes', base64.encodestring)
 
 
 def _decode_attribute_value(typ, text):
@@ -96,11 +99,9 @@ def _decode_attribute_value(typ, text):
     if typ == XSD + "float" or typ == XSD + "double":
         return str(float(text))
     if typ == XSD + "boolean":
-        return "%s" % (text == "true" or text == "True")
+        return str(text.lower() == "true")
     if typ == XSD + "base64Binary":
-        import base64
-
-        return base64.decodestring(text)
+        return _b64_decode_fn(text)
     raise ValueError("type %s not supported" % type)
 
 
@@ -124,9 +125,7 @@ def _verify_value_type(typ, val):
         else:
             raise ValueError("Faulty boolean value")
     if typ == XSD + "base64Binary":
-        import base64
-
-        return base64.decodestring(val.encode('utf-8'))
+        return _b64_decode_fn(val.encode())
 
 
 class AttributeValueBase(SamlBase):
@@ -181,7 +180,6 @@ def set_type(self, typ):
             except AttributeError:
                 self._extatt['xmlns:xs'] = XS_NAMESPACE
 
-
     def get_type(self):
         try:
             return self.extension_attributes[XSI_TYPE]
@@ -204,13 +202,11 @@ def clear_type(self):
     def set_text(self, val, base64encode=False):
         typ = self.get_type()
         if base64encode:
-            import base64
-
-            val = base64.encodestring(val)
+            val = _b64_encode_fn(val)
             self.set_type("xs:base64Binary")
         else:
             if isinstance(val, six.binary_type):
-                val = val.decode('utf-8')
+                val = val.decode()
             if isinstance(val, six.string_types):
                 if not typ:
                     self.set_type("xs:string")

src/saml2/server.py

@@ -113,7 +113,6 @@ def choose_session_storage(self):
             typ, data = _spec
             if typ.lower() == "mongodb":
                 from saml2.mongo_store import SessionStorageMDB
-
                 return SessionStorageMDB(database=data, collection="session")
 
         raise NotImplementedError("No such storage type implemented")
@@ -142,15 +141,12 @@ def init_config(self, stype="idp"):
                 idb = _shelve_compat(addr, writeback=True, protocol=2)
             elif typ == "memcached":
                 import memcache
-
                 idb = memcache.Client(addr)
             elif typ == "dict":  # in-memory dictionary
                 idb = {}
             elif typ == "mongodb":
                 from saml2.mongo_store import IdentMDB
-
                 self.ident = IdentMDB(database=addr, collection="ident")
-
             elif typ == "identdb":
                 mod, clas = addr.rsplit('.', 1)
                 mod = importlib.import_module(mod)
@@ -182,7 +178,6 @@ def init_config(self, stype="idp"):
                     self.eptid = EptidShelve(secret, addr)
                 elif typ == "mongodb":
                     from saml2.mongo_store import EptidMDB
-
                     self.eptid = EptidMDB(secret, database=addr,
                                           collection="eptid")
                 else:

src/saml2/sigver.py

@@ -488,54 +488,6 @@ def base64_to_long(data):
     return intarr2long(dehexlify(_d))
 
 
-def key_from_key_value(key_info):
-    res = []
-    for value in key_info.key_value:
-        if value.rsa_key_value:
-            e = base64_to_long(value.rsa_key_value.exponent)
-            m = base64_to_long(value.rsa_key_value.modulus)
-            key = RSA.construct((m, e))
-            res.append(key)
-    return res
-
-
-def key_from_key_value_dict(key_info):
-    res = []
-    if not "key_value" in key_info:
-        return res
-
-    for value in key_info["key_value"]:
-        if "rsa_key_value" in value:
-            e = base64_to_long(value["rsa_key_value"]["exponent"])
-            m = base64_to_long(value["rsa_key_value"]["modulus"])
-            key = RSA.construct((m, e))
-            res.append(key)
-    return res
-
-
-# =============================================================================
-
-
-# def rsa_load(filename):
-#    """Read a PEM-encoded RSA key pair from a file."""
-#    return M2Crypto.RSA.load_key(filename, M2Crypto.util
-# .no_passphrase_callback)
-#
-#
-# def rsa_loads(key):
-#    """Read a PEM-encoded RSA key pair from a string."""
-#    return M2Crypto.RSA.load_key_string(key,
-#                                        M2Crypto.util.no_passphrase_callback)
-
-
-def rsa_eq(key1, key2):
-    # Check if two RSA keys are in fact the same
-    if key1.n == key2.n and key1.e == key2.e:
-        return True
-    else:
-        return False
-
-
 def extract_rsa_key_from_x509_cert(pem):
     cert = load_pem_x509_certificate(pem, backend)
     return cert.public_key()