Changeset 6396


Ignore:
Timestamp:
25/01/10 14:17:49 (9 years ago)
Author:
pjkersha
Message:
 
Location:
TI12-security/trunk/WSSecurity/ndg/wssecurity
Files:
1 added
7 edited
1 moved

Legend:

Unmodified
Added
Removed
  • TI12-security/trunk/WSSecurity/ndg/wssecurity/common/signaturehandler/__init__.py

    r6392 r6396  
    2727 
    2828from ndg.wssecurity.common import WSSecurityConfigError, WSSecurityError 
    29 from ndg.wssecurity.utils.configfileparsers import CaseSensitiveConfigParser 
    30 from ndg.wssecurity.utils.pki import (X509Cert, X509CertParse, X509CertRead,  
    31                                       X509Stack, X509StackParseFromDER) 
     29from ndg.wssecurity.common.utils import classfactory 
     30from ndg.wssecurity.common.utils.configfileparsers import ( 
     31                                            CaseSensitiveConfigParser,  
     32                                            WithGetListConfigParser) 
     33from ndg.wssecurity.common.utils.pki import (X509Cert, X509Stack,  
     34                                             X509StackParseFromDER) 
    3235 
    3336 
     
    6568 
    6669 
     70_isIterable = lambda obj: getattr(obj, '__iter__', False)  
     71  
     72 
    6773class BaseSignatureHandler(object): 
    6874    """Class to handle signature and verification of signature with  
     
    8591    message verified 
    8692    @type b64EncSignatureValue: string/None""" 
     93    isIterable = staticmethod(_isIterable) 
    8794 
    8895    BINARY_SECURITY_TOK_ENCODING_TYPE = ( 
     
    100107    ZSI_C14N_KEYWORD_NAME = 'inclusive_namespaces' 
    101108     
    102     CFG_PARSER_CLASS = CaseSensitiveConfigParser 
     109    CFG_PARSER_CLASS = WithGetListConfigParser 
    103110    PROPERTY_DEFAULTS = dict( 
     111        className=('',), 
    104112        reqBinarySecurityTokValType=(OASIS.X509TOKEN.X509,), 
    105113        verifyingCert=(None,), 
    106         verifyingCertFilePath=(None,), 
     114        verifyingCertFilePath=(None, ''), 
    107115        signingCert=(None,), 
    108         signingCertFilePath=(None,),  
     116        signingCertFilePath=(None, ''),  
    109117        signingCertChain=([],), 
    110118        signingPriKey=(None,), 
    111         signingPriKeyFilePath=(None,''),  
    112         signingPriKeyPwd=(None,), 
    113         caCertDirPath=(None,), 
     119        signingPriKeyFilePath=(None, ''),  
     120        signingPriKeyPwd=(None, ''), 
     121        caCertDirPath=(None, ''), 
    114122        caCertFilePathList=([],), 
    115123        addTimestamp=(True,), 
     
    123131        cfg=(CFG_PARSER_CLASS(),)) 
    124132     
    125     LIST_STRING_PAT = re.compile(',\s*') 
    126     _parseListString = lambda opt, section: LIST_STRING_PAT.split( 
    127                                             CFG_PARSER_CLASS.get(opt, section)) 
    128     parseListString = classmethod(_parseListString) 
    129      
    130133    CFG_PARSER_GET_FUNC_MAP = { 
    131         basestring: CFG_PARSER_CLASS.get, 
     134        str: CFG_PARSER_CLASS.get, 
     135        unicode: CFG_PARSER_CLASS.get, 
    132136        bool: CFG_PARSER_CLASS.getboolean, 
    133137        float: CFG_PARSER_CLASS.getfloat, 
    134138        int: CFG_PARSER_CLASS.getint, 
    135         list: parseListString 
     139        list: CFG_PARSER_CLASS.getlist 
    136140    } 
    137141     
    138142    TYPE_MAP = dict([(k, tuple([type(i) for i in v])) 
    139143                     for k,v in PROPERTY_DEFAULTS.items()]) 
    140     __slots__ = TYPE_MAP 
     144     
     145    __slots__ = TYPE_MAP.copy() 
     146    __slots__.update({}.fromkeys(['__%s' % i for i in TYPE_MAP.keys()]))    
     147    __slots__.update( 
     148        __caX509Stack=None, 
     149        __refC14nKw=None, 
     150        __signedInfoC14nKw=None 
     151    ) 
    141152     
    142153    def __init__(self): 
     
    145156        for name, val in BaseSignatureHandler.PROPERTY_DEFAULTS.items(): 
    146157            setattr(self, name, val[0]) 
     158 
     159        self.__caX509Stack = X509Stack() 
     160        self.__refC14nKw = {} 
     161        self.__signedInfoC14nKw = {} 
     162 
     163    @classmethod 
     164    def fromConfigFile(cls, filePath, **kw): 
     165        """Instantiate from settings in a config file""" 
     166        signatureHandler = cls() 
     167        signatureHandler.read(filePath) 
     168        signatureHandler.parse(**kw) 
     169        return signatureHandler 
     170 
     171    @classmethod 
     172    def fromKeywords(cls, *arg, **kw): 
     173        """Instantiate from keyword settings - this is useful when integrating 
     174        with Paste WSGI apps app_conf settings""" 
     175        signatureHandler = cls() 
     176        signatureHandler.update(**kw) 
     177        return signatureHandler 
     178     
     179    @classmethod 
     180    def expandVars(cls, val): 
     181        if cls.isIterable(val): 
     182            for i, v in zip(range(len(val)), val): 
     183                if isinstance(v, basestring): 
     184                    val[i] = os.path.expandvars(v)  
     185            return val 
     186         
     187        elif isinstance(val, basestring): 
     188            return os.path.expandvars(val) 
     189        else: 
     190            return val 
    147191         
    148192    def __setattr__(self, name, val): 
     
    189233             
    190234        paramSettings = zip(optNames,  
    191                             BaseSignatureHandler.PROPERTY_DEFAULTS.keys(), 
    192                             BaseSignatureHandler.TYPE_MAP)  
     235                            BaseSignatureHandler.PROPERTY_DEFAULTS.keys())  
    193236            
    194         for optName, attrName, types in paramSettings: 
     237        for optName, attrName in paramSettings: 
    195238             
    196239            # Parameters may be omitted and set later 
    197240            if self.cfg.has_option(sectionName, optName): 
     241                types = BaseSignatureHandler.TYPE_MAP.get(attrName) 
     242                if types is None: 
     243                    raise WSSecurityConfigError("No type set for %r attribute" % 
     244                                                attrName) 
     245                     
    198246                getFunc = BaseSignatureHandler.CFG_PARSER_GET_FUNC_MAP.get( 
    199                                                                     types[0]) 
     247                                                                    types[-1]) 
    200248                if getFunc is None: 
    201249                    raise WSSecurityConfigError("No Config parser get method " 
    202                         "configured for attribute %r with type %r" % 
    203                         (attrName, type[0])) 
     250                                                "configured for attribute %r " 
     251                                                "with type %r" % 
     252                                                (attrName, types[-1])) 
    204253                      
    205254                val = getFunc(self.cfg, sectionName, optName) 
    206                 setattr(self, attrName, val) 
     255                setattr(self, attrName, BaseSignatureHandler.expandVars(val)) 
    207256                  
    208257    def update(self, prefix=None, **kw): 
     
    220269            if prefix: 
    221270                optName = optName.replace(prefix, '', 1) 
    222                 setattr(self, optName, val) 
     271                setattr(self, optName, BaseSignatureHandler.expandVars(val)) 
    223272                                   
    224273    def _setReqBinarySecurityTokValType(self, value): 
     
    352401        elif isinstance(cert, basestring): 
    353402            # Nb. Assume PEM encoded string! 
    354             x509Cert = X509CertParse(cert) 
     403            x509Cert = X509Cert.Parse(cert) 
    355404         
    356405        else: 
     
    376425        @return: certificate object 
    377426        ''' 
    378         return self._verifyingCert 
     427        return self.__verifyingCert 
    379428 
    380429    def _setVerifyingCert(self, verifyingCert): 
    381430        "Set property method for X.509 cert. used to verify a signature" 
    382         self._verifyingCert = self._setCert(verifyingCert) 
     431        self.__verifyingCert = self._setCert(verifyingCert) 
    383432         
    384433        # Reset file path as it may no longer apply 
    385         self._verifyingCertFilePath = None 
     434        self.__verifyingCertFilePath = None 
    386435         
    387436    verifyingCert = property(fset=_setVerifyingCert, 
     
    393442        if verifyingCertFilePath: 
    394443            if isinstance(verifyingCertFilePath, basestring): 
    395                 self._verifyingCert = X509CertRead(verifyingCertFilePath) 
     444                self.__verifyingCert = X509Cert.Read(verifyingCertFilePath) 
    396445            else: 
    397446                raise TypeError("X.509 Cert file path is not a valid string") 
    398447         
    399         self._verifyingCertFilePath = verifyingCertFilePath 
     448        self.__verifyingCertFilePath = verifyingCertFilePath 
    400449         
    401450    verifyingCertFilePath = property(fset=_setVerifyingCertFilePath, 
     
    409458        @return: certificate object 
    410459        ''' 
    411         return self._signingCert 
     460        return self.__signingCert 
    412461 
    413462    def _setSigningCert(self, signingCert): 
    414463        "Set property method for X.509 cert. to be included with signature" 
    415         self._signingCert = self._setCert(signingCert) 
     464        self.__signingCert = self._setCert(signingCert) 
    416465     
    417466        # Reset file path as it may no longer apply 
    418         self._signingCertFilePath = None 
     467        self.__signingCertFilePath = None 
    419468         
    420469    signingCert = property(fget=_getSigningCert, 
     
    427476         
    428477        if isinstance(signingCertFilePath, basestring): 
    429             self._signingCert = X509CertRead(signingCertFilePath) 
     478            self.__signingCert = X509Cert.Read(signingCertFilePath) 
    430479             
    431480        elif signingCertFilePath is not None: 
     
    433482                                 "be a valid string") 
    434483         
    435         self._signingCertFilePath = signingCertFilePath 
     484        self.__signingCertFilePath = signingCertFilePath 
    436485         
    437486    signingCertFilePath = property(fset=_setSigningCertFilePath, 
     
    449498        chain of trust.  The last certificate is the one associated with the 
    450499        private key used to sign the message.''' 
    451          
    452         if not isinstance(signingCertChain, (list, tuple)): 
    453             log.warning('Expecting a list or tuple for "signingCertChain" - ' 
    454                         'ignoring value set, "%s"' % signingCertChain) 
    455             self._signingCertChain = None 
    456             return 
    457          
    458         self._signingCertChain = X509Stack() 
    459              
    460500        for cert in signingCertChain: 
    461             self._signingCertChain.push(cert) 
     501            self.__signingCertChain.push(cert) 
    462502             
    463503    def _getSigningCertChain(self): 
    464         return self._signingCertChain 
     504        return self.__signingCertChain 
    465505     
    466506    signingCertChain = property(fset=_setSigningCertChain, 
     
    476516                                 "or a valid string") 
    477517         
    478         self._signingPriKeyPwd = signingPriKeyPwd 
    479  
    480     def _getSigningPriKeyPwd(self): 
    481         if hasattr(self, '_signingPriKeyPwd'): 
    482             return self._signingPriKeyPwd 
    483         else: 
    484             return "" 
    485          
     518        self.__signingPriKeyPwd = signingPriKeyPwd 
     519 
     520    def _getSigningPriKeyPwd(self):        
     521        return self.__signingPriKeyPwd 
     522 
    486523    signingPriKeyPwd = property(fset=_setSigningPriKeyPwd, 
    487524                                fget=_getSigningPriKeyPwd, 
     
    489526                                    "used to sign message") 
    490527 
    491   
    492528    def _setSigningPriKey(self, signingPriKey): 
    493529        """Set method for client private key 
     
    496532        the key is password protected. 
    497533         
    498         @type signingPriKey: M2Crypto.RSA.RSA / string 
     534        @type signingPriKey: M2Crypto.RSA.RSA / string / None 
    499535        @param signingPriKey: private key used to sign message""" 
    500536         
    501537        if isinstance(signingPriKey, basestring): 
    502             pwdCallback = lambda *ar, **kw: self._signingPriKeyPwd 
    503             self._signingPriKey = RSA.load_key_string(signingPriKey, 
     538            pwdCallback = lambda *ar, **kw: self.__signingPriKeyPwd 
     539            self.__signingPriKey = RSA.load_key_string(signingPriKey, 
    504540                                                       callback=pwdCallback) 
    505  
    506541        elif isinstance(signingPriKey, RSA.RSA): 
    507             self._signingPriKey = signingPriKey  
    508                     
     542            self.__signingPriKey = signingPriKey 
     543             
     544        elif signingPriKey is None: 
     545            self.__signingPriKey = None         
    509546        else: 
    510             raise AttributeError("Signing private key must be a valid " 
    511                                   "M2Crypto.RSA.RSA type or a string") 
     547            raise TypeError("Signing private key must be a valid " 
     548                            "M2Crypto.RSA.RSA type or a string") 
    512549                 
    513550    def _getSigningPriKey(self): 
    514         return self._signingPriKey 
     551        return self.__signingPriKey 
    515552 
    516553    signingPriKey = property(fset=_setSigningPriKey, 
     
    527564                # Read Private key to sign with     
    528565                priKeyFile = BIO.File(open(signingPriKeyFilePath))  
    529                 pwdCallback = lambda *ar, **kw: self._signingPriKeyPwd                                            
    530                 self._signingPriKey = RSA.load_key_bio(priKeyFile,  
     566                pwdCallback = lambda *ar, **kw: self.__signingPriKeyPwd                                            
     567                self.__signingPriKey = RSA.load_key_bio(priKeyFile,  
    531568                                                        callback=pwdCallback)            
    532569            except Exception, e: 
     
    554591        @param caCertList: list or tuple 
    555592        @type caCertList: M2Crypto.X509.X509 certificate objects''' 
    556          
    557         if not hasattr(self, '_caX509Stack'): 
    558             self.__caX509Stack = X509Stack() 
    559              
    560593        for cert in caCertList: 
    561594            self.__caX509Stack.push(cert) 
     
    566599        stack 
    567600         
    568         @param caCertDir: string 
     601        @param caCertDir: string / None type 
    569602        @type caCertDir: directory from which to read CA certificate files''' 
     603         
     604        if caCertDir is None: 
     605            return 
    570606         
    571607        # Mimic OpenSSL -CApath option which expects directory of CA files 
     
    573609        reg = re.compile('\d+\.0') 
    574610        try: 
    575             caCertList = [X509CertRead(caFile)  
     611            caCertList = [X509Cert.Read(caFile)  
    576612                          for caFile in os.listdir(caCertDir)  
    577613                          if reg.match(caFile)] 
     
    594630        @param caCertFilePathList: list of file paths for CA certificates to 
    595631        be used to verify certificate used to sign message''' 
    596          
    597         if not isinstance(caCertFilePathList, (list, tuple)): 
    598             raise WSSecurityError('Expecting a list or tuple for ' 
    599                                   '"caCertFilePathList"') 
    600632 
    601633        # Mimic OpenSSL -CApath option which expects directory of CA files 
    602634        # of form <Hash cert subject name>.0 
    603635        try: 
    604             caCertList = [X509CertRead(caFile) for caFile in caCertFilePathList] 
     636            caCertList = [X509Cert.Read(caFile) for caFile in caCertFilePathList] 
    605637        except Exception: 
    606638            raise WSSecurityError('Loading CA certificate "%s" from file ' 
     
    615647         
    616648    def _get_timestampClockSkew(self): 
    617         return getattr(self, "_timestampClockSkew", 0.) 
     649        return self.__timestampClockSkew 
    618650 
    619651    def _set_timestampClockSkew(self, val): 
     
    627659            raise TypeError("Expecting string, float or int type for " 
    628660                            "timestampClockSkew attribute, got %r" %  
    629                             getattr(val, "__class__", val)) 
     661                            type(val)) 
    630662         
    631663    timestampClockSkew = property(fset=_set_timestampClockSkew, 
     
    704736                                        "timestamp element.  Set to False to " 
    705737                                        "log a warning message and continue " 
    706                                         "processing")                                   
    707  
    708                                
     738                                        "processing")            
     739     
     740     
     741class SignatureHandlerFactory(object): 
     742    """Create a new signature handler from the given class name and other  
     743    configuration settings 
     744    """ 
     745    CLASS_NAME_OPTNAME = 'className' 
     746     
     747    @classmethod 
     748    def fromConfigFile(cls, filePath, sectionName='DEFAULT', prefix=''): 
     749        """Instantiate a new signature handler from a config file""" 
     750         
     751        # Expand environment variables in file path 
     752        expandedFilePath = os.path.expandvars(filePath) 
     753         
     754        # Add 'here' item to enable convenient path substitutions in the config 
     755        # file 
     756        defaultItems = dict(here=os.path.dirname(expandedFilePath)) 
     757        cfg = CaseSensitiveConfigParser(defaults=defaultItems) 
     758         
     759        readFilePaths = cfg.read(expandedFilePath) 
     760         
     761        # Check file was read in OK 
     762        if len(readFilePaths) == 0: 
     763            raise IOError('Missing config file: "%s"' % expandedFilePath)  
     764                
     765        optName = prefix + cls.CLASS_NAME_OPTNAME 
     766        className = cfg.get(sectionName, optName) 
     767        signatureHandlerClass = classfactory.importClass(className,  
     768                                            objectType=BaseSignatureHandler) 
     769         
     770        return signatureHandlerClass.fromConfigFile(filePath, 
     771                                                    sectionName=sectionName,  
     772                                                    prefix=prefix) 
     773     
     774    @classmethod 
     775    def fromKeywords(cls, prefix='', **kw): 
     776        """Instantiate a new signature handler from keyword settings""" 
     777        optName = prefix + cls.CLASS_NAME_OPTNAME 
     778        className = kw.get(optName) 
     779        if className is None: 
     780            raise KeyError("No %r keyword setting" % cls.CLASS_NAME_OPTNAME) 
     781         
     782        signatureHandlerClass = classfactory.importClass(className,  
     783                                            objectType=BaseSignatureHandler) 
     784         
     785        return signatureHandlerClass.fromKeywords(prefix, **kw) 
     786     
  • TI12-security/trunk/WSSecurity/ndg/wssecurity/common/signaturehandler/foursuite.py

    r6387 r6396  
    3535from Ft.Xml.Domlette import CanonicalPrint 
    3636 
    37 from ndg.security.common.wssecurity import WSSecurityError 
    38 from ndg.security.common.wssecurity.signaturehandler import _WSU, OASIS, \ 
    39     BaseSignatureHandler, NoSignatureFound, InvalidSignature, TimestampError, \ 
    40     MessageExpired, VerifyError, SignatureError 
    41  
    42 from ndg.security.common.X509 import X509Cert, X509CertParse, X509CertRead, \ 
    43     X509Stack, X509StackParseFromDER 
     37from ndg.wssecurity.common import (WSSecurityError, TimestampError,  
     38                                   MessageExpired) 
     39from ndg.wssecurity.common.signaturehandler import (_WSU, OASIS,  
     40    BaseSignatureHandler, NoSignatureFound, InvalidSignature,   
     41    VerifyError, SignatureError) 
     42 
     43from ndg.wssecurity.common.utils.pki import (X509Cert, X509CertParse,  
     44                                             X509CertRead, X509Stack,  
     45                                             X509StackParseFromDER) 
    4446 
    4547 
     
    5557    WS-Security 
    5658    """ 
     59    _refC14nPfxSet = lambda self: len(self.refC14nKw.get( 
     60                            BaseSignatureHandler.ZSI_C14N_KEYWORD_NAME, [])) > 0 
     61     
     62    refC14nPfxSet = property(fget=_refC14nPfxSet, 
     63                             doc="True if exclusive namespaces are set for " 
     64                                 "signature of reference elements") 
     65     
     66    _signedInfoC14nPfxSet = lambda self: len(self.signedInfoC14nKw.get( 
     67                            BaseSignatureHandler.ZSI_C14N_KEYWORD_NAME, [])) > 0 
     68                     
     69    signedInfoC14nPfxSet = property(fget=_signedInfoC14nPfxSet, 
     70                                    doc="True if exclusive namespaces are set " 
     71                                        "for signature of signed info " 
     72                                        "elements") 
     73                 
    5774 
    5875    def _applySignatureConfirmation(self, wsseElem): 
     
    213230                                     "time %s is before the current time %s." % 
    214231                                     (dtExpiry, dtNow)) 
    215              
    216                     
     232 
    217233    def sign(self, soapWriter): 
    218234        '''Sign the message body and binary security token of a SOAP message 
     
    232248 
    233249        # Add X.509 cert as binary security token 
    234         if self.reqBINARY_SECURITY_TOK_VAL_TYPE==self.BINARY_SECURITY_TOK_VAL_TYPE['X509PKIPathv1']: 
     250        if self.reqBinarySecurityTokValType == \ 
     251           self.BINARY_SECURITY_TOK_VAL_TYPE['X509PKIPathv1']: 
    235252            if self.signingCertChain is None: 
    236253                msg = 'SignatureHandler signingCertChain attribute is not set' 
     
    255272        # Flag if inclusive namespace prefixes are set for the signature or 
    256273        # reference elements 
    257         refC14nPfxSet = len(self.refC14nKw['inclusive_namespaces']) > 0 
    258         signedInfoC14nPfxSet = \ 
    259                         len(self.signedInfoC14nKw['inclusive_namespaces']) > 0 
    260                  
    261         if refC14nPfxSet or signedInfoC14nPfxSet: 
     274        if self.refC14nPfxSet or self.signedInfoC14nPfxSet: 
    262275           soapWriter._header.setNamespaceAttribute('ec', DSIG.C14N_EXCL) 
    263276         
     
    285298        binSecTokElem.setAttributeNS(None,  
    286299                                     'ValueType',  
    287                                      self.reqBINARY_SECURITY_TOK_VAL_TYPE) 
     300                                     self.reqBinarySecurityTokValType) 
    288301 
    289302        binSecTokElem.setAttributeNS(None,  
     
    322335        c14nMethodElem.setAttributeNS(None, 'Algorithm', signedInfoC14nAlg) 
    323336         
    324         if signedInfoC14nPfxSet: 
     337        if self.signedInfoC14nPfxSet: 
    325338            c14nInclNamespacesElem = c14nMethodElem.createAppendElement( 
    326339                                                    signedInfoC14nAlg, 
     
    391404            # Set Canonicalization algorithm type 
    392405            transformElem.setAttributeNS(None, 'Algorithm', refC14nAlg) 
    393             if refC14nPfxSet: 
     406            if self.refC14nPfxSet: 
    394407                # Exclusive C14N requires inclusive namespace elements 
    395408                inclNamespacesElem = transformElem.createAppendElement( 
  • TI12-security/trunk/WSSecurity/ndg/wssecurity/common/utils/configfileparsers.py

    r6391 r6396  
    99__contact__ = "Philip.Kershaw@stfc.ac.uk" 
    1010__revision__ = '$Id: $' 
     11import re 
    1112from ConfigParser import SafeConfigParser 
    1213 
     
    2425        ''' 
    2526        return optionstr 
     27     
     28class WithGetListConfigParser(CaseSensitiveConfigParser): 
     29    LIST_STRING_PAT = re.compile(',\s*') 
     30     
     31    def getlist(self, section, option): 
     32        val = self.get(section, option) 
     33        return WithGetListConfigParser.LIST_STRING_PAT.split(val) 
  • TI12-security/trunk/WSSecurity/ndg/wssecurity/common/utils/pki.py

    r6388 r6396  
    727727         
    728728        # Check for separator from input 
    729           if separator is not None: 
     729        if separator is not None: 
    730730            if not isinstance(separator, basestring): 
    731731                raise X500DNError("dn Separator must be a valid string") 
  • TI12-security/trunk/WSSecurity/ndg/wssecurity/test/unit/__init__.py

    r6276 r6396  
    4747    '''Convenience base class from which other unit tests can extend.  Its 
    4848    sets the generic data directory path''' 
    49     configDirEnvVarName = 'NDGSEC_TEST_CONFIG_DIR' 
    50      
    51     SITEA_ATTRIBUTEAUTHORITY_PORTNUM = 5000 
    52     SITEB_ATTRIBUTEAUTHORITY_PORTNUM = 5100 
    53      
    54     SITEA_ATTRIBUTEAUTHORITY_URI = 'http://localhost:%s/AttributeAuthority' % \ 
    55                                     SITEA_ATTRIBUTEAUTHORITY_PORTNUM 
    56                                      
    57     SITEB_ATTRIBUTEAUTHORITY_URI = 'http://localhost:%s/AttributeAuthority' % \ 
    58                                     SITEB_ATTRIBUTEAUTHORITY_PORTNUM 
    59                                      
    60     SITEA_ATTRIBUTEAUTHORITY_SAML_URI = \ 
    61         'http://localhost:%s/AttributeAuthority/saml' % \ 
    62                                     SITEA_ATTRIBUTEAUTHORITY_PORTNUM 
    63                                      
    64     SITEB_ATTRIBUTEAUTHORITY_SAML_URI = \ 
    65         'http://localhost:%s/AttributeAuthority/saml' % \ 
    66                                     SITEB_ATTRIBUTEAUTHORITY_PORTNUM 
    67                                      
    68     SITEA_SSL_ATTRIBUTEAUTHORITY_PORTNUM = 5443 
    69     SITEA_SSL_ATTRIBUTEAUTHORITY_SAML_URI = \ 
    70         'https://localhost:%d/AttributeAuthority/saml' % \ 
    71                                     SITEA_SSL_ATTRIBUTEAUTHORITY_PORTNUM 
    72     SSL_CERT_DN = "/C=UK/ST=Oxfordshire/O=BADC/OU=Security/CN=localhost" 
    73                                      
    74     SITEA_SAML_ISSUER_NAME = "/O=Site A/CN=Attribute Authority" 
    75      
    76     SESSIONMANAGER_PORTNUM = 5500 
     49    TEST_CONFIG_DIR_VARNAME = 'NDGSEC_TEST_CONFIG_DIR' 
     50 
    7751     
    7852    NDGSEC_UNITTESTS_DISABLE_THREAD_SERVICES_ENVVAR = \ 
     
    8660                                         "for unit tests") 
    8761     
    88     NDGSEC_TEST_CONFIG_DIR = os.environ.get(configDirEnvVarName,  
     62    NDGSEC_TEST_CONFIG_DIR = os.environ.get(TEST_CONFIG_DIR_VARNAME,  
    8963                                            TEST_CONFIG_DIR) 
    9064     
    9165    CACERT_DIR = os.path.join(NDGSEC_TEST_CONFIG_DIR, 'ca') 
    9266    PKI_DIR = os.path.join(NDGSEC_TEST_CONFIG_DIR, 'pki') 
    93     SSL_CERT_FILEPATH = os.path.join(PKI_DIR, 'localhost.crt') 
    94     SSL_PRIKEY_FILEPATH = os.path.join(PKI_DIR, 'localhost.key') 
    95      
    96     # Test database set-up 
    97     DB_FILENAME = 'user.db' 
    98     DB_FILEPATH = join(NDGSEC_TEST_CONFIG_DIR, DB_FILENAME) 
    99     DB_CONNECTION_STR = 'sqlite:///%s' % DB_FILEPATH 
    100      
    101     USERNAME = 'pjk' 
    102     PASSWORD = 'testpassword' 
    103     MD5_PASSWORD = md5(PASSWORD).hexdigest() 
    104      
    105     OPENID_URI_STEM = 'https://localhost:7443/openid/' 
    106     OPENID_IDENTIFIER = 'philip.kershaw' 
    107     OPENID_URI = OPENID_URI_STEM + OPENID_IDENTIFIER 
    108      
    109     FIRSTNAME = 'Philip' 
    110     LASTNAME = 'Kershaw' 
    111     EMAILADDRESS = 'pjk@somewhere.ac.uk' 
    112      
    113     ATTRIBUTE_NAMES = ( 
    114         "urn:siteA:security:authz:1.0:attr", 
    115     ) 
    116  
    117     ATTRIBUTE_VALUES = ( 
    118         'urn:siteA:security:authz:1.0:attr:postdoc', 
    119         'urn:siteA:security:authz:1.0:attr:staff',  
    120         'urn:siteA:security:authz:1.0:attr:undergrad',  
    121         'urn:siteA:security:authz:1.0:attr:coapec', 
    122         'urn:siteA:security:authz:1.0:attr:rapid' 
    123     ) 
    124     N_ATTRIBUTE_VALUES = len(ATTRIBUTE_VALUES) 
    125      
    126     VALID_REQUESTOR_IDS = ( 
    127         X500DN.fromString("/O=Site A/CN=Authorisation Service"),  
    128         X500DN.fromString("/O=Site B/CN=Authorisation Service"), 
    129         X500DN.fromString('/CN=test/O=NDG/OU=BADC') 
    130     ) 
    131      
    132     SSL_PEM_FILENAME = 'localhost.pem' 
    133     SSL_PEM_FILEPATH = mkDataDirPath(os.path.join('pki', SSL_PEM_FILENAME)) 
    13467     
    13568    def __init__(self, *arg, **kw): 
    136         if BaseTestCase.configDirEnvVarName not in os.environ: 
    137             os.environ[BaseTestCase.configDirEnvVarName] = TEST_CONFIG_DIR 
     69        if BaseTestCase.TEST_CONFIG_DIR_VARNAME not in os.environ: 
     70            os.environ[BaseTestCase.TEST_CONFIG_DIR_VARNAME] = TEST_CONFIG_DIR 
    13871                 
    13972        unittest.TestCase.__init__(self, *arg, **kw) 
     
    171104        except socket.error: 
    172105            pass 
    173  
    174     def startAttributeAuthorities(self, withSSL=False, port=None): 
    175         """Serve test Attribute Authorities to test against""" 
    176         self.startSiteAAttributeAuthority(withSSL=withSSL, port=port) 
    177         self.startSiteBAttributeAuthority(withSSL=withSSL, port=port) 
    178106         
    179     def startSiteAAttributeAuthority(self, withSSL=False, port=None): 
    180         siteACfgFilePath = mkDataDirPath(join('attributeauthority',  
    181                                               'sitea',  
    182                                               'site-a.ini')) 
    183         self.addService(cfgFilePath=siteACfgFilePath,  
    184                         port=port or BaseTestCase.SITEA_ATTRIBUTEAUTHORITY_PORTNUM, 
    185                         withSSL=withSSL) 
    186          
    187     def startSiteBAttributeAuthority(self, withSSL=False, port=None): 
    188         siteBCfgFilePath = mkDataDirPath(join('attributeauthority', 
    189                                               'siteb',  
    190                                               'site-b.ini')) 
    191         self.addService(cfgFilePath=siteBCfgFilePath,  
    192                         port=port or BaseTestCase.SITEB_ATTRIBUTEAUTHORITY_PORTNUM, 
    193                         withSSL=withSSL)         
    194  
    195     def startSessionManager(self): 
    196         """Serve test Session Manager service""" 
    197         cfgFilePath = mkDataDirPath(join('sessionmanager',  
    198                                          'session-manager.ini')) 
    199         self.addService(cfgFilePath=cfgFilePath,  
    200                         port=BaseTestCase.SESSIONMANAGER_PORTNUM) 
    201          
    202  
    203107    def __del__(self): 
    204108        """Stop any services started with the addService method""" 
     
    206110            for service in self.services: 
    207111                service.terminateThread() 
    208   
    209     @classmethod 
    210     def initDb(cls): 
    211         """Wrapper to _createDb - Create database only if it doesn't already  
    212         exist""" 
    213         if not os.path.isfile(cls.DB_FILEPATH): 
    214             cls._createDb() 
    215          
    216     @classmethod   
    217     def _createDb(cls): 
    218         """Create a test SQLite database with SQLAlchemy for use with unit  
    219         tests 
    220         """ 
    221         log.debug("Creating database for %r ..." % cls.__name__) 
    222          
    223         if not sqlAlchemyInstalled: 
    224             raise NotImplementedError("SQLAlchemy must be installed in order " 
    225                                       "for this method to be implemented") 
    226              
    227         db = create_engine(cls.DB_CONNECTION_STR) 
    228          
    229         metadata = MetaData() 
    230         usersTable = Table('users', metadata, 
    231                            Column('id', Integer, primary_key=True), 
    232                            Column('username', String), 
    233                            Column('md5password', String), 
    234                            Column('openid', String), 
    235                            Column('openid_identifier', String), 
    236                            Column('firstname', String), 
    237                            Column('lastname', String), 
    238                            Column('emailaddress', String)) 
    239          
    240         attributesTable = Table('attributes', metadata, 
    241                                 Column('id', Integer, primary_key=True), 
    242                                 Column('openid', String), 
    243                                 Column('attributename', String)) 
    244         metadata.create_all(db) 
    245          
    246         class User(declarative_base()): 
    247             __tablename__ = 'users' 
    248          
    249             id = Column(Integer, primary_key=True) 
    250             username = Column('username', String(40)) 
    251             md5password = Column('md5password', String(64)) 
    252             openid = Column('openid', String(128)) 
    253             openid_identifier = Column('openid_identifier', String(40)) 
    254             firstname = Column('firstname', String(40)) 
    255             lastname = Column('lastname', String(40)) 
    256             emailAddress = Column('emailaddress', String(40)) 
    257          
    258             def __init__(self, username, md5password, openid, openid_identifier,  
    259                          firstname, lastname, emailaddress): 
    260                 self.username = username 
    261                 self.md5password = md5password 
    262                 self.openid = openid 
    263                 self.openid_identifier = openid_identifier 
    264                 self.firstname = firstname 
    265                 self.lastname = lastname 
    266                 self.emailAddress = emailaddress 
    267          
    268         class Attribute(declarative_base()): 
    269             __tablename__ = 'attributes' 
    270          
    271             id = Column(Integer, primary_key=True) 
    272             openid = Column('openid', String(128)) 
    273             attributename = Column('attributename', String(40)) 
    274          
    275             def __init__(self, openid, attributename): 
    276                 self.openid = openid 
    277                 self.attributename = attributename 
    278  
    279         Session = sessionmaker(bind=db) 
    280         session = Session() 
    281          
    282         attributes = [Attribute(cls.OPENID_URI, attrVal) 
    283                       for attrVal in cls.ATTRIBUTE_VALUES] 
    284         session.add_all(attributes) 
    285             
    286         user = User(cls.USERNAME,  
    287                     cls.MD5_PASSWORD, 
    288                     cls.OPENID_URI, 
    289                     cls.OPENID_IDENTIFIER, 
    290                     cls.FIRSTNAME, 
    291                     cls.LASTNAME, 
    292                     cls.EMAILADDRESS) 
    293          
    294         session.add(user) 
    295         session.commit()  
    296  
    297112 
    298113def _getParentDir(depth=0, path=dirname(__file__)): 
  • TI12-security/trunk/WSSecurity/ndg/wssecurity/test/unit/signaturehandler/foursuite/client/echoClientTest.cfg

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

    r6387 r6396  
    1313logging.basicConfig(level=logging.DEBUG) 
    1414 
    15 import unittest 
    1615import os 
    1716import sys 
     
    2423from EchoService_services import EchoServiceLocator 
    2524 
    26 from ndg.wssecurity.common.signaturehandler.foursuite import SignatureHandler 
     25from ndg.wssecurity.test.unit import BaseTestCase 
     26from ndg.wssecurity.common import TimestampError 
     27from ndg.wssecurity.common.utils.zsi import DomletteReader, DomletteElementProxy 
    2728from ndg.wssecurity.common.signaturehandler import (NoSignatureFound,  
    28                                                     TimestampError) 
    29 from ndg.wssecurity.common.utils import DomletteReader, DomletteElementProxy 
     29                                                    SignatureHandlerFactory) 
     30#from ndg.wssecurity.common.signaturehandler.foursuite import SignatureHandler 
    3031 
    3132 
    32 class EchoClientTestCase(unittest.TestCase): 
     33class EchoClientTestCase(BaseTestCase): 
     34    """Test 4Suite-XML based WS-Security Signature Handler""" 
    3335     
    3436    def setUp(self): 
     
    4244            os.environ['NDGSEC_WSSECLNT_UNITTEST_DIR'] = \ 
    4345                abspath(dirname(__file__)) 
    44      
    45         if 'NDGSEC_TEST_CONFIG_DIR' not in os.environ: 
    46             os.environ['NDGSEC_TEST_CONFIG_DIR'] = \ 
    47                 abspath(join(dirname(dirname(dirname(dirname(__file__)))), 
    48                              'config')) 
    49          
     46 
    5047        configFilePath = mkPath('echoClientTest.cfg') 
    5148        self.cfg = SafeConfigParser() 
     
    5451         
    5552        # Signature handler object is passed to binding 
    56         sigHandler = SignatureHandler(cfg=configFilePath, 
    57                                       cfgFileSection='setUp') 
     53        sigHandler = SignatureHandlerFactory.fromConfigFile(configFilePath,  
     54                                                            sectionName='setUp') 
    5855 
    5956        locator = EchoServiceLocator() 
     
    6461                                    tracefile=sys.stderr) 
    6562         
    66  
    6763    def test01Echo(self): 
    6864             
    6965        resp = self.clnt.Echo("Hello from client") 
    70         print "Message returned was: %s" % resp 
    71  
     66        print("Message returned was: %s" % resp) 
    7267 
    7368    def test02ServerRaiseMissingTimestampError(self): 
Note: See TracChangeset for help on using the changeset viewer.