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