X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=sfa%2Ftrust%2Fhierarchy.py;h=1ba7fb11e2b89574c6d7714f798166f0590423e2;hb=0cf0d31c313a366e3f272f830bdb4f2a7308e11f;hp=abb2328d43634e6e58067cc2c19e7b4c8a4a371e;hpb=7eb8c83b47a094da8bf7dbb0388e29cb131916d0;p=sfa.git diff --git a/sfa/trust/hierarchy.py b/sfa/trust/hierarchy.py index abb2328d..1ba7fb11 100644 --- a/sfa/trust/hierarchy.py +++ b/sfa/trust/hierarchy.py @@ -1,6 +1,6 @@ ## # This module implements a hierarchy of authorities and performs a similar -# function as the "tree" module of the original geniwrapper prototype. An HRN +# function as the "tree" module of the original SFA prototype. An HRN # is assumed to be a string of authorities separated by dots. For example, # "planetlab.us.arizona.bakers". Each component of the HRN is a different # authority, with the last component being a leaf in the tree. @@ -17,13 +17,13 @@ import os +from sfa.util.sfalogging import sfa_logger from sfa.util.report import * from sfa.trust.certificate import Keypair from sfa.trust.credential import * -from sfa.trust.gid import * - -from sfa.util.misc import * -from sfa.util.config import * +from sfa.trust.gid import GID, create_uuid +from sfa.util.namespace import * +from sfa.util.config import Config from sfa.util.sfaticket import SfaTicket ## @@ -40,12 +40,13 @@ class AuthInfo: ## # Initialize and authority object. # - # @param hrn the human readable name of the authority + # @param xrn the human readable name of the authority (urn will be converted to hrn) # @param gid_filename the filename containing the GID # @param privkey_filename the filename containing the private key # @param dbinfo_filename the filename containing the database info - def __init__(self, hrn, gid_filename, privkey_filename, dbinfo_filename): + def __init__(self, xrn, gid_filename, privkey_filename, dbinfo_filename): + hrn, type = urn_to_hrn(xrn) self.hrn = hrn self.set_gid_filename(gid_filename) self.privkey_filename = privkey_filename @@ -60,6 +61,12 @@ class AuthInfo: self.gid_filename = fn self.gid_object = None + def get_privkey_filename(self): + return self.privkey_filename + + def get_gid_filename(self): + return self.gid_filename + ## # Get the GID in the form of a GID object @@ -110,16 +117,17 @@ class Hierarchy: def __init__(self, basedir = None): if not basedir: - config = Config() - basedir = config.config_path + os.sep + "authorities" + self.config = Config() + basedir = os.path.join(self.config.SFA_DATA_DIR, "authorities") self.basedir = basedir ## # Given a hrn, return the filenames of the GID, private key, and dbinfo # files. # - # @param hrn the human readable name of the authority + # @param xrn the human readable name of the authority (urn will be convertd to hrn) - def get_auth_filenames(self, hrn): + def get_auth_filenames(self, xrn): + hrn, type = urn_to_hrn(xrn) leaf = get_leaf(hrn) parent_hrn = get_authority(hrn) directory = os.path.join(self.basedir, hrn.replace(".", "/")) @@ -136,7 +144,8 @@ class Hierarchy: # # @param the human readable name of the authority to check - def auth_exists(self, hrn): + def auth_exists(self, xrn): + hrn, type = urn_to_hrn(xrn) (directory, gid_filename, privkey_filename, dbinfo_filename) = \ self.get_auth_filenames(hrn) @@ -148,16 +157,18 @@ class Hierarchy: # Create an authority. A private key for the authority and the associated # GID are created and signed by the parent authority. # - # @param hrn the human readable name of the authority to create + # @param xrn the human readable name of the authority to create (urn will be converted to hrn) # @param create_parents if true, also create the parents if they do not exist - def create_auth(self, hrn, create_parents=False): + def create_auth(self, xrn, create_parents=False): + hrn, type = urn_to_hrn(xrn) trace("Hierarchy: creating authority: " + hrn) # create the parent authority if necessary parent_hrn = get_authority(hrn) - if (parent_hrn) and (not self.auth_exists(parent_hrn)) and (create_parents): - self.create_auth(parent_hrn, create_parents) + parent_urn = hrn_to_urn(parent_hrn, 'authority') + if (parent_hrn) and (not self.auth_exists(parent_urn)) and (create_parents): + self.create_auth(parent_urn, create_parents) (directory, gid_filename, privkey_filename, dbinfo_filename) = \ self.get_auth_filenames(hrn) @@ -171,18 +182,18 @@ class Hierarchy: pass if os.path.exists(privkey_filename): - print "using existing key", privkey_filename, "for authority", hrn + sfa_logger.debug("using existing key %r for authority %r"%(privkey_filename,hrn)) pkey = Keypair(filename = privkey_filename) else: pkey = Keypair(create = True) pkey.save_to_file(privkey_filename) - gid = self.create_gid(hrn, create_uuid(), pkey) + gid = self.create_gid(xrn, create_uuid(), pkey) gid.save_to_file(gid_filename, save_parents=True) # XXX TODO: think up a better way for the dbinfo to work - dbinfo = get_default_dbinfo() + dbinfo = Config().get_plc_dbinfo() dbinfo_file = file(dbinfo_filename, "w") dbinfo_file.write(str(dbinfo)) dbinfo_file.close() @@ -192,11 +203,12 @@ class Hierarchy: # does not exist, then an exception is thrown. As a side effect, disk files # and a subdirectory may be created to store the authority. # - # @param hrn the human readable name of the authority to create. + # @param xrn the human readable name of the authority to create (urn will be converted to hrn). - def get_auth_info(self, hrn): + def get_auth_info(self, xrn): + #trace("Hierarchy: getting authority: " + hrn) - + hrn, type = urn_to_hrn(xrn) if not self.auth_exists(hrn): raise MissingAuthority(hrn) @@ -222,11 +234,16 @@ class Hierarchy: # @param uuid the unique identifier to store in the GID # @param pkey the public key to store in the GID - def create_gid(self, hrn, uuid, pkey): - gid = GID(subject=hrn, uuid=uuid, hrn=hrn) + def create_gid(self, xrn, uuid, pkey): + hrn, type = urn_to_hrn(xrn) + # Using hrn_to_urn() here to make sure the urn is in the right format + # If xrn was a hrn instead of a urn, then the gid's urn will be + # of type None + urn = hrn_to_urn(hrn, type) + gid = GID(subject=hrn, uuid=uuid, hrn=hrn, urn=urn) parent_hrn = get_authority(hrn) - if not parent_hrn: + if not parent_hrn or hrn == self.config.SFA_INTERFACE_HRN: # if there is no parent hrn, then it must be self-signed. this # is where we terminate the recursion gid.set_issuer(pkey, hrn) @@ -235,6 +252,7 @@ class Hierarchy: parent_auth_info = self.get_auth_info(parent_hrn) gid.set_issuer(parent_auth_info.get_pkey_object(), parent_auth_info.hrn) gid.set_parent(parent_auth_info.get_gid_object()) + gid.set_intermediate_ca(True) gid.set_pubkey(pkey) gid.encode() @@ -252,20 +270,21 @@ class Hierarchy: # @param uuid if !=None, change the uuid # @param pubkey if !=None, change the public key - def refresh_gid(self, gid, hrn=None, uuid=None, pubkey=None): + def refresh_gid(self, gid, xrn=None, uuid=None, pubkey=None): # TODO: compute expiration time of GID, refresh it if necessary gid_is_expired = False # update the gid if we need to - if gid_is_expired or hrn or uuid or pubkey: - if not hrn: - hrn = gid.get_hrn() + if gid_is_expired or xrn or uuid or pubkey: + + if not xrn: + xrn = gid.get_urn() if not uuid: uuid = gid.get_uuid() if not pubkey: pubkey = gid.get_pubkey() - gid = self.create_gid(hrn, uuid, pubkey) + gid = self.create_gid(xrn, uuid, pubkey) return gid @@ -274,10 +293,11 @@ class Hierarchy: # credential will contain the authority privilege and will be signed by # the authority's parent. # - # @param hrn the human readable name of the authority + # @param hrn the human readable name of the authority (urn is converted to hrn) # @param authority type of credential to return (authority | sa | ma) - def get_auth_cred(self, hrn, kind="authority"): + def get_auth_cred(self, xrn, kind="authority"): + hrn, type = urn_to_hrn(xrn) auth_info = self.get_auth_info(hrn) gid = auth_info.get_gid_object() @@ -285,18 +305,20 @@ class Hierarchy: cred.set_gid_caller(gid) cred.set_gid_object(gid) cred.set_privileges(kind) - cred.set_delegate(True) - cred.set_pubkey(auth_info.get_gid_object().get_pubkey()) + cred.get_privileges().delegate_all_privileges(True) + #cred.set_pubkey(auth_info.get_gid_object().get_pubkey()) parent_hrn = get_authority(hrn) - if not parent_hrn: + if not parent_hrn or hrn == self.config.SFA_INTERFACE_HRN: # if there is no parent hrn, then it must be self-signed. this # is where we terminate the recursion - cred.set_issuer(auth_info.get_pkey_object(), hrn) + cred.set_issuer_keys(auth_info.get_privkey_filename(), auth_info.get_gid_filename()) else: # we need the parent's private key in order to sign this GID parent_auth_info = self.get_auth_info(parent_hrn) - cred.set_issuer(parent_auth_info.get_pkey_object(), parent_auth_info.hrn) + cred.set_issuer_keys(parent_auth_info.get_privkey_filename(), parent_auth_info.get_gid_filename()) + + cred.set_parent(self.get_auth_cred(parent_hrn, kind)) cred.encode() @@ -312,9 +334,10 @@ class Hierarchy: # This looks almost the same as get_auth_cred, but works for tickets # XXX does similarity imply there should be more code re-use? # - # @param hrn the human readable name of the authority + # @param xrn the human readable name of the authority (urn is converted to hrn) - def get_auth_ticket(self, hrn): + def get_auth_ticket(self, xrn): + hrn, type = urn_to_hrn(xrn) auth_info = self.get_auth_info(hrn) gid = auth_info.get_gid_object()