source: TI12-security/trunk/python/ndg.security.common/ndg/security/common/wssecurity/__init__.py @ 4358

Subversion URL: http://proj.badc.rl.ac.uk/svn/ndg/TI12-security/trunk/python/ndg.security.common/ndg/security/common/wssecurity/__init__.py@4358
Revision 4358, 7.5 KB checked in by pjkersha, 11 years ago (diff)

ndg.security.common.wssecurity.__init: fix for reading parameters with prefix set.

Line 
1"""NDG Security wssecurity package - contains signature handler and config
2
3NERC Data Grid Project
4"""
5__author__ = "P J Kershaw"
6__date__ = "01/04/08"
7__copyright__ = "(C) 2008 STFC & NERC"
8__contact__ = "P.J.Kershaw@rl.ac.uk"
9__license__ = \
10"""This software may be distributed under the terms of the Q Public
11License, version 1.0 or later."""
12__contact__ = "P.J.Kershaw@rl.ac.uk"
13__revision__ = "$Id$"
14
15from ConfigParser import SafeConfigParser
16from os.path import expandvars as exVar
17import copy
18from ZSI.wstools.Namespaces import OASIS
19
20class WSSecurityConfigOpNotPermitted(Exception):
21    "Raise for dict methods not allowed in WSSecurityConfig"
22   
23class WSSecurityConfig(dict):
24    """Parser for WS-Security configuration.  Extends dict to enable
25    convenient interface for access to params.
26    """
27    propertyDefaults = dict(
28             reqBinSecTokValType=OASIS.X509TOKEN.X509,
29             verifyingCert=None,
30             verifyingCertFilePath=None,
31             signingCert=None,
32             signingCertFilePath=None, 
33             signingCertChain=[],
34             signingPriKey=None,
35             signingPriKeyFilePath=None, 
36             signingPriKeyPwd=None,
37             caCertDirPath=None,
38             caCertFilePathList=[],
39             addTimestamp=True,
40             applySignatureConfirmation=False,
41             refC14nInclNS=[],
42             signedInfoC14nInclNS=[])
43   
44    def __init__(self, cfg=SafeConfigParser()):
45        '''Initialise settings from an existing config file object or the
46        given path to config file
47       
48        @type cfg: SafeConfigParser or string
49        @param cfg: config object instance or file path to config file to be
50        parsed'''
51       
52        dict.__init__(self)
53       
54        # Initialise parameters from ref in class var
55        self._param = WSSecurityConfig.propertyDefaults.copy()
56       
57        if isinstance(cfg, basestring):
58            # Assume file path to be read
59            self.read(cfg)
60        else:
61            # Assume existing config type object
62            self._cfg = cfg
63       
64
65    def read(self, *filePathList):
66        '''Read ConfigParser object
67       
68        @type filePathList: tuple/list
69        @param filePathList: list of files to read config from'''
70        self._cfg = SafeConfigParser()
71       
72        # Expand environment variables in file list
73        filePathList = exVar(':'.join(filePathList)).split(':')
74        readFilePaths = self._cfg.read(filePathList)
75       
76        # Check files were read in OK
77        missingFilePaths = [file for file in filePathList \
78                            if file not in readFilePaths]
79        if len(missingFilePaths) > 0:
80            raise IOError('Missing config file(s): "%s"' % \
81                          '", "'.join(missingFilePaths))
82
83    def parse(self, **kw):
84        '''Extract items from config file and place in dict
85        @type **kw: dict
86        @param **kw: this enables WS-Security params to be set in a config file
87        with other sections e.g. params could be under the section 'wssecurity'
88        '''
89        section = kw.pop('section', 'DEFAULT')
90       
91        # Prefix for option names - optNames = name as they appear in the
92        # config file, self._param are the names used in the code.
93        prefix = kw.pop('prefix', None)
94
95        if prefix:
96            optNames = ["%s.%s" % (prefix, optName) for optName in kw] 
97        else:
98            optNames = self._param
99           
100        for optName, paramName in zip(optNames, self._param):
101           
102            # Parameters may be omitted and set later
103            if self._cfg.has_option(section, optName):
104                if isinstance(WSSecurityConfig.propertyDefaults[paramName], 
105                              list):
106                    try:
107                        self._param[paramName] = \
108                            exVar(self._cfg.get(section, optName)).split()
109                    except AttributeError:
110                        raise SecurityConfigError('Setting "%s"' % paramName)
111                   
112                elif isinstance(WSSecurityConfig.propertyDefaults[paramName], 
113                                bool):           
114                    self._param[paramName] = self._cfg.getboolean(section, 
115                                                                  optName)
116                else:
117                    # Default to None if setting is an empty string.  Settings
118                    # of '' causes problems for M2Crypto parsing
119                    self._param[paramName] = \
120                        exVar(self._cfg.get(section, optName)) or None
121
122    def __len__(self):
123        return len(self._param)
124   
125    def __iter__(self):
126        return self._param.__iter__()
127   
128    def __repr__(self):
129        """Return file properties dictionary as representation"""
130        return repr(self._param)
131
132    def __delitem__(self, key):
133        "Session Manager keys cannot be removed"       
134        raise KeyError('Keys cannot be deleted from ' + \
135                        WSSecurityConfig.__name__)
136
137    def __getitem__(self, key):
138        WSSecurityConfig.__name__ + \
139        """ behaves as data dictionary of WS-Security properties
140        """
141        if key not in WSSecurityConfig.propertyDefaults:
142            raise KeyError("Invalid key '%s'" % key)
143       
144        return self._param[key] 
145   
146    def __setitem__(self, key, item):
147        WSSecurityConfig.__name__ + \
148        """ behaves as data dictionary of WS-Security properties"""
149        if key not in WSSecurityConfig.propertyDefaults:
150            raise KeyError("Parameter key '%s' is not recognised" % key)
151       
152        self._param[key] = item
153
154    def copy(self):
155        wsSecurityConfig = WSSecurityConfig()
156        wsSecurityConfig._param = self._param.copy()
157        return wsSecurityConfig
158   
159    def get(self, key, *arg):
160        return self._param.get(key, *arg)
161
162    def clear(self):
163        raise WSSecurityConfigOpNotPermitted("Data cannot be cleared from "+\
164                                             WSSecurityConfig.__name__)
165   
166    def keys(self):
167        return self._param.keys()
168
169    def items(self):
170        return self._param.items()
171
172    def values(self):
173        return self._param.values()
174
175    def has_key(self, key):
176        return self._param.has_key(key)
177
178    # 'in' operator
179    def __contains__(self, key):
180        return key in self._param
181   
182    def update(self, seq, *arg):
183        badKeys=[i for i in seq if i not in WSSecurityConfig.propertyDefaults]
184        if badKeys:
185            raise KeyError("Parameter key(s) %s not recognised" % \
186                           ','.join(badKeys))
187        return self._param.update(seq, *arg)
188   
189    def fromkeys(self, seq):
190        badKeys=[i for i in seq if i not in WSSecurityConfig.propertyDefaults]
191        if badKeys:
192            raise KeyError("Parameter key(s) %s not recognised" % \
193                           ','.join(badKeys))
194        return self._param.fromkeys(*arg)
195   
196    def setdefault(self, key, *arg):
197        badKeys = [i for i in b if i not in WSSecurityConfig.propertyDefaults]
198        if badKeys:
199            raise KeyError("Parameter keys '%s' not recognised" % badKeys)
200        return self._param.setdefault(key, *arg)
201
202    def pop(self, key, *arg):
203        raise WSSecurityConfigOpNotPermitted("Params should not be deleted")
204   
205    def popitem(self):
206        raise WSSecurityConfigOpNotPermitted("Params should not be deleted")
207   
208    def iteritems(self):
209        return self._param.iteritems()
210   
211    def iterkeys(self):
212        return self._param.iterkeys()
213   
214    def itervalues(self):
215        return self._param.itervalues()
216   
Note: See TracBrowser for help on using the repository browser.