from sfa.trust.hierarchy import Hierarchy
from sfa.trust.gid import GID
+from sfa.client.candidates import Candidates
+
pprinter = PrettyPrinter(indent=4)
+try:
+ help_basedir=Hierarchy().basedir
+except:
+ help_basedir='*unable to locate Hierarchy().basedir'
+
def optparse_listvalue_callback(option, opt, value, parser):
setattr(parser.values, option.dest, value.split(','))
class Commands(object):
def _get_commands(self):
- available_methods = []
+ command_names = []
for attrib in dir(self):
if callable(getattr(self, attrib)) and not attrib.startswith('_'):
- available_methods.append(attrib)
- return available_methods
+ command_names.append(attrib)
+ return command_names
class RegistryCommands(Commands):
importer.run()
@args('-a', '--all', dest='all', metavar='<all>', action='store_true', default=False,
- help='Remove all registry records and all files in %s area' % Hierarchy().basedir)
+ help='Remove all registry records and all files in %s area' % help_basedir)
@args('-c', '--certs', dest='certs', metavar='<certs>', action='store_true', default=False,
- help='Remove all cached certs/gids found in %s' % Hierarchy().basedir )
+ help='Remove all cached certs/gids found in %s' % help_basedir )
@args('-0', '--no-reinit', dest='reinit', metavar='<reinit>', action='store_false', default=True,
help='Prevents new DB schema from being installed after cleanup')
def nuke(self, all=False, certs=False, reinit=True):
'aggregate': AggregateCommands,
'slicemgr': SliceManagerCommands}
- def find_category (self, string):
- for (k,v) in SfaAdmin.CATEGORIES.items():
- if k.startswith(string): return k
- for (k,v) in SfaAdmin.CATEGORIES.items():
- if k.find(string) >=1: return k
- return None
+ # returns (name,class) or (None,None)
+ def find_category (self, input):
+ full_name=Candidates (SfaAdmin.CATEGORIES.keys()).only_match(input)
+ if not full_name: return (None,None)
+ return (full_name,SfaAdmin.CATEGORIES[full_name])
def summary_usage (self, category=None):
- print "Usage:", self.script_name + " category action [<options>]"
+ print "Usage:", self.script_name + " category command [<options>]"
if category and category in SfaAdmin.CATEGORIES:
categories=[category]
else:
self.summary_usage()
# ensure category is valid
- category_str = argv.pop(0)
- category=self.find_category (category_str)
- if not category:
- self.summary_usage()
+ category_input = argv.pop(0)
+ (category_name, category_class) = self.find_category (category_input)
+ if not category_name or not category_class:
+ self.summary_usage(category_name)
- usage = "%%prog %s action [options]" % (category)
+ usage = "%%prog %s command [options]" % (category_name)
parser = OptionParser(usage=usage)
- command_class = SfaAdmin.CATEGORIES.get(category, None)
- if not command_class:
- self.summary_usage(category)
# ensure command is valid
- command_instance = command_class()
- actions = command_instance._get_commands()
+ category_instance = category_class()
+ commands = category_instance._get_commands()
if len(argv) < 1:
- action = '__call__'
+ # xxx what is this about ?
+ command_name = '__call__'
else:
- action = argv.pop(0)
+ command_input = argv.pop(0)
+ command_name = Candidates (commands).only_match (command_input)
- if hasattr(command_instance, action):
- command = getattr(command_instance, action)
+ if command_name and hasattr(category_instance, command_name):
+ command = getattr(category_instance, command_name)
else:
- self.summary_usage(category)
+ self.summary_usage(category_name)
# ensure options are valid
options = getattr(command, 'options', [])
- usage = "%%prog %s %s [options]" % (category, action)
+ usage = "%%prog %s %s [options]" % (category_name, command_name)
parser = OptionParser(usage=usage)
for arg, kwd in options:
parser.add_option(*arg, **kwd)
except Exception:
print "Command failed, please check log for more info"
raise
+
from sfa.client.sfaserverproxy import SfaServerProxy, ServerException
from sfa.client.client_helper import pg_users_arg, sfa_users_arg
from sfa.client.return_value import ReturnValue
+from sfa.client.candidates import Candidates
CM_PORT=12346
return filtered_records
+def credential_printable (credential_string):
+ credential=Credential(string=credential_string)
+ result=""
+ result += credential.get_summary_tostring()
+ result += "\n"
+ rights = credential.get_privileges()
+ result += "rights=%s"%rights
+ result += "\n"
+ return result
+
+def show_credentials (cred_s):
+ if not isinstance (cred_s,list): cred_s = [cred_s]
+ for cred in cred_s:
+ print "Using Credential %s"%credential_printable(cred)
+
# save methods
def save_raw_to_file(var, filename, format="text", banner=None):
if filename == "-":
help="Include a credential delegated to the user's root"+\
"authority in set of credentials for this call")
+ # show_credential option
+ if command in ("list","resources","create","add","update","remove","slices","delete","status","renew"):
+ parser.add_option("-C","--credential",dest='show_credential',action='store_true',default=False,
+ help="show credential(s) used in human-readable form")
# registy filter option
if command in ("list", "show", "remove"):
parser.add_option("-t", "--type", dest="type", type="choice",
self.print_command_help(options)
return -1
- command = args[0]
+ # complete / find unique match with command set
+ command_candidates = Candidates (self.available_names)
+ input = args[0]
+ command = command_candidates.only_match(input)
+ if not command:
+ self.print_command_help(options)
+ sys.exit(1)
+ # second pass options parsing
self.command_parser = self.create_command_parser(command)
(command_options, command_args) = self.command_parser.parse_args(args[1:])
self.command_options = command_options
if options.recursive:
opts['recursive'] = options.recursive
+ if options.show_credential:
+ show_credentials(self.my_credential_string)
try:
list = self.registry().List(hrn, self.my_credential_string, options)
except IndexError:
def add(self, options, args):
"add record into registry from xml file (Register)"
auth_cred = self.my_authority_credential_string()
+ if options.show_credential:
+ show_credentials(auth_cred)
record_dict = {}
if len(args) > 0:
record_filepath = args[0]
cred = self.my_authority_credential_string()
else:
raise "unknown record type" + record_dict['type']
+ if options.show_credential:
+ show_credentials(cred)
return self.registry().Update(record_dict, cred)
def remove(self, options, args):
type = options.type
if type in ['all']:
type = '*'
+ if options.show_credential:
+ show_credentials(auth_cred)
return self.registry().Remove(hrn, auth_cred, type)
# ==================================================================
# options and call_id when supported
api_options = {}
api_options['call_id']=unique_call_id()
+ if options.show_credential:
+ show_credentials(creds)
result = server.ListSlices(creds, *self.ois(server,api_options))
value = ReturnValue.get_value(result)
if self.options.raw:
creds.append(self.my_credential_string)
if options.delegate:
creds.append(self.delegate_cred(cred, get_authority(self.authority)))
+ if options.show_credential:
+ show_credentials(creds)
# no need to check if server accepts the options argument since the options has
# been a required argument since v1 API
# credentials
creds = [self.slice_credential_string(slice_hrn)]
+
delegated_cred = None
server_version = self.get_cached_server_version(server)
if server_version.get('interface') == 'slicemgr':
#elif server_version.get('urn'):
# delegated_cred = self.delegate_cred(slice_cred, urn_to_hrn(server_version['urn']))
+ if options.show_credential:
+ show_credentials(creds)
+
# rspec
rspec_file = self.get_rspec_file(args[1])
rspec = open(rspec_file).read()
# options and call_id when supported
api_options = {}
api_options ['call_id'] = unique_call_id()
+ if options.show_credential:
+ show_credentials(creds)
result = server.DeleteSliver(slice_urn, creds, *self.ois(server, api_options ) )
value = ReturnValue.get_value(result)
if self.options.raw:
# options and call_id when supported
api_options = {}
api_options['call_id']=unique_call_id()
+ if options.show_credential:
+ show_credentials(creds)
result = server.SliverStatus(slice_urn, creds, *self.ois(server,api_options))
value = ReturnValue.get_value(result)
if self.options.raw:
# options and call_id when supported
api_options = {}
api_options['call_id']=unique_call_id()
+ if options.show_credential:
+ show_credentials(creds)
result = server.RenewSliver(slice_urn, creds, input_time, *self.ois(server,api_options))
value = ReturnValue.get_value(result)
if self.options.raw:
-#----------------------------------------------------------------------\r
-# Copyright (c) 2008 Board of Trustees, Princeton University\r
-#\r
-# Permission is hereby granted, free of charge, to any person obtaining\r
-# a copy of this software and/or hardware specification (the "Work") to\r
-# deal in the Work without restriction, including without limitation the\r
-# rights to use, copy, modify, merge, publish, distribute, sublicense,\r
-# and/or sell copies of the Work, and to permit persons to whom the Work\r
-# is furnished to do so, subject to the following conditions:\r
-#\r
-# The above copyright notice and this permission notice shall be\r
-# included in all copies or substantial portions of the Work.\r
-#\r
-# THE WORK IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS \r
-# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF \r
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND \r
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT \r
-# HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, \r
-# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, \r
-# OUT OF OR IN CONNECTION WITH THE WORK OR THE USE OR OTHER DEALINGS \r
-# IN THE WORK.\r
-#----------------------------------------------------------------------\r
-##\r
-# Implements SFA GID. GIDs are based on certificates, and the GID class is a\r
-# descendant of the certificate class.\r
-##\r
-\r
-import xmlrpclib\r
-import uuid\r
-\r
-from sfa.trust.certificate import Certificate\r
-\r
-from sfa.util.faults import GidInvalidParentHrn, GidParentHrn\r
-from sfa.util.sfalogging import logger\r
-from sfa.util.xrn import hrn_to_urn, urn_to_hrn, hrn_authfor_hrn\r
-\r
-##\r
-# Create a new uuid. Returns the UUID as a string.\r
-\r
-def create_uuid():\r
- return str(uuid.uuid4().int)\r
-\r
-##\r
-# GID is a tuple:\r
-# (uuid, urn, public_key)\r
-#\r
-# UUID is a unique identifier and is created by the python uuid module\r
-# (or the utility function create_uuid() in gid.py).\r
-#\r
-# HRN is a human readable name. It is a dotted form similar to a backward domain\r
-# name. For example, planetlab.us.arizona.bakers.\r
-#\r
-# URN is a human readable identifier of form:\r
-# "urn:publicid:IDN+toplevelauthority[:sub-auth.]*[\res. type]\ +object name"\r
-# For example, urn:publicid:IDN+planetlab:us:arizona+user+bakers \r
-#\r
-# PUBLIC_KEY is the public key of the principal identified by the UUID/HRN.\r
-# It is a Keypair object as defined in the cert.py module.\r
-#\r
-# It is expected that there is a one-to-one pairing between UUIDs and HRN,\r
-# but it is uncertain how this would be inforced or if it needs to be enforced.\r
-#\r
-# These fields are encoded using xmlrpc into the subjectAltName field of the\r
-# x509 certificate. Note: Call encode() once the fields have been filled in\r
-# to perform this encoding.\r
-\r
-\r
-class GID(Certificate):\r
- uuid = None\r
- hrn = None\r
- urn = None\r
- email = None # for adding to the SubjectAltName\r
-\r
- ##\r
- # Create a new GID object\r
- #\r
- # @param create If true, create the X509 certificate\r
- # @param subject If subject!=None, create the X509 cert and set the subject name\r
- # @param string If string!=None, load the GID from a string\r
- # @param filename If filename!=None, load the GID from a file\r
- # @param lifeDays life of GID in days - default is 1825==5 years\r
-\r
- def __init__(self, create=False, subject=None, string=None, filename=None, uuid=None, hrn=None, urn=None, lifeDays=1825):\r
- \r
- Certificate.__init__(self, lifeDays, create, subject, string, filename)\r
- if subject:\r
- logger.debug("Creating GID for subject: %s" % subject)\r
- if uuid:\r
- self.uuid = int(uuid)\r
- if hrn:\r
- self.hrn = hrn\r
- self.urn = hrn_to_urn(hrn, 'unknown')\r
- if urn:\r
- self.urn = urn\r
- self.hrn, type = urn_to_hrn(urn)\r
-\r
- def set_uuid(self, uuid):\r
- if isinstance(uuid, str):\r
- self.uuid = int(uuid)\r
- else:\r
- self.uuid = uuid\r
-\r
- def get_uuid(self):\r
- if not self.uuid:\r
- self.decode()\r
- return self.uuid\r
-\r
- def set_hrn(self, hrn):\r
- self.hrn = hrn\r
-\r
- def get_hrn(self):\r
- if not self.hrn:\r
- self.decode()\r
- return self.hrn\r
-\r
- def set_urn(self, urn):\r
- self.urn = urn\r
- self.hrn, type = urn_to_hrn(urn)\r
- \r
- def get_urn(self):\r
- if not self.urn:\r
- self.decode()\r
- return self.urn \r
-\r
- # Will be stuffed into subjectAltName\r
- def set_email(self, email):\r
- self.email = email\r
-\r
- def get_email(self):\r
- if not self.email:\r
- self.decode()\r
- return self.email\r
-\r
- def get_type(self):\r
- if not self.urn:\r
- self.decode()\r
- _, t = urn_to_hrn(self.urn)\r
- return t\r
- \r
- ##\r
- # Encode the GID fields and package them into the subject-alt-name field\r
- # of the X509 certificate. This must be called prior to signing the\r
- # certificate. It may only be called once per certificate.\r
-\r
- def encode(self):\r
- if self.urn:\r
- urn = self.urn\r
- else:\r
- urn = hrn_to_urn(self.hrn, None)\r
- \r
- str = "URI:" + urn\r
-\r
- if self.uuid:\r
- str += ", " + "URI:" + uuid.UUID(int=self.uuid).urn\r
- \r
- if self.email:\r
- str += ", " + "email:" + self.email\r
-\r
- self.set_data(str, 'subjectAltName')\r
-\r
- \r
-\r
-\r
- ##\r
- # Decode the subject-alt-name field of the X509 certificate into the\r
- # fields of the GID. This is automatically called by the various get_*()\r
- # functions in this class.\r
-\r
- def decode(self):\r
- data = self.get_data('subjectAltName')\r
- dict = {}\r
- if data:\r
- if data.lower().startswith('uri:http://<params>'):\r
- dict = xmlrpclib.loads(data[11:])[0][0]\r
- else:\r
- spl = data.split(', ')\r
- for val in spl:\r
- if val.lower().startswith('uri:urn:uuid:'):\r
- dict['uuid'] = uuid.UUID(val[4:]).int\r
- elif val.lower().startswith('uri:urn:publicid:idn+'):\r
- dict['urn'] = val[4:]\r
- elif val.lower().startswith('email:'):\r
- # FIXME: Ensure there isn't cruft in that address...\r
- # EG look for email:copy,....\r
- dict['email'] = val[6:]\r
- \r
- self.uuid = dict.get("uuid", None)\r
- self.urn = dict.get("urn", None)\r
- self.hrn = dict.get("hrn", None)\r
- self.email = dict.get("email", None)\r
- if self.urn:\r
- self.hrn = urn_to_hrn(self.urn)[0]\r
-\r
- ##\r
- # Dump the credential to stdout.\r
- #\r
- # @param indent specifies a number of spaces to indent the output\r
- # @param dump_parents If true, also dump the parents of the GID\r
-\r
- def dump(self, *args, **kwargs):\r
- print self.dump_string(*args,**kwargs)\r
-\r
- def dump_string(self, indent=0, dump_parents=False):\r
- result=" "*(indent-2) + "GID\n"\r
- result += " "*indent + "hrn:" + str(self.get_hrn()) +"\n"\r
- result += " "*indent + "urn:" + str(self.get_urn()) +"\n"\r
- result += " "*indent + "uuid:" + str(self.get_uuid()) + "\n"\r
- if self.get_email() is not None:\r
- result += " "*indent + "email:" + str(self.get_email()) + "\n"\r
- filename=self.get_filename()\r
- if filename: result += "Filename %s\n"%filename\r
-\r
- if self.parent and dump_parents:\r
- result += " "*indent + "parent:\n"\r
- result += self.parent.dump_string(indent+4, dump_parents)\r
- return result\r
-\r
- ##\r
- # Verify the chain of authenticity of the GID. First perform the checks\r
- # of the certificate class (verifying that each parent signs the child,\r
- # etc). In addition, GIDs also confirm that the parent's HRN is a prefix\r
- # of the child's HRN, and the parent is of type 'authority'.\r
- #\r
- # Verifying these prefixes prevents a rogue authority from signing a GID\r
- # for a principal that is not a member of that authority. For example,\r
- # planetlab.us.arizona cannot sign a GID for planetlab.us.princeton.foo.\r
-\r
- def verify_chain(self, trusted_certs = None):\r
- # do the normal certificate verification stuff\r
- trusted_root = Certificate.verify_chain(self, trusted_certs) \r
- \r
- if self.parent:\r
- # make sure the parent's hrn is a prefix of the child's hrn\r
- if not hrn_authfor_hrn(self.parent.get_hrn(), self.get_hrn()):\r
- raise GidParentHrn("This cert HRN %s isn't in the namespace for parent HRN %s" % (self.get_hrn(), self.parent.get_hrn()))\r
-\r
- # Parent must also be an authority (of some type) to sign a GID\r
- # There are multiple types of authority - accept them all here\r
- if not self.parent.get_type().find('authority') == 0:\r
- raise GidInvalidParentHrn("This cert %s's parent %s is not an authority (is a %s)" % (self.get_hrn(), self.parent.get_hrn(), self.parent.get_type()))\r
-\r
- # Then recurse up the chain - ensure the parent is a trusted\r
- # root or is in the namespace of a trusted root\r
- self.parent.verify_chain(trusted_certs)\r
- else:\r
- # make sure that the trusted root's hrn is a prefix of the child's\r
- trusted_gid = GID(string=trusted_root.save_to_string())\r
- trusted_type = trusted_gid.get_type()\r
- trusted_hrn = trusted_gid.get_hrn()\r
- #if trusted_type == 'authority':\r
- # trusted_hrn = trusted_hrn[:trusted_hrn.rindex('.')]\r
- cur_hrn = self.get_hrn()\r
- if not hrn_authfor_hrn(trusted_hrn, cur_hrn):\r
- raise GidParentHrn("Trusted root with HRN %s isn't a namespace authority for this cert %s" % (trusted_hrn, cur_hrn))\r
-\r
- # There are multiple types of authority - accept them all here\r
- if not trusted_type.find('authority') == 0:\r
- raise GidInvalidParentHrn("This cert %s's trusted root signer %s is not an authority (is a %s)" % (self.get_hrn(), trusted_hrn, trusted_type))\r
-\r
- return\r
+#----------------------------------------------------------------------
+# Copyright (c) 2008 Board of Trustees, Princeton University
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and/or hardware specification (the "Work") to
+# deal in the Work without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense,
+# and/or sell copies of the Work, and to permit persons to whom the Work
+# is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Work.
+#
+# THE WORK IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+# OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+# HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+# WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE WORK OR THE USE OR OTHER DEALINGS
+# IN THE WORK.
+#----------------------------------------------------------------------
+##
+# Implements SFA GID. GIDs are based on certificates, and the GID class is a
+# descendant of the certificate class.
+##
+
+import xmlrpclib
+import uuid
+
+from sfa.trust.certificate import Certificate
+
+from sfa.util.faults import GidInvalidParentHrn, GidParentHrn
+from sfa.util.sfalogging import logger
+from sfa.util.xrn import hrn_to_urn, urn_to_hrn, hrn_authfor_hrn
+
+##
+# Create a new uuid. Returns the UUID as a string.
+
+def create_uuid():
+ return str(uuid.uuid4().int)
+
+##
+# GID is a tuple:
+# (uuid, urn, public_key)
+#
+# UUID is a unique identifier and is created by the python uuid module
+# (or the utility function create_uuid() in gid.py).
+#
+# HRN is a human readable name. It is a dotted form similar to a backward domain
+# name. For example, planetlab.us.arizona.bakers.
+#
+# URN is a human readable identifier of form:
+# "urn:publicid:IDN+toplevelauthority[:sub-auth.]*[\res. type]\ +object name"
+# For example, urn:publicid:IDN+planetlab:us:arizona+user+bakers
+#
+# PUBLIC_KEY is the public key of the principal identified by the UUID/HRN.
+# It is a Keypair object as defined in the cert.py module.
+#
+# It is expected that there is a one-to-one pairing between UUIDs and HRN,
+# but it is uncertain how this would be inforced or if it needs to be enforced.
+#
+# These fields are encoded using xmlrpc into the subjectAltName field of the
+# x509 certificate. Note: Call encode() once the fields have been filled in
+# to perform this encoding.
+
+
+class GID(Certificate):
+ uuid = None
+ hrn = None
+ urn = None
+ email = None # for adding to the SubjectAltName
+
+ ##
+ # Create a new GID object
+ #
+ # @param create If true, create the X509 certificate
+ # @param subject If subject!=None, create the X509 cert and set the subject name
+ # @param string If string!=None, load the GID from a string
+ # @param filename If filename!=None, load the GID from a file
+ # @param lifeDays life of GID in days - default is 1825==5 years
+
+ def __init__(self, create=False, subject=None, string=None, filename=None, uuid=None, hrn=None, urn=None, lifeDays=1825):
+
+ Certificate.__init__(self, lifeDays, create, subject, string, filename)
+ if subject:
+ logger.debug("Creating GID for subject: %s" % subject)
+ if uuid:
+ self.uuid = int(uuid)
+ if hrn:
+ self.hrn = hrn
+ self.urn = hrn_to_urn(hrn, 'unknown')
+ if urn:
+ self.urn = urn
+ self.hrn, type = urn_to_hrn(urn)
+
+ def set_uuid(self, uuid):
+ if isinstance(uuid, str):
+ self.uuid = int(uuid)
+ else:
+ self.uuid = uuid
+
+ def get_uuid(self):
+ if not self.uuid:
+ self.decode()
+ return self.uuid
+
+ def set_hrn(self, hrn):
+ self.hrn = hrn
+
+ def get_hrn(self):
+ if not self.hrn:
+ self.decode()
+ return self.hrn
+
+ def set_urn(self, urn):
+ self.urn = urn
+ self.hrn, type = urn_to_hrn(urn)
+
+ def get_urn(self):
+ if not self.urn:
+ self.decode()
+ return self.urn
+
+ # Will be stuffed into subjectAltName
+ def set_email(self, email):
+ self.email = email
+
+ def get_email(self):
+ if not self.email:
+ self.decode()
+ return self.email
+
+ def get_type(self):
+ if not self.urn:
+ self.decode()
+ _, t = urn_to_hrn(self.urn)
+ return t
+
+ ##
+ # Encode the GID fields and package them into the subject-alt-name field
+ # of the X509 certificate. This must be called prior to signing the
+ # certificate. It may only be called once per certificate.
+
+ def encode(self):
+ if self.urn:
+ urn = self.urn
+ else:
+ urn = hrn_to_urn(self.hrn, None)
+
+ str = "URI:" + urn
+
+ if self.uuid:
+ str += ", " + "URI:" + uuid.UUID(int=self.uuid).urn
+
+ if self.email:
+ str += ", " + "email:" + self.email
+
+ self.set_data(str, 'subjectAltName')
+
+
+
+
+ ##
+ # Decode the subject-alt-name field of the X509 certificate into the
+ # fields of the GID. This is automatically called by the various get_*()
+ # functions in this class.
+
+ def decode(self):
+ data = self.get_data('subjectAltName')
+ dict = {}
+ if data:
+ if data.lower().startswith('uri:http://<params>'):
+ dict = xmlrpclib.loads(data[11:])[0][0]
+ else:
+ spl = data.split(', ')
+ for val in spl:
+ if val.lower().startswith('uri:urn:uuid:'):
+ dict['uuid'] = uuid.UUID(val[4:]).int
+ elif val.lower().startswith('uri:urn:publicid:idn+'):
+ dict['urn'] = val[4:]
+ elif val.lower().startswith('email:'):
+ # FIXME: Ensure there isn't cruft in that address...
+ # EG look for email:copy,....
+ dict['email'] = val[6:]
+
+ self.uuid = dict.get("uuid", None)
+ self.urn = dict.get("urn", None)
+ self.hrn = dict.get("hrn", None)
+ self.email = dict.get("email", None)
+ if self.urn:
+ self.hrn = urn_to_hrn(self.urn)[0]
+
+ ##
+ # Dump the credential to stdout.
+ #
+ # @param indent specifies a number of spaces to indent the output
+ # @param dump_parents If true, also dump the parents of the GID
+
+ def dump(self, *args, **kwargs):
+ print self.dump_string(*args,**kwargs)
+
+ def dump_string(self, indent=0, dump_parents=False):
+ result=" "*(indent-2) + "GID\n"
+ result += " "*indent + "hrn:" + str(self.get_hrn()) +"\n"
+ result += " "*indent + "urn:" + str(self.get_urn()) +"\n"
+ result += " "*indent + "uuid:" + str(self.get_uuid()) + "\n"
+ if self.get_email() is not None:
+ result += " "*indent + "email:" + str(self.get_email()) + "\n"
+ filename=self.get_filename()
+ if filename: result += "Filename %s\n"%filename
+
+ if self.parent and dump_parents:
+ result += " "*indent + "parent:\n"
+ result += self.parent.dump_string(indent+4, dump_parents)
+ return result
+
+ ##
+ # Verify the chain of authenticity of the GID. First perform the checks
+ # of the certificate class (verifying that each parent signs the child,
+ # etc). In addition, GIDs also confirm that the parent's HRN is a prefix
+ # of the child's HRN, and the parent is of type 'authority'.
+ #
+ # Verifying these prefixes prevents a rogue authority from signing a GID
+ # for a principal that is not a member of that authority. For example,
+ # planetlab.us.arizona cannot sign a GID for planetlab.us.princeton.foo.
+
+ def verify_chain(self, trusted_certs = None):
+ # do the normal certificate verification stuff
+ trusted_root = Certificate.verify_chain(self, trusted_certs)
+
+ if self.parent:
+ # make sure the parent's hrn is a prefix of the child's hrn
+ if not hrn_authfor_hrn(self.parent.get_hrn(), self.get_hrn()):
+ raise GidParentHrn("This cert HRN %s isn't in the namespace for parent HRN %s" % (self.get_hrn(), self.parent.get_hrn()))
+
+ # Parent must also be an authority (of some type) to sign a GID
+ # There are multiple types of authority - accept them all here
+ if not self.parent.get_type().find('authority') == 0:
+ raise GidInvalidParentHrn("This cert %s's parent %s is not an authority (is a %s)" % (self.get_hrn(), self.parent.get_hrn(), self.parent.get_type()))
+
+ # Then recurse up the chain - ensure the parent is a trusted
+ # root or is in the namespace of a trusted root
+ self.parent.verify_chain(trusted_certs)
+ else:
+ # make sure that the trusted root's hrn is a prefix of the child's
+ trusted_gid = GID(string=trusted_root.save_to_string())
+ trusted_type = trusted_gid.get_type()
+ trusted_hrn = trusted_gid.get_hrn()
+ #if trusted_type == 'authority':
+ # trusted_hrn = trusted_hrn[:trusted_hrn.rindex('.')]
+ cur_hrn = self.get_hrn()
+ if not hrn_authfor_hrn(trusted_hrn, cur_hrn):
+ raise GidParentHrn("Trusted root with HRN %s isn't a namespace authority for this cert %s" % (trusted_hrn, cur_hrn))
+
+ # There are multiple types of authority - accept them all here
+ if not trusted_type.find('authority') == 0:
+ raise GidInvalidParentHrn("This cert %s's trusted root signer %s is not an authority (is a %s)" % (self.get_hrn(), trusted_hrn, trusted_type))
+
+ return