Changeset 5637


Ignore:
Timestamp:
19/08/09 16:41:13 (10 years ago)
Author:
pjkersha
Message:

Refactoring Attribute Authority for inclusion of SAML attribute query interface.

Location:
TI12-security/trunk/python
Files:
2 added
20 edited

Legend:

Unmodified
Added
Removed
  • TI12-security/trunk/python/ndg.security.saml/saml/xml/etree.py

    r5622 r5637  
    760760        @return: SAML ESG Group/Role Attribute value 
    761761        """ 
     762         
     763        # Update namespace map for the Group/Role type referenced.   
     764        ElementTree._namespace_map[cls.DEFAULT_NS] = cls.DEFAULT_PREFIX 
     765         
    762766        if not ElementTree.iselement(elem): 
    763767            raise TypeError("Expecting %r input type for parsing; got %r" % 
     
    781785                                    cls.TYPE_LOCAL_NAME) 
    782786 
    783          
    784         # Update namespace map for the Group/Role type referenced.  This will 
    785         # ensure the correct prefix is applied if it is re-serialised. 
    786         ElementTree._namespace_map[cls.DEFAULT_NS] = cls.DEFAULT_PREFIX 
    787787                                       
    788788        attributeValue = XSGroupRoleAttributeValue() 
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/attributeauthority.py

    r4840 r5637  
    3232log = logging.getLogger(__name__) 
    3333 
     34import re 
     35 
     36from ndg.security.common.utils import TypedList 
     37from ndg.security.common.utils.configfileparsers import \ 
     38    CaseSensitiveConfigParser 
     39     
    3440# X509 Certificate handling 
    3541from ndg.security.common.X509 import X509Cert 
     
    7177 
    7278 
    73 class AttributeAuthority(dict): 
     79class AttributeAuthority(object): 
    7480    """NDG Attribute Authority - service for allocation of user authorization 
    7581    tokens - attribute certificates. 
     
    8692    keywords for the Map Configuration XML Host element 
    8793     
    88     @type _confDir: string 
    89     @cvar _confDir: configuration directory under $NDGSEC_DIR - default  
     94    @type DEFAULT_CONFIG_DIRNAME: string 
     95    @cvar DEFAULT_CONFIG_DIRNAME: configuration directory under $NDGSEC_DIR - default  
    9096    location for properties file  
    9197     
    92     @type _propFileName: string 
    93     @cvar _propFileName: default file name for properties file under  
    94     _confDir 
     98    @type DEFAULT_PROPERTY_FILENAME: string 
     99    @cvar DEFAULT_PROPERTY_FILENAME: default file name for properties file under  
     100    DEFAULT_CONFIG_DIRNAME 
    95101     
    96102    @type ATTR_INTERFACE_KEYNAME: basestring 
    97103    @param ATTR_INTERFACE_KEYNAME: attribute interface parameters key name -  
    98     see _initAttributeInterface for details 
     104    see initAttributeInterface for details 
    99105    """ 
    100106 
     
    105111    # implementation of NDG Security 
    106112 
    107     _confDir = "conf" 
    108     _propFileName = "attributeAuthority.cfg" 
     113    DEFAULT_CONFIG_DIRNAME = "conf" 
     114    DEFAULT_PROPERTY_FILENAME = "attributeAuthority.cfg" 
    109115    ATTR_INTERFACE_KEYNAME = 'attributeInterface' 
     116    CONFIG_LIST_SEP_PAT = re.compile(',\W*') 
    110117     
    111118    attributeInterfacePropertyDefaults = { 
    112119        'modFilePath':  '', 
    113         'modName':      NotImplemented, 
    114         'className':    NotImplemented 
     120        'modName':      '', 
     121        'className':    '' 
    115122    } 
    116123     
     
    120127    propertyDefaults = {  
    121128        'name':                 '', 
    122         'portNum':              -1, 
    123         'useSSL':               False, 
    124         'sslCertFile':          '', 
    125         'sslKeyFile':           '', 
    126         'sslKeyPwd':            '', 
    127         'sslCACertDir':         '', 
    128         'signingCertFilePath':  NotImplemented, 
    129         'signingPriKeyFilePath':NotImplemented, 
    130         'signingPriKeyPwd':     None, 
    131         'caCertFilePathList':   [NotImplemented], 
     129        'signingCertFilePath':  '', 
     130        'signingPriKeyFilePath':'', 
     131        'signingPriKeyPwd':     '', 
     132        'caCertFilePathList':   [], 
    132133        'attCertLifetime':      -1, 
    133134        'attCertNotBeforeOff':  0, 
    134         'attCertFileName':      NotImplemented, 
     135        'attCertFileName':      '', 
    135136        'attCertFileLogCnt':    0, 
    136         'mapConfigFile':        NotImplemented, 
    137         'attCertDir':           NotImplemented, 
     137        'mapConfigFilePath':    '', 
     138        'attCertDir':           '', 
    138139        'dnSeparator':          '/', 
    139140        ATTR_INTERFACE_KEYNAME: attributeInterfacePropertyDefaults 
     
    149150    } 
    150151 
    151     def __init__(self,  
    152                  propFilePath=None,  
    153                  propFileSection='DEFAULT', 
    154                  propPrefix='', 
    155                  bReadMapConfig=True): 
    156         """Create new NDG Attribute Authority instance 
     152    def __init__(self): 
     153        """Create new Attribute Authority instance""" 
     154        log.info("Initialising service ...") 
     155         
     156        # Initial config file property based attributes 
     157        for name, val in AttributeAuthority.propertyDefaults.items(): 
     158            setattr(self, '__'+name, val) 
     159         
     160        self.__caCertFilePathList = TypedList(basestring) 
     161         
     162        self.__propFilePath = None         
     163        self.__propFileSection = 'DEFAULT' 
     164        self.__propPrefix = '' 
     165         
     166        # Initialise role mapping look-ups - These are set in readMapConfig() 
     167        self.__mapConfig = None 
     168        self.__localRole2RemoteRole = None 
     169        self.__remoteRole2LocalRole = None 
     170         
     171        self.__cert = None 
     172         
     173        # Issuer details - serialise using the separator string set in the 
     174        # properties file 
     175        self.__issuer = None 
     176        self.__issuerSerialNumber = None 
     177        self._attCertLog = None 
     178        self.__name = None 
     179         
     180        self.__attributeInterfaceCfg = {} 
     181 
     182    def _getMapConfig(self): 
     183        return self.__mapConfig 
     184 
     185    def _getCert(self): 
     186        return self.__cert 
     187 
     188    def _getIssuer(self): 
     189        return self.__issuer 
     190 
     191    def _getIssuerSerialNumber(self): 
     192        return self.__issuerSerialNumber 
     193 
     194    def _getAttCertLog(self): 
     195        return self.__attCertLog 
     196 
     197    def _getName(self): 
     198        return self.__name 
     199 
     200    def _getAttCertLifetime(self): 
     201        return self.__attCertLifetime 
     202 
     203    def _getAttCertNotBeforeOff(self): 
     204        return self.__attCertNotBeforeOff 
     205 
     206    def _getAttCertDir(self): 
     207        return self.__attCertDir 
     208 
     209    def _getAttributeInterface(self): 
     210        return self.__attributeInterface 
     211 
     212    def _getMapConfigFile(self): 
     213        return self.__mapConfigFile 
     214 
     215    def _getName(self): 
     216        return self.__name 
     217 
     218    def _getTrustedHostInfo(self): 
     219        return self.__trustedHostInfo 
     220 
     221    def _setCert(self, value): 
     222        if not isinstance(value, X509Cert): 
     223            raise TypeError('Expecting %r type for "cert"; got %r' % 
     224                            (X509Cert, type(value))) 
     225             
     226        self.__cert = value 
     227 
     228    def _setIssuer(self, value): 
     229        self.__issuer = value 
     230 
     231    def _setIssuerSerialNumber(self, value): 
     232        if not isinstance(value, (long, int)): 
     233            raise TypeError('Expecting long or int type for "name"; got %r' % 
     234                            type(value)) 
     235        self.__issuerSerialNumber = value 
     236 
     237    def _setName(self, value): 
     238        if not isinstance(value, basestring): 
     239            raise TypeError('Expecting string type for "name"; got %r' % 
     240                            type(value)) 
     241        self.__name = value 
     242 
     243    def _setAttCertLifetime(self, value): 
     244        if isinstance(value, float): 
     245            self.__attCertLifetime = value 
     246             
     247        elif isinstance(value, (basestring, int, long)): 
     248            self.__attCertLifetime = float(value) 
     249        else: 
     250            raise TypeError('Expecting float, int, long or string type for ' 
     251                            '"attCertLifetime"; got %r' % type(value)) 
     252 
     253    def _setAttCertNotBeforeOff(self, value): 
     254        if isinstance(value, float): 
     255            self.__attCertNotBeforeOff = value 
     256             
     257        elif isinstance(value, (basestring, int, long)): 
     258            self.__attCertNotBeforeOff = float(value) 
     259        else: 
     260            raise TypeError('Expecting float, int, long or string type for ' 
     261                            '"attCertNotBeforeOff"; got %r' % type(value)) 
     262 
     263    def _setAttCertDir(self, value): 
     264        if not isinstance(value, basestring): 
     265            raise TypeError('Expecting string type for "attCertDir"; got %r' %  
     266                            type(value)) 
     267 
     268        # Check directory path 
     269        try: 
     270            dirList = os.listdir(value) 
     271 
     272        except OSError, osError: 
     273            raise AttributeAuthorityConfigError('Invalid directory path for ' 
     274                                                'Attribute Certificates store ' 
     275                                                '"%s": %s' %  
     276                                                (value, osError.strerror)) 
     277        self.__attCertDir = value 
     278 
     279    def _setMapConfigFilePath(self, value): 
     280        self.__mapConfigFilePath = value 
     281 
     282    def _setTrustedHostInfo(self, value): 
     283        self.__trustedHostInfo = value 
     284 
     285    def _get_caCertFilePathList(self): 
     286        return self.__caCertFilePathList 
     287 
     288    def _set_caCertFilePathList(self, val): 
     289        if not isinstance(val, (list, tuple)): 
     290            raise TypeError('Expecting list or tuple type for ' 
     291                            '"caCertFilePathList"; got %r' % type(val)) 
     292 
     293        self.__caCertFilePathList += val 
     294    
     295    caCertFilePathList = property(fget=_get_caCertFilePathList, 
     296                                  fset=_set_caCertFilePathList, 
     297                                  doc="list of file paths for CA certificates " 
     298                                      "used to validate an Attribute " 
     299                                      "Certificate") 
     300     
     301    def _get_signingCertFilePath(self): 
     302        return self.__signingCertFilePath 
     303     
     304    def _set_signingCertFilePath(self, value): 
     305        if not isinstance(value, basestring): 
     306            raise TypeError('Expecting string type for "signingCertFilePath"; ' 
     307                            'got %r' % type(value)) 
     308        self.__signingCertFilePath = value 
     309          
     310    signingCertFilePath = property(fget=_get_signingCertFilePath,  
     311                                   fset=_set_signingCertFilePath, 
     312                                   doc="X.509 certificate used for Attribute " 
     313                                       "certificate signature") 
     314     
     315    def _get_signingPriKeyFilePath(self): 
     316        return self.__signingPriKeyFilePath 
     317     
     318    def _set_signingPriKeyFilePath(self, value): 
     319        if not isinstance(value, basestring): 
     320            raise TypeError('Expecting string type for ' 
     321                            '"signingPriKeyFilePath"; got %r' % type(value)) 
     322        self.__signingPriKeyFilePath = value 
     323          
     324    signingPriKeyFilePath = property(fget=_get_signingPriKeyFilePath,  
     325                                     fset=_set_signingPriKeyFilePath, 
     326                                     doc="File Path for private key used to " 
     327                                         "sign Attribute certificate") 
     328     
     329    def _get_signingPriKeyPwd(self): 
     330        return self.__signingPriKeyPwd 
     331     
     332    def _set_signingPriKeyPwd(self, value): 
     333        if not isinstance(value, (type(None), basestring)): 
     334            raise TypeError('Expecting string or None type for ' 
     335                            '"signingPriKeyFilePath"; got %r' % type(value)) 
     336        self.__signingPriKeyPwd = value 
     337          
     338    signingPriKeyPwd = property(fget=_get_signingPriKeyPwd,  
     339                                fset=_set_signingPriKeyPwd, 
     340                                doc="Password for private key file used to " 
     341                                    "for Attribute certificate signature") 
     342 
     343    def _get_attributeInterfaceCfg(self): 
     344        return self.__attributeInterfaceCfg 
     345     
     346    attributeInterfaceCfg = property(fget=_get_attributeInterfaceCfg, 
     347                                     doc="Settings for Attribute Interface " 
     348                                         "initialisation") 
     349     
     350    def _get_attCertFileName(self): 
     351        return self.__attCertFileName 
     352     
     353    def _set_attCertFileName(self, value): 
     354        if not isinstance(value, basestring): 
     355            raise TypeError('Expecting string type for "attCertFileName"; got ' 
     356                            '%r' % type(value)) 
     357        self.__signingPriKeyPwd = value 
     358          
     359    attCertFileName = property(fget=_get_attCertFileName,  
     360                                fset=_set_attCertFileName, 
     361                                doc="Attribute certificate file name for log") 
     362     
     363    def _get_dnSeparator(self): 
     364        return self.__dnSeparator 
     365     
     366    def _set_dnSeparator(self, value): 
     367        if not isinstance(value, basestring): 
     368            raise TypeError('Expecting string type for "dnSeparator"; got ' 
     369                            '%r' % type(value)) 
     370        self.__dnSeparator = value 
     371          
     372    dnSeparator = property(fget=_get_dnSeparator,  
     373                           fset=_set_dnSeparator, 
     374                           doc="Distinguished Name separator character used " 
     375                               "with X.509 Certificate issuer certificate") 
     376     
     377    mapConfig = property(fget=_getMapConfig,  
     378                         doc="MapConfig object") 
     379 
     380    cert = property(fget=_getCert,  
     381                    fset=_setCert,  
     382                    doc="X.509 Issuer Certificate") 
     383 
     384    issuer = property(fget=_getIssuer,  
     385                      fset=_setIssuer,  
     386                      doc="Issuer name") 
     387 
     388    issuerSerialNumber = property(fget=_getIssuerSerialNumber,  
     389                                  fset=_setIssuerSerialNumber,  
     390                                  doc="Issuer Serial Number") 
     391 
     392    attCertLog = property(fget=_getAttCertLog,  
     393                          doc="Attribute certificate logging object") 
     394 
     395    name = property(fget=_getName,  
     396                    fset=_setName,  
     397                    doc="Issuer organisation name") 
     398 
     399    attCertLifetime = property(fget=_getAttCertLifetime,  
     400                               fset=_setAttCertLifetime,  
     401                               doc="Attribute certificate lifetime") 
     402 
     403    attCertNotBeforeOff = property(fget=_getAttCertNotBeforeOff,  
     404                                   fset=_setAttCertNotBeforeOff,  
     405                                   doc="Attribute certificate clock skew in " 
     406                                       "seconds") 
     407 
     408    attCertDir = property(fget=_getAttCertDir,  
     409                          fset=_setAttCertDir,  
     410                          doc="Attribute certificate log directory") 
     411 
     412    attributeInterface = property(fget=_getAttributeInterface,  
     413                                  doc="Attribute Interface object") 
     414 
     415    name = property(fget=_getName, fset=_setName, doc="Organisation Name") 
     416 
     417    trustedHostInfo = property(fget=_getTrustedHostInfo,  
     418                               fset=_setTrustedHostInfo,  
     419                               doc="Dictionary of trusted organisations") 
     420         
     421    @classmethod 
     422    def fromPropertyFile(cls, propFilePath=None, bReadMapConfig=True): 
     423        """Create new NDG Attribute Authority instance from the property file 
     424        settings 
    157425 
    158426        @type propFilePath: string 
     
    171439        read.  Set this flag to False to override. 
    172440        """ 
    173         log.info("Initialising service ...") 
    174          
    175         # Base class initialisation 
    176         dict.__init__(self) 
    177  
    178         # Set from input or use defaults based or environment variables 
    179         self.propFilePath = propFilePath 
    180          
    181         self.propFileSection = propFileSection 
    182         self.propPrefix = propPrefix 
    183          
    184         # Initialise role mapping look-ups - These are set in readMapConfig() 
    185         self._mapConfig = None 
    186         self._localRole2RemoteRole = None 
    187         self._remoteRole2LocalRole = None 
    188  
    189         self.readProperties() 
     441             
     442        attributeAuthority = AttributeAuthority() 
     443        attributeAuthority.propFilePath = propFilePath 
     444             
     445        attributeAuthority.readProperties() 
    190446 
    191447        # Read the Map Configuration file 
    192448        if bReadMapConfig: 
    193             self.readMapConfig() 
     449            attributeAuthority.readMapConfig() 
    194450 
    195451        # Instantiate Certificate object 
    196452        log.debug("Reading and checking Attribute Authority X.509 cert. ...") 
    197         self.__cert = X509Cert.Read(self._prop['signingCertFilePath']) 
     453        attributeAuthority.cert = X509Cert.Read( 
     454                                        attributeAuthority.signingCertFilePath) 
    198455 
    199456        # Check it's valid 
    200457        try: 
    201             self.__cert.isValidTime(raiseExcep=True) 
     458            attributeAuthority.cert.isValidTime(raiseExcep=True) 
    202459             
    203460        except Exception, e: 
     
    207464        # Check CA certificate 
    208465        log.debug("Reading and checking X.509 CA certificate ...") 
    209         for caCertFile in self._prop['caCertFilePathList']: 
     466        for caCertFile in attributeAuthority.caCertFilePathList: 
    210467            caCert = X509Cert(caCertFile) 
    211468            caCert.read() 
     
    220477        # Issuer details - serialise using the separator string set in the 
    221478        # properties file 
    222         self.__issuer = \ 
    223             self.__cert.dn.serialise(separator=self._prop['dnSeparator']) 
    224  
    225         self.__issuerSerialNumber = self.__cert.serialNumber 
     479        attributeAuthority.issuer = attributeAuthority.cert.dn.serialise( 
     480                                    separator=attributeAuthority.dnSeparator) 
     481 
     482        attributeAuthority.issuerSerialNumber = \ 
     483                                        attributeAuthority.cert.serialNumber 
    226484         
    227485        # Load user - user attribute look-up plugin  
    228         self._initAttributeInterface() 
    229          
    230         attCertFilePath = os.path.join(self._prop['attCertDir'], 
    231                                        self._prop['attCertFileName']) 
     486        attributeAuthority.initAttributeInterface() 
     487         
     488        attCertFilePath = os.path.join(attributeAuthority.attCertDir,  
     489                                       attributeAuthority.attCertFileName) 
    232490                 
    233491        # Rotating file handler used for logging attribute certificates  
    234492        # issued. 
    235         self._attCertLog=AttCertLog(attCertFilePath, 
    236                                     backUpCnt=self._prop['attCertFileLogCnt']) 
    237  
    238  
    239     def readProperties(self, section=None, prefix=None): 
     493        attributeAuthority.attCertLog = AttCertLog(attCertFilePath, 
     494                                backUpCnt=attributeAuthority.attCertFileLogCnt) 
     495     
     496        return attributeAuthority 
     497 
     498    def setProperties(self, **prop): 
     499        """Set configuration from an input property dictionary 
     500        @type prop: dict 
     501        @param prop: properties dictionary containing configuration items 
     502        to be set 
     503        """ 
     504        lenPropPrefix = len(self.propPrefix) 
     505        lenAttributeInterfacePrefix = len( 
     506                                    AttributeAuthority.ATTR_INTERFACE_KEYNAME) 
     507         
     508        for name, val in prop.items(): 
     509            if name.startswith(self.propPrefix): 
     510                name = name[lenPropPrefix:] 
     511             
     512            if name.startswith(AttributeAuthority.ATTR_INTERFACE_KEYNAME): 
     513                name = name[lenAttributeInterfacePrefix:] 
     514                self.attributeInterfaceCfg[name] = val 
     515                continue 
     516             
     517            if name not in AttributeAuthority.propertyDefaults: 
     518                raise AttributeError('Invalid attribute name "%s"' % name) 
     519             
     520            if isinstance(val, basestring): 
     521                val = os.path.expandvars(val) 
     522             
     523            if isinstance(AttributeAuthority.propertyDefaults[name], list): 
     524                val = AttributeAuthority.CONFIG_LIST_SEP_PAT.split(val) 
     525                 
     526            # This makes an implicit call to the appropriate property method 
     527            try: 
     528                setattr(self, name, val) 
     529            except AttributeError: 
     530                raise AttributeError("Can't set attribute \"%s\"" % name) 
     531             
     532             
     533    def readProperties(self): 
    240534        '''Read the properties files and do some checking/converting of input  
    241535        values 
    242          
    243         @type section: basestring 
    244         @param section: ini file section to read properties from - doesn't  
    245         apply to XML format properties files.  section setting defaults to  
    246         current propFileSection attribute 
    247          
    248         @type prefix: basestring 
    249         @param prefix: apply prefix to ini file properties - doesn't  
    250         apply to XML format properties files.  This enables filtering of 
    251         properties so that only those relevant to this class are read in 
    252536        ''' 
    253         if section is None: 
    254             section = self.propFileSection 
    255          
    256         if prefix is None: 
    257             prefix = self.propPrefix 
    258                
    259         # Configuration file properties are held together in a dictionary 
    260         fileProp = readAndValidateProperties(self.propFilePath,  
    261                                  validKeys=AttributeAuthority.propertyDefaults, 
    262                                  prefix=prefix, 
    263                                  sections=(section,)) 
    264          
    265         # Allow for section and prefix names which will nest the Attribute 
    266         # Authority properties in a hierarchy 
    267         propBranch = fileProp 
    268         if section != 'DEFAULT': 
    269             propBranch = propBranch[section] 
    270              
    271         self._prop = propBranch 
    272          
    273         # Ensure Certificate time parameters are converted to numeric type 
    274         self._prop['attCertLifetime'] = float(self._prop['attCertLifetime']) 
    275         self._prop['attCertNotBeforeOff'] = \ 
    276                                     float(self._prop['attCertNotBeforeOff']) 
    277  
    278         # Check directory path 
    279         try: 
    280             dirList = os.listdir(self._prop['attCertDir']) 
    281  
    282         except OSError, osError: 
    283             raise AttributeAuthorityConfigError('Invalid directory path for ' 
    284                                                 'Attribute Certificates store ' 
    285                                                 '"%s": %s' %  
    286                                                 (self._prop['attCertDir'],  
    287                                                  osError.strerror)) 
    288     def _initAttributeInterface(self): 
     537        if not os.path.isfile(self.propFilePath): 
     538            raise IOError('Error parsing properties file "%s": No such file' %  
     539                          self.propFilePath) 
     540             
     541        defaultItems = {'here': os.path.dirname(self.propFilePath)} 
     542         
     543        cfg = CaseSensitiveConfigParser(defaults=defaultItems) 
     544        cfg.read(self.propFilePath) 
     545         
     546        cfgItems = dict([(name, val)  
     547                         for name, val in cfg.items(self.propFileSection) 
     548                         if name != 'here']) 
     549        self.setProperties(**cfgItems) 
     550 
     551    def initAttributeInterface(self): 
    289552        '''Load host sites custom user roles interface to enable the AA to 
    290553        # assign roles in an attribute certificate on a getAttCert request''' 
    291         keyName = AttributeAuthority.ATTR_INTERFACE_KEYNAME 
    292          
    293         modName = self._prop[keyName].pop('modName') 
    294         className = self._prop[keyName].pop('className')       
    295         modFilePath = self._prop[keyName].pop('modFilePath')  
     554        classProperties = {} 
     555        classProperties.update(self.attributeInterfaceCfg) 
     556         
     557        modName = classProperties.pop('modName') 
     558        className = classProperties.pop('className')       
     559        modFilePath = classProperties.pop('modFilePath')  
    296560                       
    297         self._attributeInterface = instantiateClass(modName, 
     561        self.__attributeInterface = instantiateClass(modName, 
    298562                                         className, 
    299563                                         moduleFilePath=modFilePath, 
    300564                                         objectType=AttributeInterface, 
    301                                          classProperties=self._prop[keyName]) 
    302          
    303     # Methods for Attribute Authority dictionary like behaviour         
    304     def __repr__(self): 
    305         """Return file properties dictionary as string""" 
    306         return repr(self._prop) 
    307      
    308     def __delitem__(self, key): 
    309         AttributeAuthority.__name__ + " keys cannot be removed"         
    310         raise KeyError('Keys cannot be deleted from '+AttributeAuthority.__name__) 
    311  
    312  
    313     def __getitem__(self, key): 
    314         AttributeAuthority.__name__ + """ behaves as data dictionary of Attribute 
    315         Authority properties 
    316         """ 
    317         if key not in self._prop: 
    318             raise KeyError("Invalid key '%s'" % key) 
    319          
    320         return self._prop[key] 
    321          
    322     def get(self, kw): 
    323         return self._prop.get(kw) 
    324      
    325     def clear(self): 
    326         raise KeyError("Data cannot be cleared from "+AttributeAuthority.__name__) 
    327     
    328     def keys(self): 
    329         return self._prop.keys() 
    330  
    331     def items(self): 
    332         return self._prop.items() 
    333  
    334     def values(self): 
    335         return self._prop.values() 
    336  
    337     def has_key(self, key): 
    338         return self._prop.has_key(key) 
    339  
    340     # 'in' operator 
    341     def __contains__(self, key): 
    342         return key in self._prop 
    343  
     565                                         classProperties=classProperties) 
    344566 
    345567    def setPropFilePath(self, val=None): 
     
    356578            elif 'NDGSEC_DIR' in os.environ: 
    357579                val = os.path.join(os.environ['NDGSEC_DIR'],  
    358                                    AttributeAuthority._confDir, 
    359                                    AttributeAuthority._propFileName) 
     580                                   AttributeAuthority.DEFAULT_CONFIG_DIRNAME, 
     581                                   AttributeAuthority.DEFAULT_PROPERTY_FILENAME) 
    360582            else: 
    361583                raise AttributeError('Unable to set default Attribute ' 
     
    368590                                 "must be a valid string.") 
    369591       
    370         self._propFilePath = os.path.expandvars(val) 
     592        self.__propFilePath = os.path.expandvars(val) 
    371593        log.debug("Path set to: %s" % val) 
    372594         
     
    376598        @rtype: basestring 
    377599        @return: properties file path''' 
    378         log.debug("Getting property file path") 
    379         if hasattr(self, '_propFilePath'): 
    380             return self._propFilePath 
    381         else: 
    382             return "" 
     600        return self.__propFilePath 
    383601         
    384602    # Also set up as a property 
    385603    propFilePath = property(fset=setPropFilePath, 
    386604                            fget=getPropFilePath, 
    387                             doc="Set the path to the properties file")    
     605                            doc="path to file containing Attribute Authority " 
     606                                "configuration parameters.  It defaults to " 
     607                                "$NDGSEC_AA_PROPFILEPATH or if not set, " 
     608                                "$NDGSEC_DIR/conf/attributeAuthority.cfg")    
    388609     
    389610    def setPropFileSection(self, val=None): 
     
    402623                                 "must be a valid string.") 
    403624       
    404         self._propFileSection = val 
     625        self.__propFileSection = val 
    405626        log.debug("Properties file section set to: %s" % val) 
    406627         
     
    411632        @rtype: basestring 
    412633        @return: section name''' 
    413         log.debug("Getting property file section name") 
    414         if hasattr(self, '_propFileSection'): 
    415             return self._propFileSection 
    416         else: 
    417             return ""     
     634        return self.__propFileSection 
    418635         
    419636    # Also set up as a property 
    420637    propFileSection = property(fset=setPropFileSection, 
    421                     fget=getPropFileSection, 
    422                     doc="Set the file section name for ini file properties")    
     638                               fget=getPropFileSection, 
     639                               doc="Set the file section name for ini file " 
     640                                   "properties")    
    423641     
    424642    def setPropPrefix(self, val=None): 
     
    439657                                 "must be a valid string.") 
    440658       
    441         self._propPrefix = val 
     659        self.__propPrefix = val 
    442660        log.debug("Properties file section set to: %s" % val) 
    443661         
     
    449667        @return: section name''' 
    450668        log.debug("Getting property file prefix") 
    451         if hasattr(self, '_propPrefix'): 
    452             return self._propPrefix 
    453         else: 
    454             return ""     
     669        return self.__propPrefix 
     670    
    455671         
    456672    # Also set up as a property 
     
    552768            try: 
    553769                userId = holderX509Cert.dn.serialise(\ 
    554                                          separator=self._prop['dnSeparator'])  
     770                                         separator=self.dnSeparator)  
    555771            except Exception, e: 
    556772                log.error("Setting user Id from holder certificate DN: %s" % e) 
     
    563779        # First certificate in list contains the public key corresponding to  
    564780        # the private key 
    565         attCert.certFilePathList = [self._prop['signingCertFilePath']] + \ 
    566                                                                 self._prop['caCertFilePathList'] 
     781        attCert.certFilePathList = [self.signingCertFilePath] + \ 
     782                                                                self.caCertFilePathList 
    567783              
    568784        # Check for expiry of each certificate                    
     
    570786            X509Cert.Read(x509Cert).isValidTime(raiseExcep=True) 
    571787                                                                 
    572         attCert.signingKeyFilePath = self._prop['signingPriKeyFilePath'] 
    573         attCert.signingKeyPwd = self._prop['signingPriKeyPwd'] 
     788        attCert.signingKeyFilePath = self.signingPriKeyFilePath 
     789        attCert.signingKeyPwd = self.signingPriKeyPwd 
    574790         
    575791         
     
    579795            try: 
    580796                attCert['holder'] = holderX509Cert.dn.serialise( 
    581                                         separator=self._prop['dnSeparator'])             
     797                                        separator=self.dnSeparator)             
    582798            except Exception, e: 
    583799                 log.error("Holder X.509 Certificate DN: %s" % e) 
     
    585801             
    586802        # Set Issuer details from Attribute Authority 
    587         issuerDN = self.__cert.dn 
     803        issuerDN = self.cert.dn 
    588804        try: 
    589805            attCert['issuer'] = \ 
    590                     issuerDN.serialise(separator=self._prop['dnSeparator'])             
     806                    issuerDN.serialise(separator=self.dnSeparator)             
    591807        except Exception, e: 
    592808            log.error("Issuer X.509 Certificate DN: %s" % e) 
    593809            raise  
    594810            
    595         attCert['issuerName'] = self._prop['name'] 
    596         attCert['issuerSerialNumber'] = self.__issuerSerialNumber 
     811        attCert['issuerName'] = self.name 
     812        attCert['issuerSerialNumber'] = self.issuerSerialNumber 
    597813 
    598814        attCert['userId'] = userId 
     
    601817        try: 
    602818            attCert.setValidityTime( 
    603                         lifetime=self._prop['attCertLifetime'], 
    604                         notBeforeOffset=self._prop['attCertNotBeforeOff']) 
     819                        lifetime=self.attCertLifetime, 
     820                        notBeforeOffset=self.attCertNotBeforeOff) 
    605821 
    606822            # Check against the holder X.509 certificate's expiry if set 
     
    616832                    # still applied 
    617833                    attCert.setValidityTime(dtNotAfter=dtHolderCertNotAfter, 
    618                             notBeforeOffset=self._prop['attCertNotBeforeOff']) 
     834                            notBeforeOffset=self.attCertNotBeforeOff) 
    619835             
    620836        except Exception, e: 
     
    677893            try: 
    678894                # Give path to CA cert to allow check 
    679                 userAttCert.certFilePathList=self._prop['caCertFilePathList'] 
     895                userAttCert.certFilePathList = self.caCertFilePathList 
    680896                userAttCert.isValid(raiseExcep=True) 
    681897                 
     
    740956            raise AttributeAuthorityError('New Attribute Certificate "%s": %s'% 
    741957                                          (attCert.filePath, e)) 
    742         
    743          
    744     def readMapConfig(self, mapConfigFilePath=None): 
     958             
     959    def _getMapConfigFilePath(self): 
     960        return self.__mapConfigFilePath 
     961     
     962    def _setMapConfigFilePath(self, val): 
     963        if not isinstance(val, basestring): 
     964            raise AttributeAuthorityConfigError("Input Map Configuration " 
     965                                                "file path must be a " 
     966                                                "valid string.") 
     967        self.__mapConfigFilePath = val 
     968           
     969    mapConfigFilePath = property(fget=_getMapConfigFilePath, 
     970                                 fset=_setMapConfigFilePath, 
     971                                 doc="File path for Role Mapping configuration")  
     972         
     973    def readMapConfig(self): 
    745974        """Parse Map Configuration file. 
    746  
    747         @type mapConfigFilePath: string 
    748         @param mapConfigFilePath: file path for map configuration file.  If  
    749         omitted, it uses member variable _prop['mapConfigFile']. 
    750975        """ 
    751976         
    752977        log.debug("Reading map configuration file ...") 
    753978         
    754         if mapConfigFilePath is not None: 
    755             if not isinstance(mapConfigFilePath, basestring): 
    756                 raise AttributeAuthorityConfigError("Input Map Configuration " 
    757                                                     "file path must be a " 
    758                                                     "valid string.") 
    759              
    760             self._prop['mapConfigFile'] = mapConfigFilePath 
    761  
    762  
    763979        try: 
    764             tree = ElementTree.parse(self._prop['mapConfigFile']) 
     980            tree = ElementTree.parse(self.mapConfigFilePath) 
    765981            rootElem = tree.getroot() 
    766982             
     
    772988            raise AttributeAuthorityConfigError('Error parsing Map ' 
    773989                                                'Configuration file: "%s": %s'%  
    774                                                 (self._prop['mapConfigFile'],  
     990                                                (self.mapConfigFilePath,  
    775991                                                 e)) 
    776992 
     
    7841000        # Dictionaries: 
    7851001        # 1) to hold all the data 
    786         self._mapConfig = {'thisHost': {}, 'trustedHosts': {}} 
     1002        self.__mapConfig = {'thisHost': {}, 'trustedHosts': {}} 
    7871003 
    7881004        # ... look-up 
     
    7901006        # 3) roles of external data centre to this data centre 
    7911007        self._localRole2TrustedHost = {} 
    792         self._localRole2RemoteRole = {} 
    793         self._remoteRole2LocalRole = {} 
     1008        self.__localRole2RemoteRole = {} 
     1009        self.__remoteRole2LocalRole = {} 
    7941010 
    7951011 
     
    8011017            raise AttributeAuthorityConfigError('"thisHost" tag not found in ' 
    8021018                                                'Map Configuration file "%s"' %  
    803                                                 self._prop['mapConfigFile']) 
     1019                                                self.mapConfigFilePath) 
    8041020 
    8051021        try: 
     
    8111027                                                'in Map Configuration file ' 
    8121028                                                '"%s"' %  
    813                                                 self._prop['mapConfigFile']) 
     1029                                                self.mapConfigFilePath) 
    8141030 
    8151031 
     
    8221038        # 
    8231039        # P J Kershaw 14/06/06 
    824         if hostName != self._prop['name']: 
     1040        if hostName != self.name: 
    8251041            raise AttributeAuthorityError('"name" attribute of "thisHost" ' 
    8261042                                          'element in Map Configuration file ' 
     
    8291045         
    8301046        # Information for THIS Attribute Authority 
    831         self._mapConfig['thisHost'][hostName] = {} 
     1047        self.__mapConfig['thisHost'][hostName] = {} 
    8321048 
    8331049        for k, v in AttributeAuthority.mapConfigHostDefaults.items(): 
     
    8361052                raise AttributeAuthorityConfigError('<thisHost> option <%s> ' 
    8371053                                                    'must be set.' % k) 
    838             self._mapConfig['thisHost'][hostName][k] = val 
     1054            self.__mapConfig['thisHost'][hostName][k] = val 
    8391055                 
    8401056         
     
    8581074            # 
    8591075            # P J Kershaw 25/05/06 
    860             self._mapConfig['trustedHosts'][trustedHost] = {} 
     1076            self.__mapConfig['trustedHosts'][trustedHost] = {} 
    8611077            for k, v in AttributeAuthority.mapConfigHostDefaults.items(): 
    8621078                val = thisHostElem.findtext(k) 
     
    8651081                                                        '<%s> must be set.'%k) 
    8661082                     
    867                 self._mapConfig['trustedHosts'][trustedHost][k] = \ 
     1083                self.__mapConfig['trustedHosts'][trustedHost][k] = \ 
    8681084                                                        elem.findtext(k)    
    8691085 
     
    8721088                # Role keyword value requires special parsing before  
    8731089                # assignment 
    874                 self._mapConfig['trustedHosts'][trustedHost]['role'] = \ 
     1090                self.__mapConfig['trustedHosts'][trustedHost]['role'] = \ 
    8751091                                        [dict(i.items()) for i in roleElem] 
    8761092            else: 
     
    8781094                # role mapping.  e.g. a site's login service trusting other 
    8791095                # sites login requests 
    880                 self._mapConfig['trustedHosts'][trustedHost]['role'] = [] 
     1096                self.__mapConfig['trustedHosts'][trustedHost]['role'] = [] 
    8811097                        
    882             self._localRole2RemoteRole[trustedHost] = {} 
    883             self._remoteRole2LocalRole[trustedHost] = {} 
    884              
    885             for role in self._mapConfig['trustedHosts'][trustedHost]['role']: 
     1098            self.__localRole2RemoteRole[trustedHost] = {} 
     1099            self.__remoteRole2LocalRole[trustedHost] = {} 
     1100             
     1101            for role in self.__mapConfig['trustedHosts'][trustedHost]['role']: 
    8861102                try: 
    8871103                    localRole = role['local'] 
     
    8911107                                                  ' file "%s": no element ' 
    8921108                                                  '"%s" for host "%s"' %  
    893                                                 (self._prop['mapConfigFile'],  
     1109                                                (self.mapConfigFilePath,  
    8941110                                                 e,  
    8951111                                                 trustedHost)) 
     
    9091125                # map look-ups 
    9101126                try: 
    911                     self._remoteRole2LocalRole[trustedHost][remoteRole].\ 
     1127                    self.__remoteRole2LocalRole[trustedHost][remoteRole].\ 
    9121128                                                            append(localRole)                   
    9131129                except KeyError: 
    914                     self._remoteRole2LocalRole[trustedHost][remoteRole] = \ 
     1130                    self.__remoteRole2LocalRole[trustedHost][remoteRole] = \ 
    9151131                                                                [localRole] 
    9161132                     
    9171133                try: 
    918                     self._localRole2RemoteRole[trustedHost][localRole].\ 
     1134                    self.__localRole2RemoteRole[trustedHost][localRole].\ 
    9191135                                                            append(remoteRole)                   
    9201136                except KeyError: 
    921                     self._localRole2RemoteRole[trustedHost][localRole] = \ 
     1137                    self.__localRole2RemoteRole[trustedHost][localRole] = \ 
    9221138                                                                [remoteRole] 
    9231139         
     
    9431159                                                       ).keys() 
    9441160                } 
    945             ) for k, v in self._mapConfig['trustedHosts'].items() 
     1161            ) for k, v in self.__mapConfig['trustedHosts'].items() 
    9461162        ]) 
    9471163 
    948         log.info('Loaded map configuration file "%s"' %  
    949                  self._prop['mapConfigFile']) 
     1164        log.info('Loaded map configuration file "%s"' % self.mapConfigFilePath) 
    9501165        
    9511166         
     
    9631178        # define how roles are accessed 
    9641179        try: 
    965             return self._attributeInterface.getRoles(userId) 
     1180            return self.__attributeInterface.getRoles(userId) 
    9661181 
    9671182        except Exception, e: 
     
    9781193        configuration""" 
    9791194         
    980         return self._mapConfig['thisHost'] 
     1195        return self.__mapConfig['thisHost'] 
    9811196         
    9821197    hostInfo = property(fget=_getHostInfo,  
     
    10021217        log.debug('Calling getTrustedHostInfo with role = "%s" ...' % role)  
    10031218                                  
    1004         if not self._mapConfig or not self._localRole2RemoteRole: 
     1219        if not self.__mapConfig or not self.__localRole2RemoteRole: 
    10051220            # This Attribute Authority has no trusted hosts 
    10061221            raise AttributeAuthorityNoTrustedHosts("The %s Attribute " 
    10071222                                                   "Authority has no trusted " 
    10081223                                                   "hosts" %  
    1009                                                    self._prop['name']) 
     1224                                                   self.name) 
    10101225 
    10111226 
     
    10311246            host,  
    10321247            { 
    1033                 'siteName': self._mapConfig['trustedHosts'][host]['siteName'], 
    1034                 'aaURI':    self._mapConfig['trustedHosts'][host]['aaURI'], 
    1035                 'aaDN':     self._mapConfig['trustedHosts'][host]['aaDN'], 
    1036                 'loginURI': self._mapConfig['trustedHosts'][host]['loginURI'], 
     1248                'siteName': self.__mapConfig['trustedHosts'][host]['siteName'], 
     1249                'aaURI':    self.__mapConfig['trustedHosts'][host]['aaURI'], 
     1250                'aaDN':     self.__mapConfig['trustedHosts'][host]['aaDN'], 
     1251                'loginURI': self.__mapConfig['trustedHosts'][host]['loginURI'], 
    10371252                'loginServerDN':  
    1038                         self._mapConfig['trustedHosts'][host]['loginServerDN'], 
     1253                        self.__mapConfig['trustedHosts'][host]['loginServerDN'], 
    10391254                'loginRequestServerDN':  
    1040                 self._mapConfig['trustedHosts'][host]['loginRequestServerDN'], 
    1041                 'role':     self._localRole2RemoteRole[host][role] 
     1255                self.__mapConfig['trustedHosts'][host]['loginRequestServerDN'], 
     1256                'role':     self.__localRole2RemoteRole[host][role] 
    10421257            } 
    10431258        ) for host in trustedHosts]) 
     
    10551270        @return: list of mapped roles""" 
    10561271 
    1057         if not self._remoteRole2LocalRole: 
     1272        if not self.__remoteRole2LocalRole: 
    10581273            raise AttributeAuthorityError("Roles map is not set - ensure "  
    10591274                                    "readMapConfig() has been called.") 
     
    10621277        # Check the host name is a trusted one recorded in the map 
    10631278        # configuration 
    1064         if not self._remoteRole2LocalRole.has_key(trustedHost): 
     1279        if not self.__remoteRole2LocalRole.has_key(trustedHost): 
    10651280            return [] 
    10661281 
     
    10681283        localRoles = [] 
    10691284        for trustedRole in trustedHostRoles: 
    1070             if trustedRole in self._remoteRole2LocalRole[trustedHost]: 
    1071                 localRoles.extend(\ 
    1072                         self._remoteRole2LocalRole[trustedHost][trustedRole]) 
     1285            if trustedRole in self.__remoteRole2LocalRole[trustedHost]: 
     1286                localRoles.extend( 
     1287                        self.__remoteRole2LocalRole[trustedHost][trustedRole]) 
    10731288                 
    10741289        return localRoles 
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/conf/attAuthority.cfg

    r5465 r5637  
    4040 
    4141# Location of role mapping file 
    42 mapConfigFile: $NDGSEC_DIR/conf/mapConfig.xml 
     42mapConfigFilePath: $NDGSEC_DIR/conf/mapConfig.xml 
    4343# All Attribute Certificates issued are recorded in this dir 
    4444attCertDir: $NDGSEC_DIR/conf/attCertLog 
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/wsgi/saml.py

    r5623 r5637  
    9191                                                        'environ') 
    9292         
    93         soapRequestTxt = soapRequestStream.read()   
     93        # TODO: allow for chunked data 
     94        contentLength = environ.get('CONTENT_LENGTH') 
     95        if contentLength is None: 
     96            raise SOAPAttributeInterfaceMiddlewareError('No "CONTENT_LENGTH" ' 
     97                                                        'in environ') 
     98 
     99        contentLength = int(contentLength)         
     100        soapRequestTxt = soapRequestStream.read(contentLength) 
     101         
     102        # Parse into a SOAP envelope object 
    94103        soapRequest = SOAPEnvelope() 
    95         soapRequest.parse(soapRequestStream) 
    96          
     104        soapRequest.parse(StringIO(soapRequestTxt)) 
     105         
     106        # Filter based on SOAP Body content - expecting an AttributeQuery 
     107        # element 
    97108        if not SOAPAttributeInterfaceMiddleware.isAttributeQuery( 
    98109                                                            soapRequest.body): 
     
    101112            return self._app(environ, start_response) 
    102113         
    103         # Filter based on SOAP Body content - expecting an AttributeQuery 
    104         # element 
     114        log.debug("SOAPAttributeInterfaceMiddleware.__call__: received SAML " 
     115                  "SOAP AttributeQuery ...") 
     116         
    105117        attributeQueryElem = soapRequest.body.elem[0] 
    106118        attributeQuery = AttributeQueryElementTree.fromXML(attributeQueryElem) 
    107          
    108         print("Received request from client:\n") 
    109         print soapRequest.prettyPrint() 
    110          
     119                 
    111120        samlResponse = Response() 
    112121         
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/wsgi/soap.py

    r5543 r5637  
    1313log = logging.getLogger(__name__) 
    1414 
    15 import sys 
    16  
    17 from ZSI.parse import ParsedSoap 
    18 from ZSI.writer import SoapWriter 
    19 from ZSI import fault 
    20  
    21 from ZSI.ServiceContainer import ServiceSOAPBinding 
    22 from ndg.security.common.utils.classfactory import instantiateClass, \ 
    23     importClass 
    24 from ndg.security.common.wssecurity.utils import DomletteReader, \ 
    25     DomletteElementProxy 
    2615      
    2716class SOAPMiddlewareError(Exception): 
     
    3423            self.__class__._log.error(arg[0]) 
    3524        Exception.__init__(self, *arg, **kw) 
    36      
     25 
     26 
    3727class SOAPMiddlewareReadError(SOAPMiddlewareError): 
    3828    """SOAP Middleware read error""" 
    3929 
     30 
    4031class SOAPMiddlewareConfigError(SOAPMiddlewareError): 
    4132    """SOAP Middleware configuration error""" 
     33 
    4234 
    4335class SOAPMiddleware(object): 
     
    5951        from exception2SOAPFault''' 
    6052        return bool(environ.get(cls.soapFaultSetKey, False)) == True 
    61           
    62 class ZSIMiddlewareError(SOAPMiddlewareError): 
    63     pass 
    64      
    65 class ZSIMiddlewareReadError(SOAPMiddlewareReadError): 
    66     """ZSI Middleware read error""" 
    67  
    68 class ZSIMiddlewareConfigError(SOAPMiddlewareConfigError): 
    69     """ZSI middleware configuration error""" 
    70       
    71 class ZSIMiddleware(SOAPMiddleware): 
    72     '''Middleware configurable to a given ZSI SOAP binding'''   
    73      
    74     soapWriterKey = 'ZSI.writer.SoapWriter' 
    75     parsedSOAPKey = 'ZSI.parse.ParsedSoap' 
    76     soapFaultSetKey = 'ndg.security.server.wsgi.soap.soapFault' 
    77      
    78     def __init__(self, app, app_conf, **kw): 
    79         log.debug("ZSIMiddleware.__init__ ...") 
    80         self.app = app 
    81         self.app_conf = app_conf 
    82         self.app_conf.update(kw) 
    83          
    84         if 'charset' in self.app_conf: 
    85             self.app_conf['charset'] = '; charset=' + self.app_conf['charset'] 
    86         else: 
    87             self.app_conf['charset'] = '; charset=utf-8' 
    88  
    89         if 'path' in self.app_conf: 
    90             if self.app_conf['path'] != '/': 
    91                 self.app_conf['path'] = self.app_conf['path'].rstrip('/') 
    92         else: 
    93             self.app_conf['path'] = '/' 
    94  
    95         # This flag if set to True causes this handler to call the  
    96         # start_response method and output the SOAP response 
    97         self.writeResponseSet = self.app_conf.get('writeResponse', 
    98                                                   'false').lower() == 'true' 
    99  
    100         # Check for a list of other filters to be referenced by this one 
    101         if 'referencedFilters' in self.app_conf: 
    102             # __call__  may reference any filters in environ keyed by these 
    103             # keywords 
    104             self.referencedFilterKeys = self.app_conf.pop( 
    105                                                 'referencedFilters').split() 
    106                                  
    107             # Remove equivalent keyword if present 
    108             kw.pop('referencedFilters', None) 
    109              
    110         # The endpoint that this services will be referenced from externally. 
    111         # e.g. the Session Manager client running locally can check the 
    112         # input URI and compare with this value to see if the request is  
    113         # actually to the local Session Manager instance 
    114         if 'publishedURI' in self.app_conf: 
    115             self.publishedURI = self.app_conf.pop('publishedURI') 
    116              
    117         if 'readerclass' in self.app_conf: 
    118             self.readerclass = importClass(self.app_conf.pop('readerclass')) 
    119         else: 
    120             self.readerclass = DomletteReader 
    121          
    122         if 'writerclass' in self.app_conf: 
    123             self.writerclass = importClass(self.app_conf.pop('writerclass')) 
    124         else: 
    125             self.writerclass = DomletteElementProxy 
    126              
    127  
    128     def __call__(self, environ, start_response): 
    129         log.debug("ZSIMiddleware.__call__") 
    130                          
    131         # Derived class must implement SOAP Response via overloaded version of 
    132         # this method.  ParsedSoap object is available as a key in environ via 
    133         # the parseRequest method 
    134          
    135         return self.writeResponse(environ, start_response) 
    136  
    137      
    138     def _initCall(self, environ, start_response): 
    139         '''Sub-divided out from __call__ to enable derived classes to easily 
    140         include this functionality: 
    141          - Set a reference to this WSGI filter in environ if filterID was  
    142         set in the config and  
    143          - check the request to see if this filter should handle it 
    144         ''' 
    145          
    146         # Add any filter references for this WSGI component regardless of the 
    147         # current request ID.  This ensures that other WSGI components called 
    148         # may reference it if they need to. 
    149         self.addFilter2Environ(environ) 
    150          
    151         # Apply filter for calls 
    152         if not self.isSOAPMessage(environ): 
    153             log.debug("ZSIMiddleware.__call__: skipping non-SOAP call") 
    154             return self.app(environ, start_response) 
    155          
    156         elif not self.pathMatch(environ): 
    157             log.debug("ZSIMiddleware.__call__: path doesn't match SOAP " 
    158                       "service endpoint") 
    159             return self.app(environ, start_response) 
    160          
    161         elif self.isSOAPFaultSet(environ): 
    162             # This MUST be checked in a overloaded version especially in  
    163             # consideration of security: e.g. an upstream signature  
    164             # verification may have found an error in a signature 
    165             log.debug("ZSIMiddleware.__call__: SOAP fault set by previous " 
    166                       "SOAP middleware filter") 
    167             return self.app(environ, start_response) 
    168  
    169         # Parse input into a ZSI ParsedSoap object set as a key in environ 
    170         try: 
    171             self.parseRequest(environ) 
    172         except Exception, e: 
    173             sw = self.exception2SOAPFault(environ, e) 
    174             self.setSOAPWriter(environ, sw) 
    175             return self.writeResponse(environ, start_response) 
    176          
    177         # Return None to __call__ to indicate that it can proceed with  
    178         # processing the input 
    179         return None 
    180  
    181     def exception2SOAPFault(self, environ, exception): 
    182         '''Convert an exception into a SOAP fault message''' 
    183         soapFault = fault.FaultFromException(exception,  
    184                                              None, 
    185                                              tb=sys.exc_info()[2]) 
    186         sw = SoapWriter(outputclass=self.writerclass) 
    187         soapFault.serialize(sw) 
    188         environ[ZSIMiddleware.soapFaultSetKey] = 'True' 
    189         return sw 
    190      
    191     pathMatch = lambda self,environ:environ['PATH_INFO']==self.app_conf['path'] 
    192      
    193     def parseRequest(self, environ): 
    194         '''Parse SOAP message from environ['wsgi.input'] 
    195          
    196         Reading from environ['wsgi.input'] may be a destructive process so the 
    197         content is saved in a ZSI.parse.ParsedSoap object for use by SOAP 
    198         handlers which follow in the chain 
    199          
    200         environ['ZSI.parse.ParsedSoap'] may be set to a ParsedSoap object 
    201         parsed by a SOAP handler ahead of the current one in the chain.  In 
    202         this case, don't re-parse.  If NOT parsed, parse and set 
    203         'ZSI.parse.ParsedSoap' environ key''' 
    204          
    205         # Check for ParsedSoap object set in environment, if not present, 
    206         # make one 
    207         ps = environ.get(ZSIMiddleware.parsedSOAPKey) 
    208         if ps is None: 
    209             # TODO: allow for chunked data 
    210             contentLength = int(environ['CONTENT_LENGTH']) 
    211             soapIn = environ['wsgi.input'].read(contentLength) 
    212             if len(soapIn) < contentLength: 
    213                 raise ZSIMiddlewareReadError("Expecting %d content length; " 
    214                                               "received %d instead." %  
    215                                               (contentLength, len(soapIn))) 
    216              
    217             log.debug("SOAP Request for handler %r" % ZSIMiddleware) 
    218             log.debug("_" * 80) 
    219             log.debug(soapIn) 
    220             log.debug("_" * 80) 
    221              
    222             ps = ParsedSoap(soapIn, readerclass=self.readerclass) 
    223             environ[ZSIMiddleware.parsedSOAPKey] = ps 
    224              
    225         return environ[ZSIMiddleware.parsedSOAPKey] 
    226  
    227  
    228     def writeResponse(self, environ, start_response, errorCode=None): 
    229         '''This method serializes the SOAP output and sets the response header. 
    230         It's the final step and should be called in the last SOAP handler in  
    231         a chain of handlers or else specify it in the ini file as the last 
    232         SOAP handler''' 
    233          
    234         # This flag must be set to True to write out the final response from 
    235         # this handler 
    236         if self.writeResponseSet == False: 
    237             return self.app(environ, start_response) 
    238          
    239         sw = self.getSOAPWriter(environ) 
    240         soapOut = str(sw) 
    241         charset = self.app_conf['charset'] 
    242          
    243         if errorCode is None: 
    244             if self.isSOAPFaultSet(environ): 
    245                 errorCode = "500 Internal Server Error" 
    246             else: 
    247                 errorCode = "200 OK" 
    248                  
    249         log.debug("SOAP Response for handler %r" % self.__class__) 
    250         log.debug("_" * 80) 
    251         log.debug(soapOut) 
    252         log.debug("_" * 80) 
    253         start_response(errorCode, 
    254                        [('content-type', 'text/xml' + charset), 
    255                         ('content-length', str(len(soapOut)))]) 
    256         return soapOut 
    257  
    258     @classmethod 
    259     def getSOAPWriter(cls, environ): 
    260         '''Access SoapWriter object set in environment by this classes' call 
    261         method''' 
    262          
    263         sw = environ.get(ZSIMiddleware.soapWriterKey) 
    264         if sw is None: 
    265             raise KeyError("Expecting '%s' key in environ: missing call to " 
    266                            "ZSIMiddleware?" % ZSIMiddleware.soapWriterKey) 
    267         return sw 
    268      
    269     @classmethod 
    270     def setSOAPWriter(cls, environ, sw): 
    271         '''Set SoapWriter object in environment'''    
    272         environ[ZSIMiddleware.soapWriterKey] = sw 
    273  
    274     def addFilter2Environ(self, environ): 
    275         '''Add a key to the current application in the environment so that 
    276         other middleware can reference it.  This is dependent on filterID set 
    277         in app_conf''' 
    278         filterID = self.app_conf.get('filterID') 
    279         if filterID is not None:            
    280             if filterID in environ: 
    281                 raise ZSIMiddlewareConfigError("An filterID key '%s' is " 
    282                                                 "already set in environ" %  
    283                                                 filterID) 
    284             environ[filterID] = self 
    285  
    286  
    287 class SOAPBindingMiddleware(ZSIMiddleware):   
    288     '''Apply a ZSI ServiceSOAPBinding type SOAP service''' 
    289           
    290     def __init__(self, *arg, **kw): 
    291          
    292         super(SOAPBindingMiddleware, self).__init__(*arg, **kw) 
    293          
    294         # Check for Service binding in config 
    295         if 'ServiceSOAPBindingClass' in self.app_conf: 
    296             modName, className = \ 
    297                         self.app_conf['ServiceSOAPBindingClass'].rsplit('.', 1) 
    298  
    299             self.serviceSOAPBinding = instantiateClass(modName, 
    300                                    className, 
    301                                    objectType=ServiceSOAPBinding, 
    302                                    classProperties=self.serviceSOAPBindingKw)             
    303         else:  
    304             self.serviceSOAPBinding = ServiceSOAPBinding() 
    305          
    306         # Flag to enable display of WSDL via wsdl query arg in a GET request 
    307         self.enableWSDLQuery = self.app_conf.get('enableWSDLQuery', False) and\ 
    308                                 hasattr(self.serviceSOAPBinding, '_wsdl') 
    309  
    310  
    311     def _getServiceSOAPBindingKw(self): 
    312         '''Extract keywords to specific to SOAP Service Binding set in app_conf 
    313         ''' 
    314         if 'ServiceSOAPBindingPropPrefix' not in self.app_conf: 
    315             return {} 
    316          
    317         prefix = self.app_conf['ServiceSOAPBindingPropPrefix'] + '.' 
    318         serviceSOAPBindingKw = dict([(k.replace(prefix, ''), v) \ 
    319                                      for k, v in self.app_conf.items() \ 
    320                                      if k.startswith(prefix)]) 
    321         return serviceSOAPBindingKw 
    322      
    323     serviceSOAPBindingKw = property(fget=_getServiceSOAPBindingKw) 
    324      
    325     def __call__(self, environ, start_response): 
    326         log.debug("SOAPBindingMiddleware.__call__ ...") 
    327                  
    328         if self.pathMatch(environ) and self.enableWSDLQuery and \ 
    329            environ.get('REQUEST_METHOD', '') == 'GET' and \ 
    330            environ.get('QUERY_STRING', '') == 'wsdl': 
    331             wsdl = self.serviceSOAPBinding._wsdl 
    332             start_response("200 OK", [('Content-type', 'text/xml'), 
    333                                       ('Content-length', str(len(wsdl)))]) 
    334             return wsdl 
    335                  
    336                  
    337         # Apply filter for calls 
    338         response = self._initCall(environ, start_response) 
    339         if response is not None: 
    340             return response 
    341          
    342          
    343         try: 
    344             # Other filters in the middleware chain may be passed by setting 
    345             # a reference to them in the config.  This is useful if the SOAP 
    346             # binding code needs to access results from upstream middleware  
    347             # e.g. check output from signature verification filter 
    348             if hasattr(self, 'referencedFilterKeys'): 
    349                 try: 
    350                     self.serviceSOAPBinding.referencedWSGIFilters = \ 
    351                                     dict([(i, environ[i])  
    352                                           for i in self.referencedFilterKeys]) 
    353                 except KeyError: 
    354                     raise ZSIMiddlewareConfigError('No filter ID "%s" found ' 
    355                                                     'in environ' % i)     
    356             ps = self.parseRequest(environ) 
    357              
    358             # Map SOAP Action to method in binding class 
    359             soapMethodName = 'soap_%s' % environ['HTTP_SOAPACTION'].strip('"') 
    360              
    361             method = getattr(self.serviceSOAPBinding, soapMethodName)             
    362             resp = method(ps) 
    363         except Exception, e: 
    364             sw = self.exception2SOAPFault(environ, e) 
    365         else:  
    366             # Serialize output using SOAP writer class 
    367             sw = SoapWriter(outputclass=self.writerclass) 
    368             sw.serialize(resp) 
    369          
    370         # Make SoapWriter object available to any SOAP filters that follow 
    371         self.setSOAPWriter(environ, sw) 
    372          
    373         soapOut = str(sw) 
    374         charset = self.app_conf['charset'] 
    375  
    376         return self.writeResponse(environ, start_response) 
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/zsi/attributeauthority/__init__.py

    r5063 r5637  
    170170            host.LoginURI = hostInfo['loginURI'] 
    171171            host.LoginServerDN = hostInfo['loginServerDN'] 
    172             host.LoginRequestServerDN=hostInfo['loginRequestServerDN'] 
     172            host.LoginRequestServerDN = hostInfo['loginRequestServerDN'] 
    173173            host.RoleList = hostInfo['role'] 
    174174             
     
    207207            trustedHost.LoginURI = hostInfo['loginURI'] 
    208208            trustedHost.LoginServerDN = hostInfo['loginServerDN'] 
    209             trustedHost.LoginRequestServerDN=hostInfo['loginRequestServerDN'] 
     209            trustedHost.LoginRequestServerDN = hostInfo['loginRequestServerDN'] 
    210210            trustedHost.RoleList = hostInfo['role'] 
    211211             
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/config/attributeauthority/sitea/site-a.ini

    r5465 r5637  
    3838 
    3939# Location of role mapping file 
    40 attributeAuthority.mapConfigFile: %(here)s/siteAMapConfig.xml 
     40attributeAuthority.mapConfigFilePath: %(here)s/siteAMapConfig.xml 
    4141 
    4242# Settings for custom AttributeInterface derived class to get user roles for given  
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/config/attributeauthority/sitea/siteAAttributeAuthority.cfg

    r5465 r5637  
    3737 
    3838# Location of role mapping file 
    39 mapConfigFile: %(here)s/siteAMapConfig.xml 
     39mapConfigFilePath: %(here)s/siteAMapConfig.xml 
    4040 
    4141# Settings for custom AttributeInterface derived class to get user roles for given  
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/config/attributeauthority/siteb/site-b.ini

    r5465 r5637  
    3838 
    3939# Location of role mapping file 
    40 attributeAuthority.mapConfigFile: %(here)s/siteBMapConfig.xml 
     40attributeAuthority.mapConfigFilePath: %(here)s/siteBMapConfig.xml 
    4141 
    4242# Settings for custom AttributeInterface derived class to get user roles for given  
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/config/attributeauthority/siteb/siteBAttAuthority.cfg

    r5465 r5637  
    3333 
    3434# Location of role mapping file 
    35 mapConfigFile: %(here)s/siteBMapConfig.xml 
     35mapConfigFilePath: %(here)s/siteBMapConfig.xml 
    3636 
    3737# Settings for custom AttributeInterface derived class to get user roles for given user ID 
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/integration/authz/securityservices.ini

    r5588 r5637  
    5151 
    5252# Location of role mapping file 
    53 attributeAuthority.mapConfigFile: %(testConfigDir)s/attributeauthority/sitea/siteAMapConfig.xml 
     53attributeAuthority.mapConfigFilePath: %(testConfigDir)s/attributeauthority/sitea/siteAMapConfig.xml 
    5454 
    5555# Settings for custom AttributeInterface derived class to get user roles for given  
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/integration/authz_lite/securityservices.ini

    r5588 r5637  
    4848 
    4949# Location of role mapping file 
    50 attributeAuthority.mapConfigFile: %(testConfigDir)s/attributeauthority/sitea/siteAMapConfig.xml 
     50attributeAuthority.mapConfigFilePath: %(testConfigDir)s/attributeauthority/sitea/siteAMapConfig.xml 
    5151 
    5252# Settings for custom AttributeInterface derived class to get user roles for given  
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/integration/combinedservices/services.ini

    r5181 r5637  
    4646 
    4747# Location of role mapping file 
    48 attributeAuthority.mapConfigFile: %(testConfigDir)s/attributeauthority/sitea/siteAMapConfig.xml 
     48attributeAuthority.mapConfigFilePath: %(testConfigDir)s/attributeauthority/sitea/siteAMapConfig.xml 
    4949 
    5050# Settings for custom AttributeInterface derived class to get user roles for given  
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/integration/openid/securityservices.ini

    r5588 r5637  
    4747 
    4848# Location of role mapping file 
    49 attributeAuthority.mapConfigFile: %(testConfigDir)s/attributeauthority/sitea/siteAMapConfig.xml 
     49attributeAuthority.mapConfigFilePath: %(testConfigDir)s/attributeauthority/sitea/siteAMapConfig.xml 
    5050 
    5151# Settings for custom AttributeInterface derived class to get user roles for given  
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/integration/openidprovider/securityservices.ini

    r5588 r5637  
    4545 
    4646# Location of role mapping file 
    47 attributeAuthority.mapConfigFile: %(testConfigDir)s/attributeauthority/sitea/siteAMapConfig.xml 
     47attributeAuthority.mapConfigFilePath: %(testConfigDir)s/attributeauthority/sitea/siteAMapConfig.xml 
    4848 
    4949# Settings for custom AttributeInterface derived class to get user roles for given  
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/integration/openidrelyingparty_withapp/securityservices.ini

    r5588 r5637  
    4848 
    4949# Location of role mapping file 
    50 attributeAuthority.mapConfigFile: %(testConfigDir)s/attributeauthority/sitea/siteAMapConfig.xml 
     50attributeAuthority.mapConfigFilePath: %(testConfigDir)s/attributeauthority/sitea/siteAMapConfig.xml 
    5151 
    5252# Settings for custom AttributeInterface derived class to get user roles for given  
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/unit/attributeauthority/test_attributeauthority.py

    r5355 r5637  
    5555            self.cfg[section] = dict(self.cfgParser.items(section)) 
    5656             
    57         self.aa = AttributeAuthority( 
    58                             propFilePath=self.cfg['setUp']['propFilePath'])             
    59  
    60     _mkSiteBAttributeAuthority = lambda self: AttributeAuthority(\ 
     57        self.aa = AttributeAuthority() 
     58        self.aa.propFilePath = self.cfg['setUp']['propFilePath'] 
     59        self.aa.readProperties() 
     60 
     61    _mkSiteBAttributeAuthority = lambda self: \ 
     62        AttributeAuthority.fromPropertyFile( 
    6163                        propFilePath=self.cfg['DEFAULT']['siteBPropFilePath']) 
    6264     
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/unit/saml/test_samlinterface.py

    r5622 r5637  
    327327         
    328328    def test03ParseResponse(self): 
    329         response = '''<SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/"> 
     329        response = \ 
     330'''<SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/"> 
    330331   <SOAP-ENV:Body> 
    331332      <samlp:Response ID="05680cb2-4973-443d-9d31-7bc99bea87c1" InResponseTo="e3183380-ae82-4285-8827-8c40613842de" IssueInstant="2009-08-17T12:28:37.325Z" Version="2.0" xmlns:samlp="urn:oasis:names:tc:SAML:2.0:protocol"> 
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/unit/wsgi/authn/test.ini

    r5362 r5637  
    1515 
    1616[app:TestApp] 
    17 paste.app_factory = ndg.security.test.unit.wsgi.authn.test_authn:TestAuthNMiddleware 
     17paste.app_factory = ndg.security.test.unit.wsgi.authn.test_authn:TestAuthNApp 
    1818 
    1919[filter:AuthNRedirectFilter] 
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/unit/wsgi/authn/test_authn.py

    r5329 r5637  
    2929from paste.deploy import loadapp 
    3030 
    31 class TestAuthNMiddleware(object): 
     31class TestAuthNApp(object): 
    3232    '''Test Application for the Authentication handler to protect''' 
    3333    response = "Test Authentication redirect application" 
     
    5555        start_response(status, 
    5656                       [('Content-length',  
    57                          str(len(TestAuthNMiddleware.response))), 
     57                         str(len(TestAuthNApp.response))), 
    5858                        ('Content-type', 'text/plain')]) 
    59         return [TestAuthNMiddleware.response] 
     59        return [TestAuthNApp.response] 
    6060 
    6161 
Note: See TracChangeset for help on using the changeset viewer.