a little more robust against odd conditions
[sfa.git] / sfa / trust / credential.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 signed XML files that assign a subject gid privileges to an object gid
27 ##
28
29 import os
30 from types import StringTypes
31 import datetime
32 from StringIO import StringIO
33 from tempfile import mkstemp
34 from xml.dom.minidom import Document, parseString
35
36 HAVELXML = False
37 try:
38     from lxml import etree
39     HAVELXML = True
40 except:
41     pass
42
43 from xml.parsers.expat import ExpatError
44
45 from sfa.util.faults import CredentialNotVerifiable, ChildRightsNotSubsetOfParent
46 from sfa.util.sfalogging import logger
47 from sfa.util.sfatime import utcparse
48 from sfa.trust.rights import Right, Rights, determine_rights
49 from sfa.trust.gid import GID
50 from sfa.util.xrn import urn_to_hrn, hrn_authfor_hrn
51
52 # 31 days, in seconds 
53 DEFAULT_CREDENTIAL_LIFETIME = 86400 * 31
54
55
56 # TODO:
57 # . make privs match between PG and PL
58 # . Need to add support for other types of credentials, e.g. tickets
59 # . add namespaces to signed-credential element?
60
61 signature_template = \
62 '''
63 <Signature xml:id="Sig_%s" xmlns="http://www.w3.org/2000/09/xmldsig#">
64   <SignedInfo>
65     <CanonicalizationMethod Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315"/>
66     <SignatureMethod Algorithm="http://www.w3.org/2000/09/xmldsig#rsa-sha1"/>
67     <Reference URI="#%s">
68       <Transforms>
69         <Transform Algorithm="http://www.w3.org/2000/09/xmldsig#enveloped-signature" />
70       </Transforms>
71       <DigestMethod Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"/>
72       <DigestValue></DigestValue>
73     </Reference>
74   </SignedInfo>
75   <SignatureValue />
76   <KeyInfo>
77     <X509Data>
78       <X509SubjectName/>
79       <X509IssuerSerial/>
80       <X509Certificate/>
81     </X509Data>
82     <KeyValue />
83   </KeyInfo>
84 </Signature>
85 '''
86
87 # PG formats the template (whitespace) slightly differently.
88 # Note that they don't include the xmlns in the template, but add it later.
89 # Otherwise the two are equivalent.
90 #signature_template_as_in_pg = \
91 #'''
92 #<Signature xml:id="Sig_%s" >
93 # <SignedInfo>
94 #  <CanonicalizationMethod      Algorithm="http://www.w3.org/TR/2001/REC-xml-c14n-20010315"/>
95 #  <SignatureMethod      Algorithm="http://www.w3.org/2000/09/xmldsig#rsa-sha1"/>
96 #  <Reference URI="#%s">
97 #    <Transforms>
98 #      <Transform         Algorithm="http://www.w3.org/2000/09/xmldsig#enveloped-signature" />
99 #    </Transforms>
100 #    <DigestMethod        Algorithm="http://www.w3.org/2000/09/xmldsig#sha1"/>
101 #    <DigestValue></DigestValue>
102 #    </Reference>
103 # </SignedInfo>
104 # <SignatureValue />
105 # <KeyInfo>
106 #  <X509Data >
107 #   <X509SubjectName/>
108 #   <X509IssuerSerial/>
109 #   <X509Certificate/>
110 #  </X509Data>
111 #  <KeyValue />
112 # </KeyInfo>
113 #</Signature>
114 #'''
115
116 ##
117 # Convert a string into a bool
118 # used to convert an xsd:boolean to a Python boolean
119 def str2bool(str):
120     if str.lower() in ['true','1']:
121         return True
122     return False
123
124
125 ##
126 # Utility function to get the text of an XML element
127
128 def getTextNode(element, subele):
129     sub = element.getElementsByTagName(subele)[0]
130     if len(sub.childNodes) > 0:            
131         return sub.childNodes[0].nodeValue
132     else:
133         return None
134         
135 ##
136 # Utility function to set the text of an XML element
137 # It creates the element, adds the text to it,
138 # and then appends it to the parent.
139
140 def append_sub(doc, parent, element, text):
141     ele = doc.createElement(element)
142     ele.appendChild(doc.createTextNode(text))
143     parent.appendChild(ele)
144
145 ##
146 # Signature contains information about an xmlsec1 signature
147 # for a signed-credential
148 #
149
150 class Signature(object):
151    
152     def __init__(self, string=None):
153         self.refid = None
154         self.issuer_gid = None
155         self.xml = None
156         if string:
157             self.xml = string
158             self.decode()
159
160
161     def get_refid(self):
162         if not self.refid:
163             self.decode()
164         return self.refid
165
166     def get_xml(self):
167         if not self.xml:
168             self.encode()
169         return self.xml
170
171     def set_refid(self, id):
172         self.refid = id
173
174     def get_issuer_gid(self):
175         if not self.gid:
176             self.decode()
177         return self.gid        
178
179     def set_issuer_gid(self, gid):
180         self.gid = gid
181
182     def decode(self):
183         try:
184             doc = parseString(self.xml)
185         except ExpatError,e:
186             logger.log_exc ("Failed to parse credential, %s"%self.xml)
187             raise
188         sig = doc.getElementsByTagName("Signature")[0]
189         self.set_refid(sig.getAttribute("xml:id").strip("Sig_"))
190         keyinfo = sig.getElementsByTagName("X509Data")[0]
191         szgid = getTextNode(keyinfo, "X509Certificate")
192         szgid = "-----BEGIN CERTIFICATE-----\n%s\n-----END CERTIFICATE-----" % szgid
193         self.set_issuer_gid(GID(string=szgid))        
194         
195     def encode(self):
196         self.xml = signature_template % (self.get_refid(), self.get_refid())
197
198 ##
199 # A credential provides a caller gid with privileges to an object gid.
200 # A signed credential is signed by the object's authority.
201 #
202 # Credentials are encoded in one of two ways. 
203 # The legacy style (now unsupported) places it in the subjectAltName of an X509 certificate.
204 # The new credentials are placed in signed XML.
205 #
206 # WARNING:
207 # In general, a signed credential obtained externally should
208 # not be changed else the signature is no longer valid.  So, once
209 # you have loaded an existing signed credential, do not call encode() or sign() on it.
210
211 def filter_creds_by_caller(creds, caller_hrn_list):
212         """
213         Returns a list of creds who's gid caller matches the
214         specified caller hrn
215         """
216         if not isinstance(creds, list): creds = [creds]
217         if not isinstance(caller_hrn_list, list): 
218             caller_hrn_list = [caller_hrn_list]
219         caller_creds = []
220         for cred in creds:
221             try:
222                 tmp_cred = Credential(string=cred)
223                 if tmp_cred.get_gid_caller().get_hrn() in caller_hrn_list:
224                     caller_creds.append(cred)
225             except: pass
226         return caller_creds
227
228 class Credential(object):
229
230     ##
231     # Create a Credential object
232     #
233     # @param create If true, create a blank x509 certificate
234     # @param subject If subject!=None, create an x509 cert with the subject name
235     # @param string If string!=None, load the credential from the string
236     # @param filename If filename!=None, load the credential from the file
237     # FIXME: create and subject are ignored!
238     def __init__(self, create=False, subject=None, string=None, filename=None, cred=None):
239         self.gidCaller = None
240         self.gidObject = None
241         self.expiration = None
242         self.privileges = None
243         self.issuer_privkey = None
244         self.issuer_gid = None
245         self.issuer_pubkey = None
246         self.parent = None
247         self.signature = None
248         self.xml = None
249         self.refid = None
250         self.type = None
251         self.version = None
252
253         if cred:
254             if isinstance(cred, StringTypes):
255                 string = cred
256                 self.type = 'geni_sfa'
257                 self.version = '1.0'
258             elif isinstance(cred, dict):
259                 string = cred['geni_value']
260                 self.type = cred['geni_type']
261                 self.version = cred['geni_version']
262                 
263
264         if string or filename:
265             if string:                
266                 str = string
267             elif filename:
268                 str = file(filename).read()
269                 
270             # if this is a legacy credential, write error and bail out
271             if isinstance (str, StringTypes) and str.strip().startswith("-----"):
272                 logger.error("Legacy credentials not supported any more - giving up with %s..."%str[:10])
273                 return
274             else:
275                 self.xml = str
276                 self.decode()
277
278         # Find an xmlsec1 path
279         self.xmlsec_path = ''
280         paths = ['/usr/bin','/usr/local/bin','/bin','/opt/bin','/opt/local/bin']
281         for path in paths:
282             if os.path.isfile(path + '/' + 'xmlsec1'):
283                 self.xmlsec_path = path + '/' + 'xmlsec1'
284                 break
285
286     def get_subject(self):
287         subject = ""
288         if not self.gidObject:
289             self.decode()
290         if self.gidObject:
291             subject = self.gidObject.get_printable_subject()
292         return subject
293
294     # sounds like this should be __repr__ instead ??
295     def get_summary_tostring(self):
296         if not self.gidObject:
297             self.decode()
298         obj = self.gidObject.get_printable_subject()
299         caller = self.gidCaller.get_printable_subject()
300         exp = self.get_expiration()
301         # Summarize the rights too? The issuer?
302         return "[ Grant %s rights on %s until %s ]" % (caller, obj, exp)
303
304     def get_signature(self):
305         if not self.signature:
306             self.decode()
307         return self.signature
308
309     def set_signature(self, sig):
310         self.signature = sig
311
312         
313     ##
314     # Need the issuer's private key and name
315     # @param key Keypair object containing the private key of the issuer
316     # @param gid GID of the issuing authority
317
318     def set_issuer_keys(self, privkey, gid):
319         self.issuer_privkey = privkey
320         self.issuer_gid = gid
321
322
323     ##
324     # Set this credential's parent
325     def set_parent(self, cred):
326         self.parent = cred
327         self.updateRefID()
328
329     ##
330     # set the GID of the caller
331     #
332     # @param gid GID object of the caller
333
334     def set_gid_caller(self, gid):
335         self.gidCaller = gid
336         # gid origin caller is the caller's gid by default
337         self.gidOriginCaller = gid
338
339     ##
340     # get the GID of the object
341
342     def get_gid_caller(self):
343         if not self.gidCaller:
344             self.decode()
345         return self.gidCaller
346
347     ##
348     # set the GID of the object
349     #
350     # @param gid GID object of the object
351
352     def set_gid_object(self, gid):
353         self.gidObject = gid
354
355     ##
356     # get the GID of the object
357
358     def get_gid_object(self):
359         if not self.gidObject:
360             self.decode()
361         return self.gidObject
362             
363     ##
364     # Expiration: an absolute UTC time of expiration (as either an int or string or datetime)
365     # 
366     def set_expiration(self, expiration):
367         if isinstance(expiration, (int, float)):
368             self.expiration = datetime.datetime.fromtimestamp(expiration)
369         elif isinstance (expiration, datetime.datetime):
370             self.expiration = expiration
371         elif isinstance (expiration, StringTypes):
372             self.expiration = utcparse (expiration)
373         else:
374             logger.error ("unexpected input type in Credential.set_expiration")
375
376
377     ##
378     # get the lifetime of the credential (always in datetime format)
379
380     def get_expiration(self):
381         if not self.expiration:
382             self.decode()
383         # at this point self.expiration is normalized as a datetime - DON'T call utcparse again
384         return self.expiration
385
386     ##
387     # set the privileges
388     #
389     # @param privs either a comma-separated list of privileges of a Rights object
390
391     def set_privileges(self, privs):
392         if isinstance(privs, str):
393             self.privileges = Rights(string = privs)
394         else:
395             self.privileges = privs        
396
397     ##
398     # return the privileges as a Rights object
399
400     def get_privileges(self):
401         if not self.privileges:
402             self.decode()
403         return self.privileges
404
405     ##
406     # determine whether the credential allows a particular operation to be
407     # performed
408     #
409     # @param op_name string specifying name of operation ("lookup", "update", etc)
410
411     def can_perform(self, op_name):
412         rights = self.get_privileges()
413         
414         if not rights:
415             return False
416
417         return rights.can_perform(op_name)
418
419
420     ##
421     # Encode the attributes of the credential into an XML string    
422     # This should be done immediately before signing the credential.    
423     # WARNING:
424     # In general, a signed credential obtained externally should
425     # not be changed else the signature is no longer valid.  So, once
426     # you have loaded an existing signed credential, do not call encode() or sign() on it.
427
428     def encode(self):
429         # Create the XML document
430         doc = Document()
431         signed_cred = doc.createElement("signed-credential")
432
433         # Declare namespaces
434         # Note that credential/policy.xsd are really the PG schemas
435         # in a PL namespace.
436         # Note that delegation of credentials between the 2 only really works
437         # cause those schemas are identical.
438         # Also note these PG schemas talk about PG tickets and CM policies.
439         signed_cred.setAttribute("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance")
440         signed_cred.setAttribute("xsi:noNamespaceSchemaLocation", "http://www.planet-lab.org/resources/sfa/credential.xsd")
441         signed_cred.setAttribute("xsi:schemaLocation", "http://www.planet-lab.org/resources/sfa/ext/policy/1 http://www.planet-lab.org/resources/sfa/ext/policy/1/policy.xsd")
442
443         # PG says for those last 2:
444        #signed_cred.setAttribute("xsi:noNamespaceSchemaLocation", "http://www.protogeni.net/resources/credential/credential.xsd")
445        # signed_cred.setAttribute("xsi:schemaLocation", "http://www.protogeni.net/resources/credential/ext/policy/1 http://www.protogeni.net/resources/credential/ext/policy/1/policy.xsd")
446
447         doc.appendChild(signed_cred)  
448         
449         # Fill in the <credential> bit        
450         cred = doc.createElement("credential")
451         cred.setAttribute("xml:id", self.get_refid())
452         signed_cred.appendChild(cred)
453         append_sub(doc, cred, "type", "privilege")
454         append_sub(doc, cred, "serial", "8")
455         append_sub(doc, cred, "owner_gid", self.gidCaller.save_to_string())
456         append_sub(doc, cred, "owner_urn", self.gidCaller.get_urn())
457         append_sub(doc, cred, "target_gid", self.gidObject.save_to_string())
458         append_sub(doc, cred, "target_urn", self.gidObject.get_urn())
459         append_sub(doc, cred, "uuid", "")
460         if not self.expiration:
461             self.set_expiration(datetime.datetime.utcnow() + datetime.timedelta(seconds=DEFAULT_CREDENTIAL_LIFETIME))
462         self.expiration = self.expiration.replace(microsecond=0)
463         append_sub(doc, cred, "expires", self.expiration.isoformat())
464         privileges = doc.createElement("privileges")
465         cred.appendChild(privileges)
466
467         if self.privileges:
468             rights = self.get_privileges()
469             for right in rights.rights:
470                 priv = doc.createElement("privilege")
471                 append_sub(doc, priv, "name", right.kind)
472                 append_sub(doc, priv, "can_delegate", str(right.delegate).lower())
473                 privileges.appendChild(priv)
474
475         # Add the parent credential if it exists
476         if self.parent:
477             sdoc = parseString(self.parent.get_xml())
478             # If the root node is a signed-credential (it should be), then
479             # get all its attributes and attach those to our signed_cred
480             # node.
481             # Specifically, PG and PLadd attributes for namespaces (which is reasonable),
482             # and we need to include those again here or else their signature
483             # no longer matches on the credential.
484             # We expect three of these, but here we copy them all:
485             #  signed_cred.setAttribute("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance")
486             # and from PG (PL is equivalent, as shown above):
487             #  signed_cred.setAttribute("xsi:noNamespaceSchemaLocation", "http://www.protogeni.net/resources/credential/credential.xsd")
488             #  signed_cred.setAttribute("xsi:schemaLocation", "http://www.protogeni.net/resources/credential/ext/policy/1 http://www.protogeni.net/resources/credential/ext/policy/1/policy.xsd")
489
490             # HOWEVER!
491             # PL now also declares these, with different URLs, so
492             # the code notices those attributes already existed with
493             # different values, and complains.
494             # This happens regularly on delegation now that PG and
495             # PL both declare the namespace with different URLs.
496             # If the content ever differs this is a problem,
497             # but for now it works - different URLs (values in the attributes)
498             # but the same actual schema, so using the PG schema
499             # on delegated-to-PL credentials works fine.
500
501             # Note: you could also not copy attributes
502             # which already exist. It appears that both PG and PL
503             # will actually validate a slicecred with a parent
504             # signed using PG namespaces and a child signed with PL
505             # namespaces over the whole thing. But I don't know
506             # if that is a bug in xmlsec1, an accident since
507             # the contents of the schemas are the same,
508             # or something else, but it seems odd. And this works.
509             parentRoot = sdoc.documentElement
510             if parentRoot.tagName == "signed-credential" and parentRoot.hasAttributes():
511                 for attrIx in range(0, parentRoot.attributes.length):
512                     attr = parentRoot.attributes.item(attrIx)
513                     # returns the old attribute of same name that was
514                     # on the credential
515                     # Below throws InUse exception if we forgot to clone the attribute first
516                     oldAttr = signed_cred.setAttributeNode(attr.cloneNode(True))
517                     if oldAttr and oldAttr.value != attr.value:
518                         msg = "Delegating cred from owner %s to %s over %s:\n - Replaced attribute %s value '%s' with '%s'" % (self.parent.gidCaller.get_urn(), self.gidCaller.get_urn(), self.gidObject.get_urn(), oldAttr.name, oldAttr.value, attr.value)
519                         logger.warn(msg)
520                         #raise CredentialNotVerifiable("Can't encode new valid delegated credential: %s" % msg)
521
522             p_cred = doc.importNode(sdoc.getElementsByTagName("credential")[0], True)
523             p = doc.createElement("parent")
524             p.appendChild(p_cred)
525             cred.appendChild(p)
526         # done handling parent credential
527
528         # Create the <signatures> tag
529         signatures = doc.createElement("signatures")
530         signed_cred.appendChild(signatures)
531
532         # Add any parent signatures
533         if self.parent:
534             for cur_cred in self.get_credential_list()[1:]:
535                 sdoc = parseString(cur_cred.get_signature().get_xml())
536                 ele = doc.importNode(sdoc.getElementsByTagName("Signature")[0], True)
537                 signatures.appendChild(ele)
538                 
539         # Get the finished product
540         self.xml = doc.toxml()
541
542
543     def save_to_random_tmp_file(self):       
544         fp, filename = mkstemp(suffix='cred', text=True)
545         fp = os.fdopen(fp, "w")
546         self.save_to_file(filename, save_parents=True, filep=fp)
547         return filename
548     
549     def save_to_file(self, filename, save_parents=True, filep=None):
550         if not self.xml:
551             self.encode()
552         if filep:
553             f = filep 
554         else:
555             f = open(filename, "w")
556         f.write(self.xml)
557         f.close()
558
559     def save_to_string(self, save_parents=True):
560         if not self.xml:
561             self.encode()
562         return self.xml
563
564     def get_refid(self):
565         if not self.refid:
566             self.refid = 'ref0'
567         return self.refid
568
569     def set_refid(self, rid):
570         self.refid = rid
571
572     ##
573     # Figure out what refids exist, and update this credential's id
574     # so that it doesn't clobber the others.  Returns the refids of
575     # the parents.
576     
577     def updateRefID(self):
578         if not self.parent:
579             self.set_refid('ref0')
580             return []
581         
582         refs = []
583
584         next_cred = self.parent
585         while next_cred:
586             refs.append(next_cred.get_refid())
587             if next_cred.parent:
588                 next_cred = next_cred.parent
589             else:
590                 next_cred = None
591
592         
593         # Find a unique refid for this credential
594         rid = self.get_refid()
595         while rid in refs:
596             val = int(rid[3:])
597             rid = "ref%d" % (val + 1)
598
599         # Set the new refid
600         self.set_refid(rid)
601
602         # Return the set of parent credential ref ids
603         return refs
604
605     def get_xml(self):
606         if not self.xml:
607             self.encode()
608         return self.xml
609
610     ##
611     # Sign the XML file created by encode()
612     #
613     # WARNING:
614     # In general, a signed credential obtained externally should
615     # not be changed else the signature is no longer valid.  So, once
616     # you have loaded an existing signed credential, do not call encode() or sign() on it.
617
618     def sign(self):
619         if not self.issuer_privkey or not self.issuer_gid:
620             return
621         doc = parseString(self.get_xml())
622         sigs = doc.getElementsByTagName("signatures")[0]
623
624         # Create the signature template to be signed
625         signature = Signature()
626         signature.set_refid(self.get_refid())
627         sdoc = parseString(signature.get_xml())        
628         sig_ele = doc.importNode(sdoc.getElementsByTagName("Signature")[0], True)
629         sigs.appendChild(sig_ele)
630
631         self.xml = doc.toxml()
632
633
634         # Split the issuer GID into multiple certificates if it's a chain
635         chain = GID(filename=self.issuer_gid)
636         gid_files = []
637         while chain:
638             gid_files.append(chain.save_to_random_tmp_file(False))
639             if chain.get_parent():
640                 chain = chain.get_parent()
641             else:
642                 chain = None
643
644
645         # Call out to xmlsec1 to sign it
646         ref = 'Sig_%s' % self.get_refid()
647         filename = self.save_to_random_tmp_file()
648         signed = os.popen('%s --sign --node-id "%s" --privkey-pem %s,%s %s' \
649                  % (self.xmlsec_path, ref, self.issuer_privkey, ",".join(gid_files), filename)).read()
650         os.remove(filename)
651
652         for gid_file in gid_files:
653             os.remove(gid_file)
654
655         self.xml = signed
656
657         # Update signatures
658         self.decode()       
659
660         
661     ##
662     # Retrieve the attributes of the credential from the XML.
663     # This is automatically called by the various get_* methods of
664     # this class and should not need to be called explicitly.
665
666     def decode(self):
667         if not self.xml:
668             return
669
670         doc = None
671         try:
672             doc = parseString(self.xml)
673         except ExpatError,e:
674             raise CredentialNotVerifiable("Malformed credential")
675         doc = parseString(self.xml)
676         sigs = []
677         signed_cred = doc.getElementsByTagName("signed-credential")
678
679         # Is this a signed-cred or just a cred?
680         if len(signed_cred) > 0:
681             creds = signed_cred[0].getElementsByTagName("credential")
682             signatures = signed_cred[0].getElementsByTagName("signatures")
683             if len(signatures) > 0:
684                 sigs = signatures[0].getElementsByTagName("Signature")
685         else:
686             creds = doc.getElementsByTagName("credential")
687         
688         if creds is None or len(creds) == 0:
689             # malformed cred file
690             raise CredentialNotVerifiable("Malformed XML: No credential tag found")
691
692         # Just take the first cred if there are more than one
693         cred = creds[0]
694
695         self.set_refid(cred.getAttribute("xml:id"))
696         self.set_expiration(utcparse(getTextNode(cred, "expires")))
697         self.gidCaller = GID(string=getTextNode(cred, "owner_gid"))
698         self.gidObject = GID(string=getTextNode(cred, "target_gid"))   
699
700
701         # Process privileges
702         privs = cred.getElementsByTagName("privileges")[0]
703         rlist = Rights()
704         for priv in privs.getElementsByTagName("privilege"):
705             kind = getTextNode(priv, "name")
706             deleg = str2bool(getTextNode(priv, "can_delegate"))
707             if kind == '*':
708                 # Convert * into the default privileges for the credential's type
709                 # Each inherits the delegatability from the * above
710                 _ , type = urn_to_hrn(self.gidObject.get_urn())
711                 rl = determine_rights(type, self.gidObject.get_urn())
712                 for r in rl.rights:
713                     r.delegate = deleg
714                     rlist.add(r)
715             else:
716                 rlist.add(Right(kind.strip(), deleg))
717         self.set_privileges(rlist)
718
719
720         # Is there a parent?
721         parent = cred.getElementsByTagName("parent")
722         if len(parent) > 0:
723             parent_doc = parent[0].getElementsByTagName("credential")[0]
724             parent_xml = parent_doc.toxml()
725             self.parent = Credential(string=parent_xml)
726             self.updateRefID()
727
728         # Assign the signatures to the credentials
729         for sig in sigs:
730             Sig = Signature(string=sig.toxml())
731
732             for cur_cred in self.get_credential_list():
733                 if cur_cred.get_refid() == Sig.get_refid():
734                     cur_cred.set_signature(Sig)
735                                     
736             
737     ##
738     # Verify
739     #   trusted_certs: A list of trusted GID filenames (not GID objects!) 
740     #                  Chaining is not supported within the GIDs by xmlsec1.
741     #
742     #   trusted_certs_required: Should usually be true. Set False means an
743     #                 empty list of trusted_certs would still let this method pass.
744     #                 It just skips xmlsec1 verification et al. Only used by some utils
745     #    
746     # Verify that:
747     # . All of the signatures are valid and that the issuers trace back
748     #   to trusted roots (performed by xmlsec1)
749     # . The XML matches the credential schema
750     # . That the issuer of the credential is the authority in the target's urn
751     #    . In the case of a delegated credential, this must be true of the root
752     # . That all of the gids presented in the credential are valid
753     #    . Including verifying GID chains, and includ the issuer
754     # . The credential is not expired
755     #
756     # -- For Delegates (credentials with parents)
757     # . The privileges must be a subset of the parent credentials
758     # . The privileges must have "can_delegate" set for each delegated privilege
759     # . The target gid must be the same between child and parents
760     # . The expiry time on the child must be no later than the parent
761     # . The signer of the child must be the owner of the parent
762     #
763     # -- Verify does *NOT*
764     # . ensure that an xmlrpc client's gid matches a credential gid, that
765     #   must be done elsewhere
766     #
767     # @param trusted_certs: The certificates of trusted CA certificates
768     def verify(self, trusted_certs=None, schema=None, trusted_certs_required=True):
769         if not self.xml:
770             self.decode()
771
772         # validate against RelaxNG schema
773         if HAVELXML:
774             if schema and os.path.exists(schema):
775                 tree = etree.parse(StringIO(self.xml))
776                 schema_doc = etree.parse(schema)
777                 xmlschema = etree.XMLSchema(schema_doc)
778                 if not xmlschema.validate(tree):
779                     error = xmlschema.error_log.last_error
780                     message = "%s: %s (line %s)" % (self.get_summary_tostring(), error.message, error.line)
781                     raise CredentialNotVerifiable(message)
782
783         if trusted_certs_required and trusted_certs is None:
784             trusted_certs = []
785
786 #        trusted_cert_objects = [GID(filename=f) for f in trusted_certs]
787         trusted_cert_objects = []
788         ok_trusted_certs = []
789         # If caller explicitly passed in None that means skip cert chain validation.
790         # Strange and not typical
791         if trusted_certs is not None:
792             for f in trusted_certs:
793                 try:
794                     # Failures here include unreadable files
795                     # or non PEM files
796                     trusted_cert_objects.append(GID(filename=f))
797                     ok_trusted_certs.append(f)
798                 except Exception, exc:
799                     logger.error("Failed to load trusted cert from %s: %r"%( f, exc))
800             trusted_certs = ok_trusted_certs
801
802         # make sure it is not expired
803         if self.get_expiration() < datetime.datetime.utcnow():
804             raise CredentialNotVerifiable("Credential %s expired at %s" % (self.get_summary_tostring(), self.expiration.isoformat()))
805
806         # Verify the signatures
807         filename = self.save_to_random_tmp_file()
808         if trusted_certs is not None:
809             cert_args = " ".join(['--trusted-pem %s' % x for x in trusted_certs])
810
811         # If caller explicitly passed in None that means skip cert chain validation.
812         # - Strange and not typical
813         if trusted_certs is not None:
814             # Verify the gids of this cred and of its parents
815             for cur_cred in self.get_credential_list():
816                 cur_cred.get_gid_object().verify_chain(trusted_cert_objects)
817                 cur_cred.get_gid_caller().verify_chain(trusted_cert_objects)
818
819         refs = []
820         refs.append("Sig_%s" % self.get_refid())
821
822         parentRefs = self.updateRefID()
823         for ref in parentRefs:
824             refs.append("Sig_%s" % ref)
825
826         for ref in refs:
827             # If caller explicitly passed in None that means skip xmlsec1 validation.
828             # Strange and not typical
829             if trusted_certs is None:
830                 break
831
832 #            print "Doing %s --verify --node-id '%s' %s %s 2>&1" % \
833 #                (self.xmlsec_path, ref, cert_args, filename)
834             verified = os.popen('%s --verify --node-id "%s" %s %s 2>&1' \
835                             % (self.xmlsec_path, ref, cert_args, filename)).read()
836             if not verified.strip().startswith("OK"):
837                 # xmlsec errors have a msg= which is the interesting bit.
838                 mstart = verified.find("msg=")
839                 msg = ""
840                 if mstart > -1 and len(verified) > 4:
841                     mstart = mstart + 4
842                     mend = verified.find('\\', mstart)
843                     msg = verified[mstart:mend]
844                 raise CredentialNotVerifiable("xmlsec1 error verifying cred %s using Signature ID %s: %s %s" % (self.get_summary_tostring(), ref, msg, verified.strip()))
845         os.remove(filename)
846
847         # Verify the parents (delegation)
848         if self.parent:
849             self.verify_parent(self.parent)
850
851         # Make sure the issuer is the target's authority, and is
852         # itself a valid GID
853         self.verify_issuer(trusted_cert_objects)
854         return True
855
856     ##
857     # Creates a list of the credential and its parents, with the root 
858     # (original delegated credential) as the last item in the list
859     def get_credential_list(self):    
860         cur_cred = self
861         list = []
862         while cur_cred:
863             list.append(cur_cred)
864             if cur_cred.parent:
865                 cur_cred = cur_cred.parent
866             else:
867                 cur_cred = None
868         return list
869     
870     ##
871     # Make sure the credential's target gid (a) was signed by or (b)
872     # is the same as the entity that signed the original credential,
873     # or (c) is an authority over the target's namespace.
874     # Also ensure that the credential issuer / signer itself has a valid
875     # GID signature chain (signed by an authority with namespace rights).
876     def verify_issuer(self, trusted_gids):
877         root_cred = self.get_credential_list()[-1]
878         root_target_gid = root_cred.get_gid_object()
879         root_cred_signer = root_cred.get_signature().get_issuer_gid()
880
881         # Case 1:
882         # Allow non authority to sign target and cred about target.
883         #
884         # Why do we need to allow non authorities to sign?
885         # If in the target gid validation step we correctly
886         # checked that the target is only signed by an authority,
887         # then this is just a special case of case 3.
888         # This short-circuit is the common case currently -
889         # and cause GID validation doesn't check 'authority',
890         # this allows users to generate valid slice credentials.
891         if root_target_gid.is_signed_by_cert(root_cred_signer):
892             # cred signer matches target signer, return success
893             return
894
895         # Case 2:
896         # Allow someone to sign credential about themeselves. Used?
897         # If not, remove this.
898         #root_target_gid_str = root_target_gid.save_to_string()
899         #root_cred_signer_str = root_cred_signer.save_to_string()
900         #if root_target_gid_str == root_cred_signer_str:
901         #    # cred signer is target, return success
902         #    return
903
904         # Case 3:
905
906         # root_cred_signer is not the target_gid
907         # So this is a different gid that we have not verified.
908         # xmlsec1 verified the cert chain on this already, but
909         # it hasn't verified that the gid meets the HRN namespace
910         # requirements.
911         # Below we'll ensure that it is an authority.
912         # But we haven't verified that it is _signed by_ an authority
913         # We also don't know if xmlsec1 requires that cert signers
914         # are marked as CAs.
915
916         # Note that if verify() gave us no trusted_gids then this
917         # call will fail. So skip it if we have no trusted_gids
918         if trusted_gids and len(trusted_gids) > 0:
919             root_cred_signer.verify_chain(trusted_gids)
920         else:
921             logger.debug("No trusted gids. Cannot verify that cred signer is signed by a trusted authority. Skipping that check.")
922
923         # See if the signer is an authority over the domain of the target.
924         # There are multiple types of authority - accept them all here
925         # Maybe should be (hrn, type) = urn_to_hrn(root_cred_signer.get_urn())
926         root_cred_signer_type = root_cred_signer.get_type()
927         if (root_cred_signer_type.find('authority') == 0):
928             #logger.debug('Cred signer is an authority')
929             # signer is an authority, see if target is in authority's domain
930             signerhrn = root_cred_signer.get_hrn()
931             if hrn_authfor_hrn(signerhrn, root_target_gid.get_hrn()):
932                 return
933
934         # We've required that the credential be signed by an authority
935         # for that domain. Reasonable and probably correct.
936         # A looser model would also allow the signer to be an authority
937         # in my control framework - eg My CA or CH. Even if it is not
938         # the CH that issued these, eg, user credentials.
939
940         # Give up, credential does not pass issuer verification
941
942         raise CredentialNotVerifiable("Could not verify credential owned by %s for object %s. Cred signer %s not the trusted authority for Cred target %s" % (self.gidCaller.get_urn(), self.gidObject.get_urn(), root_cred_signer.get_hrn(), root_target_gid.get_hrn()))
943
944
945     ##
946     # -- For Delegates (credentials with parents) verify that:
947     # . The privileges must be a subset of the parent credentials
948     # . The privileges must have "can_delegate" set for each delegated privilege
949     # . The target gid must be the same between child and parents
950     # . The expiry time on the child must be no later than the parent
951     # . The signer of the child must be the owner of the parent        
952     def verify_parent(self, parent_cred):
953         # make sure the rights given to the child are a subset of the
954         # parents rights (and check delegate bits)
955         if not parent_cred.get_privileges().is_superset(self.get_privileges()):
956             raise ChildRightsNotSubsetOfParent(("Parent cred ref %s rights " % parent_cred.get_refid()) +
957                 self.parent.get_privileges().save_to_string() + (" not superset of delegated cred %s ref %s rights " % (self.get_summary_tostring(), self.get_refid())) +
958                 self.get_privileges().save_to_string())
959
960         # make sure my target gid is the same as the parent's
961         if not parent_cred.get_gid_object().save_to_string() == \
962            self.get_gid_object().save_to_string():
963             raise CredentialNotVerifiable("Delegated cred %s: Target gid not equal between parent and child. Parent %s" % (self.get_summary_tostring(), parent_cred.get_summary_tostring()))
964
965         # make sure my expiry time is <= my parent's
966         if not parent_cred.get_expiration() >= self.get_expiration():
967             raise CredentialNotVerifiable("Delegated credential %s expires after parent %s" % (self.get_summary_tostring(), parent_cred.get_summary_tostring()))
968
969         # make sure my signer is the parent's caller
970         if not parent_cred.get_gid_caller().save_to_string(False) == \
971            self.get_signature().get_issuer_gid().save_to_string(False):
972             raise CredentialNotVerifiable("Delegated credential %s not signed by parent %s's caller" % (self.get_summary_tostring(), parent_cred.get_summary_tostring()))
973                 
974         # Recurse
975         if parent_cred.parent:
976             parent_cred.verify_parent(parent_cred.parent)
977
978
979     def delegate(self, delegee_gidfile, caller_keyfile, caller_gidfile):
980         """
981         Return a delegated copy of this credential, delegated to the 
982         specified gid's user.    
983         """
984         # get the gid of the object we are delegating
985         object_gid = self.get_gid_object()
986         object_hrn = object_gid.get_hrn()        
987  
988         # the hrn of the user who will be delegated to
989         delegee_gid = GID(filename=delegee_gidfile)
990         delegee_hrn = delegee_gid.get_hrn()
991   
992         #user_key = Keypair(filename=keyfile)
993         #user_hrn = self.get_gid_caller().get_hrn()
994         subject_string = "%s delegated to %s" % (object_hrn, delegee_hrn)
995         dcred = Credential(subject=subject_string)
996         dcred.set_gid_caller(delegee_gid)
997         dcred.set_gid_object(object_gid)
998         dcred.set_parent(self)
999         dcred.set_expiration(self.get_expiration())
1000         dcred.set_privileges(self.get_privileges())
1001         dcred.get_privileges().delegate_all_privileges(True)
1002         #dcred.set_issuer_keys(keyfile, delegee_gidfile)
1003         dcred.set_issuer_keys(caller_keyfile, caller_gidfile)
1004         dcred.encode()
1005         dcred.sign()
1006
1007         return dcred
1008
1009     # only informative
1010     def get_filename(self):
1011         return getattr(self,'filename',None)
1012     
1013     def actual_caller_hrn (self):
1014         """a helper method used by some API calls like e.g. Allocate
1015         to try and find out who really is the original caller
1016         
1017         This admittedly is a bit of a hack, please USE IN LAST RESORT
1018         
1019         This code uses a heuristic to identify a delegated credential
1020
1021         A first known restriction if for traffic that gets through a slice manager
1022         in this case the hrn reported is the one from the last SM in the call graph
1023         which is not at all what is meant here"""
1024
1025         caller_hrn = self.get_gid_caller().get_hrn()
1026         issuer_hrn = self.get_signature().get_issuer_gid().get_hrn()
1027         subject_hrn = self.get_gid_object().get_hrn()
1028         # if we find that the caller_hrn is an immediate descendant of the issuer, then
1029         # this seems to be a 'regular' credential
1030         if caller_hrn.startswith(issuer_hrn): 
1031             actual_caller_hrn=caller_hrn
1032         # else this looks like a delegated credential, and the real caller is the issuer
1033         else:
1034             actual_caller_hrn=issuer_hrn
1035         logger.info("actual_caller_hrn: caller_hrn=%s, issuer_hrn=%s, returning %s"%(caller_hrn,issuer_hrn,actual_caller_hrn))
1036         return actual_caller_hrn
1037             
1038     ##
1039     # Dump the contents of a credential to stdout in human-readable format
1040     #
1041     # @param dump_parents If true, also dump the parent certificates
1042     def dump (self, *args, **kwargs):
1043         print self.dump_string(*args, **kwargs)
1044
1045     # show_xml is ignored
1046     def dump_string(self, dump_parents=False, show_xml=None):
1047         result=""
1048         result += "CREDENTIAL %s\n" % self.get_subject()
1049         filename=self.get_filename()
1050         if filename: result += "Filename %s\n"%filename
1051         privileges = self.get_privileges()
1052         if privileges:
1053             result += "      privs: %s\n" % privileges.save_to_string()
1054         else:
1055             result += "      privs: \n" 
1056         gidCaller = self.get_gid_caller()
1057         if gidCaller:
1058             result += "  gidCaller:\n"
1059             result += gidCaller.dump_string(8, dump_parents)
1060
1061         if self.get_signature():
1062             print "  gidIssuer:"
1063             self.get_signature().get_issuer_gid().dump(8, dump_parents)
1064
1065         if self.expiration:
1066             print "  expiration:", self.expiration.isoformat()
1067
1068         gidObject = self.get_gid_object()
1069         if gidObject:
1070             result += "  gidObject:\n"
1071             result += gidObject.dump_string(8, dump_parents)
1072
1073         if self.parent and dump_parents:
1074             result += "\nPARENT"
1075             result += self.parent.dump_string(True)
1076
1077         return result