Changeset 6417 for TI12-security


Ignore:
Timestamp:
26/01/10 14:43:23 (10 years ago)
Author:
pjkersha
Message:
 
Location:
TI12-security/trunk/NDGSoap
Files:
6 added
6 edited

Legend:

Unmodified
Added
Removed
  • TI12-security/trunk/NDGSoap/.pydevproject

    r6416 r6417  
    55<pydev_property name="org.python.pydev.PYTHON_PROJECT_VERSION">python 2.5</pydev_property> 
    66<pydev_property name="org.python.pydev.PYTHON_PROJECT_INTERPRETER">Default</pydev_property> 
     7<pydev_pathproperty name="org.python.pydev.PROJECT_SOURCE_PATH"> 
     8<path>/NDGSoap</path> 
     9</pydev_pathproperty> 
    710</pydev_project> 
  • TI12-security/trunk/NDGSoap/ndg/soap/wssecurity/__init__.py

    r6416 r6417  
    99__contact__ = "Philip.Kershaw@stfc.ac.uk" 
    1010__revision__ = '$Id$' 
     11class WSSecurityError(Exception): 
     12    """For WS-Security generic exceptions not covered by other exception 
     13    classes in this module""" 
     14         
     15class WSSecurityConfigError(WSSecurityError): 
     16    """Configuration error with WS-Security setting or settings""" 
     17  
     18class TimestampError(WSSecurityError): 
     19    """Raised from SignatureHandler._verifyTimestamp if there is a problem with 
     20    the created or expiry times in an input message Timestamp""" 
     21 
     22class MessageExpired(TimestampError): 
     23    """Raised from SignatureHandler._verifyTimestamp if the timestamp of 
     24    the message being processed is before the current time.  Can be caught in 
     25    order to set a wsu:MessageExpired fault code""" 
     26 
     27class InvalidCertChain(WSSecurityError):     
     28    """Raised from SignatureHandler.verify if the certificate submitted to 
     29    verify a signature is not from a known CA""" 
  • TI12-security/trunk/NDGSoap/ndg/soap/wssecurity/signaturehandler/__init__.py

    r6409 r6417  
    1 """ Base class for the WS-Security digital signature handlers - to allow  
     1"""Base class for the WS-Security digital signature handlers - to allow  
    22sharing of common code 
    33 
     
    55""" 
    66__author__ = "C Byrom, Philip Kershaw" 
    7 __date__ = "18/08/08" 
     7__date__ = "18/08/08, refactored for NDGSoap egg 22/01/2010" 
    88__copyright__ = "" 
    99__license__ = "BSD - see LICENSE file in top-level directory" 
     
    2626from ZSI.wstools.Namespaces import OASIS as _OASIS 
    2727 
    28 from ndg.wssecurity.common import WSSecurityConfigError, WSSecurityError 
    29 from ndg.wssecurity.common.utils import classfactory 
    30 from ndg.wssecurity.common.utils.configfileparsers import ( 
    31                                             CaseSensitiveConfigParser,  
    32                                             WithGetListConfigParser) 
    33 from ndg.wssecurity.common.utils.pki import (X509Cert, X509Stack,  
    34                                              X509StackParseFromDER) 
     28from ndg.soap.utils import classfactory 
     29from ndg.soap.utils.configfileparsers import (CaseSensitiveConfigParser,  
     30                                              WithGetListConfigParser) 
     31from ndg.soap.wssecurity import WSSecurityConfigError, WSSecurityError 
     32from ndg.soap.wssecurity.utils.pki import (X509Cert, X509Stack,  
     33                                           X509StackParseFromDER) 
    3534 
    3635 
     
    147146    __slots__.update( 
    148147        __caX509Stack=None, 
    149         __refC14nKw=None, 
    150         __signedInfoC14nKw=None 
     148        __referenceElemsC14nKeywords=None, 
     149        __signedInfoElemC14nKeywords=None 
    151150    ) 
    152151     
     
    158157 
    159158        self.__caX509Stack = X509Stack() 
    160         self.__refC14nKw = {} 
    161         self.__signedInfoC14nKw = {} 
     159        self.__referenceElemsC14nKeywords = {} 
     160        self.__signedInfoElemC14nKeywords = {} 
    162161 
    163162    @classmethod 
     
    341340         
    342341                 
    343     def _setRefC14nKw(self, kw): 
     342    def _setReferenceElemsC14nKeywords(self, kw): 
    344343        """Set keywords for canonicalization of reference elements in the  
    345344        signing process""" 
    346345        self.__checkC14nKw(kw)                     
    347         self.__refC14nKw = kw 
    348          
    349     def _getRefC14nKw(self): 
    350         return self.__refC14nKw 
    351          
    352     refC14nKw = property(fset=_setRefC14nKw, 
    353                          fget=_getRefC14nKw, 
     346        self.__referenceElemsC14nKeywords = kw 
     347         
     348    def _getReferenceElemsC14nKeywords(self): 
     349        return self.__referenceElemsC14nKeywords 
     350         
     351    referenceElemsC14nKeywords = property(fset=_setReferenceElemsC14nKeywords, 
     352                         fget=_getReferenceElemsC14nKeywords, 
    354353                         doc="Keywords for C14N of reference elements") 
    355354         
    356     def _setSignedInfoC14nKw(self, kw): 
     355    def _setSignedInfoElemC14nKeywords(self, kw): 
    357356        """Set keywords for canonicalization of SignedInfo element in the  
    358357        signing process""" 
    359358        self.__checkC14nKw(kw)                     
    360         self.__signedInfoC14nKw = kw 
    361          
    362     def _getSignedInfoC14nKw(self): 
    363         if hasattr(self, '_signedInfoC14nKw'): 
    364             return self.__signedInfoC14nKw 
     359        self.__signedInfoElemC14nKeywords = kw 
     360         
     361    def _getSignedInfoElemC14nKeywords(self): 
     362        if hasattr(self, '_signedInfoElemC14nKeywords'): 
     363            return self.__signedInfoElemC14nKeywords 
    365364        else: 
    366365            return {} 
    367366         
    368     signedInfoC14nKw = property(fset=_setSignedInfoC14nKw, 
    369                                 fget=_getSignedInfoC14nKw, 
     367    signedInfoElemC14nKeywords = property(fset=_setSignedInfoElemC14nKeywords, 
     368                                fget=_getSignedInfoElemC14nKeywords, 
    370369                                doc="Keywords for C14N of SignedInfo element") 
    371370 
  • TI12-security/trunk/NDGSoap/ndg/soap/wssecurity/signaturehandler/foursuite.py

    r6409 r6417  
    3636from Ft.Xml.Domlette import CanonicalPrint 
    3737 
    38 from ndg.wssecurity.common import (WSSecurityError, TimestampError,  
    39                                    MessageExpired) 
    40 from ndg.wssecurity.common.signaturehandler import (_WSU, OASIS,  
     38from ndg.soap.wssecurity import (WSSecurityError, TimestampError,  
     39                                 MessageExpired) 
     40from ndg.soap.wssecurity.utils.pki import (X509Cert, X509Stack,  
     41                                           X509StackParseFromDER) 
     42from ndg.soap.wssecurity.signaturehandler import (_WSU, OASIS,  
    4143    BaseSignatureHandler, NoSignatureFound, InvalidSignature,   
    4244    VerifyError, SignatureError) 
    43  
    44 from ndg.wssecurity.common.utils.pki import (X509Cert, X509CertParse,  
    45                                              X509CertRead, X509Stack,  
    46                                              X509StackParseFromDER) 
    4745 
    4846 
     
    6664    } 
    6765     
    68     _refC14nPfxSet = lambda self: len(self.refC14nKw.get( 
     66    _refC14nPfxSet = lambda self: len(self.referenceElemsC14nKeywords.get( 
    6967                            BaseSignatureHandler.ZSI_C14N_KEYWORD_NAME, [])) > 0 
    7068     
     
    7371                                 "signature of reference elements") 
    7472     
    75     _signedInfoC14nPfxSet = lambda self: len(self.signedInfoC14nKw.get( 
     73    _signedInfoC14nPfxSet = lambda self: len(self.signedInfoElemC14nKeywords.get( 
    7674                            BaseSignatureHandler.ZSI_C14N_KEYWORD_NAME, [])) > 0 
    7775                     
     
    8078                                        "for signature of signed info " 
    8179                                        "elements") 
     80     
     81    XPATH_C14N_METHOD = "//ds:CanonicalizationMethod" 
     82    XPATH_REF_ELEMS = "//ds:Reference" 
     83    XPATH_SIGNED_INFO_ELEM = "//ds:SignedInfo" 
     84    XPATH_SIGNATURE_ELEM = "//ds:Signature" 
     85    XPATH_SIGNATURE_VAL_ELEM = "//ds:SignatureValue" 
     86    XPATH_BINARY_SECURITY_TOK_ELEM = "//wsse:BinarySecurityToken" 
     87     
     88    INCLUSIVE_NS_PREFIXES_ATTRNAME = "InclusiveNamespaces" 
     89    PREFIX_LIST_ATTRNAME = "PrefixList" 
    8290 
    8391    def sign(self, soapWriter): 
     
    9098        # Add X.509 cert as binary security token 
    9199        if self.reqBinarySecurityTokValType == \ 
    92            self.BINARY_SECURITY_TOK_VAL_TYPE['X509PKIPathv1']: 
     100           self.__class__.BINARY_SECURITY_TOK_VAL_TYPE['X509PKIPathv1']: 
    93101            if self.signingCertChain is None: 
    94102                msg = 'SignatureHandler signingCertChain attribute is not set' 
     
    174182        signedInfoC14nAlg = c14nAlgOpt[int(self.signedInfoC14nIsExcl)] 
    175183         
    176         c14nMethodElem.setAttributeNS(None, 'Algorithm', signedInfoC14nAlg) 
     184        c14nMethodElem.setAttributeNS(None,  
     185                                      SignatureHandler.C14N_ALG_ATTRNAME,  
     186                                      signedInfoC14nAlg) 
    177187         
    178188        if self.signedInfoC14nPfxSet: 
     
    180190                                                    signedInfoC14nAlg, 
    181191                                                    'InclusiveNamespaces') 
    182             inclNsPfx = ' '.join(self.signedInfoC14nKw[ 
     192            inclNsPfx = ' '.join(self.signedInfoElemC14nKeywords[ 
    183193                                        SignatureHandler.ZSI_C14N_KEYWORD_NAME]) 
    184             c14nInclNamespacesElem.setAttributeNS(None, 'PrefixList', inclNsPfx) 
     194            c14nInclNamespacesElem.setAttributeNS( 
     195                                        None,  
     196                                        SignatureHandler.PREFIX_LIST_ATTRNAME,  
     197                                        inclNsPfx) 
    185198         
    186199        # Signed Info - Signature method 
    187200        sigMethodElem = signedInfoElem.createAppendElement(DSIG.BASE, 
    188201                                                           'SignatureMethod') 
    189         sigMethodElem.setAttributeNS(None, 'Algorithm', DSIG.SIG_RSA_SHA1) 
     202        sigMethodElem.setAttributeNS(None,  
     203                                     SignatureHandler.C14N_ALG_ATTRNAME,  
     204                                     DSIG.SIG_RSA_SHA1) 
    190205         
    191206        # Signature - Signature value 
     
    224239            # Canonicalize reference 
    225240            # 
    226             # ndg.wssecurity.common.utils.zsi.DomletteElementProxy's C14N method 
     241            # ndg.soap.wssecurity.utils.zsi.DomletteElementProxy's C14N method 
    227242            # wraps 4Suite-XML CanonicalPrint 
    228             unsuppressedPrefixes = self.refC14nKw.get( 
     243            unsuppressedPrefixes = self.referenceElemsC14nKeywords.get( 
    229244                                    SignatureHandler.ZSI_C14N_KEYWORD_NAME, []) 
    230245             
     
    250265 
    251266            # Set Canonicalization algorithm type 
    252             transformElem.setAttributeNS(None, 'Algorithm', refC14nAlg) 
     267            transformElem.setAttributeNS(None, SignatureHandler.C14N_ALG_ATTRNAME, refC14nAlg) 
    253268            if self.refC14nPfxSet: 
    254269                # Exclusive C14N requires inclusive namespace elements 
     
    256271                                                       refC14nAlg, 
    257272                                                       'InclusiveNamespaces') 
    258                 refInclNsPfx = ' '.join(self.refC14nKw[ 
     273                refInclNsPfx = ' '.join(self.referenceElemsC14nKeywords[ 
    259274                                        SignatureHandler.ZSI_C14N_KEYWORD_NAME]) 
    260                 inclNamespacesElem.setAttributeNS(None, 'PrefixList',  
     275                inclNamespacesElem.setAttributeNS(None, SignatureHandler.PREFIX_LIST_ATTRNAME,  
    261276                                                  refInclNsPfx) 
    262277             
     
    264279            digestMethodElem = refElem.createAppendElement(DSIG.BASE,  
    265280                                                           'DigestMethod') 
    266             digestMethodElem.setAttributeNS(None, 'Algorithm', DSIG.DIGEST_SHA1) 
     281            digestMethodElem.setAttributeNS(None, SignatureHandler.C14N_ALG_ATTRNAME, DSIG.DIGEST_SHA1) 
    267282             
    268283            # Digest Value 
     
    275290        # Canonicalize the signedInfo node 
    276291        try: 
    277             signedInfoElem = soapWriter.body.evaluate('//ds:SignedInfo', 
     292            signedInfoElem = soapWriter.body.evaluate( 
     293                                SignatureHandler.XPATH_SIGNED_INFO_ELEM, 
    278294                                processorNss=SignatureHandler.PROCESSOR_NSS)[0] 
    279295        except TypeError, e: 
     
    281297            raise  
    282298         
    283         unsuppressedPrefixes = self.refC14nKw.get( 
     299        unsuppressedPrefixes = self.referenceElemsC14nKeywords.get( 
    284300                                    SignatureHandler.ZSI_C14N_KEYWORD_NAME, []) 
    285301 
    286         # ndg.wssecurity.common.utils.zsi.DomletteElementProxy's C14N method 
     302        # ndg.soap.utils.zsi.DomletteElementProxy's C14N method 
    287303        # wraps 4Suite-XML CanonicalPrint 
    288304        c14nSignedInfo = signedInfoElem.canonicalize( 
     
    300316 
    301317        log.info("Signature generation complete") 
    302  
     318             
    303319    def verify(self, parsedSOAP, raiseNoSignatureFound=True): 
    304320        """Verify signature 
     
    308324        sender""" 
    309325 
    310         signatureElem = parsedSOAP.dom.xpath('//ds:Signature',  
     326        signatureElem = parsedSOAP.dom.xpath( 
     327                                    SignatureHandler.XPATH_SIGNATURE_ELEM,  
    311328                                    explicitNss=SignatureHandler.PROCESSOR_NSS) 
    312329        nSignatureElem = len(signatureElem) 
     
    334351        # the transforms elements 
    335352        try: 
    336             c14nMethodElem = parsedSOAP.dom.xpath('//ds:CanonicalizationMethod', 
     353            c14nMethodElem = parsedSOAP.dom.xpath( 
     354                                SignatureHandler.XPATH_C14N_METHOD, 
    337355                                explicitNss=SignatureHandler.PROCESSOR_NSS)[0] 
    338356        except TypeError: 
     
    342360            raise 
    343361         
    344         refElems = parsedSOAP.dom.xpath('//ds:Reference', 
     362        refElems = parsedSOAP.dom.xpath(SignatureHandler.XPATH_REF_ELEMS, 
    345363                                    explicitNss=SignatureHandler.PROCESSOR_NSS) 
    346364 
     
    354372     
    355373                refAlgorithm = transformElems[0].getAttributeNS(None, 
    356                                                                 'Algorithm') 
     374                                                                SignatureHandler.C14N_ALG_ATTRNAME) 
    357375            except Exception, e: 
    358376                raise VerifyError('failed to get transform algorithm for ' 
     
    361379                 
    362380            # Add extra keyword for Exclusive canonicalization method 
    363             refC14nKw = {} 
     381            referenceElemsC14nKeywords = {} 
    364382            if self.refC14nIsExcl: 
    365383                try: 
    366384                    # Check for no inclusive namespaces set 
    367385                    inclusiveNS = getElements(transformElems[0],  
    368                                               "InclusiveNamespaces")                    
     386                                SignatureHandler.INCLUSIVE_NS_PREFIXES_ATTRNAME)                    
    369387                    if len(inclusiveNS) > 0: 
    370                         pfxListAttElem = inclusiveNS[0].getAttributeNodeNS(None,  
    371                                                                 'PrefixList') 
     388                        pfxListAttElem = inclusiveNS[0].getAttributeNodeNS( 
     389                                        None,  
     390                                        SignatureHandler.PREFIX_LIST_ATTRNAME) 
    372391                             
    373                         refC14nKw['inclusivePrefixes'] = \ 
     392                        referenceElemsC14nKeywords['inclusivePrefixes'] = \ 
    374393                                                pfxListAttElem.value.split() 
    375394                    else: 
    376                         refC14nKw['inclusivePrefixes'] = None 
     395                        referenceElemsC14nKeywords['inclusivePrefixes'] = None 
    377396                except Exception, e: 
    378397                    raise VerifyError('failed to handle transform (%s) in ' 
     
    392411            f = StringIO() 
    393412            CanonicalPrint(uriElem, stream=f, exclusive=self.refC14nIsExcl, 
    394                            **refC14nKw) 
     413                           **referenceElemsC14nKeywords) 
    395414            refC14n = f.getvalue() 
    396415            digestValue = base64.encodestring(sha(refC14n).digest()).strip() 
     
    408427                 
    409428        # 2) Signature Validation 
    410         signedInfoElem = parsedSOAP.dom.xpath('//ds:SignedInfo', 
     429        signedInfoElem = parsedSOAP.dom.xpath(SignatureHandler.XPATH_SIGNED_INFO_ELEM, 
    411430                                explicitNss=SignatureHandler.PROCESSOR_NSS)[0] 
    412431 
     
    414433        # element.  Nb. This is NOT necessarily the same as that used to 
    415434        # canonicalize the reference elements checked above! 
    416         signedInfoC14nAlg = c14nMethodElem.getAttributeNS(None, "Algorithm") 
    417         signedInfoC14nKw = {} 
     435        signedInfoC14nAlg = c14nMethodElem.getAttributeNS( 
     436                                            None,  
     437                                            SignatureHandler.C14N_ALG_ATTRNAME) 
     438        signedInfoElemC14nKeywords = {} 
    418439        if self.signedInfoC14nIsExcl: 
    419440            try: 
    420441                # Check for inclusive namespaces 
    421442                inclusiveNsElem = getElements(c14nMethodElem, 
    422                                               "InclusiveNamespaces") 
     443                                SignatureHandler.INCLUSIVE_NS_PREFIXES_ATTRNAME) 
    423444                if len(inclusiveNsElem) > 0:                     
    424445                    pfxListAttElem = inclusiveNsElem[0].getAttributeNodeNS(None, 
    425                                                                  'PrefixList') 
    426                     signedInfoC14nKw['inclusivePrefixes' 
     446                                                                 SignatureHandler.PREFIX_LIST_ATTRNAME) 
     447                    signedInfoElemC14nKeywords['inclusivePrefixes' 
    427448                                     ] = pfxListAttElem.value.split() 
    428449                else: 
    429                     signedInfoC14nKw['inclusivePrefixes'] = None 
     450                    signedInfoElemC14nKeywords['inclusivePrefixes'] = None 
    430451            except Exception, e: 
    431452                raise VerifyError('failed to handle exclusive ' 
     
    437458                       stream=f, 
    438459                       exclusive=self.signedInfoC14nIsExcl,  
    439                        **signedInfoC14nKw)        
     460                       **signedInfoElemC14nKeywords)        
    440461        c14nSignedInfo = f.getvalue()   
    441462                        
     
    445466        # calculated 
    446467        try: 
    447             signatureValueElem = parsedSOAP.dom.xpath('//ds:SignatureValue', 
     468            signatureValueElem = parsedSOAP.dom.xpath( 
     469                                SignatureHandler.XPATH_SIGNATURE_VAL_ELEM, 
    448470                                explicitNss=SignatureHandler.PROCESSOR_NSS)[0] 
    449471        except: 
     
    470492        # Look for X.509 Cert in wsse:BinarySecurityToken node 
    471493        try: 
    472             binSecTokElem = parsedSOAP.dom.xpath('//wsse:BinarySecurityToken', 
     494            binSecTokElem = parsedSOAP.dom.xpath( 
     495                                SignatureHandler.XPATH_BINARY_SECURITY_TOK_ELEM, 
    473496                                explicitNss=SignatureHandler.PROCESSOR_NSS)[0] 
    474497        except: 
  • TI12-security/trunk/NDGSoap/ndg/soap/wssecurity/test/unit/signaturehandler/foursuite/client/echoClientTest.cfg

    r6396 r6417  
    77# BSD - See LICENCE file for details 
    88[setUp] 
    9 className = ndg.wssecurity.common.signaturehandler.foursuite.SignatureHandler 
     9className = ndg.soap.wssecurity.signaturehandler.foursuite.SignatureHandler 
    1010uri = http://localhost:7600/Echo 
    1111signingPriKeyFilePath = $NDGSEC_TEST_CONFIG_DIR/pki/wsse-clnt.key 
  • TI12-security/trunk/NDGSoap/ndg/soap/wssecurity/test/unit/signaturehandler/foursuite/client/test_echoclient.py

    r6396 r6417  
    55""" 
    66__author__ = "P J Kershaw" 
    7 __date__ = "13/12/06" 
     7__date__ = "22/01/2010" 
    88__copyright__ = "(C) 2009 Science and Technology Facilities Council" 
    99__license__ = "BSD - see LICENSE file in top-level directory" 
     
    1717 
    1818from os.path import join, dirname, abspath 
    19 mkPath = lambda file: join(os.environ['NDGSEC_WSSECLNT_UNITTEST_DIR'], file) 
     19mkPath = lambda file: join(os.environ['NDGSOAP_WSSECLNT_UNITTEST_DIR'], file) 
    2020 
    2121from ConfigParser import SafeConfigParser 
     
    2323from EchoService_services import EchoServiceLocator 
    2424 
    25 from ndg.wssecurity.test.unit import BaseTestCase 
    26 from ndg.wssecurity.common import TimestampError 
    27 from ndg.wssecurity.common.utils.zsi import DomletteReader, DomletteElementProxy 
    28 from ndg.wssecurity.common.signaturehandler import (NoSignatureFound,  
    29                                                     SignatureHandlerFactory) 
    30 #from ndg.wssecurity.common.signaturehandler.foursuite import SignatureHandler 
     25from ndg.soap.utils.zsi import DomletteReader, DomletteElementProxy 
     26from ndg.soap.wssecurity.test.unit import BaseTestCase 
     27from ndg.soap.wssecurity import TimestampError 
     28from ndg.soap.wssecurity.signaturehandler import (NoSignatureFound,  
     29                                                  SignatureHandlerFactory) 
    3130 
    3231 
     
    3736        super(EchoClientTestCase, self).setUp() 
    3837         
    39         if 'NDGSEC_INT_DEBUG' in os.environ: 
     38        if 'NDGSOAP_INT_DEBUG' in os.environ: 
    4039            import pdb 
    4140            pdb.set_trace() 
    4241         
    43         if 'NDGSEC_WSSECLNT_UNITTEST_DIR' not in os.environ: 
    44             os.environ['NDGSEC_WSSECLNT_UNITTEST_DIR'] = \ 
     42        if 'NDGSOAP_WSSECLNT_UNITTEST_DIR' not in os.environ: 
     43            os.environ['NDGSOAP_WSSECLNT_UNITTEST_DIR'] = \ 
    4544                abspath(dirname(__file__)) 
    4645 
Note: See TracChangeset for help on using the changeset viewer.