Changeset 6615 for TI12-security


Ignore:
Timestamp:
23/02/10 16:40:24 (10 years ago)
Author:
pjkersha
Message:

AuthzService? unit test wiht ndg.security.server.wsgi.authzservice.AuthzServiceMiddleware? near complete. Fixes required to PIP callout to Attribute Authority.

Location:
TI12-security/trunk/NDGSecurity/python
Files:
1 added
1 deleted
29 edited

Legend:

Unmodified
Added
Removed
  • TI12-security/trunk/NDGSecurity/python/.pydevproject

    r6605 r6615  
    99<path>/ndg_security_python/ndg_security_common</path> 
    1010<path>/ndg_security_python/ndg_security_server</path> 
    11 <path>/ndg_security_python/ndg_security_test</path> 
    1211</pydev_pathproperty> 
    1312<pydev_pathproperty name="org.python.pydev.PROJECT_EXTERNAL_SOURCE_PATH"> 
    14 <path>/home/pjkersha/workspace/ndg_security_saml</path> 
    1513<path>/home/pjkersha/workspace/AuthKit/trunk</path> 
     14<path>/home/pjkersha/workspace/ndg_saml</path> 
    1615</pydev_pathproperty> 
    1716</pydev_project> 
  • TI12-security/trunk/NDGSecurity/python/Tests/esg_integration/test_soapauthzdecisioninterface.py

    r6584 r6615  
    1717from xml.etree import ElementTree 
    1818 
    19 from saml.saml2.core import StatusCode, DecisionType, Action 
    20 from saml.xml.etree import ResponseElementTree 
     19from ndg.saml.saml2.core import StatusCode, DecisionType, Action 
     20from ndg.saml.xml.etree import ResponseElementTree 
    2121from ndg.security.common.utils.etree import prettyPrint 
    2222from ndg.security.common.saml_utils.binding.soap.authzdecisionquery import (  
  • TI12-security/trunk/NDGSecurity/python/ndg_security_common/ndg/security/common/authz/pip/esginterface.py

    r6598 r6615  
    1919from ndg.security.common.utils.configfileparsers import \ 
    2020                                            CaseSensitiveConfigParser 
    21 from ndg.security.common.saml_utils.attributeQuery import \ 
     21from ndg.security.common.saml_utils.binding.soap.attributequery import \ 
    2222                                            AttributeQuerySslSOAPBinding 
    2323from ndg.security.common.X509 import X509Cert 
     
    2626                                           PIPAttributeResponse) 
    2727     
    28  
     28     
    2929class PIP(PIPBase): 
    3030    """Policy Information Point to query ESG Attribute Authority for user 
    3131    attributes 
    3232    """ 
    33           
     33    # Subject attributes makes no sense for external configuration - these  
     34    # are set at run time based on the given subject identity 
     35    DISALLOWED_ATTRIBUTE_QUERY_OPTNAMES = ( 
     36        AttributeQuerySslSOAPBinding.SUBJECT_ID_OPTNAME, 
     37    ) 
    3438    ATTRIBUTE_QUERY_ATTRNAME = 'attributeQuery' 
    3539    LEN_ATTRIBUTE_QUERY_ATTRNAME = len(ATTRIBUTE_QUERY_ATTRNAME) 
     
    3943    def __init__(self): 
    4044        '''Initialise settings for connection to an Attribute Authority''' 
    41         self.__attributeQueryBinding = None        
     45        self.__attributeQueryBinding = AttributeQuerySslSOAPBinding()     
    4246 
    4347    @classmethod 
     
    9094                setattr(self, optName, val) 
    9195                 
    92         if not self.__attributeQueryBinding.issuerName: 
     96        if (not self.attributeQueryBinding.issuerName and  
     97            self.attributeQueryBinding.sslCtxProxy.sslCertFilePath is not None): 
    9398            issuerX509Cert = X509Cert.Read( 
    94                     self.__attributeQueryBinding.sslCtxProxy.sslCertFilePath) 
    95             self.__attributeQueryBinding.issuerName = str(issuerX509Cert.dn) 
     99                        self.attributeQueryBinding.sslCtxProxy.sslCertFilePath) 
     100            self.attributeQueryBinding.issuerName = str(issuerX509Cert.dn) 
    96101             
    97102    def __setattr__(self, name, value): 
     
    105110        # attributeQuery.clockSkew or attributeQuery_issuerDN 
    106111        if name.startswith(PIP.ATTRIBUTE_QUERY_ATTRNAME): 
    107             setattr(self.__attributeQueryBinding,  
    108                     name[PIP.LEN_ATTRIBUTE_QUERY_ATTRNAME+1:],  
    109                     value) 
     112            queryAttrName = name[PIP.LEN_ATTRIBUTE_QUERY_ATTRNAME+1:] 
     113             
     114            # Skip subject related parameters to prevent settings from static 
     115            # configuration.  These are set at runtime 
     116            if queryAttrName in PIP.DISALLOWED_ATTRIBUTE_QUERY_OPTNAMES: 
     117                super(PIP, self).__setattr__(name, value) 
     118                 
     119            setattr(self.__attributeQueryBinding, queryAttrName, value) 
    110120        else: 
    111121            super(PIP, self).__setattr__(name, value)     
     
    129139                            'got %r' % (PIPAttributeQuery,  
    130140                                        type(attributeQuery))) 
    131                              
     141         
     142        self.attributeQueryBinding.subjectID = attributeQuery[ 
     143                                PIPAttributeQuery.SUBJECT_NS][Subject.USERID_NS] 
     144                
    132145        attributeAuthorityURI = attributeQuery[ 
    133146                                        PIPAttributeQuery.ATTRIBUTEAUTHORITY_NS] 
     
    135148        log.debug("PIP: received attribute query: %r", attributeQuery) 
    136149          
    137         response = self.attributeQueryBinding.send(uri=attributeAuthorityURI) 
     150        try: 
     151            response = self.attributeQueryBinding.send( 
     152                                                    uri=attributeAuthorityURI) 
     153        finally: 
     154            # Ensure subject ID is reset ready for any subsequent query 
     155            self.attributeQueryBinding.subjectID = '' 
    138156         
    139157        attributeResponse = PIPAttributeResponse() 
  • TI12-security/trunk/NDGSecurity/python/ndg_security_common/ndg/security/common/credentialwallet.py

    r6570 r6615  
    2323from ConfigParser import ConfigParser 
    2424 
    25 from saml.utils import SAMLDateTime 
    26 from saml.saml2.core import Assertion 
     25from ndg.saml.utils import SAMLDateTime 
     26from ndg.saml.saml2.core import Assertion 
    2727 
    2828# Access Attribute Authority's web service using ZSI - allow pass if not  
  • TI12-security/trunk/NDGSecurity/python/ndg_security_common/ndg/security/common/saml_utils/binding/soap/__init__.py

    r6584 r6615  
    1515from ConfigParser import ConfigParser 
    1616 
    17 from saml.common import SAMLObject 
     17from ndg.saml.common import SAMLObject 
    1818 
    1919from ndg.security.common.utils.factory import importModuleObject 
  • TI12-security/trunk/NDGSecurity/python/ndg_security_common/ndg/security/common/saml_utils/binding/soap/attributequery.py

    r6584 r6615  
    1515from M2Crypto.m2urllib2 import HTTPSHandler 
    1616 
    17 from saml.saml2.core import Attribute, AttributeQuery 
     17from ndg.saml.saml2.core import Attribute, AttributeQuery 
    1818 
    1919from ndg.security.common.utils import TypedList 
     
    5555        # Default to ElementTree based serialisation/deserialisation 
    5656        if AttributeQuerySOAPBinding.SERIALISE_KW not in kw: 
    57             from saml.xml.etree import AttributeQueryElementTree 
     57            from ndg.saml.xml.etree import AttributeQueryElementTree 
    5858            kw[AttributeQuerySOAPBinding.SERIALISE_KW 
    5959               ] = AttributeQueryElementTree.toXML 
    6060                
    6161        if AttributeQuerySOAPBinding.DESERIALISE_KW not in kw: 
    62             from saml.xml.etree import ResponseElementTree 
     62            from ndg.saml.xml.etree import ResponseElementTree 
    6363            kw[AttributeQuerySOAPBinding.DESERIALISE_KW 
    6464               ] = ResponseElementTree.fromXML 
  • TI12-security/trunk/NDGSecurity/python/ndg_security_common/ndg/security/common/saml_utils/binding/soap/authzdecisionquery.py

    r6578 r6615  
    1515from M2Crypto.m2urllib2 import HTTPSHandler 
    1616 
    17 from saml.saml2.core import AuthzDecisionQuery 
     17from ndg.saml.saml2.core import AuthzDecisionQuery 
    1818 
    1919from ndg.security.common.saml_utils.binding.soap.subjectquery import ( 
     
    5151        # Default to ElementTree based serialisation/deserialisation 
    5252        if cls.SERIALISE_KW not in kw: 
    53             from saml.xml.etree import AuthzDecisionQueryElementTree 
     53            from ndg.saml.xml.etree import AuthzDecisionQueryElementTree 
    5454            kw[cls.SERIALISE_KW] = AuthzDecisionQueryElementTree.toXML 
    5555                
    5656        if cls.DESERIALISE_KW not in kw: 
    57             from saml.xml.etree import ResponseElementTree 
     57            from ndg.saml.xml.etree import ResponseElementTree 
    5858            kw[cls.DESERIALISE_KW] = ResponseElementTree.fromXML 
    5959 
  • TI12-security/trunk/NDGSecurity/python/ndg_security_common/ndg/security/common/saml_utils/binding/soap/subjectquery.py

    r6584 r6615  
    1515from uuid import uuid4 
    1616 
    17 from saml.common import SAMLObject 
    18 from saml.utils import SAMLDateTime 
    19 from saml.saml2.core import (SubjectQuery, StatusCode, Response, 
     17from ndg.saml.common import SAMLObject 
     18from ndg.saml.utils import SAMLDateTime 
     19from ndg.saml.saml2.core import (SubjectQuery, StatusCode, Response, 
    2020                             Issuer, Subject, SAMLVersion, NameID) 
    2121 
     
    173173 
    174174    issuerName = property(_getIssuerName, _setIssuerName,  
    175                         doc="Distinguished Name of issuer of SAML Attribute " 
    176                             "Query to Attribute Authority") 
     175                          doc="Name of issuer of SAML Subject Query") 
    177176 
    178177    def _getVerifyTimeConditions(self): 
  • TI12-security/trunk/NDGSecurity/python/ndg_security_common/ndg/security/common/saml_utils/esg/__init__.py

    r6570 r6615  
    99__contact__ = "Philip.Kershaw@stfc.ac.uk" 
    1010__revision__ = '$Id: $' 
    11 from saml.saml2.core import XSStringAttributeValue, AttributeValue, Attribute 
    12 from saml.common.xml import QName, SAMLConstants 
     11from ndg.saml.saml2.core import XSStringAttributeValue, AttributeValue, Attribute 
     12from ndg.saml.common.xml import QName, SAMLConstants 
    1313 
    1414from ndg.security.common.utils import TypedList 
  • TI12-security/trunk/NDGSecurity/python/ndg_security_common/ndg/security/common/saml_utils/esg/xml/etree.py

    r6578 r6615  
    1515from xml.etree import ElementTree 
    1616 
    17 from saml.xml import XMLTypeParseError, UnknownAttrProfile 
    18 from saml.xml.etree import (AttributeValueElementTreeBase, ResponseElementTree, 
     17from ndg.saml.xml import XMLTypeParseError, UnknownAttrProfile 
     18from ndg.saml.xml.etree import (AttributeValueElementTreeBase, ResponseElementTree, 
    1919                            QName) 
    2020 
  • TI12-security/trunk/NDGSecurity/python/ndg_security_server/ndg/security/server/attributeauthority.py

    r6572 r6615  
    2828from datetime import datetime, timedelta 
    2929 
    30 from saml.utils import SAMLDateTime 
    31 from saml.saml2.core import (Response, Assertion, Attribute, AttributeStatement, 
     30from ndg.saml.utils import SAMLDateTime 
     31from ndg.saml.saml2.core import (Response, Assertion, Attribute, AttributeStatement, 
    3232                             SAMLVersion, Subject, NameID, Issuer, Conditions, 
    3333                             AttributeQuery, XSStringAttributeValue, Status,  
  • TI12-security/trunk/NDGSecurity/python/ndg_security_server/ndg/security/server/authnservice/myproxyauthn.py

    r4840 r6615  
    1313 
    1414from ndg.security.server.sessionmanager import AbstractAuthNService 
    15 from ndg.security.common.myproxy import MyProxyClient 
     15from myproxy.client import MyProxyClient 
    1616 
    1717class MyProxyAuthN(AbstractAuthNService): 
  • TI12-security/trunk/NDGSecurity/python/ndg_security_server/ndg/security/server/myproxy/certificate_extapp/saml_attribute_assertion.py

    r6570 r6615  
    2525    import ElementTree 
    2626 
    27 from saml.utils import SAMLDateTime 
    28 from saml.common.xml import SAMLConstants 
    29 from saml.saml2.core import (Attribute,  
     27from ndg.saml.utils import SAMLDateTime 
     28from ndg.saml.common.xml import SAMLConstants 
     29from ndg.saml.saml2.core import (Attribute,  
    3030                             SAMLVersion,  
    3131                             Subject,  
     
    3737                             StatusCode, 
    3838                             StatusMessage) 
    39 from saml.xml.etree import AssertionElementTree, ResponseElementTree 
     39from ndg.saml.xml.etree import AssertionElementTree, ResponseElementTree 
    4040    
    4141from ndg.security.common.saml_utils.binding.soap.attributequery import \ 
  • TI12-security/trunk/NDGSecurity/python/ndg_security_server/ndg/security/server/wsgi/authzservice.py

    r6605 r6615  
    1212log = logging.getLogger(__name__) 
    1313 
     14from datetime import datetime, timedelta 
     15from uuid import uuid4 
     16 
     17from ndg.saml.saml2.core import (Response, AuthzDecisionStatement, Assertion, 
     18                                 Action, DecisionType, SAMLVersion, Issuer,  
     19                                 Status, StatusCode, StatusMessage, NameID,  
     20                                 Subject, Conditions) 
     21 
    1422from ndg.security.common.utils.factory import importModuleObject 
    15 from ndg.security.common.authz import Subject 
    16 from ndg.security.common.authz.msi import (Policy, PDP, Request, Response, 
    17                                            Resource) 
    18 from ndg.security.common.authz.pip.esg import PIP 
     23from ndg.security.common.authz import Subject as PDPSubject 
     24from ndg.security.common.authz.msi import Response as PDPResponse 
     25from ndg.security.common.authz.msi import Policy, PDP, Request, Resource 
     26from ndg.security.common.authz.pip.esginterface import PIP 
    1927 
    2028 
     
    3341    to the same Authorization Service 
    3442    ''' 
    35     DEFAULT_AUTHZ_DECISION_QUERY_IFACE_KEYNAME = \ 
    36     'ndg.security.server.wsgi.authorizationservice.authzDecisionQueryInterface' 
    37      
    38     ENVIRON_KEYNAME_AUTHZ_DECISION_QUERY_IFACE_OPTNAME = \ 
    39         'authzDecisionQueryInterfaceEnvironKeyName' 
    40      
    41     AUTHZ_DECISION_QUERY_IFACE_OPTNAME = 'authzDecisionQueryInterface' 
     43    DEFAULT_QUERY_IFACE_KEYNAME = \ 
     44                        'ndg.security.server.wsgi.authzservice.queryInterface' 
     45     
     46    ENVIRON_KEYNAME_QUERY_IFACE_OPTNAME = 'queryInterfaceKeyName' 
     47    QUERY_IFACE_OPTNAME = 'queryInterface' 
     48    ISSUER_NAME_OPTNAME = 'issuerName' 
     49    ISSUER_FORMAT_OPTNAME = 'issuerFormat' 
     50    CLOCK_SKEW_TOLERANCE_OPTNAME = 'clockSkewTolerance' 
     51    ASSERTION_LIFETIME_OPTNAME = 'assertionLifetime' 
     52     
     53    # For loop based assignment where possible of config options in initialise() 
     54    AUTHZ_SRVC_OPTION_DEFAULTS = { 
     55        ENVIRON_KEYNAME_QUERY_IFACE_OPTNAME: DEFAULT_QUERY_IFACE_KEYNAME, 
     56        ISSUER_NAME_OPTNAME: None, 
     57        ISSUER_FORMAT_OPTNAME: Issuer.X509_SUBJECT, 
     58        ASSERTION_LIFETIME_OPTNAME: 60*60*8, # 8 hours as default 
     59    } 
    4260     
    4361    POLICY_FILEPATH_OPTNAME = 'filePath' 
     
    4563    PIP_CFG_PREFIX = 'pip.' 
    4664     
    47     __slots__ = ('__pdp', '__authzDecisionFunc', '__authzDecisionFuncKeyName') 
     65    __slots__ = ( 
     66        '__policyFilePath', 
     67        '__' + QUERY_IFACE_OPTNAME,  
     68        '__' + ENVIRON_KEYNAME_QUERY_IFACE_OPTNAME, 
     69        '__' + CLOCK_SKEW_TOLERANCE_OPTNAME, 
     70        '__' + ASSERTION_LIFETIME_OPTNAME, 
     71        '__pdp',  
     72        '_app', 
     73        '__issuerProxy', 
     74        '__subjectProxy' 
     75    ) 
    4876         
    4977    def __init__(self, app): 
     
    5381          
    5482        self._app = app 
     83        self.__policyFilePath = None 
    5584        self.__pdp = None 
    56         self.__authzDecisionFunc = None 
    57         self.__authzDecisionFuncKeyName = None 
    58      
     85        self.__queryInterface = None 
     86        self.__queryInterfaceKeyName = None 
     87        self.__clockSkewTolerance = None 
     88        self.__assertionLifetime = 0. 
     89         
     90        # Proxy object for SAML Response Issuer attributes.  By generating a  
     91        # proxy the Response objects inherent attribute validation can be  
     92        # applied to Issuer related config parameters before they're assigned to 
     93        # the response issuer object generated in the authorisation decision  
     94        # query response 
     95        self.__issuerProxy = Issuer() 
     96         
    5997    def initialise(self, global_conf, prefix='authorizationservice.', 
    6098                   **app_conf): 
     
    75113        cls = AuthzServiceMiddleware 
    76114         
     115        # Loop based assignment where possible 
     116        for optName, default in cls.AUTHZ_SRVC_OPTION_DEFAULTS.items(): 
     117            value = app_conf.get(prefix + optName, default) 
     118            setattr(self, optName, value) 
     119         
     120        # Address special cases ...         
     121        authzDecisionQueryIfaceOptName = prefix + cls.QUERY_IFACE_OPTNAME 
     122                                          
     123        # Use decision function set in config but default to the implementation 
     124        # in this class if no config option is set 
     125        self.queryInterface = app_conf.get(authzDecisionQueryIfaceOptName, 
     126                                           self.createQueryInterface())         
     127 
    77128        # Initialise the Authorisation Policy 
    78129        policyCfgPrefix = prefix + cls.POLICY_CFG_PREFIX 
    79130        policyFilePathOptName = policyCfgPrefix + cls.POLICY_FILEPATH_OPTNAME 
    80          
    81         policyFilePath = app_conf.get(policyFilePathOptName) 
    82         if policyFilePath is None: 
    83             raise AuthzServiceMiddlewareConfigError("Expecting policy file " 
    84                                                     "setting option %r" % 
    85                                                     policyFilePathOptName) 
    86          
    87         policy = Policy.Parse(policyFilePath) 
     131        self.policyFilePath = app_conf.get(policyFilePathOptName) 
     132              
     133        policy = Policy.Parse(self.policyFilePath) 
    88134         
    89135        # Initialise the Policy Information Point  
    90136        pipCfgPrefix = prefix + cls.PIP_CFG_PREFIX 
    91         pip = PIP.fromConfig(prefix=pipCfgPrefix, **app_conf) 
    92          
     137        pip = PIP.fromConfig(app_conf, prefix=pipCfgPrefix) 
     138         
     139        # Set default issuer name if not already specified.  Nb. format must 
     140        # be overridden 
     141        if pip.attributeQueryBinding.issuerName is None: 
     142            pip.attributeQueryBinding.issuerFormat = self.issuerFormat 
     143            pip.attributeQueryBinding.issuerName = self.issuerName 
     144             
    93145        # Initialise the PDP reading in the policy         
    94146        self.pdp = PDP(policy, pip) 
    95          
    96         authzDecisionQueryIfaceEnvironKeyOptName = prefix + \ 
    97             cls.ENVIRON_KEYNAME_AUTHZ_DECISION_QUERY_IFACE_OPTNAME 
    98              
    99         self.authzDecisionFuncKeyName = app_conf.get( 
    100                                 authzDecisionQueryIfaceEnvironKeyOptName, 
    101                                 cls.DEFAULT_AUTHZ_DECISION_QUERY_IFACE_KEYNAME) 
    102          
    103         authzDecisionQueryIfaceOptName = prefix + \ 
    104                                          cls.AUTHZ_DECISION_QUERY_IFACE_OPTNAME 
    105                                           
    106         authzDecisionFunc = app_conf.get(authzDecisionQueryIfaceOptName) 
    107         if authzDecisionFunc is not None: 
    108             # Use decision function set in config 
    109             self.authzDecisionFunc = authzDecisionFunc 
    110         else: 
    111             # Use default decision function 
    112             self.authzDecisionFunc = self.createAuthzDecisionFunc() 
    113147         
    114148    @classmethod 
     
    142176        @return: next application in the WSGI stack 
    143177        ''' 
    144         environ[self.authzDecisionFuncKeyName] = self.authzDecisionFunc 
     178        environ[self.queryInterfaceKeyName] = self.queryInterface 
    145179        return self._app(environ, start_response) 
    146180 
     181    _getPolicyFilePath = lambda self: self.__policyFilePath 
     182     
     183    def _setPolicyFilePath(self, value): 
     184        if not isinstance(value, basestring): 
     185            raise TypeError('Expecting string type for "policyFilePath" ' 
     186                            'attribute; got %r' % type(value)) 
     187        self.__policyFilePath = value 
     188 
     189    policyFilePath = property(_getPolicyFilePath,  
     190                              _setPolicyFilePath,  
     191                              doc="Policy file path") 
     192 
     193    def _getIssuerFormat(self): 
     194        if self.__issuerProxy is None: 
     195            return None 
     196        else: 
     197            return self.__issuerProxy.value 
     198 
     199    def _setIssuerFormat(self, value): 
     200        if self.__issuerProxy is None: 
     201            self.__issuerProxy = Issuer() 
     202             
     203        self.__issuerProxy.format = value 
     204 
     205    issuerFormat = property(_getIssuerFormat, _setIssuerFormat,  
     206                            doc="Issuer format") 
     207 
     208    def _getIssuerName(self): 
     209        if self.__issuerProxy is None: 
     210            return None 
     211        else: 
     212            return self.__issuerProxy.value 
     213 
     214    def _setIssuerName(self, value): 
     215        if self.__issuerProxy is None: 
     216            self.__issuerProxy = Issuer() 
     217             
     218        self.__issuerProxy.value = value 
     219 
     220    issuerName = property(_getIssuerName, _setIssuerName,  
     221                          doc="Name of issuer of SAML Authorisation Query " 
     222                              "Response") 
     223 
     224    def _getClockSkewTolerance(self): 
     225        return self.__clockSkewTolerance 
     226 
     227    def _setClockSkewTolerance(self, value): 
     228        if isinstance(value, (float, int, long)): 
     229            self.__clockSkewTolerance = timedelta(seconds=value) 
     230             
     231        elif isinstance(value, basestring): 
     232            self.__clockSkewTolerance = timedelta(seconds=float(value)) 
     233        else: 
     234            raise TypeError('Expecting float, int, long or string type for ' 
     235                            '"clockSkewTolerance"; got %r' % type(value)) 
     236 
     237    clockSkewTolerance = property(fget=_getClockSkewTolerance,  
     238                                  fset=_setClockSkewTolerance,  
     239                                  doc="Allow a tolerance in seconds for SAML " 
     240                                      "Query issueInstant parameter check and " 
     241                                      "assertion condition notBefore and " 
     242                                      "notOnOrAfter times to allow for clock " 
     243                                      "skew") 
     244     
     245    _getAssertionLifetime = lambda self: self.__assertionLifetime 
     246     
     247    def _setAssertionLifetime(self, value): 
     248        if isinstance(value, (int, float, basestring)): 
     249            self.__assertionLifetime = float(value) 
     250        else: 
     251            raise TypeError('Expecting int, float or string type for ' 
     252                            '"assertionLifetime" attribute; got %s instead' %  
     253                            type(value)) 
     254 
     255    assertionLifetime = property(fget=_getAssertionLifetime, 
     256                                 fset=_setAssertionLifetime, 
     257                                 doc="lifetime of assertion in seconds used to " 
     258                                     "set assertion conditions notOnOrAfter " 
     259                                     "time") 
     260          
    147261    def _getPdp(self): 
    148262        return self.__pdp 
     
    157271    pdp = property(_getPdp, _setPdp, None, "Policy Decision Point") 
    158272 
    159     def _get_authzDecisionFuncKeyName(self): 
    160         return self.__authzDecisionFuncKeyName 
    161  
    162     def _set_authzDecisionFuncKeyName(self, val): 
     273    def _get_queryInterfaceKeyName(self): 
     274        return self.__queryInterfaceKeyName 
     275 
     276    def _set_queryInterfaceKeyName(self, val): 
    163277        if not isinstance(val, basestring): 
    164278            raise TypeError('Expecting %r for "getAuthzDecisionKeyName" ' 
    165279                            'attribute; got %r' % (basestring, type(val))) 
    166         self.__authzDecisionFuncKeyName = val 
    167          
    168     authzDecisionFuncKeyName = property(fget=_get_authzDecisionFuncKeyName,  
    169                                         fset=_set_authzDecisionFuncKeyName,  
    170                                         doc="Key name used to index " 
    171                                             "Authorization Service SAML authz " 
    172                                             "decision query function in " 
    173                                             "environ dictionary") 
    174      
    175     def _getAuthzDecisionFunc(self): 
    176         return self.__authzDecisionFunc 
    177      
    178     def _setAuthzDecisionFunc(self, value): 
     280        self.__queryInterfaceKeyName = val 
     281         
     282    queryInterfaceKeyName = property(fget=_get_queryInterfaceKeyName,  
     283                                     fset=_set_queryInterfaceKeyName,  
     284                                     doc="Key name used to index " 
     285                                         "Authorization Service SAML authz " 
     286                                         "decision query function in environ " 
     287                                         "dictionary") 
     288     
     289    def _get_queryInterface(self): 
     290        return self.__queryInterface 
     291     
     292    def _set_queryInterface(self, value): 
    179293        if isinstance(value, basestring): 
    180             self.__authzDecisionFunc = importModuleObject(value) 
     294            self.__queryInterface = importModuleObject(value) 
    181295             
    182296        elif callable(value): 
    183             self.__authzDecisionFunc = value 
     297            self.__queryInterface = value 
    184298        else: 
    185             raise TypeError('Expecting callable for "authzDecisionFunc" ' 
     299            raise TypeError('Expecting callable for "queryInterface" ' 
    186300                            'attribute; got %r instead.' % type(value)) 
    187301     
    188     authzDecisionFunc = property(_getAuthzDecisionFunc, 
    189                                  _setAuthzDecisionFunc, 
    190                                  doc="authorisation decision function set in " 
    191                                      "environ for downstream SAML Query " 
    192                                      "middleware to invoke in response to " 
    193                                      "<authzDecisionQuery>s") 
     302    queryInterface = property(_get_queryInterface, 
     303                              _set_queryInterface, 
     304                              doc="authorisation decision function set in " 
     305                                  "environ for downstream SAML Query " 
     306                                  "middleware to invoke in response to " 
     307                                  "<authzDecisionQuery>s") 
    194308          
    195     def createAuthzDecisionFunc(self): 
     309    def createQueryInterface(self): 
    196310        """Return the authorisation decision function so that __call__ can add 
    197311        it to environ for the SAML Query middleware to pick up and invoke 
     
    214328            # Make a request object to pass to the PDP 
    215329            request = Request() 
    216             request.subject[Subject.USERID_NS 
     330            request.subject[PDPSubject.USERID_NS 
    217331                            ] = authzDecisionQuery.subject.nameID.value 
    218332             
     
    226340     
    227341            # Call the PDP 
    228             pdpResponse = self.pdp.evaluate(request)         
    229              
     342            pdpResponse = self.pdp.evaluate(request) 
     343             
     344            # Create the SAML Response 
    230345            response = Response() 
     346             
     347            now = datetime.utcnow() 
     348            response.issueInstant = now 
     349             
     350            # Make up a request ID that this response is responding to 
     351            response.inResponseTo = authzDecisionQuery.id 
     352            response.id = str(uuid4()) 
     353            response.version = SAMLVersion(SAMLVersion.VERSION_20) 
     354                 
     355            response.issuer = Issuer() 
     356            response.issuer.format = self.issuerFormat 
     357            response.issuer.value = self.issuerName 
     358 
     359            response.status = Status() 
     360            response.status.statusCode = StatusCode() 
     361            response.status.statusMessage = StatusMessage()         
     362             
     363            response.status.statusCode.value = StatusCode.SUCCESS_URI 
     364            response.status.statusMessage.value = ("Response created " 
     365                                                   "successfully") 
     366             
     367            assertion = Assertion() 
     368            response.assertions.append(assertion) 
     369                
     370            assertion.version = SAMLVersion(SAMLVersion.VERSION_20) 
     371            assertion.id = str(uuid4()) 
     372            assertion.issueInstant = now 
     373             
     374            # Add a conditions statement for a validity of 8 hours 
     375            assertion.conditions = Conditions() 
     376            assertion.conditions.notBefore = now 
     377            assertion.conditions.notOnOrAfter = now + timedelta( 
     378                                                seconds=self.assertionLifetime) 
     379                    
     380            assertion.subject = Subject() 
     381            assertion.subject.nameID = NameID() 
     382            assertion.subject.nameID.format = \ 
     383                authzDecisionQuery.subject.nameID.format 
     384            assertion.subject.nameID.value = \ 
     385                authzDecisionQuery.subject.nameID.value 
     386                 
     387            assertion.issuer = Issuer() 
     388            assertion.issuer.format = self.issuerFormat 
     389            assertion.issuer.value = self.issuerName 
     390             
     391            authzDecisionStatement = AuthzDecisionStatement() 
     392            assertion.authzDecisionStatements.append(authzDecisionStatement) 
    231393                         
    232             authzDecisionStatement = AuthzDecisionStatement() 
    233394            authzDecisionStatement.resource = authzDecisionQuery.resource 
    234395            authzDecisionStatement.actions.append(Action()) 
    235396            authzDecisionStatement.actions[-1].namespace = Action.GHPP_NS_URI 
    236397            authzDecisionStatement.actions[-1].value = Action.HTTP_GET_ACTION 
    237             assertion.authzDecisionStatements.append(authzDecisionStatement) 
    238  
    239             if pdpResponse.status == Response.DECISION_PERMIT: 
     398 
     399            if pdpResponse.status == PDPResponse.DECISION_PERMIT: 
    240400                log.info("AuthzServiceMiddleware.__call__: PDP granted " 
    241401                         "access for URI path [%s] using policy [%s]",  
    242                          resourceURI,  
     402                         authzDecisionQuery.resource,  
    243403                         self.policyFilePath) 
    244404                 
    245405                authzDecisionStatement.decision = DecisionType.PERMIT 
    246406             
    247             elif pdpResponse.status == Response.DECISION_INDETERMINATE: 
     407            elif pdpResponse.status == PDPResponse.DECISION_INDETERMINATE: 
    248408                log.info("AuthzServiceMiddleware.__call__: PDP returned a " 
    249409                         "status of [%s] denying access for URI path [%s] " 
    250410                         "using policy [%s]",  
    251                          pdpResponse.decisionValue2String[response.status], 
    252                          resourceURI, 
     411                         pdpResponse.decisionValue2String[pdpResponse.status], 
     412                         authzDecisionQuery.resource, 
    253413                         self.policyFilePath)  
    254414                 
     
    259419                         "status of [%s] denying access for URI path [%s] " 
    260420                         "using policy [%s]",  
    261                          pdpResponse.decisionValue2String[response.status], 
    262                          resourceURI, 
     421                         pdpResponse.decisionValue2String[pdpResponse.status], 
     422                         authzDecisionQuery.resource, 
    263423                         self.policyFilePath)  
    264424                 
    265425                authzDecisionStatement.decision = DecisionType.DENY 
    266                                                                  
    267              
    268             now = datetime.utcnow() 
    269             response.issueInstant = now 
    270              
    271             # Make up a request ID that this response is responding to 
    272             response.inResponseTo = query.id 
    273             response.id = str(uuid4()) 
    274             response.version = SAMLVersion(SAMLVersion.VERSION_20) 
    275                  
    276             response.issuer = Issuer() 
    277             response.issuer.format = self.issuerFormat 
    278             response.issuer.value = self.issuer 
    279  
    280             response.status = Status() 
    281             response.status.statusCode = StatusCode() 
    282             response.status.statusMessage = StatusMessage()         
    283              
    284             response.status.statusCode.value = StatusCode.SUCCESS_URI 
    285             response.status.statusMessage.value = ("Response created " 
    286                                                    "successfully") 
    287                 
    288             assertion = Assertion() 
    289             assertion.version = SAMLVersion(SAMLVersion.VERSION_20) 
    290             assertion.id = str(uuid4()) 
    291             assertion.issueInstant = now 
    292              
    293             # Add a conditions statement for a validity of 8 hours 
    294             assertion.conditions = Conditions() 
    295             assertion.conditions.notBefore = now 
    296             assertion.conditions.notOnOrAfter = now + timedelta(seconds=60*60*8) 
    297                     
    298             assertion.subject = Subject()   
    299             assertion.subject.nameID = NameID() 
    300             assertion.subject.nameID.format = query.subject.nameID.format 
    301             assertion.subject.nameID.value = query.subject.nameID.value 
    302                  
    303             assertion.issuer = Issuer() 
    304             assertion.issuer.format = self.issuerFormat 
    305             assertion.issuer.value = self.issuer 
    306      
    307             response.assertions.append(assertion) 
     426     
    308427            return response 
    309428         
  • TI12-security/trunk/NDGSecurity/python/ndg_security_server/ndg/security/server/wsgi/saml/__init__.py

    r6586 r6615  
    1818from xml.etree import ElementTree 
    1919 
    20 from saml.saml2.core import Response, AttributeQuery, Status, StatusCode  
    21 from saml.xml import UnknownAttrProfile 
    22 from saml.xml.etree import AttributeQueryElementTree, ResponseElementTree 
     20from ndg.saml.saml2.core import Response, AttributeQuery, Status, StatusCode  
     21from ndg.saml.xml import UnknownAttrProfile 
     22from ndg.saml.xml.etree import AttributeQueryElementTree, ResponseElementTree 
    2323 
    2424from ndg.security.common.saml_utils.esg import XSGroupRoleAttributeValue 
  • TI12-security/trunk/NDGSecurity/python/ndg_security_test/ndg/security/test/config/attributeauthority/sitea/site-a.ini

    r6586 r6615  
    108108prefix = saml.soapbinding. 
    109109 
    110 saml.soapbinding.deserialise = saml.xml.etree:AttributeQueryElementTree.fromXML 
     110saml.soapbinding.deserialise = ndg.saml.xml.etree:AttributeQueryElementTree.fromXML 
    111111 
    112112# Specialisation to incorporate ESG Group/Role type 
  • TI12-security/trunk/NDGSecurity/python/ndg_security_test/ndg/security/test/config/attributeauthority/sitea/siteAUserRoles.py

    r6578 r6615  
    1414from uuid import uuid4 
    1515 
    16 from saml.common.xml import SAMLConstants 
    17 from saml.saml2.core import (Assertion, Attribute, AttributeStatement, Issuer, 
     16from ndg.saml.common.xml import SAMLConstants 
     17from ndg.saml.saml2.core import (Assertion, Attribute, AttributeStatement, Issuer, 
    1818                             SAMLVersion, Subject, NameID, Conditions, 
    1919                             XSStringAttributeValue) 
  • TI12-security/trunk/NDGSecurity/python/ndg_security_test/ndg/security/test/config/sessionmanager/userx509certauthn.py

    r5357 r6615  
    1818from ndg.security.server.sessionmanager import SessionManager, \ 
    1919    AbstractAuthNService, AuthNServiceInvalidCredentials, AuthNServiceError 
    20 from ndg.security.common.myproxy import MyProxyClient 
     20from myproxy.client import MyProxyClient 
     21 
    2122 
    2223class UserX509CertAuthN(AbstractAuthNService): 
  • TI12-security/trunk/NDGSecurity/python/ndg_security_test/ndg/security/test/integration/authz_lite/securityservices.ini

    r6605 r6615  
    414414prefix = saml.soapbinding. 
    415415 
    416 saml.soapbinding.deserialise = saml.xml.etree:AttributeQueryElementTree.fromXML 
     416saml.soapbinding.deserialise = ndg.saml.xml.etree:AttributeQueryElementTree.fromXML 
    417417 
    418418# Specialisation to incorporate ESG Group/Role type 
  • TI12-security/trunk/NDGSecurity/python/ndg_security_test/ndg/security/test/unit/attributeauthority/test_attributeauthority.py

    r6069 r6615  
    244244from uuid import uuid4 
    245245from datetime import datetime 
    246 from saml.saml2.core import (Response, Attribute, SAMLVersion, Subject, NameID, 
     246from ndg.saml.saml2.core import (Response, Attribute, SAMLVersion, Subject, NameID, 
    247247                             Issuer, AttributeQuery, XSStringAttributeValue,  
    248248                             Status, StatusMessage, StatusCode) 
    249 from saml.xml import XMLConstants 
     249from ndg.saml.xml import XMLConstants 
    250250from ndg.security.common.saml_utils.esg import EsgSamlNamespaces 
    251251 
  • TI12-security/trunk/NDGSecurity/python/ndg_security_test/ndg/security/test/unit/attributeauthorityclient/test_samlattributeauthorityclient.py

    r6575 r6615  
    1717from xml.etree import ElementTree 
    1818 
    19 from saml.common import SAMLVersion 
    20 from saml.common.xml import SAMLConstants 
    21 from saml.xml.etree import AttributeQueryElementTree, ResponseElementTree 
    22 from saml.saml2.core import (Subject, Issuer, Attribute, NameID, AttributeQuery, 
     19from ndg.saml.common import SAMLVersion 
     20from ndg.saml.common.xml import SAMLConstants 
     21from ndg.saml.xml.etree import AttributeQueryElementTree, ResponseElementTree 
     22from ndg.saml.saml2.core import (Subject, Issuer, Attribute, NameID, AttributeQuery, 
    2323                             StatusCode, XSStringAttributeValue, ) 
    2424 
  • TI12-security/trunk/NDGSecurity/python/ndg_security_test/ndg/security/test/unit/credentialwallet/test_credentialwallet.py

    r6512 r6615  
    2323from time import sleep 
    2424from datetime import datetime, timedelta 
    25 from saml.utils import SAMLDateTime 
    26 from saml.xml.etree import AssertionElementTree 
     25from ndg.saml.utils import SAMLDateTime 
     26from ndg.saml.xml.etree import AssertionElementTree 
    2727 
    2828from ndg.security.test.unit import BaseTestCase 
  • TI12-security/trunk/NDGSecurity/python/ndg_security_test/ndg/security/test/unit/saml/test_samlinterface.py

    r6069 r6615  
    2020from xml.etree import ElementTree 
    2121 
    22 from saml.saml2.core import (Response, Assertion, Attribute,  
     22from ndg.saml.saml2.core import (Response, Assertion, Attribute,  
    2323                             AttributeStatement, SAMLVersion, Subject, NameID, 
    2424                             Issuer, AttributeQuery, XSStringAttributeValue,  
    2525                             Conditions, Status, StatusCode) 
    26 from saml.xml import XMLConstants 
    27 from saml.xml.etree import AttributeQueryElementTree, ResponseElementTree 
     26from ndg.saml.xml import XMLConstants 
     27from ndg.saml.xml.etree import AttributeQueryElementTree, ResponseElementTree 
    2828 
    2929from ndg.security.common.soap.client import (UrlLib2SOAPClient,  
  • TI12-security/trunk/NDGSecurity/python/ndg_security_test/ndg/security/test/unit/sessionmanager/userx509certauthn.py

    r4840 r6615  
    1616from ndg.security.server.sessionmanager import SessionManager, \ 
    1717    AbstractAuthNService, AuthNServiceInvalidCredentials, AuthNServiceError 
    18 from ndg.security.common.myproxy import MyProxyClient 
     18from myproxy.client import MyProxyClient 
     19 
    1920 
    2021class UserX509CertAuthN(AbstractAuthNService): 
  • TI12-security/trunk/NDGSecurity/python/ndg_security_test/ndg/security/test/unit/wsgi/saml/attribute-interface.ini

    r6578 r6615  
    2525saml.pathMatchList = /attributeauthority/saml 
    2626saml.queryInterfaceKeyName = attributeQueryInterface 
    27 saml.deserialise = saml.xml.etree:AttributeQueryElementTree.fromXML 
     27saml.deserialise = ndg.saml.xml.etree:AttributeQueryElementTree.fromXML 
    2828 
    2929# Specialisation to incorporate ESG Group/Role type 
  • TI12-security/trunk/NDGSecurity/python/ndg_security_test/ndg/security/test/unit/wsgi/saml/authz-decision-interface.ini

    r6605 r6615  
    2828saml.pathMatchList = /authorisationservice 
    2929saml.queryInterfaceKeyName = AUTHZ_DECISION_QUERY_FUNC 
    30 saml.deserialise = saml.xml.etree:AuthzDecisionQueryElementTree.fromXML 
    31 saml.serialise = saml.xml.etree:ResponseElementTree.toXML 
     30saml.deserialise = ndg.saml.xml.etree:AuthzDecisionQueryElementTree.fromXML 
     31saml.serialise = ndg.saml.xml.etree:ResponseElementTree.toXML 
    3232 
    3333#______________________________________________________________________________ 
  • TI12-security/trunk/NDGSecurity/python/ndg_security_test/ndg/security/test/unit/wsgi/saml/authz-service.ini

    r6605 r6615  
    88port = 5000 
    99baseURI = localhost:%(port)s 
    10  
     10queryInterfaceKeyName = AUTHZ_DECISION_QUERY_FUNC 
    1111[server:main] 
    1212use = egg:Paste#http 
     
    2424prefix = saml. 
    2525saml.pathMatchList = /authorisationservice 
    26 saml.queryInterfaceKeyName = AUTHZ_DECISION_QUERY_FUNC 
    27 saml.deserialise = saml.xml.etree:AuthzDecisionQueryElementTree.fromXML 
    28 saml.serialise = saml.xml.etree:ResponseElementTree.toXML 
     26saml.queryInterfaceKeyName = %(queryInterfaceKeyName)s 
     27saml.deserialise = ndg.saml.xml.etree:AuthzDecisionQueryElementTree.fromXML 
     28saml.serialise = ndg.saml.xml.etree:ResponseElementTree.toXML 
    2929 
    3030#______________________________________________________________________________ 
     
    3434# This filter is a container for a binding to a SOAP based interface to the 
    3535# Attribute Authority 
    36 paste.filter_app_factory = ndg.security.server.wsgi.saml.authzservice:AuthzServiceMiddleware 
    37 queryInterfaceKeyName = AUTHZ_DECISION_QUERY_FUNC 
     36paste.filter_app_factory = ndg.security.server.wsgi.authzservice:AuthzServiceMiddleware.filter_app_factory 
     37prefix = authz. 
     38authz.policy.filePath = %(here)s/policy-1.1.xml 
     39authz.queryInterfaceKeyName = %(queryInterfaceKeyName)s 
     40 
     41# AuthzDecisionQuery Response settings 
     42authz.issuerName = /O=NDG/OU=CEDA/CN=Authorisation Service 
     43authz.clockSkewTolerance = 1 
     44authz.assertionLifetime = 86400 
     45 
     46# Policy Information Point settings - makes an Attribute Queries to  
     47# Attribute Authorities 
     48authz.pip.attributeQuery.subjectIdFormat = urn:esg:openid 
     49authz.pip.attributeQuery.verifyTimeConditions = True 
  • TI12-security/trunk/NDGSecurity/python/ndg_security_test/ndg/security/test/unit/wsgi/saml/test_soapattributeinterface.py

    r6578 r6615  
    1515from cStringIO import StringIO 
    1616 
    17 from saml.saml2.core import (Attribute, SAMLVersion, Subject, NameID, Issuer,  
     17from ndg.saml.saml2.core import (Attribute, SAMLVersion, Subject, NameID, Issuer,  
    1818                             AttributeQuery, XSStringAttributeValue,  
    1919                             StatusCode) 
    20 from saml.xml import XMLConstants 
    21 from saml.xml.etree import AttributeQueryElementTree, ResponseElementTree 
     20from ndg.saml.xml import XMLConstants 
     21from ndg.saml.xml.etree import AttributeQueryElementTree, ResponseElementTree 
    2222 
    2323from ndg.security.common.soap.etree import SOAPEnvelope 
  • TI12-security/trunk/NDGSecurity/python/ndg_security_test/ndg/security/test/unit/wsgi/saml/test_soapauthzdecisioninterface.py

    r6605 r6615  
    1515from cStringIO import StringIO 
    1616 
    17 from saml.saml2.core import (SAMLVersion, Subject, NameID, Issuer, Response, 
     17from ndg.saml.saml2.core import (SAMLVersion, Subject, NameID, Issuer, Response, 
    1818                             AuthzDecisionQuery, AuthzDecisionStatement, Status, 
    1919                             StatusCode, StatusMessage, DecisionType, Action,  
    2020                             Conditions, Assertion) 
    21 from saml.xml.etree import AuthzDecisionQueryElementTree, ResponseElementTree 
     21from ndg.saml.xml.etree import AuthzDecisionQueryElementTree, ResponseElementTree 
    2222 
    2323from ndg.security.common.soap.etree import SOAPEnvelope 
     
    101101                                        SoapSamlInterfaceMiddlewareTestCase): 
    102102    CONFIG_FILENAME = 'authz-decision-interface.ini' 
    103  
     103    RESOURCE_URI = TestAuthorisationServiceMiddleware.RESOURCE_URI 
     104     
    104105    def _createAuthzDecisionQuery(self,  
    105                     issuer="/O=Site A/CN=PEP", 
    106                     subject="https://openid.localhost/philip.kershaw", 
    107                     resource=TestAuthorisationServiceMiddleware.RESOURCE_URI, 
    108                     action=Action.HTTP_GET_ACTION, 
    109                     actionNs=Action.GHPP_NS_URI): 
     106                            issuer="/O=Site A/CN=PEP", 
     107                            subject="https://openid.localhost/philip.kershaw", 
     108                            resource=RESOURCE_URI, 
     109                            action=Action.HTTP_GET_ACTION, 
     110                            actionNs=Action.GHPP_NS_URI): 
    110111        query = AuthzDecisionQuery() 
    111112        query.version = SAMLVersion(SAMLVersion.VERSION_20) 
     
    196197    """ 
    197198    CONFIG_FILENAME = 'authz-service.ini' 
     199    RESOURCE_URI = 'http://localhost/dap/data/my.nc.dods?time[0:1:0]' 
     200     
     201    def __init__(self, *arg, **kw): 
     202        """Extend base init to include SAML Attribute Authority required by 
     203        Authorisation Service""" 
     204        super(SOAPAuthzDecisionInterfaceMiddlewareTestCase, self).__init__( 
     205                                                                    *arg, **kw) 
     206        self.startSiteAAttributeAuthority(withSSL=True, port=5443) 
    198207     
    199208     
Note: See TracChangeset for help on using the changeset viewer.