Changeset 6387 for TI12-security


Ignore:
Timestamp:
22/01/10 16:40:12 (10 years ago)
Author:
pjkersha
Message:
 
Location:
TI12-security/trunk/WSSecurity
Files:
1 deleted
8 edited

Legend:

Unmodified
Added
Removed
  • TI12-security/trunk/WSSecurity/.project

    r6378 r6387  
    11<?xml version="1.0" encoding="UTF-8"?> 
    22<projectDescription> 
    3         <name>wssecurity</name> 
     3        <name>WSSecurity</name> 
    44        <comment></comment> 
    55        <projects> 
  • TI12-security/trunk/WSSecurity/.pydevproject

    r6378 r6387  
    66<pydev_property name="org.python.pydev.PYTHON_PROJECT_INTERPRETER">Default</pydev_property> 
    77<pydev_pathproperty name="org.python.pydev.PROJECT_SOURCE_PATH"> 
    8 <path>/wssecurity</path> 
     8<path>/WSSecurity</path> 
    99</pydev_pathproperty> 
    1010</pydev_project> 
  • TI12-security/trunk/WSSecurity/ndg/wssecurity/common/__init__.py

    r6386 r6387  
    4141    """ 
    4242    propertyDefaults = dict( 
    43         reqBinSecTokValType=OASIS.X509TOKEN.X509, 
     43        reqBINARY_SECURITY_TOK_VAL_TYPE=OASIS.X509TOKEN.X509, 
    4444        verifyingCert=None, 
    4545        verifyingCertFilePath=None, 
  • TI12-security/trunk/WSSecurity/ndg/wssecurity/common/signaturehandler/__init__.py

    r6386 r6387  
    8282    WS-Security 
    8383     
    84     @cvar binSecTokValType: supported ValueTypes for BinarySecurityToken 
     84    @cvar BINARY_SECURITY_TOK_VAL_TYPE: supported ValueTypes for BinarySecurityToken 
    8585    element in WSSE header 
    86     @type binSecTokValType: dict 
     86    @type BINARY_SECURITY_TOK_VAL_TYPE: dict 
    8787     
    8888    @ivar addTimestamp: set to true to add a timestamp to outbound messages 
     
    9898    @type b64EncSignatureValue: string/None""" 
    9999 
    100     _binSecTokEncType = ("http://docs.oasis-open.org/wss/2004/01/" 
    101                          "oasis-200401-wss-soap-message-security-1.0#" 
    102                          "Base64Binary") 
    103      
    104     binSecTokValType = { 
     100    BINARY_SECURITY_TOK_ENCODING_TYPE = ( 
     101        "http://docs.oasis-open.org/wss/2004/01/" 
     102        "oasis-200401-wss-soap-message-security-1.0#Base64Binary" 
     103    ) 
     104     
     105    BINARY_SECURITY_TOK_VAL_TYPE = { 
    105106        "X509PKIPathv1": OASIS.X509TOKEN.X509PKIPathv1, 
    106107        "X509":          OASIS.X509TOKEN.X509, 
     
    109110 
    110111    PROPERTY_DEFAULTS = dict( 
    111         reqBinSecTokValType=(OASIS.X509TOKEN.X509,), 
     112        reqBINARY_SECURITY_TOK_VAL_TYPE=(OASIS.X509TOKEN.X509,), 
    112113        verifyingCert=(None,), 
    113114        verifyingCertFilePath=(None,), 
     
    134135    __slots__ = TYPE_MAP 
    135136     
    136     def __init__(self, cfg=None, cfgFileSection='DEFAULT', cfgFilePrefix='', 
    137                  cfgClass=WSSecurityConfig, **kw): 
     137    def __init__(self, cfg=None): 
    138138        ''' 
    139139        @param cfg: object from which to read config items - a file path, 
    140140        config parser object or WSSecurityConfig object 
    141141        @type cfg: basestring/RawConfigParser/WSSecurityConfig 
    142          
    143         @param cfgFileSection: section name in config file containing  
    144         parameters 
    145         @type cfgFileSection: basestring 
    146          
    147         @param cfgFilePrefix: prefix for parameter names in the config file. 
    148         This enables these parameters to be filtered from other unrelated 
    149         parameters in the same section 
    150         @type cfgFilePrefix: basestring 
    151          
    152         @param cfgClass: class used to parse the settings 
    153         @type cfgClass: WSSecurityConfig derived class type 
    154          
    155         @param kw: any config parameters as specified by WSSecurityConfig class 
    156         @type kw: dict 
    157142        ''' 
    158143        log.debug("BaseSignatureHandler.__init__ ...") 
    159  
    160         # WSSecurityConfig is the default class for reading config params but 
    161         # alternative derivative class may be passed in instead. 
    162         if not issubclass(cfgClass, WSSecurityConfig): 
    163             raise TypeError("%s is not a sub-class of WSSecurityConfig" %  
    164                             cfgClass) 
    165          
    166         # Read parameters from config file if set 
    167         if isinstance(cfg, basestring): 
    168             log.debug("BaseSignatureHandler.__init__: config file path input " 
    169                       "...") 
    170             self.cfg = cfgClass() 
    171             self.cfg.read(cfg) 
    172             self.cfg.parse(section=cfgFileSection, prefix=cfgFilePrefix) 
    173  
    174         elif isinstance(cfg, RawConfigParser): 
    175             log.debug("BaseSignatureHandler.__init__: config object input ...") 
    176             self.cfg = cfgClass(cfg=cfg) 
    177             self.cfg.parse(section=cfgFileSection, prefix=cfgFilePrefix) 
    178              
    179         elif isinstance(cfg, WSSecurityConfig): 
    180             log.debug("BaseSignatureHandler.__init__:  WSSSecurityConfig " 
    181                       "object input ...") 
    182             self.cfg = cfg 
    183         else: 
    184             self.cfg = cfgClass() 
    185                  
    186         # Also update config from keywords set  
    187         log.debug("BaseSignatureHandler.__init__: updating config from " 
    188                   "keywords...") 
    189          
    190         # Filter keywords if a prefix is set removing any that don't start with 
    191         # the prefix given 
    192         self.cfg.update(kw, prefix=cfgFilePrefix) 
    193          
    194         # set default value type, if none specified in config file 
    195         if not self.cfg['reqBinSecTokValType']: 
    196             self.cfg['reqBinSecTokValType'] = "X509v3" 
    197              
    198         self.reqBinSecTokValType = self.cfg['reqBinSecTokValType'] 
    199  
    200         # Set keywords for canonicalization of SignedInfo and reference  
    201         # elements 
    202         self.refC14nKw = {'inclusive_namespaces': self.cfg['refC14nInclNS']} 
    203  
    204         self.signedInfoC14nKw = {'inclusive_namespaces':  
    205                                  self.cfg['signedInfoC14nInclNS']} 
    206  
    207         self.verifyingCert = self.cfg['verifyingCert'] 
    208         self.verifyingCertFilePath = self.cfg['verifyingCertFilePath'] 
    209          
    210         self.signingCert = self.cfg['signingCert'] 
    211         self.signingCertFilePath = self.cfg['signingCertFilePath'] 
    212  
    213         self.signingCertChain = self.cfg['signingCertChain'] 
    214               
    215         # MUST be set before _setSigningPriKeyFilePath / _setSigningPriKey 
    216         # are called 
    217         self.signingPriKeyPwd = self.cfg['signingPriKeyPwd'] 
    218          
    219         if self.cfg.get('signingPriKey'): 
    220             # Don't allow None for private key setting 
    221             self.signingPriKey = self.cfg['signingPriKey'] 
    222              
    223         self.signingPriKeyFilePath = self.cfg['signingPriKeyFilePath'] 
    224          
    225         # CA certificate(s) for verification of X.509 certificate used with 
    226         # signature. 
    227         if self.cfg.get('caCertDirPath'): 
    228             self.caCertDirPath = self.cfg['caCertDirPath'] 
    229              
    230         elif self.cfg.get('caCertFilePathList'): 
    231             self.caCertFilePathList = self.cfg['caCertFilePathList'] 
    232          
    233         # Configure signature generation to add/omit a timestamp 
    234         self.addTimestamp = self.cfg['addTimestamp'] 
    235          
    236         # Configure timestamp checking in Signature verification handler 
    237         self.timestampClockSkew = self.cfg['timestampClockSkew'] 
    238         self.timestampMustBeSet = self.cfg['timestampMustBeSet'] 
    239         self.createdElemMustBeSet = self.cfg['createdElemMustBeSet'] 
    240         self.expiresElemMustBeSet = self.cfg['expiresElemMustBeSet'] 
    241          
    242         # set default value, if none specified in config file 
    243         if not self.cfg['applySignatureConfirmation']: 
    244             self.cfg['applySignatureConfirmation'] = False 
    245  
    246         self.applySignatureConfirmation=self.cfg['applySignatureConfirmation'] 
    247         self.b64EncSignatureValue = None 
    248          
    249         log.debug("WSSE Config = %s" % self.cfg) 
    250  
    251                  
    252     def _setReqBinSecTokValType(self, value): 
     144        for name, val in BaseSignatureHandler.PROPERTY_DEFAULTS.items(): 
     145            setattr(self, name, val[0]) 
     146 
     147    def __setattr__(self, name, val): 
     148        expectedTypes = BaseSignatureHandler.TYPE_MAP.get(name) 
     149        if expectedTypes is not None: 
     150            if not isinstance(val, expectedTypes): 
     151                raise TypeError('Expected type(s) for % attribute are %r; ' 
     152                                'got %r' % (name, expectedTypes, type(val)) 
     153                                 
     154        super(BaseSignatureHandler, self).__setattr__(name, val) 
     155 
     156    def read(self, filePath): 
     157        '''Read ConfigParser object 
     158         
     159        @type filePath: basestring 
     160        @param filePath: file to read config from''' 
     161         
     162        # Expand environment variables in file path 
     163        expandedFilePath = os.path.expandvars(filePath) 
     164         
     165        # Add 'here' item to enable convenient path substitutions in the config 
     166        # file 
     167        defaultItems = dict(here=os.path.dirname(expandedFilePath)) 
     168        self._cfg = CaseSensitiveConfigParser(defaults=defaultItems) 
     169         
     170        readFilePaths = self._cfg.read(expandedFilePath) 
     171         
     172        # Check file was read in OK 
     173        if len(readFilePaths) == 0: 
     174            raise IOError('Missing config file: "%s"' % expandedFilePath) 
     175 
     176    def parse(self, **kw): 
     177        '''Extract items from config file and place in dict 
     178        @type **kw: dict 
     179        @param **kw: this enables WS-Security params to be set in a config file 
     180        with other sections e.g. params could be under the section 'wssecurity' 
     181        ''' 
     182        section = kw.pop('section', 'DEFAULT') 
     183         
     184        # Prefix for option names - optNames = name as they appear in the  
     185        # config file, self._param are the names used in the code. 
     186        prefix = kw.pop('prefix', None) 
     187 
     188        if prefix: 
     189            optNames = ["%s.%s" % (prefix, optName) for optName in self._param]  
     190        else: 
     191            optNames = self._param 
     192             
     193        for optName, paramName in zip(optNames, self._param): 
     194             
     195            # Parameters may be omitted and set later 
     196            if self._cfg.has_option(section, optName): 
     197                  
     198    def _setReqBinarySecurityTokValType(self, value): 
    253199        """Set ValueType attribute for BinarySecurityToken used in a request 
    254200          
    255201        @type value: string 
    256202        @param value: name space for BinarySecurityToken ValueType check 
    257         'binSecTokValType' class variable for supported types.  Input can be  
    258         shortened to binSecTokValType keyword if desired. 
     203        'BINARY_SECURITY_TOK_VAL_TYPE' class variable for supported types.  Input can be  
     204        shortened to BINARY_SECURITY_TOK_VAL_TYPE keyword if desired. 
    259205        """ 
    260         log.debug("Setting reqBinSecTokValType - to %s" %value) 
    261         if value in self.__class__.binSecTokValType: 
    262             self._reqBinSecTokValType = self.__class__.binSecTokValType[value] 
     206        log.debug("Setting reqBINARY_SECURITY_TOK_VAL_TYPE - to %s" %value) 
     207        if value in self.__class__.BINARY_SECURITY_TOK_VAL_TYPE: 
     208            self.__reqBinarySecurityTokValType = self.__class__.BINARY_SECURITY_TOK_VAL_TYPE[value] 
    263209  
    264         elif value in self.__class__.binSecTokValType.values(): 
    265             self._reqBinSecTokValType = value 
     210        elif value in self.__class__.BINARY_SECURITY_TOK_VAL_TYPE.values(): 
     211            self.__reqBinarySecurityTokValType = value 
    266212        else: 
    267213            raise WSSecurityError('Request BinarySecurityToken ValueType ' 
    268214                                  '"%s" not recognised' % value) 
    269215             
    270     def _getReqBinSecTokValType(self): 
     216    def _getReqBinarySecurityTokValType(self): 
    271217        """ 
    272218        Get ValueType attribute for BinarySecurityToken used in a request 
    273219        """ 
    274         log.debug("Getting reqBinSecTokValType value") 
    275         if hasattr(self, '_reqBinSecTokValType'): 
    276             return self._reqBinSecTokValType 
     220        log.debug("Getting reqBINARY_SECURITY_TOK_VAL_TYPE value") 
     221        if hasattr(self, '__reqBinarySecurityTokValType'): 
     222            return self.__reqBinarySecurityTokValType 
    277223        else: 
    278224            return "" 
    279225         
    280     reqBinSecTokValType = property(fset=_setReqBinSecTokValType, 
    281                                    fget=_getReqBinSecTokValType, 
     226    reqBINARY_SECURITY_TOK_VAL_TYPE = property(fset=_setReqBinarySecurityTokValType, 
     227                                   fget=_getReqBinarySecurityTokValType, 
    282228         doc="ValueType attribute for BinarySecurityToken used in request") 
    283229         
  • TI12-security/trunk/WSSecurity/ndg/wssecurity/common/signaturehandler/dom.py

    r5441 r6387  
    136136         
    137137        # Value type can be any be any one of those supported via  
    138         # binSecTokValType 
     138        # BINARY_SECURITY_TOK_VAL_TYPE 
    139139        createdElem = timestampElem.createAppendElement(_WSU.UTILITY,'Created') 
    140140        dtCreatedTime = datetime.utcnow() 
     
    261261 
    262262        # Add X.509 cert as binary security token 
    263         if self.reqBinSecTokValType==self.binSecTokValType['X509PKIPathv1']: 
     263        if self.reqBINARY_SECURITY_TOK_VAL_TYPE==self.BINARY_SECURITY_TOK_VAL_TYPE['X509PKIPathv1']: 
    264264            if self.signingCertChain is None: 
    265265                msg = 'SignatureHandler signingCertChain attribute is not set' 
     
    315315         
    316316        # Value type can be any be any one of those supported via  
    317         # binSecTokValType 
     317        # BINARY_SECURITY_TOK_VAL_TYPE 
    318318        binSecTokElem.node.setAttribute('ValueType',  
    319                                         self.reqBinSecTokValType) 
    320  
    321         binSecTokElem.node.setAttribute('EncodingType', self._binSecTokEncType) 
     319                                        self.reqBINARY_SECURITY_TOK_VAL_TYPE) 
     320 
     321        binSecTokElem.node.setAttribute('EncodingType', self.BINARY_SECURITY_TOK_ENCODING_TYPE) 
    322322         
    323323        # Add ID so that the binary token can be included in the signature 
     
    706706                 
    707707                valueType = binSecTokNode.getAttributeNode("ValueType").value 
    708                 if valueType in (self.__class__.binSecTokValType['X509v3'], 
    709                                  self.__class__.binSecTokValType['X509']): 
     708                if valueType in (self.__class__.BINARY_SECURITY_TOK_VAL_TYPE['X509v3'], 
     709                                 self.__class__.BINARY_SECURITY_TOK_VAL_TYPE['X509']): 
    710710                    # Remove base 64 encoding 
    711711                    derString = base64.decodestring(x509CertTxt) 
     
    715715 
    716716                elif valueType == \ 
    717                     self.__class__.binSecTokValType['X509PKIPathv1']: 
     717                    self.__class__.BINARY_SECURITY_TOK_VAL_TYPE['X509PKIPathv1']: 
    718718                     
    719719                    derString = base64.decodestring(x509CertTxt) 
  • TI12-security/trunk/WSSecurity/ndg/wssecurity/common/signaturehandler/etree.py

    r6069 r6387  
    112112         
    113113        # Value type can be any be any one of those supported via  
    114         # binSecTokValType 
     114        # BINARY_SECURITY_TOK_VAL_TYPE 
    115115        createdElem = ElementTree.Element("{%s}%s" % (_WSU.UTILITY,'Created')) 
    116116        timestampElem.append(createdElem) 
     
    238238        # Add X.509 cert as binary security token 
    239239        # TODO: sub encodestring with b64encode? 
    240         if self.reqBinSecTokValType==self.binSecTokValType['X509PKIPathv1']: 
     240        if self.reqBINARY_SECURITY_TOK_VAL_TYPE==self.BINARY_SECURITY_TOK_VAL_TYPE['X509PKIPathv1']: 
    241241            binSecTokVal = base64.encodestring(self.signingCertChain.asDER()) 
    242242        else: 
     
    293293         
    294294        # Value type can be any be any one of those supported via  
    295         # binSecTokValType 
    296         binSecTokElem.set('ValueType', self.reqBinSecTokValType) 
    297         binSecTokElem.set('EncodingType', self._binSecTokEncType) 
     295        # BINARY_SECURITY_TOK_VAL_TYPE 
     296        binSecTokElem.set('ValueType', self.reqBINARY_SECURITY_TOK_VAL_TYPE) 
     297        binSecTokElem.set('EncodingType', self.BINARY_SECURITY_TOK_ENCODING_TYPE) 
    298298         
    299299        # Add ID so that the binary token can be included in the signature 
     
    637637             
    638638            valueType = binSecTokElem.get("ValueType") 
    639             if valueType in (self.binSecTokValType['X509v3'], 
    640                              self.binSecTokValType['X509']): 
     639            if valueType in (self.BINARY_SECURITY_TOK_VAL_TYPE['X509v3'], 
     640                             self.BINARY_SECURITY_TOK_VAL_TYPE['X509']): 
    641641                # Remove base 64 encoding 
    642642                derString = base64.decodestring(x509CertTxt) 
     
    646646                x509Stack = X509Stack() 
    647647 
    648             elif valueType == self.binSecTokValType['X509PKIPathv1']: 
     648            elif valueType == self.BINARY_SECURITY_TOK_VAL_TYPE['X509PKIPathv1']: 
    649649                 
    650650                derString = base64.decodestring(x509CertTxt) 
  • TI12-security/trunk/WSSecurity/ndg/wssecurity/common/signaturehandler/foursuite.py

    r5771 r6387  
    104104         
    105105        # Value type can be any be any one of those supported via  
    106         # binSecTokValType 
     106        # BINARY_SECURITY_TOK_VAL_TYPE 
    107107        createdElem = timestampElem.createAppendElement(_WSU.UTILITY,'Created') 
    108108        dtCreatedTime = datetime.utcnow() 
     
    232232 
    233233        # Add X.509 cert as binary security token 
    234         if self.reqBinSecTokValType==self.binSecTokValType['X509PKIPathv1']: 
     234        if self.reqBINARY_SECURITY_TOK_VAL_TYPE==self.BINARY_SECURITY_TOK_VAL_TYPE['X509PKIPathv1']: 
    235235            if self.signingCertChain is None: 
    236236                msg = 'SignatureHandler signingCertChain attribute is not set' 
     
    282282         
    283283        # Value type can be any be any one of those supported via  
    284         # binSecTokValType 
     284        # BINARY_SECURITY_TOK_VAL_TYPE 
    285285        binSecTokElem.setAttributeNS(None,  
    286286                                     'ValueType',  
    287                                      self.reqBinSecTokValType) 
     287                                     self.reqBINARY_SECURITY_TOK_VAL_TYPE) 
    288288 
    289289        binSecTokElem.setAttributeNS(None,  
    290290                                     'EncodingType', 
    291                                      self._binSecTokEncType) 
     291                                     self.BINARY_SECURITY_TOK_ENCODING_TYPE) 
    292292         
    293293        # Add ID so that the binary token can be included in the signature 
     
    643643                 
    644644                valueType = binSecTokElem.getAttributeNS(None, "ValueType") 
    645                 if valueType in (self.__class__.binSecTokValType['X509v3'], 
    646                                  self.__class__.binSecTokValType['X509']): 
     645                if valueType in (self.__class__.BINARY_SECURITY_TOK_VAL_TYPE['X509v3'], 
     646                                 self.__class__.BINARY_SECURITY_TOK_VAL_TYPE['X509']): 
    647647                    # Remove base 64 encoding 
    648648                    derString = base64.decodestring(x509CertTxt) 
     
    652652 
    653653                elif valueType == \ 
    654                     self.__class__.binSecTokValType['X509PKIPathv1']: 
     654                    self.__class__.BINARY_SECURITY_TOK_VAL_TYPE['X509PKIPathv1']: 
    655655                     
    656656                    derString = base64.decodestring(x509CertTxt) 
  • TI12-security/trunk/WSSecurity/ndg/wssecurity/test/unit/signaturehandler/foursuite/client/test_echoclient.py

    r6385 r6387  
    1616import os 
    1717import sys 
    18 import traceback 
    1918 
    20 from os.path import expandvars as xpdVars 
    2119from os.path import join, dirname, abspath 
    2220mkPath = lambda file: join(os.environ['NDGSEC_WSSECLNT_UNITTEST_DIR'], file) 
     
    2624from EchoService_services import EchoServiceLocator 
    2725 
    28 from ndg.wssecurity.signaturehandler.foursuite import SignatureHandler 
    29 from ndg.wssecurity.signaturehandler import NoSignatureFound, TimestampError 
    30 from ndg.wssecurity.utils import DomletteReader, DomletteElementProxy 
     26from ndg.wssecurity.common.signaturehandler.foursuite import SignatureHandler 
     27from ndg.wssecurity.common.signaturehandler import (NoSignatureFound,  
     28                                                    TimestampError) 
     29from ndg.wssecurity.common.utils import DomletteReader, DomletteElementProxy 
    3130 
    3231 
Note: See TracChangeset for help on using the changeset viewer.