Changeset 6018


Ignore:
Timestamp:
17/11/09 16:54:48 (10 years ago)
Author:
pjkersha
Message:

Refactoring ndg.security.common.authz.msi:

  • to enable 1 to 1 attribute name - attribute authority URI mapping
  • TODO: hook up SOAP/SAML based attribute query replacing old SOAP/WSDL getAttCert operation.
Location:
TI12-security/trunk/python
Files:
1 added
11 edited

Legend:

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

    r5977 r6018  
    767767    def __repr__(self): 
    768768        """Give representation based on underlying dict object""" 
    769         return self.__dat 
     769        return repr(self.__dat) 
    770770         
    771771    def __str__(self): 
  • TI12-security/trunk/python/ndg_security_common/ndg/security/common/authz/msi.py

    r6009 r6018  
    1313import logging 
    1414log = logging.getLogger(__name__) 
     15 
     16import warnings 
    1517from elementtree import ElementTree 
     18 
     19from ndg.security.common.utils import TypedList 
    1620 
    1721# For parsing: ElementTree helpers  
     
    2327 
    2428class Policy(object): 
     29    """NDG MSI Policy.""" 
     30    __slots__ = ( 
     31        'policyFilePath', 
     32        'description', 
     33        'targets' 
     34    ) 
     35    __slots__ += tuple(["_Policy__%s" % name for name in __slots__]) 
     36    del name 
     37     
    2538    def __init__(self, policyFilePath=None): 
    26         self.policyFilePath = policyFilePath 
    27         self.description = None 
    28         self.targets = [] 
    29          
     39        self.__policyFilePath = policyFilePath 
     40        self.__description = None 
     41        self.__targets = TypedList(Target) 
     42 
     43    def getPolicyFilePath(self): 
     44        return self.__policyFilePath 
     45 
     46    def setPolicyFilePath(self, value): 
     47        if not isinstance(value, basestring): 
     48            raise TypeError('Expecting string type for "policyFilePath" ' 
     49                            'attribute; got %r' % type(value)) 
     50             
     51        self.__policyFilePath = value 
     52 
     53    policyFilePath = property(getPolicyFilePath, setPolicyFilePath,  
     54                              doc="Policy file path") 
     55 
     56    def getTargets(self): 
     57        return self.__targets 
     58 
     59    def setTargets(self, value): 
     60        if (not isinstance(value, TypedList) and  
     61            not issubclass(value.elementType, Target.__class__)): 
     62            raise TypeError('Expecting TypedList(Target) for "targets" ' 
     63                            'attribute; got %r' % type(value)) 
     64        self.__targets = value 
     65 
     66    targets = property(getTargets, setTargets,  
     67                       doc="list of Policy targets") 
     68 
     69    def getDescription(self): 
     70        return self.__description 
     71 
     72    def setDescription(self, value): 
     73        if not isinstance(value, basestring): 
     74            raise TypeError('Expecting string type for "description" ' 
     75                            'attribute; got %r' % type(value)) 
     76        self.__description = value 
     77 
     78    description = property(getDescription, setDescription,  
     79                           doc="Policy Description text") 
     80    
    3081    def parse(self): 
    3182        """Parse the policy file set in policyFilePath attribute 
     
    59110class Target(object): 
    60111    """Define access behaviour for a resource match a given URI pattern""" 
     112    URI_PATTERN_LOCALNAME = "URIPattern" 
     113    ATTRIBUTE_LOCALNAME = "Attributes" 
     114    ATTRIBUTE_AUTHORITY_LOCALNAME = "AttributeAuthority" 
     115     
     116    __slots__ = ( 
     117        URI_PATTERN_LOCALNAME, 
     118        ATTRIBUTE_LOCALNAME, 
     119        ATTRIBUTE_LOCALNAME        
     120    ) 
     121    __slots__ += tuple(["_Target__%s" % name for name in __slots__]) 
     122    del name 
     123     
    61124    def __init__(self): 
    62         self.uriPattern = None 
    63         self.attributes = [] 
    64         self.attributeAuthorityURI = None 
     125        self.__uriPattern = None 
     126        self.__attributes = [] 
     127        self.__regEx = None 
     128         
     129    def getUriPattern(self): 
     130        return self.__uriPattern 
     131 
     132    def setUriPattern(self, value): 
     133        if not isinstance(value, basestring): 
     134            raise TypeError('Expecting string type for "uriPattern" ' 
     135                            'attribute; got %r' % type(value)) 
     136        self.__uriPattern = value 
     137 
     138    uriPattern = property(getUriPattern,  
     139                          setUriPattern,  
     140                          doc="URI Pattern to match this target") 
     141 
     142    def getAttributes(self): 
     143        return self.__attributes 
     144 
     145    def setAttributes(self, value): 
     146        if (not isinstance(value, TypedList) and  
     147            not issubclass(value.elementType, Attribute.__class__)): 
     148            raise TypeError('Expecting TypedList(Attribute) for "attributes" ' 
     149                            'attribute; got %r' % type(value)) 
     150        self.__attributes = value 
     151 
     152    attributes = property(getAttributes,  
     153                          setAttributes,   
     154                          doc="Attributes restricting access to this target") 
     155 
     156    def getRegEx(self): 
     157        return self.__regEx 
     158 
     159    def setRegEx(self, value): 
     160        self.__regEx = value 
     161 
     162    regEx = property(getRegEx, setRegEx, dpc="RegEx's Docstring") 
    65163         
    66164    def parse(self, root): 
    67165        for elem in root: 
    68166            localName = getLocalName(elem) 
    69             if localName == "URIPattern": 
     167            if localName == Target.URI_PATTERN_LOCALNAME: 
    70168                self.uriPattern = elem.text.strip() 
    71169                self.regEx = re.compile(self.uriPattern) 
    72170                 
    73             elif localName == "Attributes": 
     171            elif localName == Target.ATTRIBUTES_LOCALNAME: 
    74172                for attrElem in elem: 
    75                     self.attributes.append(attrElem.text.strip()) 
     173                    self.attributes.append(Attribute(attrElem)) 
    76174                     
    77             elif localName == "AttributeAuthority": 
     175            elif localName == Target.ATTRIBUTE_AUTHORITY_LOCALNAME: 
    78176                # Expecting first element to contain the URI 
    79                 self.attributeAuthorityURI = elem[0].text.strip() 
     177                warnings.warn("Use of a %r child element is deprecated for " 
     178                              "Target elements.  Put the Attribute Authority " 
     179                              "setting in an Attribute AttributeAuthorityURI " 
     180                              "element e.g.\n\n" 
     181                              "<Target>\n" 
     182                              "    <Attribute>\n" 
     183                              "        <Name>myattribute</Name>" 
     184                              "        <AttributeAuthorityURI>" 
     185                              "https://myattributeauthority.ac.uk" 
     186                              "</AttributeAuthorityURI>\n" 
     187                              "    </Attribute>\n" 
     188                              "</Target>"                              
     189                               % Target.ATTRIBUTE_AUTHORITY_LOCALNAME,  
     190                              DeprecationWarning) 
    80191            else: 
    81192                raise ResourceParseError("Invalid resource attribute: %s" %  
     
    91202        return str(self.uriPattern) 
    92203 
     204 
     205class Attribute(object): 
     206    """encapsulate a target attribute including the name and an Attribute 
     207    Authority from which user attribute information may be queried 
     208    """ 
     209    NAME_LOCALNAME = "name" 
     210    ATTRIBUTE_AUTHORITY_URI_LOCALNAME = "attributeAuthorityURI" 
     211     
     212    def __init__(self): 
     213        self.__name = '' 
     214        self.__attributeAuthorityURI = None 
     215 
     216    def __str__(self): 
     217        return self.__name 
     218     
     219    def getName(self): 
     220        return self.__name 
     221 
     222    def setName(self, value): 
     223        if not isinstance(value, basestring): 
     224            raise TypeError('Expecting string type for "name"; got %r' % 
     225                            type(value)) 
     226        self.__name = value 
     227 
     228    name = property(fget=_getName,  
     229                    fset=_setName,  
     230                    doc="Attribute name") 
     231         
     232    def getAttributeAuthorityURI(self): 
     233        return self.__attributeAuthorityURI 
     234 
     235    def setAttributeAuthorityURI(self, value): 
     236        self.__attributeAuthorityURI = value 
     237 
     238    attributeAuthorityURI = property(getAttributeAuthorityURI,  
     239                                     setAttributeAuthorityURI,  
     240                                     doc="Attribute Authority URI") 
     241         
     242    def parse(self, root): 
     243        """Parse from an ElementTree Element""" 
     244        for elem in root: 
     245            localName = getLocalName(elem) 
     246            if localName == Attribute.ATTRIBUTE_AUTHORITY_URI_LOCALNAME: 
     247                self.attributeAuthorityURI = elem.text.strip() 
     248                 
     249            elif localName == Attribute.NAME_LOCALNAME: 
     250                self.name = elem.text.strip() 
     251            else: 
     252                raise ResourceParseError("Invalid Attribute element name: %s" %  
     253                                         localName) 
     254     
     255    @classmethod 
     256    def Parse(cls, root): 
     257        """Parse from an ElementTree Element and return a new instance""" 
     258        resource = cls() 
     259        resource.parse(root) 
     260        return resource 
     261  
     262        
    93263class _AttrDict(dict): 
    94264    """Utility class for holding a constrained list of attributes governed 
     
    176346                      doc="Integer response code; one of %r" % decisionValues) 
    177347         
    178 from ndg.security.common.AttCert import AttCertInvalidSignature, \ 
    179     AttCertNotBeforeTimeError, AttCertExpired, AttCertError  
     348from ndg.security.common.AttCert import (AttCertInvalidSignature,  
     349    AttCertNotBeforeTimeError, AttCertExpired, AttCertError) 
    180350       
    181 from ndg.security.common.sessionmanager import SessionManagerClient, \ 
    182     SessionNotFound, SessionCertTimeError, SessionExpired, InvalidSession, \ 
    183     AttributeRequestDenied 
    184  
    185 from ndg.security.common.attributeauthority import AttributeAuthorityClient, \ 
    186     NoTrustedHosts, NoMatchingRoleInTrustedHosts, \ 
    187     InvalidAttributeAuthorityClientCtx 
     351from ndg.security.common.sessionmanager import (SessionManagerClient,  
     352    SessionNotFound, SessionCertTimeError, SessionExpired, InvalidSession,  
     353    AttributeRequestDenied) 
     354 
     355from ndg.security.common.attributeauthority import (AttributeAuthorityClient,  
     356    NoTrustedHosts, NoMatchingRoleInTrustedHosts,  
     357    InvalidAttributeAuthorityClientCtx) 
    188358from ndg.security.common.attributeauthority import AttributeRequestDenied as \ 
    189359    AA_AttributeRequestDenied 
    190360                    
    191 from ndg.security.common.authz.pdp import PDPUserNotLoggedIn, \ 
    192     PDPUserAccessDenied 
     361from ndg.security.common.authz.pdp import (PDPUserNotLoggedIn,  
     362    PDPUserAccessDenied) 
     363     
    193364     
    194365class SubjectRetrievalError(Exception): 
     
    330501        return attributeResponse 
    331502     
    332      
    333503    def _getAttributeCertificate(self, 
    334504                                 attributeAuthorityURI, 
     
    497667                      e.__class__, e) 
    498668            raise AttributeCertificateRequestError() 
    499  
    500             
     669  
    501670            
    502671class PDP(object): 
  • TI12-security/trunk/python/ndg_security_common/ndg/security/common/saml/esg/__init__.py

    r5982 r6018  
    1919     
    2020    @property 
     21    def FIRSTNAME_FRIENDLYNAME(self): 
     22        return "FirstName" 
     23    
     24    @property 
    2125    def LASTNAME_ATTRNAME(self): 
    2226        return "urn:esg:last:name" 
     27     
     28    @property 
     29    def LASTNAME_FRIENDLYNAME(self): 
     30        return "LastName" 
    2331     
    2432    @property 
     
    2634        return "urn:esg:email:address" 
    2735     
     36    @property 
     37    def EMAILADDRESS_FRIENDLYNAME(self): 
     38        return "EmailAddress" 
     39    
    2840    @property 
    2941    def NAMEID_FORMAT(self): 
  • TI12-security/trunk/python/ndg_security_common/ndg/security/common/utils/classfactory.py

    r5779 r6018  
    128128 
    129129    except Exception, e: 
    130         log.error("Instantiating class, %s: %s" % (importedClass.__name__, e)) 
     130        log.error("Instantiating class, %s: %s" % (importedClass.__name__,  
     131                                                   traceback.format_exc())) 
    131132        raise 
    132133             
  • TI12-security/trunk/python/ndg_security_server/ndg/security/server/attributeauthority.py

    r6009 r6018  
    11081108            return samlResponse 
    11091109         
    1110         elif attributeQuery.subject.nameID.format != EsgSamlNamespaces.NAMEID_FORMAT: 
     1110        elif (attributeQuery.subject.nameID.format !=  
     1111              EsgSamlNamespaces.NAMEID_FORMAT): 
    11111112            log.error('SAML Attribute Query subject format is %r; expecting ' 
    11121113                      '%r' % (attributeQuery.subject.nameID.format, 
     
    18971898     
    18981899    select attr from user_table where username = $userId 
    1899     '''     
     1900     
     1901    @type SAML_VALID_REQUESTOR_DNS_PAT: _sre.SRE_Pattern 
     1902    @param SAML_VALID_REQUESTOR_DNS_PAT: regular expression to split list of 
     1903    SAML requestor DNs.  These must comma separated.  Each comma may be  
     1904    separated by any white space including new line characters 
     1905    '''   
     1906    DEFAULT_SAML_ASSERTION_LIFETIME = timedelta(seconds=60*60*8)  
     1907      
    19001908    SQLQUERY_USERID_KEYNAME = 'userId' 
    19011909     
     
    19221930    del i 
    19231931     
     1932#    For Reference - split based on space separated ' or " quoted items 
     1933#    SAML_VALID_REQUESTOR_DNS_PAT = re.compile("['\"]?\s*['\"]") 
     1934     
     1935    SAML_VALID_REQUESTOR_DNS_PAT = re.compile(',\s*') 
     1936     
    19241937    def __init__(self, **properties): 
    19251938        '''Instantiate object taking in settings from the input properties''' 
     
    19321945        self.__attributeSqlQuery = None 
    19331946        self.__samlSubjectSqlQuery = None 
    1934         self.__samlValidRequestorDNs = None 
    1935         self.__samlAssertionLifetime = None 
     1947        self.__samlValidRequestorDNs = [] 
     1948        self.__samlAssertionLifetime = \ 
     1949            SQLAlchemyAttributeInterface.DEFAULT_SAML_ASSERTION_LIFETIME 
    19361950        self.__samlAttribute2SqlQuery = {} 
    19371951         
     
    20702084    def _setSamlValidRequestorDNs(self, value): 
    20712085        if isinstance(value, basestring): 
    2072             self.__samlValidRequestorDNs = [X500DN.fromString(dn)  
    2073                                             for dn in value.split()] 
     2086             
     2087            pat = SQLAlchemyAttributeInterface.SAML_VALID_REQUESTOR_DNS_PAT 
     2088            self.__samlValidRequestorDNs = [ 
     2089                X500DN.fromString(dn) for dn in pat.split(value) 
     2090            ] 
     2091             
    20742092        elif isinstance(value, (tuple, list)): 
    20752093            self.__samlValidRequestorDNs = [X500DN.fromString(dn)  
     
    22692287                        SQLAlchemyAttributeInterface.SQLQUERY_USERID_KEYNAME)     
    22702288 
     2289        log.debug('Checking for SAML subject with SQL Query = "%s"', query) 
    22712290        try: 
    22722291            connection = dbEngine.connect() 
     
    23222341                        "attribute query string.  The valid key is %r" %  
    23232342                        SQLAlchemyAttributeInterface.SQLQUERY_USERID_KEYNAME) 
     2343             
     2344             
     2345        log.debug('Checking for SAML attributes with SQL Query = "%s"', query) 
    23242346                 
    23252347        try: 
  • TI12-security/trunk/python/ndg_security_server/ndg/security/server/myproxy/certificate_extapp/saml_attribute_assertion.py

    r6009 r6018  
    1414 
    1515import traceback 
    16 from datetime import datetime 
     16from datetime import datetime, timedelta 
    1717from uuid import uuid4 
    1818from string import Template 
     
    2525    import ElementTree 
    2626 
     27from saml.utils import SAMLDateTime 
    2728from saml.common.xml import SAMLConstants 
    28 from saml.saml2.core import ( 
    29     Assertion, Attribute,  
    30     SAMLVersion, Subject, NameID, Issuer, AttributeQuery,  
    31     XSStringAttributeValue,  
    32     StatusCode) 
    33 from saml.xml.etree import AssertionElementTree 
     29from saml.saml2.core import (Attribute,  
     30                             SAMLVersion,  
     31                             Subject,  
     32                             NameID,  
     33                             Issuer,  
     34                             AttributeQuery,  
     35                             XSStringAttributeValue,  
     36                             Status, 
     37                             StatusCode, 
     38                             StatusMessage) 
     39from saml.xml.etree import AssertionElementTree, ResponseElementTree 
    3440    
    3541from ndg.security.common.saml.bindings import SOAPBinding as SamlSoapBinding 
    3642from ndg.security.common.saml.esg import EsgSamlNamespaces 
     43from ndg.security.common.utils.etree import prettyPrint 
    3744from ndg.security.common.X509 import X500DN 
    3845from ndg.security.server.wsgi.openid.provider import IdentityMapping 
     
    5663     
    5764     
     65class CertExtAppSamlResponseError(CertExtAppError): 
     66    """Attribute Authority returned a SAML Response error code""" 
     67    def __init__(self, *arg, **kw): 
     68        CertExtAppError.__init__(self, *arg, **kw) 
     69        self.__status = Status() 
     70        self.__status.statusCode = StatusCode() 
     71        self.__status.statusMessage = StatusMessage() 
     72     
     73    def _getStatus(self): 
     74        '''Gets the Status of this response. 
     75         
     76        @return the Status of this response 
     77        ''' 
     78        return self.__status 
     79 
     80    def _setStatus(self, value): 
     81        '''Sets the Status of this response. 
     82         
     83        @param value: the Status of this response 
     84        ''' 
     85        if not isinstance(value, Status): 
     86            raise TypeError('"status" must be a %r, got %r' % (Status, 
     87                                                               type(value))) 
     88        self.__status = value 
     89         
     90    status = property(fget=_getStatus, fset=_setStatus,  
     91                      doc="Attribute Authority SAML Response error status") 
     92     
     93    def __str__(self): 
     94        if self.status is not None: 
     95            return self.status.statusMessage.value or '' 
     96        else: 
     97            return '' 
     98         
     99    def _getStatusMessage(self): 
     100        ''' 
     101        Gets the Message of this Status. 
     102         
     103        @return Status StatusMessage 
     104        ''' 
     105        return self.__statusMessage 
     106 
     107    def _setStatusMessage(self, value): 
     108        ''' 
     109        Sets the Message of this Status. 
     110         
     111        @param newStatusMessage the Message of this Status 
     112        ''' 
     113        if not isinstance(value, StatusMessage): 
     114            raise TypeError('"statusMessage" must be a %r derived type, ' 
     115                            "got %r" % (StatusMessage, type(value))) 
     116             
     117        self.__statusMessage = value 
     118         
     119    statusMessage = property(fget=_getStatusMessage, 
     120                             fset=_setStatusMessage, 
     121                             doc="SAML response status message") 
     122     
     123            
    58124class CertExtApp(object): 
    59125    """Application to create a X.509 certificate extension containing a SAML 
     
    74140    ) 
    75141    N_ATTR_DESCR_ELEM_ITEMS = 3 
     142     
    76143    DEFAULT_ATTR_DESCR = ( 
    77         (EsgSamlNamespaces.FIRSTNAME_ATTRNAME, "FirstName", XSSTRING_NS), 
    78         (EsgSamlNamespaces.LASTNAME_ATTRNAME, "LastName", XSSTRING_NS), 
    79         (EsgSamlNamespaces.EMAILADDRESS_ATTRNAME, "emailAddress", XSSTRING_NS), 
     144        (EsgSamlNamespaces.FIRSTNAME_ATTRNAME,  
     145         EsgSamlNamespaces.FIRSTNAME_FRIENDLYNAME,  
     146         XSSTRING_NS), 
     147        (EsgSamlNamespaces.LASTNAME_ATTRNAME,  
     148         EsgSamlNamespaces.LASTNAME_FRIENDLYNAME,  
     149         XSSTRING_NS), 
     150        (EsgSamlNamespaces.EMAILADDRESS_ATTRNAME,  
     151         EsgSamlNamespaces.EMAILADDRESS_FRIENDLYNAME,  
     152         XSSTRING_NS), 
    80153    ) 
    81154    ESG_NAME_ID_FORMAT = EsgSamlNamespaces.NAMEID_FORMAT 
     
    86159    ATTRIBUTE_AUTHORITY_URI_OPTNAME = 'attributeAuthorityURI' 
    87160    ISSUER_DN_OPTNAME = 'issuerDN' 
     161    CLOCK_SKEW_OPTNAME = 'clockSkew' 
    88162     
    89163    CONFIG_FILE_OPTNAMES = ( 
     
    92166        CONNECTION_STRING_OPTNAME, 
    93167        OPENID_SQLQUERY_OPTNAME, 
    94         OPENID_IDENTITY_URI_TMPL_OPTNAME                    
     168        OPENID_IDENTITY_URI_TMPL_OPTNAME, 
     169        CLOCK_SKEW_OPTNAME             
    95170    ) 
    96171    __slots__ = ( 
     
    101176    __PRIVATE_ATTR_PREFIX = '_CertExtApp__' 
    102177    __slots__ += tuple([__PRIVATE_ATTR_PREFIX + i for i in __slots__]) 
     178    del i 
    103179     
    104180    def __init__(self): 
     
    109185        self.__openIdSqlQuery = None 
    110186        self.__identityUriTemplate = None  
     187        self.__clockSkew = timedelta(seconds=0.) 
    111188                
    112189        # Use property here as a safeguard in case DEFAULT_ATTR_DESCR has been 
     
    163240            val = cfg.get(section, prefix+optName) 
    164241            setattr(self, optName, val) 
    165                      
     242             
    166243    def _getAttributeDescr(self): 
    167244        return self.__attributeDescr 
     
    281358                                       "${userIdentifier} template " 
    282359                                       "substitution parameter") 
     360 
     361    def _getClockSkew(self): 
     362        return self.__clockSkew 
     363 
     364    def _setClockSkew(self, value): 
     365        if isinstance(value, (float, int, long)): 
     366            self.__clockSkew = timedelta(seconds=value) 
     367             
     368        elif isinstance(value, basestring): 
     369            self.__clockSkew = timedelta(seconds=float(value)) 
     370        else: 
     371            raise TypeError('Expecting float, int, long or string type for ' 
     372                            '"clockSkew"; got %r' % type(value)) 
     373 
     374    clockSkew = property(fget=_getClockSkew,  
     375                         fset=_setClockSkew,  
     376                         doc="Allow a clock skew in seconds for SAML Attribute" 
     377                             " Query issueInstant parameter check") 
    283378         
    284379    def __getstate__(self): 
     
    331426                                          self.attributeAuthorityURI) 
    332427         
    333         assert(response.status.statusCode.value==StatusCode.SUCCESS_URI) 
     428        if log.level <= logging.DEBUG:             
     429            log.debug("Attribute Authority [%s] SAML Response:",  
     430                      self.attributeAuthorityURI) 
     431            log.debug("_"*80) 
     432            responseElem = ResponseElementTree.toXML(response) 
     433            log.debug(prettyPrint(responseElem)) 
     434         
     435        if response.status.statusCode.value != StatusCode.SUCCESS_URI: 
     436            samlResponseError = CertExtAppSamlResponseError() 
     437            samlResponseError.status = response.status 
     438            raise samlResponseError 
    334439         
    335440        # Check Query ID matches the query ID the service received 
    336         assert(response.inResponseTo == attributeQuery.id) 
    337          
    338         now = datetime.utcnow() 
    339         assert(response.issueInstant < now) 
    340         assert(response.assertions[-1].issueInstant < now)         
    341         assert(response.assertions[-1].conditions.notBefore < now)  
    342         assert(response.assertions[-1].conditions.notOnOrAfter > now) 
     441        if response.inResponseTo != attributeQuery.id: 
     442            samlResponseError = CertExtAppSamlResponseError() 
     443            samlResponseError.status = response.status 
     444            raise samlResponseError 
     445         
     446        utcNow = datetime.utcnow()+ self.clockSkew 
     447        if response.issueInstant > utcNow: 
     448            samlResponseError = CertExtAppSamlResponseError() 
     449             
     450            msg = ('SAML Attribute Response issueInstant [%s] is after ' 
     451                   'the current clock time [%s]' %  
     452                   (attributeQuery.issueInstant, SAMLDateTime.toString(utcNow))) 
     453                       
     454            samlResponseError.status.statusCode.value = StatusCode.RESPONDER_URI 
     455            samlResponseError.status.statusMessage.value = msg 
     456            raise samlResponseError 
     457         
     458        if utcNow < response.assertions[-1].conditions.notBefore: 
     459            samlResponseError = CertExtAppSamlResponseError() 
     460             
     461            msg = ('The current clock time [%s] is before the SAML Attribute ' 
     462                   'Response assertion conditions not before time [%s]' %  
     463                   (SAMLDateTime.toString(utcNow), 
     464                    response.assertions[-1].conditions.notBefore)) 
     465                       
     466            samlResponseError.status.statusCode.value = StatusCode.RESPONDER_URI 
     467            samlResponseError.status.statusMessage.value = msg 
     468            raise samlResponseError 
     469          
     470        if utcNow >= response.assertions[-1].conditions.notOnOrAfter: 
     471            samlResponseError = CertExtAppSamlResponseError()             
     472             
     473            msg = ('The current clock time [%s] is on or after the SAML ' 
     474                   'Attribute Response assertion conditions not on or after ' 
     475                   'time [%s]' %  
     476                   (SAMLDateTime.toString(utcNow), 
     477                    response.assertions[-1].conditions.notOnOrAfter)) 
     478                       
     479            samlResponseError.status.statusCode.value = StatusCode.RESPONDER_URI 
     480            samlResponseError.status.statusMessage.value = msg 
     481            raise samlResponseError 
    343482         
    344483        return response 
     
    407546                               "the options: connectionString, " 
    408547                               "openIdSqlQuery, identityUriTemplate, " 
    409                                "attributeAuthorityURI and issuerDN") 
     548                               "attributeAuthorityURI and issuerDN.  The file " 
     549                               "can also contain sections to configure logging " 
     550                               "using the standard logging module log file " 
     551                               "format") 
    410552 
    411553        parser.add_option("-u", 
     
    423565            raise SystemExit(msg) 
    424566         
     567        # Enable the setting of logging configuration from config file 
     568        from logging.config import fileConfig 
     569        from ConfigParser import NoSectionError 
     570        try: 
     571            fileConfig(opt.configFilePath) 
     572        except NoSectionError: 
     573            pass 
     574 
    425575        certExtApp = cls.fromConfigFile(opt.configFilePath) 
    426576        assertion = certExtApp(opt.username) 
  • TI12-security/trunk/python/ndg_security_server/ndg/security/server/wsgi/openid/provider/axinterface/sqlalchemy_ax.py

    r6009 r6018  
    2828    IDENTITY_URI_SESSION_KEYNAME = \ 
    2929                        OpenIDProviderMiddleware.IDENTITY_URI_SESSION_KEYNAME 
    30      
     30    USERNAME_SESSION_KEYNAME = \ 
     31                        OpenIDProviderMiddleware.USERNAME_SESSION_KEYNAME 
     32                         
    3133    CONNECTION_STRING_OPTNAME = 'connectionString' 
    3234    SQLQUERY_OPTNAME = 'sqlQuery' 
    3335    ATTRIBUTE_NAMES_OPTNAME = "attributeNames" 
    34     IDENTITY_URI_TMPL_OPTNAME = 'identityUriTemplate' 
    3536    SQLQUERY_USERID_KEYNAME = 'username' 
    3637     
     
    140141        log.debug('SQLAlchemyAXInterface.__call__  ...') 
    141142         
     143        username = authnCtx.get(SQLAlchemyAXInterface.USERNAME_SESSION_KEYNAME) 
     144        if username is None: 
     145            raise AXInterfaceConfigError("No username set in session context") 
     146         
    142147        identityURI = authnCtx.get( 
    143148                            SQLAlchemyAXInterface.IDENTITY_URI_SESSION_KEYNAME) 
     
    164169 
    165170        # Query for available attributes 
    166         userAttributeMap = self._attributeQuery(identityURI) 
     171        userAttributeMap = self._attributeQuery(username) 
    167172         
    168173        # Add the required attributes 
     
    222227            connection.close() 
    223228 
    224         attributeValues = result.fetchall()[0] 
     229        try: 
     230            attributeValues = result.fetchall()[0] 
     231        except IndexError: 
     232            raise AuthNInterfaceRetrieveError("No attributes returned for " 
     233                                              "query=\"%s\"" % query) 
    225234         
    226235        if len(self.attributeNames) != len(attributeValues): 
  • TI12-security/trunk/python/ndg_security_server/ndg/security/server/wsgi/openid/provider/renderinginterface/genshi/templates/identityPage.html

    r5984 r6018  
    1111            <h2>OpenID Identity Page</h2> 
    1212            <p>This is the OpenID Identity Page for user:</p> 
    13             <p>${XML(c.xml)}</p> 
     13            <p>${c.xml}</p> 
    1414        </div> 
    1515        <div py:replace="footer()"/> 
  • TI12-security/trunk/python/ndg_security_server/ndg/security/server/wsgi/openid/provider/renderinginterface/genshi/templates/mainPage.html

    r5984 r6018  
    1111            <h2>OpenID Identity Page</h2> 
    1212            <p>This service manages your NDG OpenID Login.</p> 
    13             <p>${XML(c.xml)}</p> 
     13            <p>${c.xml}</p> 
    1414        </div> 
    1515        <div py:replace="footer()"/> 
  • TI12-security/trunk/python/ndg_security_test/ndg/security/test/config/attributeauthority/sitea/siteAUserRoles.py

    r5982 r6018  
    8181     
    8282    VALID_USER_IDS = ("https://openid.localhost/philip.kershaw",) 
    83     VALID_REQUESTOR_IDS = ("/O=Site A/CN=Authorisation Service", "/O=Site B/CN=Authorisation Service") 
     83    VALID_REQUESTOR_IDS = ("/O=Site A/CN=Authorisation Service",  
     84                           "/O=Site B/CN=Authorisation Service") 
    8485    INSUFFICIENT_PRIVILEGES_REQUESTOR_ID = "/O=Site B/CN=Authorisation Service" 
    8586     
  • TI12-security/trunk/python/ndg_security_test/ndg/security/test/unit/myproxy/certificate_extapp/config.ini

    r6009 r6018  
    1515attributeAuthorityURI = http://localhost:5000/AttributeAuthority/saml 
    1616issuerDN = /O=Site A/CN=Authorisation Service 
     17clockSkew = 0 
Note: See TracChangeset for help on using the changeset viewer.