sfa/trust/credential_legacy.py

   1 #----------------------------------------------------------------------
   2 # Copyright (c) 2008 Board of Trustees, Princeton University
   3 #
   4 # Permission is hereby granted, free of charge, to any person obtaining
   5 # a copy of this software and/or hardware specification (the "Work") to
   6 # deal in the Work without restriction, including without limitation the
   7 # rights to use, copy, modify, merge, publish, distribute, sublicense,
   8 # and/or sell copies of the Work, and to permit persons to whom the Work
   9 # is furnished to do so, subject to the following conditions:
  10 #
  11 # The above copyright notice and this permission notice shall be
  12 # included in all copies or substantial portions of the Work.
  13 #
  14 # THE WORK IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  15 # OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  16 # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  17 # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  18 # HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  19 # WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  20 # OUT OF OR IN CONNECTION WITH THE WORK OR THE USE OR OTHER DEALINGS
  21 # IN THE WORK.
  22 #----------------------------------------------------------------------
  23 ##
  24 # Implements SFA Credentials
  25 #
  26 # Credentials are layered on top of certificates, and are essentially a
  27 # certificate that stores a tuple of parameters.
  28 ##
  29
  30
  31 import xmlrpclib
  32
  33 from sfa.util.faults import MissingDelegateBit, ChildRightsNotSubsetOfParent
  34 from sfa.trust.certificate import Certificate
  35 from sfa.trust.gid import GID
  36
  37 ##
  38 # Credential is a tuple:
  39 #     (GIDCaller, GIDObject, LifeTime, Privileges, Delegate)
  40 #
  41 # These fields are encoded using xmlrpc into the subjectAltName field of the
  42 # x509 certificate. Note: Call encode() once the fields have been filled in
  43 # to perform this encoding.
  44
  45 class CredentialLegacy(Certificate):
  46     gidCaller = None
  47     gidObject = None
  48     lifeTime = None
  49     privileges = None
  50     delegate = False
  51
  52     ##
  53     # Create a Credential object
  54     #
  55     # @param create If true, create a blank x509 certificate
  56     # @param subject If subject!=None, create an x509 cert with the subject name
  57     # @param string If string!=None, load the credential from the string
  58     # @param filename If filename!=None, load the credential from the file
  59
  60     def __init__(self, create=False, subject=None, string=None, filename=None):
  61         Certificate.__init__(self, create, subject, string, filename)
  62
  63     ##
  64     # set the GID of the caller
  65     #
  66     # @param gid GID object of the caller
  67
  68     def set_gid_caller(self, gid):
  69         self.gidCaller = gid
  70         # gid origin caller is the caller's gid by default
  71         self.gidOriginCaller = gid
  72
  73     ##
  74     # get the GID of the object
  75
  76     def get_gid_caller(self):
  77         if not self.gidCaller:
  78             self.decode()
  79         return self.gidCaller
  80
  81     ##
  82     # set the GID of the object
  83     #
  84     # @param gid GID object of the object
  85
  86     def set_gid_object(self, gid):
  87         self.gidObject = gid
  88
  89     ##
  90     # get the GID of the object
  91
  92     def get_gid_object(self):
  93         if not self.gidObject:
  94             self.decode()
  95         return self.gidObject
  96
  97     ##
  98     # set the lifetime of this credential
  99     #
 100     # @param lifetime lifetime of credential
 101
 102     def set_lifetime(self, lifeTime):
 103         self.lifeTime = lifeTime
 104
 105     ##
 106     # get the lifetime of the credential
 107
 108     def get_lifetime(self):
 109         if not self.lifeTime:
 110             self.decode()
 111         return self.lifeTime
 112
 113     ##
 114     # set the delegate bit
 115     #
 116     # @param delegate boolean (True or False)
 117
 118     def set_delegate(self, delegate):
 119         self.delegate = delegate
 120
 121     ##
 122     # get the delegate bit
 123
 124     def get_delegate(self):
 125         if not self.delegate:
 126             self.decode()
 127         return self.delegate
 128
 129     ##
 130     # set the privileges
 131     #
 132     # @param privs either a comma-separated list of privileges of a Rights object
 133
 134     def set_privileges(self, privs):
 135         if isinstance(privs, str):
 136             self.privileges = Rights(string = privs)
 137         else:
 138             self.privileges = privs
 139
 140     ##
 141     # return the privileges as a Rights object
 142
 143     def get_privileges(self):
 144         if not self.privileges:
 145             self.decode()
 146         return self.privileges
 147
 148     ##
 149     # determine whether the credential allows a particular operation to be
 150     # performed
 151     #
 152     # @param op_name string specifying name of operation ("lookup", "update", etc)
 153
 154     def can_perform(self, op_name):
 155         rights = self.get_privileges()
 156         if not rights:
 157             return False
 158         return rights.can_perform(op_name)
 159
 160     ##
 161     # Encode the attributes of the credential into a string and store that
 162     # string in the alt-subject-name field of the X509 object. This should be
 163     # done immediately before signing the credential.
 164
 165     def encode(self):
 166         dict = {"gidCaller": None,
 167                 "gidObject": None,
 168                 "lifeTime": self.lifeTime,
 169                 "privileges": None,
 170                 "delegate": self.delegate}
 171         if self.gidCaller:
 172             dict["gidCaller"] = self.gidCaller.save_to_string(save_parents=True)
 173         if self.gidObject:
 174             dict["gidObject"] = self.gidObject.save_to_string(save_parents=True)
 175         if self.privileges:
 176             dict["privileges"] = self.privileges.save_to_string()
 177         str = xmlrpclib.dumps((dict,), allow_none=True)
 178         self.set_data('URI:http://' + str)
 179
 180     ##
 181     # Retrieve the attributes of the credential from the alt-subject-name field
 182     # of the X509 certificate. This is automatically done by the various
 183     # get_* methods of this class and should not need to be called explicitly.
 184
 185     def decode(self):
 186         data = self.get_data().lstrip('URI:http://')
 187
 188         if data:
 189             dict = xmlrpclib.loads(data)[0][0]
 190         else:
 191             dict = {}
 192
 193         self.lifeTime = dict.get("lifeTime", None)
 194         self.delegate = dict.get("delegate", None)
 195
 196         privStr = dict.get("privileges", None)
 197         if privStr:
 198             self.privileges = Rights(string = privStr)
 199         else:
 200             self.privileges = None
 201
 202         gidCallerStr = dict.get("gidCaller", None)
 203         if gidCallerStr:
 204             self.gidCaller = GID(string=gidCallerStr)
 205         else:
 206             self.gidCaller = None
 207
 208         gidObjectStr = dict.get("gidObject", None)
 209         if gidObjectStr:
 210             self.gidObject = GID(string=gidObjectStr)
 211         else:
 212             self.gidObject = None
 213
 214     ##
 215     # Verify that a chain of credentials is valid (see cert.py:verify). In
 216     # addition to the checks for ordinary certificates, verification also
 217     # ensures that the delegate bit was set by each parent in the chain. If
 218     # a delegate bit was not set, then an exception is thrown.
 219     #
 220     # Each credential must be a subset of the rights of the parent.
 221
 222     def verify_chain(self, trusted_certs = None):
 223         # do the normal certificate verification stuff
 224         Certificate.verify_chain(self, trusted_certs)
 225
 226         if self.parent:
 227             # make sure the parent delegated rights to the child
 228             if not self.parent.get_delegate():
 229                 raise MissingDelegateBit(self.parent.get_subject())
 230
 231             # make sure the rights given to the child are a subset of the
 232             # parents rights
 233             if not self.parent.get_privileges().is_superset(self.get_privileges()):
 234                 raise ChildRightsNotSubsetOfParent(self.get_subject()
 235                                                    + " " + self.parent.get_privileges().save_to_string()
 236                                                    + " " + self.get_privileges().save_to_string())
 237
 238         return
 239
 240     ##
 241     # Dump the contents of a credential to stdout in human-readable format
 242     #
 243     # @param dump_parents If true, also dump the parent certificates
 244
 245     def dump(self, *args, **kwargs):
 246         print self.dump_string(*args,**kwargs)
 247
 248     def dump_string(self, dump_parents=False):
 249         result=""
 250         result += "CREDENTIAL %s\n" % self.get_subject()
 251
 252         result += "      privs: %s\n" % self.get_privileges().save_to_string()
 253
 254         gidCaller = self.get_gid_caller()
 255         if gidCaller:
 256             result += "  gidCaller:\n"
 257             gidCaller.dump(8, dump_parents)
 258
 259         gidObject = self.get_gid_object()
 260         if gidObject:
 261             result += "  gidObject:\n"
 262             result += gidObject.dump_string(8, dump_parents)
 263
 264         result += "   delegate: %s" % self.get_delegate()
 265
 266         if self.parent and dump_parents:
 267             result += "PARENT\n"
 268             result += self.parent.dump_string(dump_parents)
 269
 270         return result