Changeset 5181


Ignore:
Timestamp:
07/04/09 16:40:44 (10 years ago)
Author:
pjkersha
Message:

Added a Policy Information Point to encapsulate subject attribute retrieval.

Location:
TI12-security/trunk/python
Files:
21 edited

Legend:

Unmodified
Added
Removed
  • TI12-security/trunk/python/ndg.security.common/ndg/security/common/AttCert.py

    r4840 r5181  
    3636 
    3737 
    38 #_____________________________________________________________________________ 
    3938class AttCertError(Exception):   
    4039    """Exception handling for NDG Attribute Certificate class.""" 
    4140 
    42 #_____________________________________________________________________________ 
     41class AttCertNotBeforeTimeError(AttCertError): 
     42    """Current time is before the Attribute Certificate's not before time""" 
     43 
     44class AttCertExpired(AttCertError): 
     45    """Current time is after the Attribute Certificate's not after time""" 
     46 
    4347class AttCertReadOnlyDict(dict): 
    4448    def __init__(self, inputDict): 
     
    4650         
    4751    def __setitem__(self, key, item): 
    48         raise KeyError, "Items are read-only in this dictionary" 
     52        raise KeyError("Items are read-only in this dictionary") 
    4953        
    50 #_____________________________________________________________________________ 
    5154class _MetaAttCert(type): 
    5255    """Enable AttCert to have read only class variables e.g. 
     
    5861    ... raises - AttributeError: can't set attribute""" 
    5962     
    60     #_________________________________________________________________________     
    6163    def __getVersion(cls): 
    6264        '''Version of THIS format for the certificate''' 
     
    10411043        version (default is True) 
    10421044 
    1043         @param chkProvenanceset to True to check provenance value is valid 
     1045        @param chkProvenance: set to True to check provenance value is valid 
    10441046        (default is True) 
    10451047 
  • TI12-security/trunk/python/ndg.security.common/ndg/security/common/authz/msi.py

    r5168 r5181  
    8888        return resource 
    8989 
    90 class Subject(object): 
     90class _AttrDict(dict): 
     91    """Utility class for holding a constrained list of attributes governed 
     92    by a namespace list""" 
     93    namespaces = () 
     94    def __init__(self, **attributes): 
     95        invalidAttributes = [attr for attr in attributes \ 
     96                             if attr not in self.__class__.namespaces] 
     97        if len(invalidAttributes) > 0: 
     98            raise TypeError("The following attribute namespace(s) are not " 
     99                            "recognised: %s" % invalidAttributes) 
     100             
     101        self.update(attributes) 
     102 
     103    def __setitem__(self, key, val): 
     104        if key not in self.__class__.namespaces: 
     105            raise KeyError('Namespace "%s" not recognised.  Valid namespaces ' 
     106                           'are: %s' % self.__class__.namespaces) 
     107             
     108        dict.__setitem__(self, key, val) 
     109 
     110 
     111    def update(self, d, **kw):         
     112        for dictArg in (d, kw): 
     113            for k in dictArg: 
     114                if key not in self.__class__.namespaces: 
     115                    raise KeyError('Namespace "%s" not recognised.  Valid ' 
     116                                   'namespaces are: %s' % 
     117                                   self.__class__.namespaces) 
     118         
     119        dict.update(self, d, **kw) 
     120 
     121class Subject(_AttrDict): 
    91122    '''Subject designator''' 
    92     def __init__(self, attributes={}): 
    93         self.attributes = attributes 
    94  
    95 class Resource(object): 
     123    namespaces = ( 
     124        "urn:ndg:security:authz:1.0:attr:subject:userId", 
     125        "urn:ndg:security:authz:1.0:attr:subject:sessionId", 
     126        "urn:ndg:security:authz:1.0:attr:subject:sessionManagerURI", 
     127        "urn:ndg:security:authz:1.0:attr:subject:roles"         
     128    ) 
     129    (USERID_NS, SESSIONID_NS, SESSIONMANAGERURI_NS, ROLES_NS) = namespaces 
     130 
     131class Resource(_AttrDict): 
    96132    '''Resource designator''' 
    97     def __init__(self, uri=''): 
    98         self.uri = uri 
    99          
    100     def __str__(self): 
    101         return self.uri 
    102         
    103     def __eq__(self, uri): 
    104         return self.uri == uri 
    105      
     133    namespaces = ( 
     134        "urn:ndg:security:authz:1.0:attr:resource:uri", 
     135    ) 
     136    (URI_NS,) = namespaces 
     137            
    106138class Request(object): 
    107139    '''Request to send to a PDP''' 
     
    129161         
    130162         
     163from ndg.security.common.sessionmanager import SessionManagerClient, \ 
     164    SessionNotFound, SessionCertTimeError, SessionExpired, InvalidSession, \ 
     165    AttributeRequestDenied 
     166                     
     167from ndg.security.common.authz.pdp import PDPUserNotLoggedIn, \ 
     168    PDPUserAccessDenied 
     169     
     170class SubjectRetrievalError(Exception): 
     171    """Generic exception class for errors related to information about the 
     172    subject""" 
     173     
     174class InvalidAttributeCertificate(SubjectRetrievalError): 
     175    "The certificate containing authorisation roles is invalid" 
     176    def __init__(self, msg=None): 
     177        SubjectRetrievalError.__init__(self, msg or  
     178                                       InvalidAttributeCertificate.__doc__) 
     179         
     180class AttributeCertificateNotBeforeTimeError(SubjectRetrievalError): 
     181    ("There is a time issuing error with certificate containing authorisation " 
     182    "roles") 
     183    def __init__(self, msg=None): 
     184        SubjectRetrievalError.__init__(self, msg or  
     185                                AttributeCertificateNotBeforeTimeError.__doc__) 
     186         
     187class AttributeCertificateExpired(SubjectRetrievalError): 
     188    "The certificate containing authorisation roles has expired" 
     189    def __init__(self, msg=None): 
     190        SubjectRetrievalError.__init__(self, msg or  
     191                                       AttributeCertificateExpired.__doc__) 
     192             
     193class SessionExpiredMsg(SubjectRetrievalError): 
     194    'Session has expired.  Please re-login at your home organisation' 
     195    def __init__(self, msg=None): 
     196        SubjectRetrievalError.__init__(self, msg or SessionExpiredMsg.__doc__) 
     197 
     198class SessionNotFoundMsg(SubjectRetrievalError): 
     199    'No session was found.  Please try re-login with your home organisation' 
     200    def __init__(self, msg=None): 
     201        SubjectRetrievalError.__init__(self, msg or  
     202                                       SessionNotFoundMsg.__doc__) 
     203 
     204class InvalidSessionMsg(SubjectRetrievalError): 
     205    'Session is invalid.  Please try re-login with your home organisation' 
     206    def __init__(self, msg=None): 
     207        SubjectRetrievalError.__init__(self, msg or  
     208                                       InvalidSessionMsg.__doc__) 
     209 
     210class InitSessionCtxError(SubjectRetrievalError): 
     211    'A problem occurred initialising a session connection' 
     212    def __init__(self, msg=None): 
     213        SubjectRetrievalError.__init__(self, msg or  
     214                                       InitSessionCtxError.__doc__) 
     215 
     216class AttributeCertificateRequestError(SubjectRetrievalError): 
     217    'A problem occurred requesting a certificate containing authorisation roles' 
     218    def __init__(self, msg=None): 
     219        SubjectRetrievalError.__init__(self,msg or  
     220                                    AttributeCertificateRequestError.__doc__) 
     221 
     222class PIPAttributeQuery(_AttrDict): 
     223    namespaces = ( 
     224        "urn:ndg:security:authz:1.0:attr:subject", 
     225        "urn:ndg:security:authz:1.0:attr:attributeAuthorityURI", 
     226    )   
     227    (SUBJECT_NS, ATTRIBUTEAUTHORITY_NS) = namespaces     
     228 
     229class PIPAttributeResponse(_AttrDict): 
     230    namespaces = ( 
     231        "urn:ndg:security:authz:1.0:attr:attributeCertificate", 
     232    ) 
     233    (ATTRIBUTECERTIFICATE_NS,) = namespaces 
     234 
     235 
     236from ndg.security.common.wssecurity import WSSecurityConfig 
     237from ndg.security.common.credentialwallet import CredentialWallet 
     238 
     239class PIP(object): 
     240    """Policy Information Point - this implementation enables the PDP to  
     241    retrieve attributes about the Subject""" 
     242 
     243    def __init__(self, prefix='', **cfg): 
     244        '''Set-up WS-Security and SSL settings for connection to an 
     245        Attribute Authority 
     246         
     247        @type **cfg: dict 
     248        @param **cfg: keywords including 'sslCACertFilePathList' used to set a 
     249        list of CA certificates for an SSL connection to the Attribute 
     250        Authority if used and also WS-Security settings as used by 
     251        ndg.security.common.wssecurity.WSSecurityConfig 
     252        ''' 
     253        self._subjectCache = {} 
     254         
     255        self.wssecurityCfg = WSSecurityConfig() 
     256        wssePrefix = prefix + 'wssecurity' 
     257        self.wssecurityCfg.update(cfg, prefix=wssePrefix) 
     258                  
     259        self.sslCACertFilePathList = cfg.get(prefix+'sslCACertFilePathList',[]) 
     260 
     261    def attributeQuery(self, attributeQuery): 
     262        """Query the Attribute Authority specified in the request to retrieve 
     263        the attributes if any corresponding to the subject 
     264         
     265        @type attributeResponse: PIPAttributeQuery 
     266        @param attributeResponse:  
     267        @rtype: PIPAttributeResponse 
     268        @return: response containing the attributes retrieved from the 
     269        Attribute Authority""" 
     270         
     271        subject = attributeQuery[PIPAttributeQuery.SUBJECT_NS] 
     272        sessionId = subject[Subject.SESSIONID_NS] 
     273        attributeAuthorityURI = attributeQuery[ 
     274                                    PIPAttributeQuery.ATTRIBUTEAUTHORITY_NS] 
     275         
     276        # Check this subject's cache for an Attribute Certificate previously 
     277        # retrieved. 
     278        attributeCertificate = None 
     279        if self._subjectCache.get(sessionId) is not None: 
     280            subjectCred = subjectCache.credentialByURI.get( 
     281                                                        attributeAuthorityURI) 
     282             
     283            if subjectCred is not None: 
     284                if subjectCred['attCert'].isValid(): 
     285                    attributeCertificate = subjectCred['attCert'] 
     286         
     287        # If no Attribute Certificate is available, retrieve from the relevant 
     288        # Attribute Authority       
     289        if attributeCertificate is None:   
     290            sessionId = subject[Subject.SESSIONID_NS] 
     291            attributeCertificate = self._getAttributeCertificate( 
     292                                        sessionId, 
     293                                        subject[Subject.SESSIONMANAGERURI_NS], 
     294                                        attributeAuthorityURI) 
     295             
     296            # Make a new wallet for this subject 
     297            self._subjectCache[sessionId] = \ 
     298                        CredentialWallet(userId=attributeCertificate.userId) 
     299                         
     300            self._subjectCache[sessionId].addCredential( 
     301                                attributeCertificate, 
     302                                attributeAuthorityURI=attributeAuthorityURI) 
     303 
     304        attributeResponse = PIPAttributeResponse() 
     305        attributeResponse[PIPAttributeResponse.ATTRIBUTECERTIFICATE_NS] = \ 
     306                                                        attributeCertificate 
     307          
     308        return attributeResponse 
     309     
     310     
     311    def _getAttributeCertificate(self,  
     312                                 sessionId, 
     313                                 sessionManagerURI, 
     314                                 attributeAuthorityURI): 
     315        '''Retrieve an Attribute Certificate using the subject's Session 
     316        Manager 
     317         
     318        @type sessionId: basestring 
     319        @param sessionId: Session Manager session handle 
     320        @type sessionManagerURI: basestring 
     321        @param sessionManagerURI: URI to remote session manager service 
     322        @type attributeAuthorityURI: basestring 
     323        @param attributeAuthorityURI: URI to Attribute Authority service 
     324        ''' 
     325         
     326        try: 
     327            # Create Session Manager client - if a file path was set, setting 
     328            # are read from a separate config file section otherwise, from the 
     329            # PDP config object 
     330            smClnt = SessionManagerClient( 
     331                            uri=sessionManagerURI, 
     332                            sslCACertFilePathList=self.sslCACertFilePathList, 
     333                            cfg=self.wssecurityCfg) 
     334        except Exception, e: 
     335            log.error("Creating Session Manager client: %s" % e) 
     336            raise InitSessionCtxError() 
     337         
     338          
     339        try: 
     340            # Make request for attribute certificate 
     341            attCert = smClnt.getAttCert( 
     342                                attributeAuthorityURI=attributeAuthorityURI, 
     343                                sessID=sessionId) 
     344         
     345        except AttributeRequestDenied, e: 
     346            log.error("Request for attribute certificate denied: %s" % e) 
     347            raise PDPUserAccessDenied() 
     348         
     349        except SessionNotFound, e: 
     350            log.error("No session found: %s" % e) 
     351            raise SessionNotFoundMsg() 
     352 
     353        except SessionExpired, e: 
     354            log.error("Session expired: %s" % e) 
     355            raise SessionExpiredMsg() 
     356 
     357        except SessionCertTimeError, e: 
     358            log.error("Session cert. time error: %s" % e) 
     359            raise InvalidSessionMsg() 
     360             
     361        except InvalidSession, e: 
     362            log.error("Invalid user session: %s" % e) 
     363            raise InvalidSessionMsg() 
     364 
     365        except Exception, e: 
     366            log.error("Request from Session Manager [%s] to Attribute " 
     367                      "Authority [%s] for attribute certificate: %s: %s" %  
     368                      (sessionManagerURI, 
     369                       attributeAuthorityURI, 
     370                       e.__class__, e)) 
     371            raise AttributeCertificateRequestError() 
     372         
     373        try: 
     374            attCert.isValid(raiseExcep=True) 
     375         
     376        except AttCertNotBeforeTimeError, e:    
     377            log.exception(e) 
     378            raise AttributeCertificateNotBeforeTimeError() 
     379         
     380        except AttCertExpired, e:    
     381            log.exception(e) 
     382            raise AttributeCertificateExpired() 
     383 
     384        except AttCertError, e: 
     385            log.exception(e) 
     386            raise InvalidAttributeCertificate() 
     387             
     388        return attCert 
     389 
     390            
     391            
    131392class PDP(object): 
    132     def __init__(self, policyFilePath): 
     393    """Policy Decision Point""" 
     394     
     395    def __init__(self, policyFilePath=Policy(), pip=None): 
     396        """Read in a file which determines access policy""" 
    133397        self.policy = Policy.Parse(policyFilePath) 
     398        self.pip = pip 
    134399         
    135400    def evaluate(self, request): 
    136401        '''Make access control decision''' 
    137              
    138         for attr in request.resource.attributes: 
    139             if attr in request.subject.attributes: 
     402         
     403        # Look for matching targets to the given resource 
     404        resourceURI = request.resource[Resource.URI_NS] 
     405        matchingTargets = [target for target in self.policy.targets  
     406                           if target.regEx.match(resourceURI) is not None] 
     407         
     408        knownAttributeAuthorityURIs = [] 
     409        for matchingTarget in matchingTargets: 
     410             
     411            # Make call to the Policy Information Point to pull user 
     412            # attributes applicable to this resource 
     413            if matchingTarget.attributeAuthorityURI not in \ 
     414               knownAttributeAuthorityURIs: 
     415                 
     416                attributeQuery = PIPAttributeQuery() 
     417                attributeQuery[PIPAttributeQuery.SUBJECT_NS]=request.subject 
     418                 
     419                attributeQuery[PIPAttributeQuery.ATTRIBUTEAUTHORITY_NS] = \ 
     420                                        matchingTarget.attributeAuthorityURI 
     421                 
     422                attributeResponse = self.pip.attributeQuery(attributeQuery) 
     423                knownAttributeAuthorityURIs.append( 
     424                                        matchingTarget.attributeAuthorityURI) 
     425                 
     426                attributeCertificate = attributeResponse[ 
     427                                PIPAttributeResponse.ATTRIBUTECERTIFICATE_NS] 
     428                request.subject[Subject.ROLES_NS] = attributeCertificate.roles  
     429                
     430        # Match the subject's attributes against the target 
     431        for attr in matchingTarget.attributes: 
     432            if attr in request.subject[Subject.ROLES_NS]: 
    140433                return Response(Response.DECISION_PERMIT) 
    141434             
  • TI12-security/trunk/python/ndg.security.common/ndg/security/common/credentialwallet.py

    r5063 r5181  
    305305        '_cfg', 
    306306        '_credentials', 
     307        '_credentialsKeyedByURI', 
    307308        '_dn', 
    308309        '_attributeAuthorityURI' 
     
    413414            self.audit() 
    414415 
     416    def __getstate__(self): 
     417        '''Enable pickling for use with beaker.session''' 
     418        return dict([(attrName, getattr(self, attrName)) \ 
     419                     for attrName in CredentialWallet._protectedAttrs]) 
     420         
     421    def __setstate__(self): 
     422        '''Enable pickling for use with beaker.session''' 
     423        pass 
     424     
    415425    def parseConfig(self, cfg, prefix='', section='DEFAULT'): 
    416426        '''Extract parameters from _cfg config object''' 
     
    631641         
    632642    def _getCredentials(self): 
    633         """Get Property method.  Credentials are read-only 
     643        """Get Property method.  Credentials doct is read-only but also see  
     644        addCredential method 
    634645         
    635646        @rtype: dict 
     
    642653                               "issuing authorities") 
    643654 
    644  
     655    def _getCredentialsKeyedByURI(self): 
     656        """Get Property method for credentials keyed by Attribute Authority URI 
     657        Credentials dict is read-only but also see addCredential method 
     658         
     659        @rtype: dict 
     660        @return: cached ACs indexed by issuing Attribute Authority""" 
     661        return self._credentialsKeyedByURI 
     662     
     663    # Publish attribute 
     664    credentialsKeyedByURI = property(fget=_getCredentials, 
     665                           doc="List of Attribute Certificates linked to " 
     666                               "attribute authority URI") 
     667         
    645668    def _getCACertFilePathList(self): 
    646669        """Get CA cert or certs used to validate AC signatures and signatures 
     
    845868 
    846869 
    847     def addCredential(self, attCert, bUpdateCredentialRepository=True): 
     870    def addCredential(self,  
     871                      attCert,  
     872                      attributeAuthorityURI=None, 
     873                      bUpdateCredentialRepository=True): 
    848874        """Add a new attribute certificate to the list of credentials held. 
    849875 
    850876        @type attCert: 
    851877        @param attCert: new attribute Certificate to be added 
     878        @type attributeAuthorityURI: basestring 
     879        @param attributeAuthorityURI: input the Attribute Authority URI from 
     880        which attCert was retrieved.  This is added to a dict to enable access 
     881        to a given Attribute Certificate keyed by Attribute Authority URI.  
     882        See the getCredential method. 
    852883        @type bUpdateCredentialRepository: bool 
    853884        @param bUpdateCredentialRepository: if set to True, and a repository  
     
    857888        @return: True if certificate was added otherwise False.  - If an 
    858889        existing certificate from the same issuer has a later expiry it will 
    859         take precence and the new input certificate is ignored.""" 
     890        take precedence and the new input certificate is ignored.""" 
    860891 
    861892        # Check input 
    862893        if not isinstance(attCert, AttCert): 
    863             raise CredentialWalletError("Attribute Certificate must be an AttCert " 
    864                                   "type object") 
     894            raise CredentialWalletError("Attribute Certificate must be an " 
     895                                        "AttCert type object") 
    865896 
    866897        # Check certificate validity 
     
    897928            # from the CredentialRepository during creation of the wallet will 
    898929            # have +ve IDs previously allocated by the database 
    899             self._credentials[issuerName] = {'id': -1, 'attCert': attCert} 
    900  
     930            self._credentials[issuerName] = { 
     931                'id': -1,  
     932                'attCert': attCert, 
     933                'attributeAuthorityURI': attributeAuthorityURI 
     934            } 
     935 
     936            if attributeAuthorityURI: 
     937                self._credentialsKeyedByURI[attributeAuthorityURI] = \ 
     938                    self._credentials[issuerName] 
     939             
    901940            # Update the Credentials Repository - the permanent store of user 
    902941            # authorisation credentials.  This allows credentials for previous 
  • TI12-security/trunk/python/ndg.security.common/ndg/security/common/wssecurity/signaturehandler/__init__.py

    r5168 r5181  
    238238            self.cfg = cfg 
    239239        else: 
    240             raise TypeError("cfg keyword set to %s type.  cfg must be a " 
    241                             "file path string, RawConfigParser derived " 
    242                             "class instance or WSSecurityConfig type" % 
    243                             cfg.__class__) 
    244  
     240            self.cfg = cfgClass() 
     241                 
    245242        # Also update config from keywords set  
    246         log.debug("BaseSignatureHandler.__init__: setting config from " 
     243        log.debug("BaseSignatureHandler.__init__: updating config from " 
    247244                  "keywords...") 
    248245         
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/sso/sso/config/ssoServiceMiddleware.py

    r4821 r5181  
    118118            self.smURI = None 
    119119             
    120         if self.cfg.has_option(defSection, 'sessionManagerEnvironKey'):         
    121             self.smEnvironKey = self.cfg.get(defSection,  
    122                                              'sessionManagerEnvironKey') 
    123         else: 
    124             self.smEnvironKey = None 
     120        if self.cfg.has_option(defSection, 'sessionManagerEnvironKeyName'):         
     121            self.smEnvironKeyName = self.cfg.get(defSection,  
     122                                             'sessionManagerEnvironKeyName') 
     123        else: 
     124            self.smEnvironKeyName = None 
    125125             
    126126        if self.cfg.has_option(defSection, 'attributeAuthorityURI'):         
     
    129129            self.aaURI = None 
    130130             
    131         if self.cfg.has_option(defSection, 'attributeAuthorityEnvironKey'):         
    132             self.aaEnvironKey = self.cfg.get(defSection,  
    133                                              'attributeAuthorityEnvironKey') 
    134         else: 
    135             self.aaEnvironKey = None 
     131        if self.cfg.has_option(defSection, 'attributeAuthorityEnvironKeyName'):         
     132            self.aaEnvironKeyName = self.cfg.get(defSection,  
     133                                             'attributeAuthorityEnvironKeyName') 
     134        else: 
     135            self.aaEnvironKeyName = None 
    136136         
    137137        # ... for SSL connections to security web services 
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/sso/sso/controllers/login.py

    r4898 r5181  
    5252        try:     
    5353            smClnt = WSGISessionManagerClient( 
    54                         environ=request.environ, 
    55                         uri=session['ndgSec']['h'], 
    56                         environKey=self.cfg.smEnvironKey, 
    57                         attributeAuthorityEnvironKey=self.cfg.aaEnvironKey, 
    58                         tracefile=self.cfg.tracefile, 
    59                         httpProxyHost=self.cfg.httpProxyHost, 
    60                         noHttpProxyList=self.cfg.noHttpProxyList, 
    61                         sslCACertFilePathList=self.cfg.sslCACertFilePathList, 
    62                         **self.cfg.wss)                                 
     54                    environ=request.environ, 
     55                    uri=session['ndgSec']['h'], 
     56                    environKeyName=self.cfg.smEnvironKeyName, 
     57                    attributeAuthorityEnvironKeyName=self.cfg.aaEnvironKeyName, 
     58                    tracefile=self.cfg.tracefile, 
     59                    httpProxyHost=self.cfg.httpProxyHost, 
     60                    noHttpProxyList=self.cfg.noHttpProxyList, 
     61                    sslCACertFilePathList=self.cfg.sslCACertFilePathList, 
     62                    **self.cfg.wss)                                 
    6363        except Exception, e: 
    6464            c.xml = ('Error establishing security context.  Please report ' 
     
    109109        try:     
    110110            smClnt = WSGISessionManagerClient( 
    111                         environ=request.environ, 
    112                         uri=self.cfg.smURI, 
    113                         environKey=self.cfg.smEnvironKey, 
    114                         attributeAuthorityEnvironKey=self.cfg.aaEnvironKey, 
    115                         tracefile=self.cfg.tracefile, 
    116                         httpProxyHost=self.cfg.httpProxyHost, 
    117                         noHttpProxyList=self.cfg.noHttpProxyList, 
    118                         **self.cfg.wss) 
     111                    environ=request.environ, 
     112                    uri=self.cfg.smURI, 
     113                    environKeyName=self.cfg.smEnvironKeyName, 
     114                    attributeAuthorityEnvironKeyName=self.cfg.aaEnvironKeyName, 
     115                    tracefile=self.cfg.tracefile, 
     116                    httpProxyHost=self.cfg.httpProxyHost, 
     117                    noHttpProxyList=self.cfg.noHttpProxyList, 
     118                    **self.cfg.wss) 
    119119                                 
    120120            username = request.params['username'] 
     
    225225                                    environ=request.environ, 
    226226                                    uri=self.cfg.aaURI, 
    227                                     environKey=self.cfg.aaEnvironKey, 
     227                                    environKeyName=self.cfg.aaEnvironKeyName, 
    228228                                    tracefile=self.cfg.tracefile, 
    229229                                    httpProxyHost=self.cfg.httpProxyHost, 
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/sso/sso/controllers/logout.py

    r4907 r5181  
    4545            smClnt = WSGISessionManagerClient(uri=session['ndgSec']['h'], 
    4646                        environ=request.environ, 
    47                         environKey=self.cfg.smEnvironKey, 
     47                        environKeyName=self.cfg.smEnvironKeyName, 
    4848                        tracefile=cfg.tracefile, 
    4949                        sslCACertFilePathList=cfg.sslCACertFilePathList, 
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/sso/sso/lib/openid_util.py

    r4900 r5181  
    128128        aaClnt = WSGIAttributeAuthorityClient(environ=pylons.request.environ, 
    129129                                        uri=cfg.aaURI, 
    130                                         environKey=cfg.aaEnvironKey, 
     130                                        environKeyName=cfg.aaEnvironKeyName, 
    131131                                        tracefile=cfg.tracefile, 
    132132                                        httpProxyHost=cfg.httpProxyHost, 
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/wsgi/authn.py

    r5154 r5181  
    2929        try: 
    3030            client = WSGISessionManagerClient(environ=environ, 
    31                                         environKey=self.sessionManagerFilterID) 
     31                                    environKeyName=self.sessionManagerFilterID) 
    3232            res = client.connect(username, passphrase=password) 
    3333 
     
    7676        self._redirectURI = None 
    7777        super(AuthenticationRedirectMiddleware, self).__init__(app,  
    78                                                       global_conf,  
    79                                                       **app_conf) 
     78                                                               global_conf,  
     79                                                               **app_conf) 
    8080         
    8181    @NDGSecurityMiddlewareBase.initCall 
     
    196196            session.pop('username', None) 
    197197            session.pop('sessionManagerURI', None) 
     198            session.pop('sessionId', None) 
    198199            session.save() 
    199200        else: 
     
    204205                # eval is safe here because AuthKit cookie is signed and  
    205206                # AuthKit middleware checks for tampering 
    206                 if 'sessionManagerURI' not in session: 
     207                if 'sessionManagerURI' not in session or \ 
     208                   'sessionId' not in session: 
    207209                    axData = eval(environ['REMOTE_USER_DATA']) 
    208210                    sessionManagerURI=axData['ax']['value.sessionManagerURI.1'] 
    209211                    session['sessionManagerURI'] = sessionManagerURI 
    210                  
     212 
     213                    sessionId = axData['ax']['value.sessionId.1'] 
     214                    session['sessionId'] = sessionId 
     215                     
    211216                # Reset cookie removing user data 
    212217                environ['paste.auth_tkt.set_user'](session['username']) 
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/wsgi/authz/__init__.py

    r5168 r5181  
    1515from ndg.security.server.wsgi import NDGSecurityPathFilter 
    1616from ndg.security.common.X509 import X500DN 
    17 from ndg.security.common.authz.msi import Policy 
    1817from ndg.security.server.wsgi import NDGSecurityMiddlewareBase, \ 
    1918    NDGSecurityMiddlewareConfigError 
     
    2221    NDGSecurityMiddlewareConfigError 
    2322 
    24 from ndg.security.common.authz.msi import PDP, Request, Resource 
    25 from ndg.security.common.wssecurity import WSSecurityConfig 
    26 from ndg.security.common.sessionmanager import SessionManagerClient, \ 
    27     SessionNotFound, SessionCertTimeError, SessionExpired, InvalidSession, \ 
    28     AttributeRequestDenied                    
    29      
    30 class SubjectRetrievalError(Exception): 
    31     """Generic exception class for errors related to information about the 
    32     subject""" 
    33      
    34 class InvalidAttributeCertificate(SubjectRetrievalError): 
    35     "The certificate containing authorisation roles is invalid" 
    36     def __init__(self, msg=None): 
    37         SubjectRetrievalError.__init__(self, msg or  
    38                                        InvalidAttributeCertificate.__doc__) 
    39      
    40 class SessionExpiredMsg(SubjectRetrievalError): 
    41     'Session has expired.  Please re-login' 
    42     def __init__(self, msg=None): 
    43         SubjectRetrievalError.__init__(self, msg or SessionExpiredMsg.__doc__) 
    44  
    45 class InvalidSessionMsg(SubjectRetrievalError): 
    46     'Session is invalid.  Please try re-login' 
    47     def __init__(self, msg=None): 
    48         SubjectRetrievalError.__init__(self, msg or  
    49                                        InvalidSessionMsg.__doc__) 
    50  
    51 class InitSessionCtxError(SubjectRetrievalError): 
    52     'A problem occurred initialising a session connection' 
    53     def __init__(self, msg=None): 
    54         SubjectRetrievalError.__init__(self, msg or  
    55                                        InitSessionCtxError.__doc__) 
    56  
    57 class AttributeCertificateRequestError(SubjectRetrievalError): 
    58     'A problem occurred requesting a certificate containing authorisation roles' 
    59     def __init__(self, msg=None): 
    60         SubjectRetrievalError.__init__(self,msg or  
    61                                     AttributeCertificateRequestError.__doc__) 
     23from ndg.security.common.authz.msi import PIP, PDP, Request, Response, \ 
     24    Resource, Subject 
    6225 
    6326class PEPMiddleware(NDGSecurityPathFilter): 
     
    7639    def __init__(self, app, global_conf, prefix='', **app_conf): 
    7740         
     41        # Policy Enforcement Point 
     42        pipCfg = PEPMiddleware._filterKeywords(app_conf, 'pip.') 
     43        pip = PIP(**pipCfg) 
     44 
     45        # Policy Decision Point 
    7846        pdpCfg = PEPMiddleware._filterKeywords(app_conf, 'pdp.') 
    79         self.pdp = PDP(**pdpCfg) 
    80  
    81         self.wssecurityCfg = WSSecurityConfig() 
    82         wssePrefix = 'sessionManagerClient.wssecurity' 
    83         self.wssecurityCfg.update(app_conf, prefix=wssePrefix) 
    84          
    85         PEPMiddleware._filterKeywords(app_conf, wssePrefix+'.') 
    86                   
    87         self.sslCACertFilePathList = app_conf.pop( 
    88                             'sessionManagerClient.sslCACertFilePathList', []) 
     47        self.pdp = PDP(pip=pip, **pdpCfg) 
    8948         
    9049        super(PEPMiddleware, self).__init__(app, 
     
    11776                           [('Content-type', 'text/plain') , 
    11877                            ('Content-length', str(len(response)))]) 
    119             return response             
    120  
    121     def _getAttributeCertificate(self, attributeAuthorityURI): 
    122         try: 
    123             # Create Session Manager client - if a file path was set, setting 
    124             # are read from a separate config file section otherwise, from the 
    125             # PDP config object 
    126             smClnt = SessionManagerClient( 
    127                             uri=self.session['sessionManagerURI'], 
    128                             sslCACertFilePathList=self.sslCACertFilePathList, 
    129                             cfg=self.wssecurityCfg) 
    130         except Exception, e: 
    131             log.error("Creating Session Manager client: %s" % e) 
    132             raise InitSessionCtxError() 
    133          
    134           
    135         try: 
    136             # Make request for attribute certificate 
    137             attCert = smClnt.getAttCert( 
    138                                 attributeAuthorityURI=attributeAuthorityURI, 
    139                                 sessID=self.session['sessionID']) 
    140             return attCert 
    141          
    142         except AttributeRequestDenied, e: 
    143             log.error("Request for attribute certificate denied: %s" % e) 
    144             raise PDPUserAccessDenied() 
    145          
    146         except SessionNotFound, e: 
    147             log.error("No session found: %s" % e) 
    148             raise PDPUserNotLoggedIn() 
    149  
    150         except SessionExpired, e: 
    151             log.error("Session expired: %s" % e) 
    152             raise InvalidSessionMsg() 
    153  
    154         except SessionCertTimeError, e: 
    155             log.error("Session cert. time error: %s" % e) 
    156             raise InvalidSessionMsg() 
    157              
    158         except InvalidSession, e: 
    159             log.error("Invalid user session: %s" % e) 
    160             raise InvalidSessionMsg() 
    161  
    162         except Exception, e: 
    163             log.error("Request from Session Manager [%s] to Attribute " 
    164                       "Authority [%s] for attribute certificate: %s: %s" %  
    165                       (self.session['sessionManagerURI'], 
    166                        attributeAuthorityURI, 
    167                        e.__class__, e)) 
    168             raise AttributeCertificateRequestError() 
    169          
     78            return response                     
    17079         
    17180    def isAuthorized(self): 
     
    17685        # Make a request object to pass to the PDP 
    17786        request = Request() 
    178         request.subject.attributes['userId'] = self.session['username'] 
    179         request.resource = self.environ.get( 
    180             'ndg.security.server.wsgi.pep.resource') or Resource(self.pathInfo) 
     87        request.subject[Subject.USERID_NS] = self.session['username'] 
     88        request.subject[Subject.SESSIONID_NS] = self.session['sessionId'] 
     89        request.subject[Subject.SESSIONMANAGERURI_NS] = self.session[ 
     90                                                        'sessionManagerURI'] 
    18191         
    182         # Look for matching targets to the given resource 
    183         matchingTargets = [target for target in self.pdp.policy.targets  
    184                            if target.regEx.match(request.resource.uri) \ 
    185                            is not None] 
    186          
    187         attributeAuthorityURIs = [] 
    188         for matchingTarget in matchingTargets: 
    189              
    190             # Make call to relevant Attribute Authority if not already 
    191             # requested  
    192             if matchingTarget.attributeAuthorityURI not in \ 
    193                attributeAuthorityURIs: 
    194                 attributeCertificate = self._getAttributeCertificate( 
    195                                         matchingTarget.attributeAuthorityURI) 
    196                 attributeAuthorityURIs.append( 
    197                                         matchingTarget.attributeAuthorityURI) 
    198                  
    199             request.subject.attributes.update( 
    200                                         {'roles': attributeCertificate.roles}) 
     92        resourceURI = self.environ.get('ndg.security.server.wsgi.pep.resource') 
     93        request.resource[Resource.URI_NS] = resourceURI or self.pathInfo 
    20194             
    20295        response = self.pdp.evaluate(request) 
    203         return status 
     96        return response.status == Response.DECISION_PERMIT 
    20497     
    20598    def accessDeniedResponse(self): 
     
    208101        response''' 
    209102        response = "Access Denied" 
    210         start_response(PEPMiddleware.getStatusMessage(403), 
    211                        [('Content-type', 'text/plain') , 
    212                         ('Content-length', str(len(response)))]) 
     103        self.start_response(PEPMiddleware.getStatusMessage(403), 
     104                            [('Content-type', 'text/plain') , 
     105                             ('Content-length', str(len(response)))]) 
    213106        return response             
    214107    
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/wsgi/openid/provider/authninterface/sessionmanager.py

    r5168 r5181  
    3030    URI to logout method AXResponse instance 
    3131    """ 
    32     def __init__(self, uri=None, environKeyName=None, sessionId=None): 
     32    def __init__(self, uri=None, environKeyNameName=None, sessionId=None): 
    3333        self.uri = uri 
    34         self.environKeyName = environKeyName 
     34        self.environKeyNameName = environKeyNameName 
    3535        self.sessionId = sessionId 
    3636 
     
    116116        try: 
    117117            authNCtx = SessionManagerAuthNCtx(uri=self._client.uri, 
    118                                     environKeyName=self._client._environKey) 
     118                                environKeyNameName=self._client.environKeyName) 
    119119            self._client.environ = environ 
    120120            authNCtx.sessionId = self._client.connect(username,  
     
    188188         
    189189        try: 
    190             self._client.environ = environ 
    191190            self._client.disconnect(sessID=authNCtx.sessionId) 
    192191             
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/wsgi/openid/provider/axinterface/sessionmanager.py

    r5168 r5181  
    2020from ndg.security.server.wsgi.openid.provider.axinterface import \ 
    2121    AXInterface, AXInterfaceConfigError, MissingRequiredAttrs 
    22      
     22from ndg.security.server.wsgi.openid.provider import AuthNInterfaceCtx     
    2323     
    2424class SessionManagerAXInterface(AXInterface): 
     
    3434        'sessionManagerURI',  
    3535        'sessionManagerURITypeURI', 
    36         'sessionId', 
    37         'sessionIdTypeURI') 
     36        'sessionIdTypeURI' 
     37    ) 
    3838     
    3939    def __init__(self, **cfg): 
     
    4848            if val is None: 
    4949                raise AXInterfaceConfigError("Missing configuration setting: " 
    50                                              "%s" % val)    
     50                                             '"%s"' % name)    
    5151                    
    5252            setattr(self, name, val) 
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/wsgi/utils/attributeauthorityclient.py

    r4891 r5181  
    3333    """ 
    3434     
    35     environKey = "ndg.security.server.wsgi.attributeAuthorityFilter" 
     35    defaultEnvironKeyName = "ndg.security.server.wsgi.attributeAuthorityFilter" 
    3636             
    37     _getRef = lambda self:self._environ[self._environKey].serviceSOAPBinding.aa 
    38     ref = property(fget=_getRef, doc="Attribute Authority local instance") 
     37    _getLocalClient = lambda self:self._environ[ 
     38                                    self.environKeyName].serviceSOAPBinding.aa 
     39    localClient = property(fget=_getLocalClient,  
     40                           doc="Attribute Authority local instance") 
    3941 
    40     def __init__(self, environKey=None, environ={}, **clientKw): 
     42    def __init__(self, environKeyName=None, environ={}, **clientKw): 
     43        """Initialise an interface to an Attribute Authority accessible either  
     44        via a keyword to a WSGI environ dictionary or via a web service call 
     45         
     46        @type environKeyName: basestring or None 
     47        @param environKeyName: dict key reference to service object to be  
     48        invoked.  This may be set later using the environKeyName property 
     49        or may be omitted altogether if the service is to be invoked via a 
     50        web service call 
     51        @type environ: dict 
     52        @param environ: WSGI environment dictionary containing a reference to 
     53        the service object.  This may not be known at instantiation of this 
     54        class.  environ is not required if the service is to be invoked over 
     55        a web service interface 
     56        @type clientKw: dict 
     57        @param clientKw: custom keywords to instantiate a web service client 
     58        interface.  Derived classes are responsible for instantiating this 
     59        from an extended version of this __init__ method. 
     60        """ 
    4161 
    4262        log.debug("WSGIAttributeAuthorityClient.__init__ ...") 
    4363         
    44         self._environKey=environKey or WSGIAttributeAuthorityClient.environKey 
     64        self.environKeyName = environKeyName or \ 
     65                            WSGIAttributeAuthorityClient.defaultEnvironKeyName 
    4566         
    4667        # Standard WSGI environment dict 
     
    4869         
    4970        if clientKw.get('uri'): 
    50             self._client = AttributeAuthorityClient(**clientKw) 
     71            self.wsClient = AttributeAuthorityClient(**clientKw) 
    5172        else: 
    52             self._client = None 
     73            self.wsClient = None 
    5374             
    5475    def getHostInfo(self): 
     
    6081        configuration held by the AA""" 
    6182         
    62         if self.refInEnviron: 
     83        if self.localClientInEnviron: 
    6384            # Connect to local instance 
    64             return self.ref.hostInfo 
     85            return self.localClient.hostInfo 
    6586         
    66         elif self._client is None:             
     87        elif self.wsClient is None:             
    6788            raise WSGIAttributeAuthorityClientConfigError("No reference to a " 
    6889                        "local Attribute Authority is set and no SOAP client " 
     
    7091        else:             
    7192            # Make connection to remote service 
    72             return self._client.getHostInfo() 
     93            return self.wsClient.getHostInfo() 
    7394         
    7495         
     
    86107        from the map configuration""" 
    87108         
    88         if self.refInEnviron: 
     109        if self.localClientInEnviron: 
    89110            # Connect to local instance 
    90             return self.ref.getTrustedHostInfo(**kw) 
    91         elif self._client is None:             
     111            return self.localClient.getTrustedHostInfo(**kw) 
     112         
     113        elif self.wsClient is None:             
    92114            raise WSGIAttributeAuthorityClientConfigError("No reference to a " 
    93115                        "local Attribute Authority is set and no SOAP client " 
     
    95117        else: 
    96118            # Make connection to remote service 
    97             return self._client.getTrustedHostHostInfo(**kw) 
     119            return self.wsClient.getTrustedHostHostInfo(**kw) 
    98120 
    99121 
     
    106128        from the map configuration""" 
    107129         
    108         if self.refInEnviron: 
     130        if self.localClientInEnviron: 
    109131            # Connect to local instance - combine this host's info with info 
    110132            # from other trusted hosts 
    111             allHostsInfo = self.ref.hostInfo 
    112             allHostsInfo.update(self.ref.getTrustedHostInfo()) 
     133            allHostsInfo = self.localClient.hostInfo 
     134            allHostsInfo.update(self.localClient.getTrustedHostInfo()) 
    113135            return allHostsInfo 
    114         elif self._client is None:             
     136        elif self.wsClient is None:             
    115137            raise WSGIAttributeAuthorityClientConfigError("No reference to a " 
    116138                        "local Attribute Authority is set and no SOAP client " 
     
    118140        else: 
    119141            # Make connection to remote service 
    120             return self._client.getAllHostsInfo() 
     142            return self.wsClient.getAllHostsInfo() 
    121143 
    122144 
     
    136158        service""" 
    137159         
    138         if self.refInEnviron: 
     160        if self.localClientInEnviron: 
    139161            # Connect to local instance 
    140162            if 'userX509Cert' in kw: 
    141163                kw['holderX509Cert'] = kw.pop('userX509Cert') 
    142164 
    143             return self.ref.getAttCert(**kw) 
    144         elif self._client is None:             
     165            return self.localClient.getAttCert(**kw) 
     166        elif self.wsClient is None:             
    145167            raise WSGIAttributeAuthorityClientConfigError("No reference to a " 
    146168                        "local Attribute Authority is set and no SOAP client " 
     
    151173                kw['userX509Cert'] = kw.pop('holderX509Cert') 
    152174                 
    153             return self._client.getAttCert(**kw) 
     175            return self.wsClient.getAttCert(**kw) 
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/wsgi/utils/clientbase.py

    r4892 r5181  
    2323    ''' 
    2424 
    25     environKey = '' 
     25    defaultEnvironKeyName = '' 
    2626     
    27     def __init__(self, 
    28                  environKey=None,  
    29                  environ={},  
    30                  **clientKw): 
    31   
    32         self._environKey = environKey or WSGICLientBase.environKey 
     27    def __init__(self, environKeyName=None, environ={}, **clientKw): 
     28        """Initialise an interface to a service accessible either via a 
     29        keyword to a WSGI environ dictionary or via a web service call 
     30         
     31        @type environKeyName: basestring or None 
     32        @param environKeyName: dict key reference to service object to be  
     33        invoked.  This may be set later using the environKeyName property 
     34        or may be omitted altogether if the service is to be invoked via a 
     35        web service call 
     36        @type environ: dict 
     37        @param environ: WSGI environment dictionary containing a reference to 
     38        the service object.  This may not be known at instantiation of this 
     39        class.  environ is not required if the service is to be invoked over 
     40        a web service interface 
     41        @type clientKw: dict 
     42        @param clientKw: custom keywords to instantiate a web service client 
     43        interface.  Derived classes are responsible for instantiating this 
     44        from an extended version of this __init__ method. 
     45        """ 
     46         
     47        self._environKeyName = environKeyName or \ 
     48                               WSGICLientBase.defaultEnvironKeyName 
    3349                         
    3450        # Standard WSGI environment dict 
     
    3753        # Derived class could instantiate required client type if a 'uri' 
    3854        # key is set in clientKw     
    39         self._client = None 
     55        self._wsClient = None 
    4056         
     57    def _getWSClient(self): 
     58        return getattr(self, '_wsClient', None) 
     59     
     60    def _setWSClient(self, wsClient): 
     61        self._wsClient = wsClient 
     62     
     63    wsClient = property(fget=_getWSClient, 
     64                        fset=_setWSClient,  
     65                        doc="Web service client to service to be invoked") 
     66     
     67    def _getWSClientURI(self): 
     68        return getattr(self.wsClient, 'uri', None) 
    4169 
     70    uri = property(fget=_getWSClientURI, 
     71                   doc="URI for web service or None if no WS Client is set") 
     72 
     73    def _setEnvironKeyName(self, keyName): 
     74        if not isinstance(keyName, (None.__class__, basestring)): 
     75            raise TypeError("environKeyName must be string or None type; got " 
     76                            "%s" % keyName) 
     77             
     78        self._environKeyName = keyName 
     79 
     80    def _getEnvironKeyName(self): 
     81        return self._environKeyName 
     82     
     83    environKeyName = property(fget=_getEnvironKeyName, 
     84                              fset=_setEnvironKeyName, 
     85                              doc="key in environ dict holding reference to " 
     86                                  "service to be invoked.  This may be None " 
     87                                  "if the service is to be invoked via the " 
     88                                  "web service client") 
     89     
    4290    def _setEnviron(self, environ): 
    4391        if not isinstance(environ, dict): 
     
    4593        self._environ = environ 
    4694         
    47     def _getEnviron(self, environ): 
     95    def _getEnviron(self): 
    4896        return self._environ 
    4997     
     
    52100                       doc="WSGI environ dictionary") 
    53101 
    54     def _getRef(self): 
     102    def _getLocalClient(self): 
    55103        """Get reference to WSGI service instance in environ""" 
    56104        raise NotImplementedError() 
    57105     
    58     ref = property(fget=_getRef, doc="local instance") 
     106    localClient = property(fget=_getLocalClient, doc="local instance") 
    59107     
    60     def _refInEnviron(self): 
     108    def _localClientInEnviron(self): 
    61109        '''Check whether a reference is present in the WSGI environ to the  
    62110        service to be queried.  Check also that if a URI was specified by the 
     
    71119        referenced must have a published URI attribute 
    72120        ''' 
    73         if self._environKey not in self._environ: 
     121        if self._environKeyName not in self._environ: 
    74122            log.debug("Checking for referenced WSGI service in environ: " 
    75123                      "the given key was not found in the environ dictionary") 
    76124            return False 
    77125         
    78         if self._client: 
     126        if self._wsClient: 
    79127            # A SOAP client was initialised - check to see if its URI matches 
    80128            # the URI for the service referenced in environ 
    81             requestedURI = getattr(self._client, 'uri', None) 
     129            requestedURI = getattr(self._wsClient, 'uri', None) 
    82130            if requestedURI is None: 
    83131                log.debug("Checking for referenced WSGI service in environ: " 
     
    86134                return True 
    87135             
    88             serviceURI = getattr(self._environ[self._environKey],  
     136            serviceURI = getattr(self._environ[self._environKeyName],  
    89137                                 'publishedURI', 
    90138                                 None) 
     
    104152     
    105153    # Define as property for convenient call syntax 
    106     refInEnviron = property(fget=_refInEnviron, 
    107                             doc="return True if referenced instance is " 
    108                                 "available in WSGI environ") 
     154    localClientInEnviron = property(fget=_localClientInEnviron, 
     155                                    doc="return True if referenced instance " 
     156                                        "is available in WSGI environ") 
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/wsgi/utils/sessionmanagerclient.py

    r4890 r5181  
    9595    keyword 
    9696     
    97     @type environKey: basestring 
    98     @cvar environKey: default WSGI environ keyword name for reference to a  
    99     local Session Manager instance.  Override with the environKey keyword to  
    100     __init__ 
    101      
    102     @type attributeAuthorityEnvironKey: basestring 
    103     @cvar attributeAuthorityEnvironKey: default WSGI environ keyword name for  
    104     reference to a local Attribute Authority instance used in calls to  
    105     getAttCert().  Override with the attributeAuthorityEnvironKey keyword to 
    106     __init__ 
     97    @type defaultEnvironKeyName: basestring 
     98    @cvar defaultEnvironKeyName: default WSGI environ keyword name for  
     99    reference to a local Session Manager instance.  Override with the  
     100    environKeyName keyword to __init__ 
     101     
     102    @type attributeAuthorityEnvironKeyName: basestring 
     103    @cvar attributeAuthorityEnvironKeyName: default WSGI environ keyword name  
     104    for reference to a local Attribute Authority instance used in calls to  
     105    getAttCert().  Override with the attributeAuthorityEnvironKeyName keyword  
     106    to __init__ 
    107107    """ 
    108     environKey = "ndg.security.server.wsgi.sessionManagerFilter" 
    109     attributeAuthorityEnvironKey = WSGIAttributeAuthorityClient.environKey 
    110          
    111     _getRef = lambda self:self._environ[self._environKey].serviceSOAPBinding.sm 
    112     ref = property(fget=_getRef, doc="local session manager instance") 
     108    defaultEnvironKeyName = "ndg.security.server.wsgi.sessionManagerFilter" 
     109    attributeAuthorityEnvironKeyName = \ 
     110        WSGIAttributeAuthorityClient.defaultEnvironKeyName 
     111         
     112    _getLocalClient = lambda self:self._environ[ 
     113                                    self.environKeyName].serviceSOAPBinding.sm 
     114                                     
     115    localClient = property(fget=_getLocalClient,  
     116                           doc="local session manager instance") 
    113117 
    114118     
    115119    def __init__(self,  
    116                  environKey=None,  
    117                  attributeAuthorityEnvironKey=None, 
     120                 environKeyName=None,  
     121                 attributeAuthorityEnvironKeyName=None, 
    118122                 environ={},  
    119                  **soapClientKw): 
     123                 **clientKw): 
     124        """Initialise an interface to a Session Manager accessible either via a 
     125        keyword to a WSGI environ dictionary or via a web service call 
     126         
     127        @type environKeyName: basestring or None 
     128        @param environKeyName: dict key reference to service object to be  
     129        invoked.  This may be set later using the environKeyName property 
     130        or may be omitted altogether if the service is to be invoked via a 
     131        web service call 
     132        @type environ: dict 
     133        @param environ: WSGI environment dictionary containing a reference to 
     134        the service object.  This may not be known at instantiation of this 
     135        class.  environ is not required if the service is to be invoked over 
     136        a web service interface 
     137        @type clientKw: dict 
     138        @param clientKw: custom keywords to instantiate a web service client 
     139        interface.  Derived classes are responsible for instantiating this 
     140        from an extended version of this __init__ method. 
     141        """ 
    120142  
    121143        log.debug("WSGISessionManagerClient.__init__ ...") 
    122144         
    123         self._environKey = environKey or WSGISessionManagerClient.environKey 
    124         self._attributeAuthorityEnvironKey = attributeAuthorityEnvironKey or \ 
    125                         WSGISessionManagerClient.attributeAuthorityEnvironKey 
     145        self.environKeyName = environKeyName or \ 
     146                               WSGISessionManagerClient.defaultEnvironKeyName 
     147                                
     148        self._attributeAuthorityEnvironKeyName = \ 
     149                    attributeAuthorityEnvironKeyName or \ 
     150                    WSGISessionManagerClient.attributeAuthorityEnvironKeyName 
    126151                         
    127152        # Standard WSGI environment dict 
    128153        self._environ = environ 
    129154         
    130         if soapClientKw.get('uri'): 
    131             self._client = SessionManagerClient(**soapClientKw) 
    132         else: 
    133             self._client = None 
     155        if clientKw.get('uri'): 
     156            self.wsClient = SessionManagerClient(**clientKw) 
     157        else: 
     158            self.wsClient = None 
    134159 
    135160    
     
    141166        """ 
    142167     
    143         if self.refInEnviron: 
     168        if self.localClientInEnviron: 
    144169            log.debug("Connecting to local Session Manager instance") 
    145170            if 'username' in kw: 
     
    148173                 
    149174            # Connect to local instance 
    150             res = self.ref.connect(username=username, **kw) 
    151              
    152         elif self._client is None:             
     175            res = self.localClient.connect(username=username, **kw) 
     176             
     177        elif self.wsClient is None:             
    153178            raise WSGISessionManagerClientConfigError("No reference to a " 
    154179                        "local Session Manager is set and no SOAP client " 
     
    162187             
    163188            # Make connection to remote service 
    164             res = self._client.connect(username, **kw) 
     189            res = self.wsClient.connect(username, **kw) 
    165190     
    166191            # Convert from unicode because unicode causes problems with 
     
    182207        # Modify keywords according to correct interface for server side / 
    183208        # SOAP client 
    184         if self.refInEnviron: 
     209        if self.localClientInEnviron: 
    185210            if 'userDN' in kw: 
    186211                log.warning('Removing keyword "userDN": this is not supported ' 
     
    189214                kw.pop('userX509Cert', None) 
    190215                 
    191             self.ref.deleteUserSession(**kw) 
    192              
    193         elif self._client is None:             
     216            self.localClient.deleteUserSession(**kw) 
     217             
     218        elif self.wsClient is None:             
    194219            raise WSGISessionManagerClientConfigError("No reference to a " 
    195220                        "local Session Manager is set and no SOAP client " 
     
    199224                kw['userDN'] = kw.pop('userX509Cert').dn 
    200225                 
    201             self._client.disconnect(**kw) 
     226            self.wsClient.disconnect(**kw) 
    202227         
    203228     
     
    212237        the SOAP client""" 
    213238     
    214         if self.refInEnviron: 
    215             return self.ref.getSessionStatus(**kw) 
    216          
    217         elif self._client is None:             
     239        if self.localClientInEnviron: 
     240            return self.localClient.getSessionStatus(**kw) 
     241         
     242        elif self.wsClient is None:             
    218243            raise WSGISessionManagerClientConfigError("No reference to a " 
    219244                        "local Session Manager is set and no SOAP client " 
    220245                        "to a remote service has been initialized") 
    221246        else: 
    222             return self._client.getSessionStatus(**kw) 
     247            return self.wsClient.getSessionStatus(**kw) 
    223248     
    224249 
     
    236261        """ 
    237262         
    238         if self.refInEnviron: 
     263        if self.localClientInEnviron: 
    239264            # Connect to local instance of Session Manager - next check for  
    240265            # an Attribute Authority URI or instance running locally 
     
    243268                wsgiAttributeAuthorityClient = WSGIAttributeAuthorityClient( 
    244269                                environ=self._environ, 
    245                                 environKey=self._attributeAuthorityEnvironKey) 
    246  
    247                 if wsgiAttributeAuthorityClient.refInEnviron: 
     270                                environKeyName=self._attributeAuthorityEnvironKeyName) 
     271 
     272                if wsgiAttributeAuthorityClient.localClientInEnviron: 
    248273                    kw['attributeAuthority'] = wsgiAttributeAuthorityClient.ref 
    249274                else: 
     
    252277                        "set and no reference is available in environ") 
    253278                     
    254             return self.ref.getAttCert(**kw) 
    255      
    256         elif self._client is None:             
     279            return self.localClient.getAttCert(**kw) 
     280     
     281        elif self.wsClient is None:             
    257282            raise WSGISessionManagerClientConfigError("No reference to a " 
    258283                        "local Session Manager is set and no SOAP client " 
     
    285310                            'this keyword') 
    286311 
    287             return self._client.getAttCert(**kw) 
     312            return self.wsClient.getAttCert(**kw) 
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/integration/authz/securedapp.ini

    r5168 r5181  
    55# 
    66[DEFAULT] 
     7testConfigDir = %(here)s/../../config 
    78 
    89[server:main] 
     
    4445pdp.policyFilePath = %(here)s/policy.xml 
    4546 
    46 # Settings for connection to the user's Session Manager 
    47 sessionManagerClient.sslCACertFilePathList= 
     47# Settings for Policy Information Point used by the Policy Decision Point to 
     48# retrieve subject attributes from the Attribute Authority associated with the 
     49# resource to be accessed 
     50pip.sslCACertFilePathList= 
     51 
    4852# 
    4953# WS-Security Settings for call to Session Manager 
     
    5761 
    5862# PEM encode cert 
    59 sessionManagerClient.wssecurity.signingCertFilePath= 
     63pip.wssecurity.signingCertFilePath=%(testConfigDir)s/pki/wsse-server.crt 
    6064 
    6165# PEM encoded private key file 
    62 sessionManagerClient.wssecurity.signingPriKeyFilePath= 
     66pip.wssecurity.signingPriKeyFilePath=%(testConfigDir)s/pki/wsse-server.key 
    6367 
    6468# Password protecting private key.  Leave blank if there is no password. 
    65 sessionManagerClient.wssecurity.signingPriKeyPwd= 
     69pip.wssecurity.signingPriKeyPwd= 
    6670 
    67 # Provide a space separated list of file paths 
    68 sessionManagerClient.wssecurity.caCertFilePathList= 
     71# For signature verification.  Provide a space separated list of file paths 
     72pip.wssecurity.caCertFilePathList=%(testConfigDir)s/ca/ndg-test-ca.crt 
    6973 
    7074# ValueType for the BinarySecurityToken added to the WSSE header 
    71 sessionManagerClient.wssecurity.reqBinSecTokValType=X509v3 
     75pip.wssecurity.reqBinSecTokValType=X509v3 
    7276 
    7377# Add a timestamp element to an outbound message 
    74 sessionManagerClient.wssecurity.addTimestamp=True 
     78pip.wssecurity.addTimestamp=True 
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/integration/authz/securityservices.ini

    r5168 r5181  
    300300openid.provider.axResponse.sessionManagerURI=%(sessionManagerURI)s 
    301301openid.provider.axResponse.sessionManagerURITypeURI=%(openid.ax.sessionManagerURI.typeURI)s 
    302 openid.provider.axResponse.sessionManagerURI=%(sessionId)s 
    303302openid.provider.axResponse.sessionIdTypeURI=%(openid.ax.sessionId.typeURI)s 
    304303 
     
    319318# setting below is the default and can be omitted if it matches the filterID 
    320319# set for the Session Manager 
    321 openid.provider.authN.environKey=filter:SessionManagerFilter 
     320openid.provider.authN.environKeyName=filter:SessionManagerFilter 
    322321 
    323322# Database connection to enable check between username and OpenID identifier 
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/integration/combinedservices/serverapp.py

    r4863 r5181  
    3131        try: 
    3232            client = WSGISessionManagerClient(environ=environ, 
    33                                         environKey=self.sessionManagerFilterID) 
     33                                    environKeyName=self.sessionManagerFilterID) 
    3434            res = client.connect(username, passphrase=password) 
    3535 
     
    3838             
    3939            # Keep a reference to the session ID for test purposes 
    40             environ[client.environKey+'.user'] = res[-1] 
     40            environ[client.environKeyName+'.user'] = res[-1] 
    4141                 
    4242        except Exception, e: 
     
    9292    def test_localSessionManagerGetSessionStatus(self, environ,start_response): 
    9393        client = WSGISessionManagerClient(environ=environ, 
    94                                         environKey=self.sessionManagerFilterID) 
    95         stat=client.getSessionStatus(sessID=environ[client.environKey+'.user']) 
     94                                    environKeyName=self.sessionManagerFilterID) 
     95        stat=client.getSessionStatus( 
     96                                sessID=environ[client.environKeyName+'.user']) 
    9697        start_response('200 OK', [('Content-type', 'text/xml')]) 
    9798        return ("test_localSessionManagerGetSessionStatus succeeded. Response " 
     
    101102    def test_localSessionManagerDisconnect(self, environ, start_response): 
    102103        client = WSGISessionManagerClient(environ=environ, 
    103                                         environKey=self.sessionManagerFilterID) 
    104         client.disconnect(sessID=environ[client.environKey+'.user']) 
     104                                    environKeyName=self.sessionManagerFilterID) 
     105        client.disconnect(sessID=environ[client.environKeyName+'.user']) 
    105106         
    106107        # Re-initialise user authentication 
     
    112113    def test_localSessionManagerGetAttCert(self, environ, start_response): 
    113114        client = WSGISessionManagerClient(environ=environ, 
    114                 environKey=self.sessionManagerFilterID, 
    115                 attributeAuthorityEnvironKey=self.attributeAuthorityFilterID) 
    116  
    117         attCert = client.getAttCert(sessID=environ[client.environKey+'.user']) 
     115            environKeyName=self.sessionManagerFilterID, 
     116            attributeAuthorityEnvironKeyName=self.attributeAuthorityFilterID) 
     117 
     118        attCert = client.getAttCert( 
     119                                sessID=environ[client.environKeyName+'.user']) 
    118120        start_response('200 OK', [('Content-type', 'text/xml')]) 
    119121        return str(attCert) 
     
    121123    def test_localAttributeAuthorityGetHostInfo(self, environ, start_response): 
    122124        client = WSGIAttributeAuthorityClient(environ=environ, 
    123                                     environKey=self.attributeAuthorityFilterID) 
     125                                environKeyName=self.attributeAuthorityFilterID) 
    124126        hostInfo = client.getHostInfo() 
    125127        start_response('200 OK', [('Content-type', 'text/html')]) 
     
    131133                                                       start_response): 
    132134        client = WSGIAttributeAuthorityClient(environ=environ, 
    133                                     environKey=self.attributeAuthorityFilterID) 
     135                                environKeyName=self.attributeAuthorityFilterID) 
    134136        role = environ.get('QUERY_STRING', '').split('=')[-1] or None 
    135137        hostInfo = client.getTrustedHostInfo(role=role) 
     
    142144                                                    start_response): 
    143145        client = WSGIAttributeAuthorityClient(environ=environ, 
    144                                     environKey=self.attributeAuthorityFilterID) 
     146                                environKeyName=self.attributeAuthorityFilterID) 
    145147        hostInfo = client.getAllHostsInfo() 
    146148        start_response('200 OK', [('Content-type', 'text/html')]) 
     
    152154         
    153155        client = WSGIAttributeAuthorityClient(environ=environ, 
    154                                     environKey=self.attributeAuthorityFilterID) 
     156                                environKeyName=self.attributeAuthorityFilterID) 
    155157        username=CombinedServicesWSGI.httpBasicAuthentication._userIn.users[-1] 
    156158         
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/integration/combinedservices/services.ini

    r5057 r5181  
    438438# setting below is the default and can be omitted if it matches the filterID 
    439439# set for the Session Manager 
    440 #openid.provider.authN.environKey=filter:SessionManagerFilter 
     440#openid.provider.authN.environKeyName=filter:SessionManagerFilter 
    441441 
    442442# Database connection to enable check between username and OpenID identifier 
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/integration/openid/securityservices.ini

    r5084 r5181  
    295295# setting below is the default and can be omitted if it matches the filterID 
    296296# set for the Session Manager 
    297 openid.provider.authN.environKey=filter:SessionManagerFilter 
     297openid.provider.authN.environKeyName=filter:SessionManagerFilter 
    298298 
    299299# Database connection to enable check between username and OpenID identifier 
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/integration/openidprovider/securityservices.ini

    r5080 r5181  
    261261# setting below is the default and can be omitted if it matches the filterID 
    262262# set for the Session Manager 
    263 openid.provider.authN.environKey=filter:SessionManagerFilter 
     263openid.provider.authN.environKeyName=filter:SessionManagerFilter 
    264264 
    265265# Database connection to enable check between username and OpenID identifier 
Note: See TracChangeset for help on using the changeset viewer.