X-Git-Url: http://git.onelab.eu/?p=sfa.git;a=blobdiff_plain;f=sfa%2Ftrust%2Fhierarchy.py;h=dc66ef80ce708151b45639c598c996fd4ca0cea5;hp=66010b7190a9864adc4db846bfce4018f32c89b3;hb=1e95f8a388325499564df5f8eb6eb1fd10ca2d42;hpb=a3ab496b43adffab4b6b628d5f00198624199eb0 diff --git a/sfa/trust/hierarchy.py b/sfa/trust/hierarchy.py index 66010b71..dc66ef80 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. @@ -12,19 +12,16 @@ # *.DBINFO - database info ## -### $Id$ -### $URL$ - import os -from sfa.util.report import * +from sfa.util.faults import * +from sfa.util.sfalogging import logger +from sfa.util.xrn import get_leaf, get_authority, hrn_to_urn, urn_to_hrn from sfa.trust.certificate import Keypair -from sfa.trust.credential import * +from sfa.trust.credential import Credential from sfa.trust.gid import GID, create_uuid - -from sfa.util.misc import * from sfa.util.config import Config -from sfa.util.sfaticket import SfaTicket +from sfa.trust.sfaticket import SfaTicket ## # The AuthInfo class contains the information for an authority. This information @@ -36,16 +33,16 @@ class AuthInfo: gid_filename = None privkey_filename = None dbinfo_filename = None - ## # 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 +57,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 @@ -117,9 +120,10 @@ class Hierarchy: # 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 +140,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 +153,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): - trace("Hierarchy: creating authority: " + hrn) + def create_auth(self, xrn, create_parents=False): + hrn, type = urn_to_hrn(xrn) + logger.debug("Hierarchy: creating authority: %s"% 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,13 +178,13 @@ class Hierarchy: pass if os.path.exists(privkey_filename): - print "using existing key", privkey_filename, "for authority", hrn + 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 @@ -192,12 +199,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): - #trace("Hierarchy: getting authority: " + hrn) - + def get_auth_info(self, xrn): + hrn, type = urn_to_hrn(xrn) if not self.auth_exists(hrn): + logger.warning("Hierarchy: mising authority - xrn=%s, hrn=%s"%(xrn,hrn)) raise MissingAuthority(hrn) (directory, gid_filename, privkey_filename, dbinfo_filename) = \ @@ -222,10 +229,28 @@ 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, CA=False): + hrn, type = urn_to_hrn(xrn) parent_hrn = get_authority(hrn) + # 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) + + # is this a CA cert + if hrn == self.config.SFA_INTERFACE_HRN or not parent_hrn: + # root or sub authority + gid.set_intermediate_ca(True) + elif type and 'authority' in type: + # authority type + gid.set_intermediate_ca(True) + elif CA: + gid.set_intermediate_ca(True) + else: + gid.set_intermediate_ca(False) + + # set issuer 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 @@ -252,20 +277,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 +300,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 +312,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 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 +341,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()