import repository from arizona
[raven.git] / our-sfa-build / sfa / trust / credential_legacy.py
1 ##
2 # Implements SFA Credentials
3 #
4 # Credentials are layered on top of certificates, and are essentially a
5 # certificate that stores a tuple of parameters.
6 ##
7
8 ### $Id: credential.py 17477 2010-03-25 16:49:34Z jkarlin $
9 ### $URL: svn+ssh://svn.planet-lab.org/svn/sfa/branches/geni-api/sfa/trust/credential.py $
10
11 import xmlrpclib
12
13 from sfa.util.faults import *
14 from sfa.trust.certificate import Certificate
15 from sfa.trust.rights import Right,Rights
16 from sfa.trust.gid import GID
17
18 ##
19 # Credential is a tuple:
20 #     (GIDCaller, GIDObject, LifeTime, Privileges, Delegate)
21 #
22 # These fields are encoded using xmlrpc into the subjectAltName field of the
23 # x509 certificate. Note: Call encode() once the fields have been filled in
24 # to perform this encoding.
25
26 class CredentialLegacy(Certificate):
27     gidCaller = None
28     gidObject = None
29     lifeTime = None
30     privileges = None
31     delegate = False
32
33     ##
34     # Create a Credential object
35     #
36     # @param create If true, create a blank x509 certificate
37     # @param subject If subject!=None, create an x509 cert with the subject name
38     # @param string If string!=None, load the credential from the string
39     # @param filename If filename!=None, load the credential from the file
40
41     def __init__(self, create=False, subject=None, string=None, filename=None):
42         Certificate.__init__(self, create, subject, string, filename)
43
44     ##
45     # set the GID of the caller
46     #
47     # @param gid GID object of the caller
48
49     def set_gid_caller(self, gid):
50         self.gidCaller = gid
51         # gid origin caller is the caller's gid by default
52         self.gidOriginCaller = gid
53
54     ##
55     # get the GID of the object
56
57     def get_gid_caller(self):
58         if not self.gidCaller:
59             self.decode()
60         return self.gidCaller
61
62     ##
63     # set the GID of the object
64     #
65     # @param gid GID object of the object
66
67     def set_gid_object(self, gid):
68         self.gidObject = gid
69
70     ##
71     # get the GID of the object
72
73     def get_gid_object(self):
74         if not self.gidObject:
75             self.decode()
76         return self.gidObject
77
78     ##
79     # set the lifetime of this credential
80     #
81     # @param lifetime lifetime of credential
82
83     def set_lifetime(self, lifeTime):
84         self.lifeTime = lifeTime
85
86     ##
87     # get the lifetime of the credential
88
89     def get_lifetime(self):
90         if not self.lifeTime:
91             self.decode()
92         return self.lifeTime
93
94     ##
95     # set the delegate bit
96     #
97     # @param delegate boolean (True or False)
98
99     def set_delegate(self, delegate):
100         self.delegate = delegate
101
102     ##
103     # get the delegate bit
104
105     def get_delegate(self):
106         if not self.delegate:
107             self.decode()
108         return self.delegate
109
110     ##
111     # set the privileges
112     #
113     # @param privs either a comma-separated list of privileges of a Rights object
114
115     def set_privileges(self, privs):
116         if isinstance(privs, str):
117             self.privileges = Rights(string = privs)
118         else:
119             self.privileges = privs
120
121     ##
122     # return the privileges as a Rights object
123
124     def get_privileges(self):
125         if not self.privileges:
126             self.decode()
127         return self.privileges
128
129     ##
130     # determine whether the credential allows a particular operation to be
131     # performed
132     #
133     # @param op_name string specifying name of operation ("lookup", "update", etc)
134
135     def can_perform(self, op_name):
136         rights = self.get_privileges()
137         if not rights:
138             return False
139         return rights.can_perform(op_name)
140
141     ##
142     # Encode the attributes of the credential into a string and store that
143     # string in the alt-subject-name field of the X509 object. This should be
144     # done immediately before signing the credential.
145
146     def encode(self):
147         dict = {"gidCaller": None,
148                 "gidObject": None,
149                 "lifeTime": self.lifeTime,
150                 "privileges": None,
151                 "delegate": self.delegate}
152         if self.gidCaller:
153             dict["gidCaller"] = self.gidCaller.save_to_string(save_parents=True)
154         if self.gidObject:
155             dict["gidObject"] = self.gidObject.save_to_string(save_parents=True)
156         if self.privileges:
157             dict["privileges"] = self.privileges.save_to_string()
158         str = xmlrpclib.dumps((dict,), allow_none=True)
159         self.set_data('URI:http://' + str)
160
161     ##
162     # Retrieve the attributes of the credential from the alt-subject-name field
163     # of the X509 certificate. This is automatically done by the various
164     # get_* methods of this class and should not need to be called explicitly.
165
166     def decode(self):
167         data = self.get_data().lstrip('URI:http://')
168         
169         if data:
170             dict = xmlrpclib.loads(data)[0][0]
171         else:
172             dict = {}
173
174         self.lifeTime = dict.get("lifeTime", None)
175         self.delegate = dict.get("delegate", None)
176
177         privStr = dict.get("privileges", None)
178         if privStr:
179             self.privileges = Rights(string = privStr)
180         else:
181             self.privileges = None
182
183         gidCallerStr = dict.get("gidCaller", None)
184         if gidCallerStr:
185             self.gidCaller = GID(string=gidCallerStr)
186         else:
187             self.gidCaller = None
188
189         gidObjectStr = dict.get("gidObject", None)
190         if gidObjectStr:
191             self.gidObject = GID(string=gidObjectStr)
192         else:
193             self.gidObject = None
194
195     ##
196     # Verify that a chain of credentials is valid (see cert.py:verify). In
197     # addition to the checks for ordinary certificates, verification also
198     # ensures that the delegate bit was set by each parent in the chain. If
199     # a delegate bit was not set, then an exception is thrown.
200     #
201     # Each credential must be a subset of the rights of the parent.
202
203     def verify_chain(self, trusted_certs = None):
204         # do the normal certificate verification stuff
205         Certificate.verify_chain(self, trusted_certs)
206
207         if self.parent:
208             # make sure the parent delegated rights to the child
209             if not self.parent.get_delegate():
210                 raise MissingDelegateBit(self.parent.get_subject())
211
212             # make sure the rights given to the child are a subset of the
213             # parents rights
214             if not self.parent.get_privileges().is_superset(self.get_privileges()):
215                 raise ChildRightsNotSubsetOfParent(self.get_subject() 
216                                                    + " " + self.parent.get_privileges().save_to_string()
217                                                    + " " + self.get_privileges().save_to_string())
218
219         return
220
221     ##
222     # Dump the contents of a credential to stdout in human-readable format
223     #
224     # @param dump_parents If true, also dump the parent certificates
225
226     def dump(self, *args, **kwargs):
227         print self.dump_string(*args,**kwargs)
228
229     def dump_string(self, dump_parents=False):
230         result=""
231         result += "CREDENTIAL %s\n" % self.get_subject()
232
233         result += "      privs: %s\n" % self.get_privileges().save_to_string()
234
235         gidCaller = self.get_gid_caller()
236         if gidCaller:
237             result += "  gidCaller:\n"
238             gidCaller.dump(8, dump_parents)
239
240         gidObject = self.get_gid_object()
241         if gidObject:
242             result += "  gidObject:\n"
243             result += gidObject.dump_string(8, dump_parents)
244
245         result += "   delegate: %s" % self.get_delegate()
246
247         if self.parent and dump_parents:
248             result += "PARENT\n"
249             result += self.parent.dump_string(dump_parents)
250
251         return result