Ignore:
Timestamp:
10/02/10 13:40:54 (11 years ago)
Author:
pjkersha
Message:

Working ElementTree serialisation/deserialisation for AuthzDecisionQuery?

File:
1 edited

Legend:

Unmodified
Added
Removed
  • TI12-security/trunk/ndg_security_saml/saml/saml2/core.py

    r6546 r6547  
    8282    ) 
    8383     
    84     def __init__(self): 
     84    def __init__(self, **kw): 
    8585        """Initialise Attribute Class attributes""" 
     86        super(Attribute, self).__init__(**kw) 
     87         
    8688        self.__name = None 
    8789        self.__nameFormat = None 
     
    172174    __slots__ = ('__attributes', '__encryptedAttributes') 
    173175     
    174     def __init__(self): 
     176    def __init__(self, **kw): 
     177        super(AttributeStatement, self).__init__(**kw) 
     178         
    175179        self.__attributes = TypedList(Attribute) 
    176180        self.__encryptedAttributes = TypedList(Attribute) 
     
    345349    # Decision attribute name 
    346350    DECISION_ATTRIB_NAME = "Decision" 
     351     
     352    def __init__(self,  
     353                 normalizeResource=True,  
     354                 safeNormalizationChars='/%', 
     355                 **kw): 
     356        '''Create new authorisation decision statement 
     357        ''' 
     358        super(AuthzDecisionStatement, self).__init__(**kw) 
     359 
     360        # Resource attribute value.  
     361        self.__resource = None 
     362         
     363        # Tuning for normalization of resource URIs in property set method 
     364        self.normalizeResource = normalizeResource 
     365        self.safeNormalizationChars = safeNormalizationChars 
     366 
     367    def _getNormalizeResource(self): 
     368        return self.__normalizeResource 
     369 
     370    def _setNormalizeResource(self, value): 
     371        if not isinstance(value, bool): 
     372            raise TypeError('Expecting bool type for "normalizeResource" ' 
     373                            'attribute; got %r instead' % type(value)) 
     374             
     375        self.__normalizeResource = value 
     376 
     377    normalizeResource = property(_getNormalizeResource,  
     378                                 _setNormalizeResource,  
     379                                 doc="Flag to normalize new resource value " 
     380                                     "assigned to the \"resource\" property.  " 
     381                                     "The setting only applies for URIs " 
     382                                     'beginning with "http://" or "https://"') 
     383 
     384    def _getSafeNormalizationChars(self): 
     385        return self.__safeNormalizationChars 
     386 
     387    def _setSafeNormalizationChars(self, value): 
     388        if not isinstance(value, basestring): 
     389            raise TypeError('Expecting string type for "normalizeResource" ' 
     390                            'attribute; got %r instead' % type(value)) 
     391             
     392        self.__safeNormalizationChars = value 
     393 
     394    safeNormalizationChars = property(_getSafeNormalizationChars,  
     395                                      _setSafeNormalizationChars,  
     396                                      doc="String containing a list of " 
     397                                          "characters that should not be " 
     398                                          "converted when Normalizing the " 
     399                                          "resource URI.  These are passed to " 
     400                                          "urllib.quote when the resource " 
     401                                          "property is set.  The default " 
     402                                          "characters are '/%'") 
    347403 
    348404    def _getResource(self): 
    349         ''' 
    350         Get URI of the resource to which authorization is saught. 
    351          
    352         @return: URI of the resource to which authorization is saught 
     405        '''Gets the Resource attrib value of this query. 
     406 
     407        @return: the Resource attrib value of this query''' 
     408        return self.__resource 
     409     
     410    def _setResource(self, value): 
     411        '''Sets the Resource attrib value of this query normalizing the path 
     412        component, removing spurious port numbers (80 for HTTP and 443 for  
     413        HTTPS) and converting the host component to lower case. 
     414         
     415        @param value: the new Resource attrib value of this query''' 
     416        if not isinstance(value, basestring): 
     417            raise TypeError('Expecting string type for "resource" attribute; ' 
     418                            'got %r instead' % type(value)) 
     419         
     420        if (self.normalizeResource and  
     421            value.startswith('http://') or value.startswith('https://')): 
     422            # Normalise the path, set the host name to lower case and remove  
     423            # port redundant numbers 80 and 443 
     424            splitResult = urlsplit(value) 
     425            uriComponents = list(splitResult) 
     426             
     427            # hostname attribute is lowercase 
     428            uriComponents[1] = splitResult.hostname 
     429             
     430            if splitResult.port is not None: 
     431                isHttpWithStdPort = (splitResult.port == 80 and  
     432                                     splitResult.scheme == 'http') 
     433                 
     434                isHttpsWithStdPort = (splitResult.port == 443 and 
     435                                      splitResult.scheme == 'https') 
     436                 
     437                if not isHttpWithStdPort and not isHttpsWithStdPort: 
     438                    uriComponents[1] += ":%d" % splitResult.port 
     439             
     440            uriComponents[2] = urllib.quote(splitResult.path,  
     441                                            self.safeNormalizationChars) 
     442             
     443            self.__resource = urlunsplit(uriComponents) 
     444        else: 
     445            self.__resource = value 
     446     
     447    resource = property(fget=_getResource, fset=_setResource, 
     448                        doc="Resource for which authorisation was requested") 
     449 
     450    def _getDecision(self): 
     451        ''' 
     452        Gets the decision of the authorization request. 
     453         
     454        @return: the decision of the authorization request 
    353455        ''' 
    354456        raise NotImplementedError() 
    355457 
    356     def _setResource(self, value): 
    357         ''' 
    358         Sets URI of the resource to which authorization is saught. 
    359          
    360         @param value: URI of the resource to which authorization is  
    361         saught 
     458    def _setDecision(self, value): 
     459        ''' 
     460        Sets the decision of the authorization request. 
     461         
     462        @param value: the decision of the authorization request 
    362463        ''' 
    363464        raise NotImplementedError() 
    364  
    365     def _getDecision(self): 
    366         ''' 
    367         Gets the decision of the authorization request. 
    368          
    369         @return: the decision of the authorization request 
    370         ''' 
    371         raise NotImplementedError() 
    372  
    373     def _setDecision(self, value): 
    374         ''' 
    375         Sets the decision of the authorization request. 
    376          
    377         @param value: the decision of the authorization request 
    378         ''' 
    379         raise NotImplementedError() 
    380  
    381     def _getActions(self): 
    382         ''' 
    383         Gets the actions authorized to be performed. 
    384          
    385         @return: the actions authorized to be performed 
    386         ''' 
    387         raise NotImplementedError() 
    388  
    389  
     465     
     466    @property 
     467    def actions(self): 
     468        '''The actions for which authorisation is requested 
     469         
     470        @return: the Actions of this statement''' 
     471        return self.__actions 
     472    
    390473    def _getEvidence(self): 
    391         ''' 
    392         Get the SAML assertion the authority relied on when making the  
    393         authorization decision. 
    394          
    395         @return: the SAML assertion the authority relied on when making the  
    396         authorization decision 
    397         ''' 
    398         raise NotImplementedError() 
     474        '''Gets the Evidence of this statement. 
     475 
     476        @return: the Evidence of this statement''' 
     477        return self.__evidence 
    399478 
    400479    def _setEvidence(self, value): 
    401         ''' 
    402         Sets the SAML assertion the authority relied on when making the  
    403         authorization decision. 
    404          
    405         @param value: the SAML assertion the authority relied on when  
    406         making the authorization decision 
    407         ''' 
    408         raise NotImplementedError() 
     480        '''Sets the Evidence of this query. 
     481        @param newEvidence: the new Evidence of this statement'''   
     482        if not isinstance(value, Evidence): 
     483            raise TypeError('Expecting Evidence type for "evidence" ' 
     484                            'attribute; got %r' % type(value)) 
     485 
     486        self.__evidence = value   
     487 
     488    evidence = property(fget=_getEvidence, fset=_setEvidence,  
     489                        doc="A set of assertions which the Authority may use " 
     490                            "to base its authorisation decision on") 
     491     
     492    def getOrderedChildren(self): 
     493        children = [] 
     494 
     495        superChildren = super(AuthzDecisionStatement, self).getOrderedChildren() 
     496        if superChildren: 
     497            children.extend(superChildren) 
     498 
     499        children.extend(self.__actions) 
     500         
     501        if self.__evidence is not None: 
     502            children.extend(self.__evidence) 
     503 
     504        if len(children) == 0: 
     505            return None 
     506 
     507        return tuple(children) 
    409508         
    410509 
     
    435534    ) 
    436535     
    437     def __init__(self,  
    438                  namespaceURI=SAMLConstants.SAML20_NS,  
    439                  elementLocalName=DEFAULT_ELEMENT_LOCAL_NAME,  
    440                  namespacePrefix=SAMLConstants.SAML20_PREFIX): 
    441         '''@param namespaceURI: the namespace the element is in 
    442         @param elementLocalName: the local name of the XML element this Object  
    443         represents 
    444         @param namespacePrefix: the prefix for the given namespace 
    445         ''' 
    446         self.__qname = QName(namespaceURI,  
    447                              elementLocalName,  
    448                              namespacePrefix) 
     536    def __init__(self, **kw): 
     537        super(Subject, self).__init__(**kw) 
    449538         
    450539        # BaseID child element. 
     
    459548        # Subject Confirmations of the Subject. 
    460549        self.__subjectConfirmations = [] 
    461      
    462     def _get_qname(self): 
    463         return self.__qname 
    464      
    465     qname = property(fget=_get_qname, doc="Qualified Name for Subject") 
    466550     
    467551    def _getBaseID(self):  
     
    15541638 
    15551639    # Name of the Namespace attribute.  
    1556     NAMEPSACE_ATTRIB_NAME = "Namespace" 
     1640    NAMESPACE_ATTRIB_NAME = "Namespace" 
    15571641 
    15581642    # Read/Write/Execute/Delete/Control action namespace.  
     
    16101694    HTTP_POST_ACTION = "POST" 
    16111695     
    1612     def __init__(self, namespaceURI, elementLocalName, namespacePrefix): 
    1613         ''' 
    1614         @param namespaceURI: the namespace the element is in 
    1615         @param elementLocalName: the local name of the XML element this object  
    1616         represents 
    1617         @param namespacePrefix: the prefix for the given namespace''' 
    1618         super(Action, self).__init__(namespaceURI,  
    1619                                      elementLocalName,  
    1620                                      namespacePrefix) 
    1621          
    1622         # URI of the Namespace of this Action 
     1696    def __init__(self, **kw): 
     1697        '''Create an authorization action type 
     1698        ''' 
     1699        super(Action, self).__init__(**kw) 
     1700 
     1701        # URI of the Namespace of this action 
    16231702        self.__namespace = None 
    16241703 
    1625         # Action value 
    1626         self.__action = None 
     1704        #Value value 
     1705        self.__action = None        
    16271706     
    16281707    def _getNamespace(self): 
    16291708        ''' 
    1630         gets the namespace scope of the specified action. 
    1631          
    1632         @return: the namespace scope of the specified action 
    1633         ''' 
    1634         self.__namespace 
     1709        gets the namespace scope of the specifiedvalue. 
     1710         
     1711        @return: the namespace scope of the specifiedvalue 
     1712        ''' 
     1713        return self.__namespace 
    16351714 
    16361715    def _setNamespace(self, value): 
    16371716        ''' 
    1638         Sets the namespace scope of the specified action. 
    1639          
    1640         @param value: the namespace scope of the specified action 
     1717        Sets the namespace scope of the specifiedvalue. 
     1718         
     1719        @param value: the namespace scope of the specifiedvalue 
    16411720        ''' 
    16421721        if not isinstance(value, basestring): 
     
    16451724        self.__namespace = value 
    16461725 
    1647     namespace = property(_getNamespace, _setNamespace,  
    1648                          doc="Action Namespace") 
    1649  
    1650     def _getAction(self): 
     1726    namespace = property(_getNamespace, _setNamespace, doc="Action Namespace") 
     1727 
     1728    def _getValue(self): 
    16511729        ''' 
    16521730        gets the URI of the action to be performed. 
     
    16541732        @return: the URI of the action to be performed 
    16551733        ''' 
    1656         return self.__action 
    1657  
    1658     def _setAction(self, value): 
     1734        return self.__value 
     1735 
     1736    def _setValue(self, value): 
    16591737        ''' 
    16601738        Sets the URI of the action to be performed. 
    16611739         
    1662         @param value: the URI of the action to be performed 
     1740        @param value: the URI of thevalue to be performed 
    16631741        ''' 
    16641742        if not isinstance(value, basestring): 
    16651743            raise TypeError('Expecting string type for "action" ' 
    16661744                            'attribute; got %r' % type(value)) 
    1667         self.__action = value 
    1668  
    1669     action = property(_getAction, _setAction,  
    1670                       doc="Action string") 
     1745        self.__value = value 
     1746 
     1747    value = property(_getValue, _setValue, doc="Action string") 
    16711748         
    16721749 
     
    19582035 
    19592036class AssertionURIRef(Evidentiary): 
     2037    '''SAML 2.0 Core AssertionURIRef''' 
    19602038    __slots__ = ('__assertionURI',) 
    19612039     
    1962     def __init__(self, namespaceURI, elementLocalName, namespacePrefix): 
    1963         ''' 
    1964         @param namespaceURI: the namespace the element is in 
    1965         @param elementLocalName: the local name of the XML element this Object  
    1966         represents 
    1967         @param namespacePrefix: the prefix for the given namespace''' 
    1968         super(AssertionURIRef, self).__init__(namespaceURI,  
    1969                                               elementLocalName,  
    1970                                               namespacePrefix) 
     2040    # Element local name 
     2041    DEFAULT_ELEMENT_LOCAL_NAME = "AssertionURIRef" 
     2042 
     2043    # Default element name 
     2044    DEFAULT_ELEMENT_NAME = QName(SAMLConstants.SAML20_NS,  
     2045                                 DEFAULT_ELEMENT_LOCAL_NAME, 
     2046                                 SAMLConstants.SAML20_PREFIX) 
     2047     
     2048    def __init__(self): 
     2049        '''Create assertion URI reference''' 
     2050        super(AssertionURIRef, self).__init__() 
    19712051         
    19722052        # URI of the Assertion 
     
    21002180                      SAMLConstants.SAML20_PREFIX) 
    21012181 
    2102     __slots__ = ('__evidence',) 
    2103      
    2104     def __init__(self, namespaceURI, elementLocalName, namespacePrefix): 
    2105         ''' 
    2106         @param namespaceURI: the namespace the element is in 
    2107         @param elementLocalName: the local name of the XML element this Object  
    2108         represents 
    2109         @param namespacePrefix: the prefix for the given namespace''' 
    2110         super(Evidence, self).__init__(namespaceURI,  
    2111                                        elementLocalName,  
    2112                                        namespacePrefix) 
     2182    __slots__ = ('__values',) 
     2183     
     2184    def __init__(self, **kw): 
     2185        '''Create an authorization evidence type 
     2186        ''' 
     2187        super(Evidence, self).__init__(**kw) 
     2188 
    21132189        # Assertion of the Evidence.  
    2114         self.__evidence = TypedList(Evidentiary) 
    2115          
    2116     def _getAssertionIDReferences(self): 
     2190        self.__values = TypedList(Evidentiary)  
     2191         
     2192    @property 
     2193    def assertionIDReferences(self): 
    21172194        '''Gets the list of AssertionID references used as evidence. 
    21182195     
    21192196        @return: the list of AssertionID references used as evidence''' 
    2120         return [i for i in self.__evidence  
     2197        return [i for i in self.__values  
    21212198                if (getattr(i, "DEFAULT_ELEMENT_NAME") ==  
    21222199                    AssertionIDRef.DEFAULT_ELEMENT_NAME)] 
    21232200     
    2124     def _getAssertionURIReferences(self): 
     2201    @property 
     2202    def assertionURIReferences(self): 
    21252203        '''Gets the list of AssertionURI references used as evidence. 
    21262204        
    21272205        @return: the list of AssertionURI references used as evidence''' 
    2128         return [i for i in self.__evidence  
     2206        return [i for i in self.__values  
    21292207                if (getattr(i, "DEFAULT_ELEMENT_NAME") ==  
    21302208                    AssertionURIRef.DEFAULT_ELEMENT_NAME)] 
    21312209     
    2132     def _getAssertions(self): 
     2210    @property 
     2211    def assertions(self): 
    21332212        '''Gets the list of Assertions used as evidence. 
    21342213        
    21352214        @return: the list of Assertions used as evidence''' 
    2136         return [i for i in self.__evidence  
     2215        return [i for i in self.__values  
    21372216                if (getattr(i, "DEFAULT_ELEMENT_NAME") ==  
    21382217                    Assertion.DEFAULT_ELEMENT_NAME)] 
    21392218     
    2140     def _getEncryptedAssertions(self): 
     2219    @property 
     2220    def encryptedAssertions(self): 
    21412221        '''Gets the list of EncryptedAssertions used as evidence. 
    21422222        
    21432223        @return: the list of EncryptedAssertions used as evidence''' 
    2144         return [i for i in self.__evidence  
     2224        return [i for i in self.__values  
    21452225                if (getattr(i, "DEFAULT_ELEMENT_NAME") ==  
    2146                     EncryptedAssertion.DEFAULT_ELEMENT_NAME)] 
    2147  
    2148     def _getEvidence(self): 
     2226                    EncryptedAssertion.DEFAULT_ELEMENT_NAME)]    
     2227 
     2228    @property 
     2229    def values(self): 
    21492230        '''Gets the list of all elements used as evidence. 
    21502231        
    21512232        @return: the list of Evidentiary objects used as evidence''' 
    2152         return self.__evidence 
     2233        return self.__values 
    21532234     
    21542235    def getOrderedChildren(self): 
    21552236        children = [] 
    21562237 
    2157         if len(self.evidence) == 0: 
     2238        if len(self.__values) == 0: 
    21582239            return None 
    21592240 
    2160         children.extend(self.evidence) 
     2241        children.extend(self.__values) 
    21612242 
    21622243        return tuple(children) 
     
    21882269       '__resource', 
    21892270       '__evidence', 
    2190        '__actions' 
     2271       '__actions', 
     2272       '__normalizeResource', 
     2273       '__safeNormalizationChars' 
    21912274    ) 
    21922275     
    2193     def __init__(self): 
     2276    def __init__(self,  
     2277                 normalizeResource=True,  
     2278                 safeNormalizationChars='/%', 
     2279                 **kw): 
    21942280        '''Create new authorisation decision query 
    21952281        ''' 
    2196         super(AuthzDecisionQuery, self).__init__() 
     2282        super(AuthzDecisionQuery, self).__init__(**kw) 
    21972283 
    21982284        # Resource attribute value.  
     
    22032289     
    22042290        # Action child elements. 
    2205         self.__actions = TypedList(Action) 
    2206          
     2291        self.__actions = TypedList(Action)    
     2292         
     2293        # Tuning for normalization of resource URIs in property set method 
     2294        self.normalizeResource = normalizeResource 
     2295        self.safeNormalizationChars = safeNormalizationChars 
     2296 
     2297    def _getNormalizeResource(self): 
     2298        return self.__normalizeResource 
     2299 
     2300    def _setNormalizeResource(self, value): 
     2301        if not isinstance(value, bool): 
     2302            raise TypeError('Expecting bool type for "normalizeResource" ' 
     2303                            'attribute; got %r instead' % type(value)) 
     2304             
     2305        self.__normalizeResource = value 
     2306 
     2307    normalizeResource = property(_getNormalizeResource,  
     2308                                 _setNormalizeResource,  
     2309                                 doc="Flag to normalize new resource value " 
     2310                                     "assigned to the \"resource\" property.  " 
     2311                                     "The setting only applies for URIs " 
     2312                                     'beginning with "http://" or "https://"') 
     2313 
     2314    def _getSafeNormalizationChars(self): 
     2315        return self.__safeNormalizationChars 
     2316 
     2317    def _setSafeNormalizationChars(self, value): 
     2318        if not isinstance(value, basestring): 
     2319            raise TypeError('Expecting string type for "normalizeResource" ' 
     2320                            'attribute; got %r instead' % type(value)) 
     2321             
     2322        self.__safeNormalizationChars = value 
     2323 
     2324    safeNormalizationChars = property(_getSafeNormalizationChars,  
     2325                                      _setSafeNormalizationChars,  
     2326                                      doc="String containing a list of " 
     2327                                          "characters that should not be " 
     2328                                          "converted when Normalizing the " 
     2329                                          "resource URI.  These are passed to " 
     2330                                          "urllib.quote when the resource " 
     2331                                          "property is set.  The default " 
     2332                                          "characters are '/%'") 
     2333 
    22072334    def _getResource(self): 
    22082335        '''Gets the Resource attrib value of this query. 
     
    22212348                            'got %r instead' % type(value)) 
    22222349         
    2223         # Normalise the path, set the host name to lower case and remove  
    2224         # port redundant numbers 80 and 443 
    2225         splitResult = urlsplit(value) 
    2226         uriComponents = list(splitResult) 
    2227          
    2228         # hostname attribute is lowercase 
    2229         uriComponents[1] = splitResult.hostname 
    2230          
    2231         isHttpWithStdPort = (splitResult.port == 80 and  
    2232                              splitResult.scheme == 'http') 
    2233          
    2234         isHttpsWithStdPort = (splitResult.port == 443 and 
    2235                               splitResult.scheme == 'https') 
    2236          
    2237         if not isHttpWithStdPort and not isHttpsWithStdPort: 
    2238             uriComponents[1] += ":%d" % splitResult.port 
    2239          
    2240         uriComponents[2] = urllib.quote(splitResult.path) 
    2241          
    2242         self.__resource = urlunsplit(uriComponents) 
     2350        if (self.normalizeResource and  
     2351            value.startswith('http://') or value.startswith('https://')): 
     2352            # Normalise the path, set the host name to lower case and remove  
     2353            # port redundant numbers 80 and 443 
     2354            splitResult = urlsplit(value) 
     2355            uriComponents = list(splitResult) 
     2356             
     2357            # hostname attribute is lowercase 
     2358            uriComponents[1] = splitResult.hostname 
     2359             
     2360            if splitResult.port is not None: 
     2361                isHttpWithStdPort = (splitResult.port == 80 and  
     2362                                     splitResult.scheme == 'http') 
     2363                 
     2364                isHttpsWithStdPort = (splitResult.port == 443 and 
     2365                                      splitResult.scheme == 'https') 
     2366                 
     2367                if not isHttpWithStdPort and not isHttpsWithStdPort: 
     2368                    uriComponents[1] += ":%d" % splitResult.port 
     2369             
     2370            uriComponents[2] = urllib.quote(splitResult.path,  
     2371                                            self.safeNormalizationChars) 
     2372             
     2373            self.__resource = urlunsplit(uriComponents) 
     2374        else: 
     2375            self.__resource = value 
    22432376     
    22442377    resource = property(fget=_getResource, fset=_setResource, 
    22452378                        doc="Resource for which authorisation is requested") 
    22462379     
    2247     def _getActions(self): 
    2248         '''Gets the Actions of this query. 
     2380    @property 
     2381    def actions(self): 
     2382        '''The actions for which authorisation is requested 
    22492383         
    22502384        @return: the Actions of this query''' 
    22512385        return self.__actions 
    2252      
    2253     actions = property(fget=_getActions,  
    2254                        doc="The actions for which authorisation is requested") 
    22552386    
    22562387    def _getEvidence(self): 
     
    22802411            children.extend(superChildren) 
    22812412 
    2282         children.extend(self.actions) 
    2283          
    2284         if evidence is not None: 
    2285             children.extend(evidence) 
     2413        children.extend(self.__actions) 
     2414         
     2415        if self.__evidence is not None: 
     2416            children.extend(self.__evidence) 
    22862417 
    22872418        if len(children) == 0: 
Note: See TracChangeset for help on using the changeset viewer.