Changeset 4320


Ignore:
Timestamp:
10/10/08 15:46:20 (11 years ago)
Author:
pjkersha
Message:
  • Fixed ConfigFileParsers? and re-tested CredWallet? unit tests.
  • Added standard exception types for Session Manager AbstractAuthNService interface.
  • Integrated AbstractAuthNService and refactored CredWallet? back into SessionMgr?
  • SessionMgr? unit tests part re-factored. Attribute Cert retrieval tests still to update.
Location:
TI12-security/trunk/python
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • TI12-security/trunk/python/ndg.security.common/ndg/security/common/CredWallet.py

    r4318 r4320  
    286286        wssCfgFilePath=None, 
    287287        wssCfgSection='DEFAULT', 
     288        wssCfgPrefix='', 
    288289        wssCfgKw={}) 
    289290     
     
    445446 
    446447    def _getAttCertRefreshElapse(self): 
     448        """Get property method for Attribute Certificate wallet refresh time 
     449        @rtype: float or int 
     450        @return: "elapse time in seconds""" 
    447451        return self._attCertRefreshElapse 
    448452     
    449453    def _setAttCertRefreshElapse(self, val): 
     454        """Set property method for Attribute Certificate wallet refresh time 
     455        @type val: float or int 
     456        @param val: "elapse time in seconds""" 
    450457        if isinstance(val, (float, int)): 
    451458            self._attCertRefreshElapse = val 
     
    724731                                cfg=self.wssCfgFilePath or self._cfg, 
    725732                                cfgFileSection=self.wssCfgSection, 
     733                                cfgFilePrefix=self.wssCfgPrefix, 
    726734                                **(self.wssCfgKw or {})) 
    727735         
  • TI12-security/trunk/python/ndg.security.common/ndg/security/common/utils/ConfigFileParsers.py

    r4319 r4320  
    6767        log.debug("File has 'xml' suffix - treating as standard XML formatted " 
    6868                  "properties file") 
     69        log.warning("Current version of code for properties handling with " 
     70                    "XML is untested - may be deprecated") 
    6971        properties = readXMLPropertyFile(propFilePath, validKeys) 
    7072        # if validKeys set, check that all loaded property values are featured  
     
    9294                        propBranch = properties[section] 
    9395                         
    94                     if prefix is not None: 
     96                    if prefix: 
    9597                        propBranch = propBranch[prefix] 
    9698     
     
    123125    log.debug("Reading properties from %s" %propFilePath) 
    124126    properties = {} 
    125     if propFilePath.lower().endswith('xml'): 
     127    if propFilePath.lower().endswith('.xml'): 
    126128        log.debug("File has 'xml' suffix - treating as standard XML formatted " 
    127129                  "properties file") 
     130        log.warning("Current version of code for properties handling with " 
     131                    "XML is untested - may be deprecated") 
    128132        properties = readXMLPropertyFile(propFilePath, validKeys) 
    129133    else: 
     
    316320            # check if key already exists; if so, append to list 
    317321            if propThisBranch.has_key(subKey): 
    318                 propThisBranch[subKey] = __listify(propThisBranch[subKey]).extend(val) 
     322                propThisBranch[subKey] = __listify( 
     323                                            propThisBranch[subKey]).extend(val) 
    319324            else: 
    320325                propThisBranch[subKey] = val 
  • TI12-security/trunk/python/ndg.security.common/ndg/security/common/wssecurity/BaseSignatureHandler.py

    r4293 r4320  
    151151 
    152152 
    153     def __init__(self, cfg=None, cfgFileSection='DEFAULT', 
     153    def __init__(self, cfg=None, cfgFileSection='DEFAULT', cfgFilePrefix='', 
    154154                 cfgClass=WSSecurityConfig, **kw): 
    155155        ''' 
     
    235235        # alternative derivative class may be passed in instead. 
    236236        if not issubclass(cfgClass, WSSecurityConfig): 
    237             raise TypeError("%s is not a sub-class of WSSecurityConfig" % \ 
     237            raise TypeError("%s is not a sub-class of WSSecurityConfig" %  
    238238                            cfgClass) 
    239239         
    240240        # Read parameters from config file if set 
    241241        if isinstance(cfg, basestring): 
    242             log.debug("BaseSignatureHandler.__init__: config file path input ...") 
     242            log.debug("BaseSignatureHandler.__init__: config file path input " 
     243                      "...") 
    243244            self.cfg = cfgClass() 
    244245            self.cfg.read(cfg) 
     
    248249             
    249250        if cfg: # config object or config file path was set 
    250             log.debug("BaseSignatureHandler.__init__: Processing config file...") 
    251             self.cfg.parse(section=cfgFileSection) 
     251            log.debug("BaseSignatureHandler.__init__: Processing config " 
     252                      "file...") 
     253            self.cfg.parse(section=cfgFileSection, prefix=cfgFilePrefix) 
    252254 
    253255        # Also update config from keywords set  
    254         log.debug("BaseSignatureHandler.__init__: setting config from keywords...") 
     256        log.debug("BaseSignatureHandler.__init__: setting config from " 
     257                  "keywords...") 
    255258        self.cfg.update(kw) 
    256259         
     
    263266        # Set keywords for canonicalization of SignedInfo and reference  
    264267        # elements 
    265         self.refC14nKw = \ 
    266             {'inclusive_namespaces': self.cfg['refC14nInclNS']} 
     268        self.refC14nKw = {'inclusive_namespaces': self.cfg['refC14nInclNS']} 
    267269 
    268270        self.signedInfoC14nKw = \ 
  • TI12-security/trunk/python/ndg.security.common/ndg/security/common/wssecurity/__init__.py

    r4318 r4320  
    8787        with other sections e.g. params could be under the section 'wssecurity' 
    8888        ''' 
    89         if 'section' in kw: 
    90             section = kw['section'] 
     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') 
     94        if prefix is not None: 
     95            optNames = ["%s.%s" % (prefix, optName) for optName in optNames]  
    9196        else: 
    92             section = 'DEFAULT' 
    93               
    94         for paramName in self._param: 
    95             # Options may be omitted and set later 
    96             if self._cfg.has_option(section, paramName): 
     97            optNames = self._param 
     98             
     99        for optName, paramName in zip(optNames, self._param): 
     100             
     101            # Parameters may be omitted and set later 
     102            if self._cfg.has_option(section, optName): 
    97103                if isinstance(WSSecurityConfig.propertyDefaults[paramName],  
    98104                              list): 
    99105                    try: 
    100106                        self._param[paramName] = \ 
    101                             exVar(self._cfg.get(section, paramName)).split() 
     107                            exVar(self._cfg.get(section, optName)).split() 
    102108                    except AttributeError: 
    103109                        raise SecurityConfigError('Setting "%s"' % paramName) 
     
    106112                                bool):            
    107113                    self._param[paramName] = self._cfg.getboolean(section,  
    108                                                                   paramName) 
     114                                                                  optName) 
    109115                else: 
    110116                    # Default to None if setting is an empty string.  Settings 
    111117                    # of '' causes problems for M2Crypto parsing 
    112118                    self._param[paramName] = \ 
    113                         exVar(self._cfg.get(section, paramName)) or None 
     119                        exVar(self._cfg.get(section, optName)) or None 
    114120 
    115121    def __len__(self): 
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/AttAuthority/__init__.py

    r4319 r4320  
    259259            propBranch = propBranch[section] 
    260260             
    261         if prefix is not None: 
     261        if prefix: 
    262262            propBranch = propBranch[prefix] 
    263263             
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/SessionMgr/__init__.py

    r4318 r4320  
    5050# generic parser to read INI/XML properties file 
    5151from ndg.security.common.utils.ConfigFileParsers import \ 
    52                                                     readAndValidateProperties 
     52                                                INIPropertyFileWithValidation 
    5353 
    5454# utility to instantiate classes dynamically 
     
    8383    sessIdLen = 32 
    8484     
    85     def __init__(self, *credWalletArgs, **credWalletKeys): 
    86         """Initialise UserSession with args and keywords to CredWallet""" 
     85    def __init__(self, **credWalletKeys): 
     86        """Initialise UserSession with keywords to CredWallet""" 
    8787                 
    8888        log.debug("UserSession.__init__ ...") 
     
    9292        self.__sessIdList = [] 
    9393        self.addNewSessID() 
    94         self.__credWallet = CredWallet(*credWalletArgs, **credWalletKeys) 
     94        self.__credWallet = CredWallet(**credWalletKeys) 
    9595 
    9696        log.info("Created a session with ID = %s" % self.__sessIdList[-1]) 
     
    103103                          doc="Read-only access to CredWallet instance") 
    104104 
    105     def __getSessIDlist(self): 
     105    def __getSessIdList(self): 
    106106        """Get Session ID list - last item is latest allocated for this 
    107107        session""" 
    108108        return self.__sessIdList 
    109109     
    110     sessIDlist = property(fget=__getSessIDlist, 
     110    sessIdList = property(fget=__getSessIdList, 
    111111                          doc="Read-only access to Session ID list") 
    112112 
     
    209209    """Raise from SessionMgr._connect2UserSession when session ID is not  
    210210    found in the Session dictionary""" 
    211      
    212 # Find the missing elements in targ referenced in ref 
    213 getMissingElem = lambda targ, ref: [e for e in targ if e not in ref] 
    214  
    215 # Expand environment variables for ElementTree Element type. 
    216 filtElemTxt = lambda elem: isinstance(elem.text, basestring) and \ 
    217                 os.path.expandvars(elem.text).strip() or elem.text 
    218211 
    219212 
     
    240233 
    241234    # valid configuration property keywords 
    242     WSSECURITY_KEYNAME = 'wssecurity' 
    243235    AUTHN_KEYNAME = 'authNService' 
    244236    CREDREPOS_KEYNAME = 'credentialRepository' 
     
    268260        AUTHN_KEYNAME:            authNServicePropertyDefaults,  
    269261        CREDWALLET_KEYNAME:       CredWallet.propertyDefaults, 
    270         CREDREPOS_KEYNAME:        credentialRepositoryPropertyDefaults, 
    271         WSSECURITY_KEYNAME:       WSSecurityConfig.propertyDefaults 
     262        CREDREPOS_KEYNAME:        credentialRepositoryPropertyDefaults 
    272263    } 
    273264 
     
    279270                 propFileSection='DEFAULT', 
    280271                 propPrefix='', 
    281                  credentialRepositoryPPhrase=None,  
    282272                 **prop):        
    283273        """Create a new session manager to manager NDG User Sessions 
     
    288278        @param propFileSection: applies to ini format config files only - the  
    289279        section to read the Session Managers settings from 
    290         @type credentialRepositoryPPhrase: basestring 
    291         @param credentialRepositoryPPhrase: for credential repository if not  
    292280        set in properties file 
    293281        @type prop: dict 
     
    319307        self.propFileSection = propFileSection 
    320308        self.propPrefix = propPrefix 
     309        self._cfg = None 
    321310         
    322311        # Set properties from file 
     
    561550             
    562551        # Configuration file properties are held together in a dictionary 
    563         self.__prop = readAndValidateProperties(self.propFilePath, 
    564                                         validKeys=SessionMgr.propertyDefaults, 
    565                                         prefix=prefix, 
    566                                         sections=(section,), 
    567                                         wsseSection=self.WSSECURITY_KEYNAME) 
    568  
    569         log.info('Loaded properties from "%s"' % self._propFilePath) 
     552        readPropertiesFile = INIPropertyFileWithValidation() 
     553        fileProp = readPropertiesFile(self.propFilePath, 
     554                                      validKeys=SessionMgr.propertyDefaults, 
     555                                      prefix=prefix, 
     556                                      sections=(section,)) 
     557         
     558        # Keep a copy of the config file for the CredWallet to reference so  
     559        # that it can retrieve WS-Security settings 
     560        self._cfg = readPropertiesFile.cfg 
     561         
     562        # Allow for section and prefix names which will nest the Attribute 
     563        # Authority properties in a hierarchy 
     564        propBranch = fileProp 
     565        if section != 'DEFAULT': 
     566            propBranch = propBranch[section] 
     567             
     568        if prefix: 
     569            propBranch = propBranch[prefix] 
     570             
     571        self.__prop = propBranch 
     572 
     573        log.info('Loaded properties from "%s"' % self.propFilePath) 
    570574        
    571575    def setProperties(self, **prop): 
     
    703707                # session 
    704708                userCreds = self.__authNService.logon(username, passphrase) 
    705                  
    706                 # unpack  
     709            except AuthNServiceError: 
     710                # Filter out known AuthNService execptions 
     711                 
     712                raise 
     713            except Exception, e: 
     714                # Catch all here for AuthNService but the particular  
     715                # implementation should make full use of AuthN* exception 
     716                # types 
     717                raise AuthNServiceError("Authentication Service: %s" % e) 
     718                             
     719            # unpack output 
     720            if userCreds is None: 
     721                nUserCreds = 0 
     722            else: 
     723                nUserCreds = len(userCreds) 
     724                 
     725            if nUserCreds > 1: 
    707726                userCert = userCreds[0] 
    708727                userPriKey = userCreds[1] 
    709                  
    710                 # Issuing cert is needed only if userCert is a proxy 
    711                 issuingCert = len(userCreds) > 2 and userCreds[2] or None 
    712                  
    713             except Exception, e: 
    714                 raise SessionMgrError("Authentication Service: %s" % e) 
     728            else: 
     729                userCert = userPriKey = None 
     730                 
     731            # Issuing cert is needed only if userCert is a proxy 
     732            issuingCert = nUserCreds > 2 and userCreds[2] or None         
    715733 
    716734            if createServerSess: 
     
    725743         
    726744        
    727     def _createUserSession(self, username, creds=None): 
     745    def _createUserSession(self, username, userCreds=None): 
    728746        """Create a new user session from input user credentials        
    729747        and return 
     
    731749        @type username: basestring 
    732750        @param username: username user logged in with 
    733         @type creds: tuple 
    734         @param creds: tuple containing user certificate, private key 
     751        @type userCreds: tuple 
     752        @param userCreds: tuple containing user certificate, private key 
    735753        and optionally an issuing certificate.  An issuing certificate is 
    736754        present if user certificate is a proxy and therefore it's issuer is 
    737         other than the CA. creds may default to None if no user certificate 
     755        other than the CA. userCreds may default to None if no user certificate 
    738756        is available.  In this case, the Session Manager server certificate 
    739757        is used to secure connections to Attribute Authorities and other  
     
    754772            # Create a new user session using the username, session ID and 
    755773            # X.509 credentials 
    756             wssSignatureHandlerKw = { 
    757             'refC14nInclNS': self.__prop.get('refC14nInclNS', []), 
    758             'signedInfoC14nInclNS': self.__prop.get('signedInfoC14nInclNS', [])} 
    759  
     774 
     775            # Copy global Credential Wallet settings into specific set for this 
     776            # user 
     777            credWalletKw = self.__prop['credentialWallet'].copy() 
     778            credWalletKw['userId'] = username 
     779             
     780            # Update user PKI settings if any are present 
     781            if userCreds is None: 
     782                nUserCreds = 0 
     783            else: 
     784                nUserCreds = len(userCreds) 
     785                 
     786            if nUserCreds > 1: 
     787                credWalletKw['userX509Cert'] = userCreds[0] 
     788                credWalletKw['userPriKey'] = userCreds[1] 
     789             
     790            if nUserCreds == 3: 
     791                credWalletKw['issuingX509Cert'] = userCreds[2] 
     792                 
    760793            try:    
    761                 userSess = UserSession(username,  
    762                          creds, 
    763                          credentialRepository=self._credentialRepository,  
    764                          caCertFilePathList=self.__prop['caCertFilePathList'], 
    765                          wssSignatureHandlerKw=wssSignatureHandlerKw)       
     794                userSess = UserSession(**credWalletKw)      
    766795            except Exception, e: 
    767796                log.error("Error occurred whilst creating User Session: %s"%e) 
     
    770799            # Also allow access by user DN if individual user PKI credentials  
    771800            # have been passed in 
    772             if creds is not None: 
     801            if userCreds is not None: 
    773802                try: 
    774                     userDN = str(X509CertParse(creds[0]).dn) 
     803                    userDN = str(X509CertParse(userCreds[0]).dn) 
    775804                     
    776805                except Exception, e: 
     
    780809 
    781810                self.__dnDict[userDN] = userSess 
    782              
    783  
    784811         
    785812        newSessID = userSess.latestSessID 
     
    795822        # Return new session 
    796823        return userSess 
     824 
    797825 
    798826    def _connect2UserSession(self, username=None, userX509Cert=None, sessID=None): 
     
    825853            log.info("Connecting to session userDN=%s; sessID=%s using " 
    826854                     "username=%s" % (userSess.credWallet.userX509Cert.dn,  
    827                                       userSess.sessIDlist, 
     855                                      userSess.sessIdList, 
    828856                                      username))             
    829857        elif sessID: 
     
    837865                     "sessID=%s" % (userSess.credWallet.userX509Cert.dn,  
    838866                                    username, 
    839                                     userSess.sessIDlist)) 
     867                                    userSess.sessIdList)) 
    840868 
    841869        elif userX509Cert is not None: 
     
    864892             
    865893            log.info("Connecting to session sessID=%s; username=%s using " 
    866                      "userDN=%s" % (userSess.sessIDlist,  
     894                     "userDN=%s" % (userSess.sessIdList,  
    867895                                    userSess.credWallet.username,  
    868896                                    userDN)) 
     
    943971        else: 
    944972            # User session not found with given ID 
    945             raise SessionMgrError( 
    946                     '"sessID", "userCert" or "userSess" keywords must be set') 
     973            raise SessionMgrError('"sessID", "userCert" or "userSess" ' 
     974                                  'keywords must be set') 
    947975  
    948976        # Delete associated sessions 
     
    952980            # 
    953981            # Use pop rather than del so that key errors are ignored 
    954             for userSessID in userSess.sessIDlist: 
     982            for userSessID in userSess.sessIdList: 
    955983                self.__sessDict.pop(userSessID, None) 
    956984 
     
    960988            raise SessionMgrError("Deleting user session: %s" % e)   
    961989 
    962         log.info("Deleted user session: user DN = %s, sessID = %s" % \ 
    963                  (userDN, userSess.sessIDlist)) 
     990        log.info("Deleted user session: user DN = %s, sessID = %s" % 
     991                 (userDN, userSess.sessIdList)) 
    964992 
    965993    def getAttCert(self, 
     
    10141042        self._credentialRepository.auditCredentials() 
    10151043         
    1016          
    1017 class AbstractAuthNService: 
     1044 
     1045class AuthNServiceError(Exception): 
     1046    """Base class for AbstractAuthNService exceptions 
     1047     
     1048    A standard message is raised set by the msg class variable but the actual 
     1049    exception details are logged to the error log.  The use of a standard  
     1050    message enbales callers to use its content for user error messages. 
     1051     
     1052    @type msg: basestring 
     1053    @cvar msg: standard message to be raised for this exception""" 
     1054    msg = "An error occured with login" 
     1055    def __init__(self, *arg, **kw): 
     1056        Exception.__init__(self, AuthNServiceError.msg, *arg, **kw) 
     1057        if len(arg) > 0: 
     1058            msg = arg[0] 
     1059        else: 
     1060            msg = AuthNServiceError.msg 
     1061             
     1062        log.error(msg) 
     1063         
     1064class AuthNServiceInvalidCredentials(AuthNServiceError): 
     1065    """User has provided incorrect username/password.  Raise from logon""" 
     1066    msg = "Invalid username/password provided" 
     1067     
     1068class AuthNServiceRetrieveError(AuthNServiceError): 
     1069    """Error with retrieval of information to authenticate user e.g. error with 
     1070    database look-up.  Raise from logon""" 
     1071    msg = \ 
     1072    "An error occured retrieving information to check the login credentials" 
     1073 
     1074class AuthNServiceInitError(AuthNServiceError): 
     1075    """Error with initialisation of AuthNService.  Raise from __init__""" 
     1076    msg = "An error occured with the initialisation of the Session " + \ 
     1077        "Manager's Authentication Service" 
     1078     
     1079class AuthNServiceConfigError(AuthNServiceError): 
     1080    """Error with Authentication configuration.  Raise from __init__""" 
     1081    msg = "An error occured with the Session Manager's Authentication " + \ 
     1082        "Service configuration" 
     1083 
     1084 
     1085class AbstractAuthNService(object): 
    10181086    """ 
    10191087    An abstract base class to define the authentication service interface for  
     
    10311099        @param **prop:         set properties via keywords - see __validKeys 
    10321100        class variable for a list of these 
     1101        @raise AuthNServiceInitError: error with initialisation 
     1102        @raise AuthNServiceConfigError: error with configuration 
     1103        @raise AuthNServiceError: generic exception not described by the other 
     1104        specific exception types. 
    10331105        """ 
    10341106        pass 
     
    10541126        @param lifetime: lifetime for generated certificate 
    10551127         
    1056         @raise GetError: 
    1057         @raise RetrieveError: 
     1128        @raise AuthNServiceInvalidCredentials: invalid username/passphrase 
     1129        @raise AuthNServiceError: error  
     1130        @raise AuthNServiceRetrieveError: error with retrieval of information 
     1131        to authenticate user e.g. error with database look-up. 
     1132        @raise AuthNServiceError: generic exception not described by the other 
     1133        specific exception types. 
    10581134        @rtype: tuple 
    1059         @return credentials as strings in PEM format: the 
    1060         user certificate, its private key and the issuing certificate.  The 
    1061         issuing certificate is only set if the user certificate is a proxy 
     1135        @return: this may be either user PKI credentials or an empty tuple 
     1136        depending on the nature of the authentication service.  The UserSession 
     1137        object in the Session Manager instance can receive an individual user 
     1138        certificate and private key as returned by for example MyProxy.  In  
     1139        this case, the tuple consists of strings in PEM format:  
     1140         - the user certificate 
     1141         - corresponding private key 
     1142         - the issuing certificate.   
     1143        The issuing certificate is optional.  It is only set if the user  
     1144        certificate is a proxy certificate 
    10621145        """ 
    10631146        raise NotImplementedError(self.logon.__doc__.replace('\n       ','')) 
  • TI12-security/trunk/python/ndg.security.server/ndg/security/server/authnservice/basicauthn.py

    r4318 r4320  
    55NERC Data Grid Project 
    66""" 
    7 __author__ = "C Byrom - Tessella" 
     7__author__ = "P J Kershaw" 
    88__date__ = "08/10/08" 
    99__copyright__ = "(C) 2008 STFC & NERC" 
     
    1313__contact__ = "P.J.Kershaw@rl.ac.uk" 
    1414__revision__ = '$Id: $' 
     15import logging 
     16log = logging.getLogger(__name__) 
    1517import hashlib 
    1618 
    17 from ndg.security.server.SessionMgr import SessionMgr, AbstractAuthNService 
     19from ndg.security.server.SessionMgr import SessionMgr, AbstractAuthNService, \ 
     20    AuthNServiceInvalidCredentials, AuthNServiceError 
    1821from ndg.security.common.myproxy import MyProxyClient 
    1922 
     
    3538        @type passphrase: basestring 
    3639        @param passphrase: passphrase (or password) for user account 
     40        @rtype: None 
     41        @return: this interface doesn't return any user PKI credentials. 
    3742        ''' 
    38         md5Passwd = hashlib.sha224(passphrase).hexdigest() 
     43        try: 
     44            md5Passwd = hashlib.sha224(passphrase).hexdigest() 
     45        except Exception, e: 
     46            raise AuthNServiceError("%s exception raised making a digest of " 
     47                                    "the input passphrase: %s" % \ 
     48                                    (e.__class__, e)) 
    3949 
    40         return self.accounts.get('username') == md5Passwd 
     50        if self.accounts.get(username) != md5Passwd: 
     51            raise AuthNServiceInvalidCredentials() 
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/sessionMgr/sessionMgr.cfg

    r4318 r4320  
    5757credentialWallet.attCertRefreshElapse=7200 
    5858 
     59# Pointer to WS-Security settings.  IN this case, they're identified by a  
     60# prefix.   
     61credentialWallet.wssCfgPrefix=wssecurity 
     62 
     63# ...A section name could also be used. 
     64#credentialWallet.wssCfgSection= 
     65 
    5966# Settings for Credential Repository plugin 
    6067# File path to plugin module - may be left blank if module is included in the  
     
    8087 
    8188# Specific settings for BasicAuthN Session Manager authentication plugin 
     89# This sets up two test accounts.  Passwords are MD5 encrypted 
    8290authNService.basicAuthN.accounts: testuser:776767df1f96e3b773eceffad55c61eae53ea31fef3563732046a7a6 ndg-user:d63dc919e201d7bc4c825630d2cf25fdc93d4b2f0d46706d29038d01 
    8391 
    8492# 
    85 # SOAP Signature Handler settings 
     93# SOAP Signature Handler settings for the Credential Wallet's Attribute  
     94# Authority interface 
    8695# 
    8796# OUTBOUND MESSAGE CONFIG 
  • TI12-security/trunk/python/ndg.security.test/ndg/security/test/sessionMgr/test_sessionMgr.py

    r4318 r4320  
    9292         
    9393                                   
    94     def test1Connect(self): 
     94    def test1Connect2AuthNServiceWithNoUserCertReturned(self): 
     95        """test1Connect: make a new session connecting to AuthN service where 
     96        no user cert. is returned""" 
     97         
     98        username = self.cfg.get('test1Connect', 'username') 
     99        if SessionMgrTestCase.test1Passphrase is None and \ 
     100           self.cfg.has_option('test1Connect', 'passphrase'): 
     101            SessionMgrTestCase.test1Passphrase = self.cfg.get('test1Connect',  
     102                                                              'passphrase') 
     103         
     104        if not SessionMgrTestCase.test1Passphrase: 
     105            SessionMgrTestCase.test1Passphrase = getpass.getpass( 
     106                prompt="\ntest1Connect pass-phrase for user %s: " % username) 
     107 
     108        print "Connecting to session manager as user: %s..." %username 
     109        userCert, userPriKey, issuingCert, sessID = self.sm.connect( 
     110                            username=username,  
     111                            passphrase=SessionMgrTestCase.test1Passphrase) 
     112        assert(userCert is None) 
     113        assert(userPriKey is None) 
     114        assert(issuingCert is None) 
     115         
     116        print "User '%s' connected to Session Manager:\n%s" % \ 
     117                                                        (username, self.sessID)        
     118                                   
     119    def test2Connect2AuthNServiceReturningAUserCert(self): 
    95120        """test1Connect: make a new session""" 
    96121         
Note: See TracChangeset for help on using the changeset viewer.